modules/gles3/functional/es3fFunctionalTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.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 Functional Test Group.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fFunctionalTests.hpp"
  25
  26 #include "es3fColorClearTest.hpp"
  27 #include "es3fDepthTests.hpp"
  28 #include "es3fPrerequisiteTests.hpp"
  29 #include "es3fStencilTests.hpp"
  30 #include "es3fDepthStencilTests.hpp"
  31 #include "es3fVertexArrayTest.hpp"
  32 #include "es3fUniformBlockTests.hpp"
  33 #include "es3fUniformApiTests.hpp"
  34 #include "es3fFragmentOutputTests.hpp"
  35 #include "es3fOcclusionQueryTests.hpp"
  36 #include "es3fDepthStencilClearTests.hpp"
  37 #include "es3fSamplerObjectTests.hpp"
  38 #include "es3fAttribLocationTests.hpp"
  39 #include "es3fPixelBufferObjectTests.hpp"
  40 #include "es3fRasterizationTests.hpp"
  41 #include "es3fRasterizerDiscardTests.hpp"
  42 #include "es3fTransformFeedbackTests.hpp"
  43 #include "es3fVertexArrayObjectTests.hpp"
  44 #include "es3fPrimitiveRestartTests.hpp"
  45 #include "es3fInstancedRenderingTests.hpp"
  46 #include "es3fSyncTests.hpp"
  47 #include "es3fBlendTests.hpp"
  48 #include "es3fRandomFragmentOpTests.hpp"
  49 #include "es3fMultisampleTests.hpp"
  50 #include "es3fImplementationLimitTests.hpp"
  51 #include "es3fDitheringTests.hpp"
  52 #include "es3fClippingTests.hpp"
  53 #include "es3fPolygonOffsetTests.hpp"
  54 #include "es3fDrawTests.hpp"
  55 #include "es3fFragOpInteractionTests.hpp"
  56 #include "es3fFlushFinishTests.hpp"
  57 #include "es3fFlushFinishTests.hpp"
  58 #include "es3fDefaultVertexAttributeTests.hpp"
  59 #include "es3fScissorTests.hpp"
  60 #include "es3fLifetimeTests.hpp"
  61 #include "es3fDefaultVertexArrayObjectTests.hpp"
  62
  63 // Shader tests
  64 #include "es3fShaderApiTests.hpp"
  65 #include "es3fShaderConstExprTests.hpp"
  66 #include "es3fShaderDiscardTests.hpp"
  67 #include "es3fShaderIndexingTests.hpp"
  68 #include "es3fShaderLoopTests.hpp"
  69 #include "es3fShaderMatrixTests.hpp"
  70 #include "es3fShaderOperatorTests.hpp"
  71 #include "es3fShaderReturnTests.hpp"
  72 #include "es3fShaderStructTests.hpp"
  73 #include "es3fShaderSwitchTests.hpp"
  74 #include "es3fRandomShaderTests.hpp"
  75 #include "es3fFragDepthTests.hpp"
  76 #include "es3fShaderPrecisionTests.hpp"
  77 #include "es3fShaderBuiltinVarTests.hpp"
  78 #include "es3fShaderTextureFunctionTests.hpp"
  79 #include "es3fShaderDerivateTests.hpp"
  80 #include "es3fShaderPackingFunctionTests.hpp"
  81 #include "es3fShaderCommonFunctionTests.hpp"
  82 #include "es3fShaderInvarianceTests.hpp"
  83 #include "es3fShaderFragDataTests.hpp"
  84 #include "es3fBuiltinPrecisionTests.hpp"
  85
  86 // Texture tests
  87 #include "es3fTextureFormatTests.hpp"
  88 #include "es3fTextureWrapTests.hpp"
  89 #include "es3fTextureFilteringTests.hpp"
  90 #include "es3fTextureMipmapTests.hpp"
  91 #include "es3fTextureSizeTests.hpp"
  92 #include "es3fTextureSwizzleTests.hpp"
  93 #include "es3fTextureShadowTests.hpp"
  94 #include "es3fTextureSpecificationTests.hpp"
  95 #include "es3fVertexTextureTests.hpp"
  96 #include "es3fTextureUnitTests.hpp"
  97 #include "es3fCompressedTextureTests.hpp"
  98
  99 // Fbo tests
 100 #include "es3fFboApiTests.hpp"
 101 #include "es3fFboCompletenessTests.hpp"
 102 #include "es3fFboColorbufferTests.hpp"
 103 #include "es3fFboDepthbufferTests.hpp"
 104 #include "es3fFboStencilbufferTests.hpp"
 105 #include "es3fFramebufferBlitTests.hpp"
 106 #include "es3fFboMultisampleTests.hpp"
 107 #include "es3fFboRenderTest.hpp"
 108 #include "es3fFboInvalidateTests.hpp"
 109
 110 // Buffer tests
 111 #include "es3fBufferWriteTests.hpp"
 112 #include "es3fBufferMapTests.hpp"
 113 #include "es3fBufferCopyTests.hpp"
 114
 115 // Negative API tests
 116 #include "es3fNegativeBufferApiTests.hpp"
 117 #include "es3fNegativeTextureApiTests.hpp"
 118 #include "es3fNegativeShaderApiTests.hpp"
 119 #include "es3fNegativeFragmentApiTests.hpp"
 120 #include "es3fNegativeVertexArrayApiTests.hpp"
 121 #include "es3fNegativeStateApiTests.hpp"
 122
 123 // State query tests
 124 #include "es3fBooleanStateQueryTests.hpp"
 125 #include "es3fIntegerStateQueryTests.hpp"
 126 #include "es3fInteger64StateQueryTests.hpp"
 127 #include "es3fFloatStateQueryTests.hpp"
 128 #include "es3fTextureStateQueryTests.hpp"
 129 #include "es3fStringQueryTests.hpp"
 130 #include "es3fSamplerStateQueryTests.hpp"
 131 #include "es3fBufferObjectQueryTests.hpp"
 132 #include "es3fFboStateQueryTests.hpp"
 133 #include "es3fRboStateQueryTests.hpp"
 134 #include "es3fShaderStateQueryTests.hpp"
 135 #include "es3fInternalFormatQueryTests.hpp"
 136 #include "es3fIndexedStateQueryTests.hpp"
 137
 138 #include "es3fReadPixelsTests.hpp"
 139
 140 #include "glsShaderLibrary.hpp"
 141
 142 namespace deqp
 143 {
 144 namespace gles3
 145 {
 146 namespace Functional
 147 {
 148
 149 class ShaderLibraryTest : public TestCaseGroup
 150 {
 151 public:
 152         ShaderLibraryTest (Context& context, const char* name, const char* description)
 153                 : TestCaseGroup(context, name, description)
 154         {
 155         }
 156
 157         void init (void)
 158         {
 159                 gls::ShaderLibrary                      shaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
 160                 std::string                                     fileName        = std::string("shaders/") + getName() + ".test";
 161                 std::vector<tcu::TestNode*>     children        = shaderLibrary.loadShaderFile(fileName.c_str());
 162
 163                 for (int i = 0; i < (int)children.size(); i++)
 164                         addChild(children[i]);
 165         }
 166 };
 167
 168 class ShaderBuiltinFunctionTests : public TestCaseGroup
 169 {
 170 public:
 171         ShaderBuiltinFunctionTests (Context& context)
 172                 : TestCaseGroup(context, "builtin_functions", "Built-in Function Tests")
 173         {
 174         }
 175
 176         void init (void)
 177         {
 178                 addChild(new ShaderCommonFunctionTests  (m_context));
 179                 addChild(new ShaderPackingFunctionTests (m_context));
 180                 addChild(createBuiltinPrecisionTests    (m_context));
 181         }
 182 };
 183
 184 class ShaderTests : public TestCaseGroup
 185 {
 186 public:
 187         ShaderTests (Context& context)
 188                 : TestCaseGroup(context, "shaders", "Shading Language Tests")
 189         {
 190         }
 191
 192         void init (void)
 193         {
 194                 addChild(new ShaderLibraryTest                  (m_context, "preprocessor",                     "Preprocessor Tests"));
 195                 addChild(new ShaderLibraryTest                  (m_context, "constants",                        "Constant Literal Tests"));
 196                 addChild(new ShaderLibraryTest                  (m_context, "linkage",                          "Linkage Tests"));
 197                 addChild(new ShaderLibraryTest                  (m_context, "conversions",                      "Type Conversion Tests"));
 198                 addChild(new ShaderLibraryTest                  (m_context, "conditionals",                     "Conditionals Tests"));
 199                 addChild(new ShaderLibraryTest                  (m_context, "declarations",                     "Declarations Tests"));
 200                 addChild(new ShaderLibraryTest                  (m_context, "swizzles",                         "Swizzle Tests"));
 201                 addChild(new ShaderLibraryTest                  (m_context, "functions",                        "Function Tests"));
 202                 addChild(new ShaderLibraryTest                  (m_context, "arrays",                           "Array Tests"));
 203                 addChild(new ShaderLibraryTest                  (m_context, "keywords",                         "Keyword Tests"));
 204                 addChild(new ShaderLibraryTest                  (m_context, "qualification_order",      "Order Of Qualification Tests"));
 205                 addChild(new ShaderLibraryTest                  (m_context, "scoping",                          "Scoping of Declarations"));
 206                 addChild(new ShaderLibraryTest                  (m_context, "negative",                         "Miscellaneous Negative Shader Compilation Tests"));
 207                 addChild(new ShaderLibraryTest                  (m_context, "uniform_block",            "Uniform block tests"));
 208
 209                 addChild(new ShaderDiscardTests                 (m_context));
 210                 addChild(new ShaderIndexingTests                (m_context));
 211                 addChild(new ShaderLoopTests                    (m_context));
 212                 addChild(new ShaderOperatorTests                (m_context));
 213                 addChild(new ShaderMatrixTests                  (m_context));
 214                 addChild(new ShaderReturnTests                  (m_context));
 215                 addChild(new ShaderStructTests                  (m_context));
 216                 addChild(new ShaderSwitchTests                  (m_context));
 217                 addChild(new FragDepthTests                             (m_context));
 218                 addChild(new ShaderPrecisionTests               (m_context));
 219                 addChild(new ShaderBuiltinVarTests              (m_context));
 220                 addChild(new ShaderTextureFunctionTests (m_context)); // \todo [pyry] Move to builtin?
 221                 addChild(new ShaderDerivateTests                (m_context)); // \todo [pyry] Move to builtin?
 222                 addChild(new ShaderBuiltinFunctionTests (m_context));
 223                 addChild(new ShaderInvarianceTests              (m_context));
 224                 addChild(new ShaderFragDataTests                (m_context));
 225                 addChild(new ShaderConstExprTests               (m_context));
 226
 227                 addChild(new RandomShaderTests                  (m_context));
 228         }
 229 };
 230
 231 class TextureTests : public TestCaseGroup
 232 {
 233 public:
 234         TextureTests (Context& context)
 235                 : TestCaseGroup(context, "texture", "Texture Tests")
 236         {
 237         }
 238
 239         void init (void)
 240         {
 241                 addChild(new TextureFormatTests                 (m_context));
 242                 addChild(new TextureSizeTests                   (m_context));
 243                 addChild(new TextureWrapTests                   (m_context));
 244                 addChild(new TextureFilteringTests              (m_context));
 245                 addChild(new TextureMipmapTests                 (m_context));
 246                 addChild(new TextureSwizzleTests                (m_context));
 247                 addChild(new TextureShadowTests                 (m_context));
 248                 addChild(new TextureSpecificationTests  (m_context));
 249                 addChild(new VertexTextureTests                 (m_context));
 250                 addChild(new TextureUnitTests                   (m_context));
 251                 addChild(new CompressedTextureTests             (m_context));
 252         }
 253 };
 254
 255 class FboTests : public TestCaseGroup
 256 {
 257 public:
 258         FboTests (Context& context)
 259                 : TestCaseGroup(context, "fbo", "Framebuffer Object Tests")
 260         {
 261         }
 262
 263         void init (void)
 264         {
 265                 addChild(new FboApiTests                        (m_context));
 266                 addChild(createFboCompletenessTests     (m_context));
 267                 addChild(new FboRenderTestGroup         (m_context));
 268                 addChild(new FboColorTests                      (m_context));
 269                 addChild(new FboDepthTests                      (m_context));
 270                 addChild(new FboStencilTests            (m_context));
 271                 addChild(new FramebufferBlitTests       (m_context));
 272                 addChild(new FboMultisampleTests        (m_context));
 273                 addChild(new FboInvalidateTests         (m_context));
 274         }
 275 };
 276
 277 class BufferTests : public TestCaseGroup
 278 {
 279 public:
 280         BufferTests (Context& context)
 281                 : TestCaseGroup(context, "buffer", "Buffer object tests")
 282         {
 283         }
 284
 285         void init (void)
 286         {
 287                 addChild(new BufferWriteTests   (m_context));
 288                 addChild(new BufferMapTests             (m_context));
 289                 addChild(new BufferCopyTests    (m_context));
 290         }
 291 };
 292
 293 class NegativeApiTestGroup : public TestCaseGroup
 294 {
 295 public:
 296         NegativeApiTestGroup (Context& context)
 297                 : TestCaseGroup(context, "negative_api", "Negative API Tests")
 298         {
 299         }
 300
 301         virtual ~NegativeApiTestGroup (void)
 302         {
 303         }
 304
 305         virtual void init (void)
 306         {
 307                 addChild(new NegativeBufferApiTests                     (m_context));
 308                 addChild(new NegativeTextureApiTests            (m_context));
 309                 addChild(new NegativeShaderApiTests                     (m_context));
 310                 addChild(new NegativeFragmentApiTests           (m_context));
 311                 addChild(new NegativeVertexArrayApiTests        (m_context));
 312                 addChild(new NegativeStateApiTests                      (m_context));
 313         }
 314 };
 315
 316 class FragmentOpTests : public TestCaseGroup
 317 {
 318 public:
 319         FragmentOpTests (Context& context)
 320                 : TestCaseGroup(context, "fragment_ops", "Per-Fragment Operation Tests")
 321         {
 322         }
 323
 324         void init (void)
 325         {
 326                 addChild(new DepthTests                         (m_context));
 327                 addChild(new StencilTests                       (m_context));
 328                 addChild(new DepthStencilTests          (m_context));
 329                 addChild(new BlendTests                         (m_context));
 330                 addChild(new RandomFragmentOpTests      (m_context));
 331                 addChild(new FragOpInteractionTests     (m_context));
 332                 addChild(new ScissorTests                       (m_context));
 333         }
 334 };
 335
 336 class StateQueryTests : public TestCaseGroup
 337 {
 338 public:
 339         StateQueryTests (Context& context)
 340                 : TestCaseGroup(context, "state_query", "State Query Tests")
 341         {
 342         }
 343
 344         void init (void)
 345         {
 346                 addChild(new BooleanStateQueryTests             (m_context));
 347                 addChild(new IntegerStateQueryTests             (m_context));
 348                 addChild(new Integer64StateQueryTests   (m_context));
 349                 addChild(new FloatStateQueryTests               (m_context));
 350                 addChild(new IndexedStateQueryTests             (m_context));
 351                 addChild(new TextureStateQueryTests             (m_context));
 352                 addChild(new StringQueryTests                   (m_context));
 353                 addChild(new SamplerStateQueryTests             (m_context));
 354                 addChild(new BufferObjectQueryTests             (m_context));
 355                 addChild(new FboStateQueryTests                 (m_context));
 356                 addChild(new RboStateQueryTests                 (m_context));
 357                 addChild(new ShaderStateQueryTests              (m_context));
 358                 addChild(new InternalFormatQueryTests   (m_context));
 359         }
 360 };
 361
 362 FunctionalTests::FunctionalTests (Context& context)
 363         : TestCaseGroup(context, "functional", "Functionality Tests")
 364 {
 365 }
 366
 367 FunctionalTests::~FunctionalTests (void)
 368 {
 369 }
 370
 371 void FunctionalTests::init (void)
 372 {
 373         addChild(new PrerequisiteTests                          (m_context));
 374         addChild(new ImplementationLimitTests           (m_context));
 375         addChild(new ColorClearTest                                     (m_context));
 376         addChild(new DepthStencilClearTests                     (m_context));
 377         addChild(new BufferTests                                        (m_context));
 378         addChild(new ShaderTests                                        (m_context));
 379         addChild(new TextureTests                                       (m_context));
 380         addChild(new FragmentOpTests                            (m_context));
 381         addChild(new FboTests                                           (m_context));
 382         addChild(new VertexArrayTestGroup                       (m_context));
 383         addChild(new UniformBlockTests                          (m_context));
 384         addChild(new UniformApiTests                            (m_context));
 385         addChild(createAttributeLocationTests           (m_context));
 386         addChild(new FragmentOutputTests                        (m_context));
 387         addChild(new SamplerObjectTests                         (m_context));
 388         addChild(new PixelBufferObjectTests                     (m_context));
 389         addChild(new RasterizationTests                         (m_context));
 390         addChild(new OcclusionQueryTests                        (m_context));
 391         addChild(new VertexArrayObjectTestGroup         (m_context));
 392         addChild(new PrimitiveRestartTests                      (m_context));
 393         addChild(new InstancedRenderingTests            (m_context));
 394         addChild(new RasterizerDiscardTests                     (m_context));
 395         addChild(new TransformFeedbackTests                     (m_context));
 396         addChild(new SyncTests                                          (m_context));
 397         addChild(new ShaderApiTests                                     (m_context));
 398         addChild(new NegativeApiTestGroup                       (m_context));
 399         addChild(new MultisampleTests                           (m_context));
 400         addChild(new ReadPixelsTests                            (m_context));
 401         addChild(new DitheringTests                                     (m_context));
 402         addChild(new StateQueryTests                            (m_context));
 403         addChild(new ClippingTests                                      (m_context));
 404         addChild(new PolygonOffsetTests                         (m_context));
 405         addChild(new DrawTests                                          (m_context));
 406         addChild(new FlushFinishTests                           (m_context));
 407         addChild(new DefaultVertexAttributeTests        (m_context));
 408         addChild(createLifetimeTests                            (m_context));
 409         addChild(new DefaultVertexArrayObjectTests      (m_context));
 410 }
 411
 412 } // Functional
 413 } // gles3
 414 } // deqp