modules/gles2/functional/es2fFunctionalTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.0 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 Base class for a test case.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fFunctionalTests.hpp"
  25
  26 #include "es2fColorClearTest.hpp"
  27 #include "es2fLightAmountTest.hpp"
  28 #include "es2fShaderExecuteTest.hpp"
  29 #include "es2fFboApiTest.hpp"
  30 #include "es2fFboRenderTest.hpp"
  31 #include "es2fFboCompletenessTests.hpp"
  32 #include "es2fRandomShaderTests.hpp"
  33 #include "es2fPrerequisiteTests.hpp"
  34 #include "es2fDepthTests.hpp"
  35 #include "es2fStencilTests.hpp"
  36 #include "es2fScissorTests.hpp"
  37 #include "es2fVertexArrayTest.hpp"
  38 #include "es2fRasterizationTests.hpp"
  39 #include "es2fDepthStencilClearTests.hpp"
  40 #include "es2fDepthStencilTests.hpp"
  41 #include "es2fBlendTests.hpp"
  42 #include "es2fRandomFragmentOpTests.hpp"
  43 #include "es2fMultisampleTests.hpp"
  44 #include "es2fUniformApiTests.hpp"
  45 #include "es2fBufferWriteTests.hpp"
  46 #include "es2fImplementationLimitTests.hpp"
  47 #include "es2fDepthRangeTests.hpp"
  48 #include "es2fDitheringTests.hpp"
  49 #include "es2fClippingTests.hpp"
  50 #include "es2fPolygonOffsetTests.hpp"
  51 #include "es2fDrawTests.hpp"
  52 #include "es2fFragOpInteractionTests.hpp"
  53 #include "es2fFlushFinishTests.hpp"
  54 #include "es2fDefaultVertexAttributeTests.hpp"
  55 #include "es2fLifetimeTests.hpp"
  56
  57 #include "es2fTextureFormatTests.hpp"
  58 #include "es2fTextureWrapTests.hpp"
  59 #include "es2fTextureFilteringTests.hpp"
  60 #include "es2fTextureMipmapTests.hpp"
  61 #include "es2fTextureSizeTests.hpp"
  62 #include "es2fTextureSpecificationTests.hpp"
  63 #include "es2fTextureCompletenessTests.hpp"
  64 #include "es2fNegativeVertexArrayApiTests.hpp"
  65 #include "es2fNegativeTextureApiTests.hpp"
  66 #include "es2fNegativeFragmentApiTests.hpp"
  67 #include "es2fNegativeBufferApiTests.hpp"
  68 #include "es2fNegativeShaderApiTests.hpp"
  69 #include "es2fNegativeStateApiTests.hpp"
  70 #include "es2fVertexTextureTests.hpp"
  71 #include "es2fTextureUnitTests.hpp"
  72
  73 #include "es2fShaderApiTests.hpp"
  74 #include "es2fShaderAlgorithmTests.hpp"
  75 #include "es2fShaderBuiltinVarTests.hpp"
  76 #include "es2fShaderConstExprTests.hpp"
  77 #include "es2fShaderDiscardTests.hpp"
  78 #include "es2fShaderIndexingTests.hpp"
  79 #include "es2fShaderLoopTests.hpp"
  80 #include "es2fShaderOperatorTests.hpp"
  81 #include "es2fShaderReturnTests.hpp"
  82 #include "es2fShaderStructTests.hpp"
  83 #include "es2fShaderMatrixTests.hpp"
  84 #include "es2fShaderTextureFunctionTests.hpp"
  85 #include "es2fAttribLocationTests.hpp"
  86 #include "es2fShaderInvarianceTests.hpp"
  87 #include "es2fShaderFragDataTests.hpp"
  88
  89 // State query tests
  90 #include "es2fBooleanStateQueryTests.hpp"
  91 #include "es2fIntegerStateQueryTests.hpp"
  92 #include "es2fFloatStateQueryTests.hpp"
  93 #include "es2fTextureStateQueryTests.hpp"
  94 #include "es2fStringQueryTests.hpp"
  95 #include "es2fBufferObjectQueryTests.hpp"
  96 #include "es2fFboStateQueryTests.hpp"
  97 #include "es2fRboStateQueryTests.hpp"
  98 #include "es2fShaderStateQueryTests.hpp"
  99
 100 #include "es2fReadPixelsTests.hpp"
 101 #include "es2fDebugMarkerTests.hpp"
 102
 103 namespace deqp
 104 {
 105 namespace gles2
 106 {
 107 namespace Functional
 108 {
 109
 110 // ShadersTestGroup
 111
 112 class ShadersTestGroup : public TestCaseGroup
 113 {
 114 public:
 115         ShadersTestGroup (Context& context)
 116                 : TestCaseGroup(context, "shaders", "Shader Tests")
 117         {
 118         }
 119
 120         virtual ~ShadersTestGroup (void)
 121         {
 122         }
 123
 124         virtual void init (void)
 125         {
 126                 addChild(new ShaderExecuteTest(m_context, "preprocessor",                                       "Preprocessor Tests"));
 127                 addChild(new ShaderExecuteTest(m_context, "constants",                                          "Constant Literal Tests"));
 128                 addChild(new ShaderExecuteTest(m_context, "linkage",                                            "Linkage Tests"));
 129                 addChild(new ShaderExecuteTest(m_context, "conversions",                                        "Type Conversion Tests"));
 130                 addChild(new ShaderExecuteTest(m_context, "conditionals",                                       "Conditionals Tests"));
 131                 addChild(new ShaderExecuteTest(m_context, "declarations",                                       "Declarations Tests"));
 132                 addChild(new ShaderExecuteTest(m_context, "swizzles",                                           "Swizzle Tests"));
 133                 addChild(new ShaderExecuteTest(m_context, "functions",                                          "Function Tests"));
 134                 addChild(new ShaderExecuteTest(m_context, "keywords",                                           "Keyword Tests"));
 135                 addChild(new ShaderExecuteTest(m_context, "reserved_operators",                         "Reserved Operator Tests"));
 136                 addChild(new ShaderExecuteTest(m_context, "qualification_order",                        "Order of Qualification Tests"));
 137                 addChild(new ShaderExecuteTest(m_context, "scoping",                                            "Scoping of Declarations"));
 138                 addChild(new ShaderExecuteTest(m_context, "invalid_implicit_conversions",       "Invalid Implicit Conversions"));
 139
 140
 141                 addChild(new ShaderIndexingTests                (m_context));
 142                 addChild(new ShaderLoopTests                    (m_context));
 143                 addChild(new ShaderOperatorTests                (m_context));
 144                 addChild(new ShaderMatrixTests                  (m_context));
 145                 addChild(new ShaderReturnTests                  (m_context));
 146                 addChild(new ShaderDiscardTests                 (m_context));
 147                 addChild(new ShaderStructTests                  (m_context));
 148                 addChild(new ShaderBuiltinVarTests              (m_context));
 149                 addChild(new ShaderTextureFunctionTests (m_context));
 150                 addChild(new ShaderInvarianceTests              (m_context));
 151                 addChild(new ShaderFragDataTests                (m_context));
 152                 addChild(new ShaderAlgorithmTests               (m_context));
 153                 addChild(new ShaderConstExprTests               (m_context));
 154
 155                 addChild(new RandomShaderTests(m_context));
 156         }
 157 };
 158
 159 // TextureTestGroup
 160
 161 class TextureTestGroup : public TestCaseGroup
 162 {
 163 public:
 164         TextureTestGroup (Context& context)
 165                 : TestCaseGroup(context, "texture", "Texture Tests")
 166         {
 167         }
 168
 169         virtual ~TextureTestGroup (void)
 170         {
 171         }
 172
 173         virtual void init (void)
 174         {
 175                 addChild(new TextureFormatTests                 (m_context));
 176                 addChild(new TextureSizeTests                   (m_context));
 177                 addChild(new TextureWrapTests                   (m_context));
 178                 addChild(new TextureFilteringTests              (m_context));
 179                 addChild(new TextureMipmapTests                 (m_context));
 180                 addChild(new TextureSpecificationTests  (m_context));
 181                 addChild(new TextureCompletenessTests   (m_context));
 182                 addChild(new VertexTextureTests                 (m_context));
 183                 addChild(new TextureUnitTests                   (m_context));
 184         }
 185
 186         virtual void deinit (void)
 187         {
 188         }
 189 };
 190
 191 class BufferTests : public TestCaseGroup
 192 {
 193 public:
 194         BufferTests (Context& context)
 195                 : TestCaseGroup(context, "buffer", "Buffer object tests")
 196         {
 197         }
 198
 199         void init (void)
 200         {
 201                 addChild(new BufferWriteTests(m_context));
 202         }
 203 };
 204
 205 // FboTestGroup
 206
 207 class FboTestGroup : public TestCaseGroup
 208 {
 209 public:
 210         FboTestGroup (Context& context)
 211                 : TestCaseGroup(context, "fbo", "Framebuffer Object Tests")
 212         {
 213         }
 214
 215         virtual ~FboTestGroup (void)
 216         {
 217         }
 218
 219         virtual void init (void)
 220         {
 221                 addChild(new FboApiTestGroup(m_context));
 222                 addChild(new FboRenderTestGroup(m_context));
 223                 addChild(createFboCompletenessTests(m_context));
 224         }
 225 };
 226
 227 // NegativeApiTestGroup
 228
 229 class NegativeApiTestGroup : public TestCaseGroup
 230 {
 231 public:
 232         NegativeApiTestGroup (Context& context)
 233                 : TestCaseGroup(context, "negative_api", "Negative API Tests")
 234         {
 235         }
 236
 237         virtual ~NegativeApiTestGroup (void)
 238         {
 239         }
 240
 241         virtual void init (void)
 242         {
 243                 addChild(new NegativeBufferApiTests                     (m_context));
 244                 addChild(new NegativeFragmentApiTests           (m_context));
 245                 addChild(new NegativeShaderApiTests                     (m_context));
 246                 addChild(new NegativeStateApiTests                      (m_context));
 247                 addChild(new NegativeTextureApiTests            (m_context));
 248                 addChild(new NegativeVertexArrayApiTests        (m_context));
 249         }
 250 };
 251
 252 // FragmentOpTests
 253
 254 class FragmentOpTests : public TestCaseGroup
 255 {
 256 public:
 257         FragmentOpTests (Context& context)
 258                 : TestCaseGroup(context, "fragment_ops", "Per-Fragment Operation Tests")
 259         {
 260         }
 261
 262         void init (void)
 263         {
 264                 addChild(new DepthTests                         (m_context));
 265                 addChild(new StencilTests                       (m_context));
 266                 addChild(new DepthStencilTests          (m_context));
 267                 addChild(new ScissorTests                       (m_context));
 268                 addChild(new BlendTests                         (m_context));
 269                 addChild(new RandomFragmentOpTests      (m_context));
 270                 addChild(new FragOpInteractionTests     (m_context));
 271         }
 272 };
 273
 274 // StateQueryTests
 275
 276 class StateQueryTests : public TestCaseGroup
 277 {
 278 public:
 279         StateQueryTests (Context& context)
 280                 : TestCaseGroup(context, "state_query", "State Query Tests")
 281         {
 282         }
 283
 284         void init (void)
 285         {
 286                 addChild(new BooleanStateQueryTests             (m_context));
 287                 addChild(new IntegerStateQueryTests             (m_context));
 288                 addChild(new FloatStateQueryTests               (m_context));
 289                 addChild(new TextureStateQueryTests             (m_context));
 290                 addChild(new StringQueryTests                   (m_context));
 291                 addChild(new BufferObjectQueryTests             (m_context));
 292                 addChild(new FboStateQueryTests                 (m_context));
 293                 addChild(new RboStateQueryTests                 (m_context));
 294                 addChild(new ShaderStateQueryTests              (m_context));
 295         }
 296 };
 297
 298 // FunctionalTestGroup
 299
 300 FunctionalTests::FunctionalTests (Context& context)
 301         : TestCaseGroup(context, "functional", "Functionality Tests")
 302 {
 303 }
 304
 305 FunctionalTests::~FunctionalTests (void)
 306 {
 307 }
 308
 309 void FunctionalTests::init (void)
 310 {
 311         addChild(new PrerequisiteTests                  (m_context));
 312         addChild(new ImplementationLimitTests   (m_context));
 313         addChild(new ColorClearTest                             (m_context));
 314         addChild(new DepthStencilClearTests             (m_context));
 315         addChild(new BufferTests                                (m_context));
 316         addChild(new LightAmountTest                    (m_context));
 317         addChild(new ShadersTestGroup                   (m_context));
 318         addChild(new TextureTestGroup                   (m_context));
 319         addChild(new FragmentOpTests                    (m_context));
 320         addChild(new FboTestGroup                               (m_context));
 321         addChild(new VertexArrayTestGroup               (m_context));
 322         addChild(new ShaderApiTests                             (m_context));
 323         addChild(new NegativeApiTestGroup               (m_context));
 324         addChild(new RasterizationTests                 (m_context));
 325         addChild(createAttributeLocationTests   (m_context));
 326         addChild(new MultisampleTests                   (m_context));
 327         addChild(new UniformApiTests                    (m_context));
 328         addChild(new ReadPixelsTests                    (m_context));
 329         addChild(new DepthRangeTests                    (m_context));
 330         addChild(new DitheringTests                             (m_context));
 331         addChild(new StateQueryTests                    (m_context));
 332         addChild(new ClippingTests                              (m_context));
 333         addChild(new PolygonOffsetTests                 (m_context));
 334         addChild(new DrawTests                                  (m_context));
 335         addChild(new FlushFinishTests                   (m_context));
 336         addChild(new DefaultVertexAttributeTests(m_context));
 337         addChild(createLifetimeTests                    (m_context));
 338         addChild(createDebugMarkerTests                 (m_context));
 339 }
 340
 341 } // Functional
 342 } // gles2
 343 } // deqp