1 /*-------------------------------------------------------------------------
2 * drawElements Internal Test Module
3 * ---------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief delibs self-tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "ditDelibsTests.hpp"
25 #include "tcuTestLog.hpp"
26
27 // depool
28 #include "dePoolArray.h"
29 #include "dePoolHeap.h"
30 #include "dePoolHash.h"
31 #include "dePoolSet.h"
32 #include "dePoolHashSet.h"
33 #include "dePoolHashArray.h"
34 #include "dePoolMultiSet.h"
35
36 // dethread
37 #include "deThreadTest.h"
38 #include "deThread.h"
39
40 // deutil
41 #include "deTimerTest.h"
42 #include "deCommandLine.h"
43
44 // debase
45 #include "deInt32.h"
46 #include "deFloat16.h"
47 #include "deMath.h"
48 #include "deSha1.h"
49 #include "deMemory.h"
50
51 // decpp
52 #include "deBlockBuffer.hpp"
53 #include "deFilePath.hpp"
54 #include "dePoolArray.hpp"
55 #include "deRingBuffer.hpp"
56 #include "deSharedPtr.hpp"
57 #include "deThreadSafeRingBuffer.hpp"
58 #include "deUniquePtr.hpp"
59 #include "deRandom.hpp"
60 #include "deCommandLine.hpp"
61 #include "deArrayBuffer.hpp"
62 #include "deStringUtil.hpp"
63 #include "deSpinBarrier.hpp"
64 #include "deSTLUtil.hpp"
65 #include "deAppendList.hpp"
66
67 namespace dit
68 {
69
70 using tcu::TestLog;
71
72 class DepoolTests : public tcu::TestCaseGroup
73 {
74 public:
DepoolTests(tcu::TestContext & testCtx)75 DepoolTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "depool", "depool self-tests")
76 {
77 }
78
init(void)79 void init(void)
80 {
81 addChild(new SelfCheckCase(m_testCtx, "array", "dePoolArray_selfTest()", dePoolArray_selfTest));
82 addChild(new SelfCheckCase(m_testCtx, "heap", "dePoolHeap_selfTest()", dePoolHeap_selfTest));
83 addChild(new SelfCheckCase(m_testCtx, "hash", "dePoolHash_selfTest()", dePoolHash_selfTest));
84 addChild(new SelfCheckCase(m_testCtx, "set", "dePoolSet_selfTest()", dePoolSet_selfTest));
85 addChild(new SelfCheckCase(m_testCtx, "hash_set", "dePoolHashSet_selfTest()", dePoolHashSet_selfTest));
86 addChild(new SelfCheckCase(m_testCtx, "hash_array", "dePoolHashArray_selfTest()", dePoolHashArray_selfTest));
87 addChild(new SelfCheckCase(m_testCtx, "multi_set", "dePoolMultiSet_selfTest()", dePoolMultiSet_selfTest));
88 }
89 };
90
91 extern "C"
92 {
93 typedef uint32_t (*GetUint32Func)(void);
94 }
95
96 class GetUint32Case : public tcu::TestCase
97 {
98 public:
GetUint32Case(tcu::TestContext & testCtx,const char * name,const char * description,GetUint32Func func)99 GetUint32Case(tcu::TestContext &testCtx, const char *name, const char *description, GetUint32Func func)
100 : tcu::TestCase(testCtx, name, description)
101 , m_func(func)
102 , m_description(description)
103 {
104 }
105
iterate(void)106 IterateResult iterate(void)
107 {
108 m_testCtx.getLog() << TestLog::Message << m_description << " returned " << m_func() << TestLog::EndMessage;
109 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
110 return STOP;
111 }
112
113 private:
114 GetUint32Func m_func;
115 const char *m_description;
116 };
117
118 class DethreadTests : public tcu::TestCaseGroup
119 {
120 public:
DethreadTests(tcu::TestContext & testCtx)121 DethreadTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "dethread", "dethread self-tests")
122 {
123 }
124
init(void)125 void init(void)
126 {
127 addChild(new SelfCheckCase(m_testCtx, "thread", "deThread_selfTest()", deThread_selfTest));
128 addChild(new SelfCheckCase(m_testCtx, "mutex", "deMutex_selfTest()", deMutex_selfTest));
129 addChild(new SelfCheckCase(m_testCtx, "semaphore", "deSemaphore_selfTest()", deSemaphore_selfTest));
130 addChild(new SelfCheckCase(m_testCtx, "atomic", "deAtomic_selfTest()", deAtomic_selfTest));
131 addChild(new SelfCheckCase(m_testCtx, "singleton", "deSingleton_selfTest()", deSingleton_selfTest));
132 addChild(new GetUint32Case(m_testCtx, "total_physical_cores", "deGetNumTotalPhysicalCores()",
133 deGetNumTotalPhysicalCores));
134 addChild(new GetUint32Case(m_testCtx, "total_logical_cores", "deGetNumTotalLogicalCores()",
135 deGetNumTotalLogicalCores));
136 addChild(new GetUint32Case(m_testCtx, "available_logical_cores", "deGetNumAvailableLogicalCores()",
137 deGetNumAvailableLogicalCores));
138 }
139 };
140
141 class DeutilTests : public tcu::TestCaseGroup
142 {
143 public:
DeutilTests(tcu::TestContext & testCtx)144 DeutilTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "deutil", "deutil self-tests")
145 {
146 }
147
init(void)148 void init(void)
149 {
150 addChild(new SelfCheckCase(m_testCtx, "timer", "deTimer_selfTest()", deTimer_selfTest));
151 addChild(new SelfCheckCase(m_testCtx, "command_line", "deCommandLine_selfTest()", deCommandLine_selfTest));
152 }
153 };
154
155 class DebaseTests : public tcu::TestCaseGroup
156 {
157 public:
DebaseTests(tcu::TestContext & testCtx)158 DebaseTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "debase", "debase self-tests")
159 {
160 }
161
init(void)162 void init(void)
163 {
164 addChild(new SelfCheckCase(m_testCtx, "int32", "deInt32_selfTest()", deInt32_selfTest));
165 addChild(new SelfCheckCase(m_testCtx, "float16", "deFloat16_selfTest()", deFloat16_selfTest));
166 addChild(new SelfCheckCase(m_testCtx, "math", "deMath_selfTest()", deMath_selfTest));
167 addChild(new SelfCheckCase(m_testCtx, "sha1", "deSha1_selfTest()", deSha1_selfTest));
168 addChild(new SelfCheckCase(m_testCtx, "memory", "deMemory_selfTest()", deMemory_selfTest));
169 }
170 };
171
172 class DecppTests : public tcu::TestCaseGroup
173 {
174 public:
DecppTests(tcu::TestContext & testCtx)175 DecppTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "decpp", "decpp self-tests")
176 {
177 }
178
init(void)179 void init(void)
180 {
181 addChild(new SelfCheckCase(m_testCtx, "block_buffer", "de::BlockBuffer_selfTest()", de::BlockBuffer_selfTest));
182 addChild(new SelfCheckCase(m_testCtx, "file_path", "de::FilePath_selfTest()", de::FilePath_selfTest));
183 addChild(new SelfCheckCase(m_testCtx, "pool_array", "de::PoolArray_selfTest()", de::PoolArray_selfTest));
184 addChild(new SelfCheckCase(m_testCtx, "ring_buffer", "de::RingBuffer_selfTest()", de::RingBuffer_selfTest));
185 addChild(new SelfCheckCase(m_testCtx, "shared_ptr", "de::SharedPtr_selfTest()", de::SharedPtr_selfTest));
186 addChild(new SelfCheckCase(m_testCtx, "thread_safe_ring_buffer", "de::ThreadSafeRingBuffer_selfTest()",
187 de::ThreadSafeRingBuffer_selfTest));
188 addChild(new SelfCheckCase(m_testCtx, "unique_ptr", "de::UniquePtr_selfTest()", de::UniquePtr_selfTest));
189 addChild(new SelfCheckCase(m_testCtx, "random", "de::Random_selfTest()", de::Random_selfTest));
190 addChild(new SelfCheckCase(m_testCtx, "commandline", "de::cmdline::selfTest()", de::cmdline::selfTest));
191 addChild(new SelfCheckCase(m_testCtx, "array_buffer", "de::ArrayBuffer_selfTest()", de::ArrayBuffer_selfTest));
192 addChild(new SelfCheckCase(m_testCtx, "string_util", "de::StringUtil_selfTest()", de::StringUtil_selfTest));
193 addChild(new SelfCheckCase(m_testCtx, "spin_barrier", "de::SpinBarrier_selfTest()", de::SpinBarrier_selfTest));
194 addChild(new SelfCheckCase(m_testCtx, "stl_util", "de::STLUtil_selfTest()", de::STLUtil_selfTest));
195 addChild(new SelfCheckCase(m_testCtx, "append_list", "de::AppendList_selfTest()", de::AppendList_selfTest));
196 }
197 };
198
DelibsTests(tcu::TestContext & testCtx)199 DelibsTests::DelibsTests(tcu::TestContext &testCtx) : tcu::TestCaseGroup(testCtx, "delibs", "delibs Tests")
200 {
201 }
202
~DelibsTests(void)203 DelibsTests::~DelibsTests(void)
204 {
205 }
206
init(void)207 void DelibsTests::init(void)
208 {
209 addChild(new DepoolTests(m_testCtx));
210 addChild(new DethreadTests(m_testCtx));
211 addChild(new DeutilTests(m_testCtx));
212 addChild(new DebaseTests(m_testCtx));
213 addChild(new DecppTests(m_testCtx));
214 }
215
216 } // namespace dit
217