Merge "Relax line width verification in primitive bbox tests" into nougat-cts-dev...
[platform/upstream/VK-GL-CTS.git] / modules / egl / teglTestPackage.cpp
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
67 namespace deqp
68 {
69 namespace egl
70 {
71
72 class StressTests : public TestCaseGroup
73 {
74 public:
75         StressTests (EglTestContext& eglTestCtx)
76                 : TestCaseGroup(eglTestCtx, "stress", "EGL stress tests")
77         {
78         }
79
80         void init (void)
81         {
82                 addChild(new MemoryStressTests(m_eglTestCtx));
83         }
84 };
85
86 class PerformanceTests : public TestCaseGroup
87 {
88 public:
89         PerformanceTests (EglTestContext& eglTestCtx)
90                 : TestCaseGroup(eglTestCtx, "performance", "EGL performance tests")
91         {
92         }
93
94         void init (void)
95         {
96                 addChild(new MakeCurrentPerfTests                       (m_eglTestCtx));
97                 addChild(new GLES2SharedRenderingPerfTests      (m_eglTestCtx));
98         }
99 };
100
101 class FunctionalTests : public TestCaseGroup
102 {
103 public:
104         FunctionalTests (EglTestContext& eglTestCtx)
105                 : TestCaseGroup(eglTestCtx, "functional", "EGL functional tests")
106         {
107         }
108
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         }
142 };
143
144 class TestCaseWrapper : public tcu::TestCaseExecutor
145 {
146 public:
147         TestCaseWrapper (void)
148         {
149         }
150
151         ~TestCaseWrapper (void)
152         {
153         }
154
155         void init (tcu::TestCase* testCase, const std::string&)
156         {
157                 testCase->init();
158         }
159
160         void deinit (tcu::TestCase* testCase)
161         {
162                 testCase->deinit();
163         }
164
165         tcu::TestNode::IterateResult iterate (tcu::TestCase* testCase)
166         {
167                 return testCase->iterate();
168         }
169 };
170
171 static const eglu::NativeDisplayFactory& getDefaultDisplayFactory (tcu::TestContext& testCtx)
172 {
173         const eglu::NativeDisplayFactory& factory = eglu::selectNativeDisplayFactory(testCtx.getPlatform().getEGLPlatform().getNativeDisplayFactoryRegistry(), testCtx.getCommandLine());
174
175         return factory;
176 }
177
178 TestPackage::TestPackage (tcu::TestContext& testCtx)
179         : tcu::TestPackage      (testCtx, "dEQP-EGL", "dEQP EGL Tests")
180         , m_eglTestCtx          (DE_NULL)
181 {
182 }
183
184 TestPackage::~TestPackage (void)
185 {
186         // Destroy children first since destructors may access context.
187         TestNode::deinit();
188         delete m_eglTestCtx;
189 }
190
191 void TestPackage::init (void)
192 {
193         DE_ASSERT(!m_eglTestCtx);
194         m_eglTestCtx = new EglTestContext(m_testCtx, getDefaultDisplayFactory(m_testCtx));
195
196         try
197         {
198                 addChild(new InfoTests                  (*m_eglTestCtx));
199                 addChild(new FunctionalTests    (*m_eglTestCtx));
200                 addChild(new PerformanceTests   (*m_eglTestCtx));
201                 addChild(new StressTests                (*m_eglTestCtx));
202         }
203         catch (...)
204         {
205                 delete m_eglTestCtx;
206                 m_eglTestCtx = DE_NULL;
207
208                 throw;
209         }
210 }
211
212 void TestPackage::deinit (void)
213 {
214         tcu::TestNode::deinit();
215         delete m_eglTestCtx;
216         m_eglTestCtx = DE_NULL;
217 }
218
219 tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
220 {
221         return new TestCaseWrapper();
222 }
223
224 } // egl
225 } // deqp