1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL 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 EGL Test Package
22 *//*--------------------------------------------------------------------*/
23
24 #include "teglTestPackage.hpp"
25
26 #include "tcuTestLog.hpp"
27 #include "tcuPlatform.hpp"
28 #include "tcuCommandLine.hpp"
29
30 #include "egluPlatform.hpp"
31 #include "egluUtil.hpp"
32
33 #include "teglInfoTests.hpp"
34 #include "teglCreateContextTests.hpp"
35 #include "teglQueryContextTests.hpp"
36 #include "teglCreateSurfaceTests.hpp"
37 #include "teglQuerySurfaceTests.hpp"
38 #include "teglChooseConfigTests.hpp"
39 #include "teglQueryConfigTests.hpp"
40 #include "teglColorClearTests.hpp"
41 #include "teglRenderTests.hpp"
42 #include "teglImageTests.hpp"
43 #include "teglGLES2SharingTests.hpp"
44 #include "teglNegativeApiTests.hpp"
45 #include "teglSyncTests.hpp"
46 #include "teglMultiThreadTests.hpp"
47 #include "teglGetProcAddressTests.hpp"
48 #include "teglMemoryStressTests.hpp"
49 #include "teglMakeCurrentPerfTests.hpp"
50 #include "teglGLES2SharedRenderingPerfTests.hpp"
51 #include "teglPreservingSwapTests.hpp"
52 #include "teglClientExtensionTests.hpp"
53 #include "teglCreateContextExtTests.hpp"
54 #include "teglSurfacelessContextTests.hpp"
55 #include "teglSwapBuffersTests.hpp"
56 #include "teglNativeColorMappingTests.hpp"
57 #include "teglNativeCoordMappingTests.hpp"
58 #include "teglResizeTests.hpp"
59 #include "teglBufferAgeTests.hpp"
60 #include "teglPartialUpdateTests.hpp"
61 #include "teglNegativePartialUpdateTests.hpp"
62 #include "teglSwapBuffersWithDamageTests.hpp"
63 #include "teglMultiContextTests.hpp"
64 #include "teglThreadCleanUpTests.hpp"
65 #include "teglMutableRenderBufferTests.hpp"
66 #include "teglGetFrameTimestampsTests.hpp"
67 #include "teglRobustnessTests.hpp"
68 #include "teglWideColorTests.hpp"
69
70 namespace deqp
71 {
72 namespace egl
73 {
74
75 class StressTests : public TestCaseGroup
76 {
77 public:
StressTests(EglTestContext & eglTestCtx)78 StressTests(EglTestContext &eglTestCtx) : TestCaseGroup(eglTestCtx, "stress", "EGL stress tests")
79 {
80 }
81
init(void)82 void init(void)
83 {
84 addChild(new MemoryStressTests(m_eglTestCtx));
85 }
86 };
87
88 class PerformanceTests : public TestCaseGroup
89 {
90 public:
PerformanceTests(EglTestContext & eglTestCtx)91 PerformanceTests(EglTestContext &eglTestCtx) : TestCaseGroup(eglTestCtx, "performance", "EGL performance tests")
92 {
93 }
94
init(void)95 void init(void)
96 {
97 addChild(new MakeCurrentPerfTests(m_eglTestCtx));
98 addChild(new GLES2SharedRenderingPerfTests(m_eglTestCtx));
99 }
100 };
101
102 class FunctionalTests : public TestCaseGroup
103 {
104 public:
FunctionalTests(EglTestContext & eglTestCtx)105 FunctionalTests(EglTestContext &eglTestCtx) : TestCaseGroup(eglTestCtx, "functional", "EGL functional tests")
106 {
107 }
108
init(void)109 void init(void)
110 {
111 addChild(new CreateContextTests(m_eglTestCtx));
112 addChild(new QueryContextTests(m_eglTestCtx));
113 addChild(new CreateSurfaceTests(m_eglTestCtx));
114 addChild(new QuerySurfaceTests(m_eglTestCtx));
115 addChild(new QueryConfigTests(m_eglTestCtx));
116 addChild(new ChooseConfigTests(m_eglTestCtx));
117 addChild(new ColorClearTests(m_eglTestCtx));
118 addChild(new RenderTests(m_eglTestCtx));
119 addChild(new ImageTests(m_eglTestCtx));
120 addChild(new SharingTests(m_eglTestCtx));
121 addChild(new NegativeApiTests(m_eglTestCtx));
122 addChild(new FenceSyncTests(m_eglTestCtx));
123 addChild(new MultiThreadedTests(m_eglTestCtx));
124 addChild(new GetProcAddressTests(m_eglTestCtx));
125 addChild(new PreservingSwapTests(m_eglTestCtx));
126 addChild(new ClientExtensionTests(m_eglTestCtx));
127 addChild(new CreateContextExtTests(m_eglTestCtx));
128 addChild(new SurfacelessContextTests(m_eglTestCtx));
129 addChild(new SwapBuffersTests(m_eglTestCtx));
130 addChild(new NativeColorMappingTests(m_eglTestCtx));
131 addChild(new NativeCoordMappingTests(m_eglTestCtx));
132 addChild(new ReusableSyncTests(m_eglTestCtx));
133 addChild(new ResizeTests(m_eglTestCtx));
134 addChild(new BufferAgeTests(m_eglTestCtx));
135 addChild(new PartialUpdateTests(m_eglTestCtx));
136 addChild(new NegativePartialUpdateTests(m_eglTestCtx));
137 addChild(new SwapBuffersWithDamageTests(m_eglTestCtx));
138 addChild(createMultiContextTests(m_eglTestCtx));
139 addChild(createThreadCleanUpTest(m_eglTestCtx));
140 addChild(new MutableRenderBufferTests(m_eglTestCtx));
141 addChild(createGetFrameTimestampsTests(m_eglTestCtx));
142 addChild(createRobustnessTests(m_eglTestCtx));
143 addChild(createWideColorTests(m_eglTestCtx));
144 addChild(createHdrColorTests(m_eglTestCtx));
145 }
146 };
147
148 class TestCaseWrapper : public tcu::TestCaseExecutor
149 {
150 public:
TestCaseWrapper(void)151 TestCaseWrapper(void)
152 {
153 }
154
~TestCaseWrapper(void)155 ~TestCaseWrapper(void)
156 {
157 }
158
init(tcu::TestCase * testCase,const std::string &)159 void init(tcu::TestCase *testCase, const std::string &)
160 {
161 testCase->init();
162 }
163
deinit(tcu::TestCase * testCase)164 void deinit(tcu::TestCase *testCase)
165 {
166 testCase->deinit();
167 }
168
iterate(tcu::TestCase * testCase)169 tcu::TestNode::IterateResult iterate(tcu::TestCase *testCase)
170 {
171 return testCase->iterate();
172 }
173 };
174
getDefaultDisplayFactory(tcu::TestContext & testCtx)175 static const eglu::NativeDisplayFactory &getDefaultDisplayFactory(tcu::TestContext &testCtx)
176 {
177 const eglu::NativeDisplayFactory &factory = eglu::selectNativeDisplayFactory(
178 testCtx.getPlatform().getEGLPlatform().getNativeDisplayFactoryRegistry(), testCtx.getCommandLine());
179
180 return factory;
181 }
182
TestPackage(tcu::TestContext & testCtx)183 TestPackage::TestPackage(tcu::TestContext &testCtx)
184 : tcu::TestPackage(testCtx, "dEQP-EGL", "dEQP EGL Tests")
185 , m_eglTestCtx(DE_NULL)
186 {
187 }
188
~TestPackage(void)189 TestPackage::~TestPackage(void)
190 {
191 // Destroy children first since destructors may access context.
192 TestNode::deinit();
193 delete m_eglTestCtx;
194 }
195
init(void)196 void TestPackage::init(void)
197 {
198 DE_ASSERT(!m_eglTestCtx);
199 m_eglTestCtx = new EglTestContext(m_testCtx, getDefaultDisplayFactory(m_testCtx));
200
201 try
202 {
203 addChild(new InfoTests(*m_eglTestCtx));
204 addChild(new FunctionalTests(*m_eglTestCtx));
205 addChild(new PerformanceTests(*m_eglTestCtx));
206 addChild(new StressTests(*m_eglTestCtx));
207 }
208 catch (...)
209 {
210 delete m_eglTestCtx;
211 m_eglTestCtx = DE_NULL;
212
213 throw;
214 }
215 }
216
deinit(void)217 void TestPackage::deinit(void)
218 {
219 tcu::TestNode::deinit();
220 delete m_eglTestCtx;
221 m_eglTestCtx = DE_NULL;
222 }
223
createExecutor(void) const224 tcu::TestCaseExecutor *TestPackage::createExecutor(void) const
225 {
226 return new TestCaseWrapper();
227 }
228
229 } // namespace egl
230 } // namespace deqp
231