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
69 namespace deqp
70 {
71 namespace egl
72 {
73
74 class StressTests : public TestCaseGroup
75 {
76 public:
StressTests(EglTestContext & eglTestCtx)77 StressTests (EglTestContext& eglTestCtx)
78 : 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)
92 : TestCaseGroup(eglTestCtx, "performance", "EGL performance tests")
93 {
94 }
95
init(void)96 void init (void)
97 {
98 addChild(new MakeCurrentPerfTests (m_eglTestCtx));
99 addChild(new GLES2SharedRenderingPerfTests (m_eglTestCtx));
100 }
101 };
102
103 class FunctionalTests : public TestCaseGroup
104 {
105 public:
FunctionalTests(EglTestContext & eglTestCtx)106 FunctionalTests (EglTestContext& eglTestCtx)
107 : TestCaseGroup(eglTestCtx, "functional", "EGL functional tests")
108 {
109 }
110
init(void)111 void init (void)
112 {
113 addChild(new CreateContextTests (m_eglTestCtx));
114 addChild(new QueryContextTests (m_eglTestCtx));
115 addChild(new CreateSurfaceTests (m_eglTestCtx));
116 addChild(new QuerySurfaceTests (m_eglTestCtx));
117 addChild(new QueryConfigTests (m_eglTestCtx));
118 addChild(new ChooseConfigTests (m_eglTestCtx));
119 addChild(new ColorClearTests (m_eglTestCtx));
120 addChild(new RenderTests (m_eglTestCtx));
121 addChild(new ImageTests (m_eglTestCtx));
122 addChild(new SharingTests (m_eglTestCtx));
123 addChild(new NegativeApiTests (m_eglTestCtx));
124 addChild(new FenceSyncTests (m_eglTestCtx));
125 addChild(new MultiThreadedTests (m_eglTestCtx));
126 addChild(new GetProcAddressTests (m_eglTestCtx));
127 addChild(new PreservingSwapTests (m_eglTestCtx));
128 addChild(new ClientExtensionTests (m_eglTestCtx));
129 addChild(new CreateContextExtTests (m_eglTestCtx));
130 addChild(new SurfacelessContextTests (m_eglTestCtx));
131 addChild(new SwapBuffersTests (m_eglTestCtx));
132 addChild(new NativeColorMappingTests (m_eglTestCtx));
133 addChild(new NativeCoordMappingTests (m_eglTestCtx));
134 addChild(new ReusableSyncTests (m_eglTestCtx));
135 addChild(new ResizeTests (m_eglTestCtx));
136 addChild(new BufferAgeTests (m_eglTestCtx));
137 addChild(new PartialUpdateTests (m_eglTestCtx));
138 addChild(new NegativePartialUpdateTests (m_eglTestCtx));
139 addChild(new SwapBuffersWithDamageTests (m_eglTestCtx));
140 addChild(createMultiContextTests (m_eglTestCtx));
141 addChild(createThreadCleanUpTest (m_eglTestCtx));
142 addChild(new MutableRenderBufferTests (m_eglTestCtx));
143 addChild(createGetFrameTimestampsTests (m_eglTestCtx));
144 addChild(createRobustnessTests (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(testCtx.getPlatform().getEGLPlatform().getNativeDisplayFactoryRegistry(), testCtx.getCommandLine());
178
179 return factory;
180 }
181
TestPackage(tcu::TestContext & testCtx)182 TestPackage::TestPackage (tcu::TestContext& testCtx)
183 : tcu::TestPackage (testCtx, "dEQP-EGL", "dEQP EGL Tests")
184 , m_eglTestCtx (DE_NULL)
185 {
186 }
187
~TestPackage(void)188 TestPackage::~TestPackage (void)
189 {
190 // Destroy children first since destructors may access context.
191 TestNode::deinit();
192 delete m_eglTestCtx;
193 }
194
init(void)195 void TestPackage::init (void)
196 {
197 DE_ASSERT(!m_eglTestCtx);
198 m_eglTestCtx = new EglTestContext(m_testCtx, getDefaultDisplayFactory(m_testCtx));
199
200 try
201 {
202 addChild(new InfoTests (*m_eglTestCtx));
203 addChild(new FunctionalTests (*m_eglTestCtx));
204 addChild(new PerformanceTests (*m_eglTestCtx));
205 addChild(new StressTests (*m_eglTestCtx));
206 }
207 catch (...)
208 {
209 delete m_eglTestCtx;
210 m_eglTestCtx = DE_NULL;
211
212 throw;
213 }
214 }
215
deinit(void)216 void TestPackage::deinit (void)
217 {
218 tcu::TestNode::deinit();
219 delete m_eglTestCtx;
220 m_eglTestCtx = DE_NULL;
221 }
222
createExecutor(void) const223 tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
224 {
225 return new TestCaseWrapper();
226 }
227
228 } // egl
229 } // deqp
230