You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
349 lines
11 KiB
349 lines
11 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 2.0 Module
|
|
* -------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief Base class for a test case.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es2fFunctionalTests.hpp"
|
|
|
|
#include "es2fColorClearTest.hpp"
|
|
#include "es2fLightAmountTest.hpp"
|
|
#include "es2fMultisampledRenderToTextureTests.hpp"
|
|
#include "es2fShaderExecuteTest.hpp"
|
|
#include "es2fFboApiTest.hpp"
|
|
#include "es2fFboRenderTest.hpp"
|
|
#include "es2fFboCompletenessTests.hpp"
|
|
#include "es2fRandomShaderTests.hpp"
|
|
#include "es2fPrerequisiteTests.hpp"
|
|
#include "es2fDepthTests.hpp"
|
|
#include "es2fStencilTests.hpp"
|
|
#include "es2fScissorTests.hpp"
|
|
#include "es2fVertexArrayTest.hpp"
|
|
#include "es2fRasterizationTests.hpp"
|
|
#include "es2fDepthStencilClearTests.hpp"
|
|
#include "es2fDepthStencilTests.hpp"
|
|
#include "es2fBlendTests.hpp"
|
|
#include "es2fRandomFragmentOpTests.hpp"
|
|
#include "es2fMultisampleTests.hpp"
|
|
#include "es2fUniformApiTests.hpp"
|
|
#include "es2fBufferWriteTests.hpp"
|
|
#include "es2fImplementationLimitTests.hpp"
|
|
#include "es2fDepthRangeTests.hpp"
|
|
#include "es2fDitheringTests.hpp"
|
|
#include "es2fClippingTests.hpp"
|
|
#include "es2fClipControlTests.hpp"
|
|
#include "es2fPolygonOffsetTests.hpp"
|
|
#include "es2fDrawTests.hpp"
|
|
#include "es2fFragOpInteractionTests.hpp"
|
|
#include "es2fFlushFinishTests.hpp"
|
|
#include "es2fDefaultVertexAttributeTests.hpp"
|
|
#include "es2fLifetimeTests.hpp"
|
|
|
|
#include "es2fTextureFormatTests.hpp"
|
|
#include "es2fTextureWrapTests.hpp"
|
|
#include "es2fTextureFilteringTests.hpp"
|
|
#include "es2fTextureMipmapTests.hpp"
|
|
#include "es2fTextureSizeTests.hpp"
|
|
#include "es2fTextureSpecificationTests.hpp"
|
|
#include "es2fTextureCompletenessTests.hpp"
|
|
#include "es2fNegativeVertexArrayApiTests.hpp"
|
|
#include "es2fNegativeTextureApiTests.hpp"
|
|
#include "es2fNegativeFragmentApiTests.hpp"
|
|
#include "es2fNegativeBufferApiTests.hpp"
|
|
#include "es2fNegativeShaderApiTests.hpp"
|
|
#include "es2fNegativeStateApiTests.hpp"
|
|
#include "es2fVertexTextureTests.hpp"
|
|
#include "es2fTextureUnitTests.hpp"
|
|
|
|
#include "es2fShaderApiTests.hpp"
|
|
#include "es2fShaderAlgorithmTests.hpp"
|
|
#include "es2fShaderBuiltinVarTests.hpp"
|
|
#include "es2fShaderConstExprTests.hpp"
|
|
#include "es2fShaderDiscardTests.hpp"
|
|
#include "es2fShaderIndexingTests.hpp"
|
|
#include "es2fShaderLoopTests.hpp"
|
|
#include "es2fShaderOperatorTests.hpp"
|
|
#include "es2fShaderReturnTests.hpp"
|
|
#include "es2fShaderStructTests.hpp"
|
|
#include "es2fShaderMatrixTests.hpp"
|
|
#include "es2fShaderTextureFunctionTests.hpp"
|
|
#include "es2fAttribLocationTests.hpp"
|
|
#include "es2fShaderInvarianceTests.hpp"
|
|
#include "es2fShaderFragDataTests.hpp"
|
|
|
|
// State query tests
|
|
#include "es2fBooleanStateQueryTests.hpp"
|
|
#include "es2fIntegerStateQueryTests.hpp"
|
|
#include "es2fFloatStateQueryTests.hpp"
|
|
#include "es2fTextureStateQueryTests.hpp"
|
|
#include "es2fStringQueryTests.hpp"
|
|
#include "es2fBufferObjectQueryTests.hpp"
|
|
#include "es2fFboStateQueryTests.hpp"
|
|
#include "es2fRboStateQueryTests.hpp"
|
|
#include "es2fShaderStateQueryTests.hpp"
|
|
|
|
#include "es2fReadPixelsTests.hpp"
|
|
#include "es2fDebugMarkerTests.hpp"
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles2
|
|
{
|
|
namespace Functional
|
|
{
|
|
|
|
// ShadersTestGroup
|
|
|
|
class ShadersTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
ShadersTestGroup (Context& context)
|
|
: TestCaseGroup(context, "shaders", "Shader Tests")
|
|
{
|
|
}
|
|
|
|
virtual ~ShadersTestGroup (void)
|
|
{
|
|
}
|
|
|
|
virtual void init (void)
|
|
{
|
|
addChild(new ShaderExecuteTest(m_context, "preprocessor", "Preprocessor Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "constants", "Constant Literal Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "linkage", "Linkage Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "conversions", "Type Conversion Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "conditionals", "Conditionals Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "declarations", "Declarations Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "swizzles", "Swizzle Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "functions", "Function Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "keywords", "Keyword Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "reserved_operators", "Reserved Operator Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "qualification_order", "Order of Qualification Tests"));
|
|
addChild(new ShaderExecuteTest(m_context, "scoping", "Scoping of Declarations"));
|
|
addChild(new ShaderExecuteTest(m_context, "invalid_implicit_conversions", "Invalid Implicit Conversions"));
|
|
addChild(new ShaderExecuteTest(m_context, "misc", "Miscellaneous Tests"));
|
|
|
|
|
|
addChild(new ShaderIndexingTests (m_context));
|
|
addChild(new ShaderLoopTests (m_context));
|
|
addChild(new ShaderOperatorTests (m_context));
|
|
addChild(new ShaderMatrixTests (m_context));
|
|
addChild(new ShaderReturnTests (m_context));
|
|
addChild(new ShaderDiscardTests (m_context));
|
|
addChild(new ShaderStructTests (m_context));
|
|
addChild(new ShaderBuiltinVarTests (m_context));
|
|
addChild(new ShaderTextureFunctionTests (m_context));
|
|
addChild(new ShaderInvarianceTests (m_context));
|
|
addChild(new ShaderFragDataTests (m_context));
|
|
addChild(new ShaderAlgorithmTests (m_context));
|
|
addChild(new ShaderConstExprTests (m_context));
|
|
|
|
addChild(new RandomShaderTests(m_context));
|
|
}
|
|
};
|
|
|
|
// TextureTestGroup
|
|
|
|
class TextureTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
TextureTestGroup (Context& context)
|
|
: TestCaseGroup(context, "texture", "Texture Tests")
|
|
{
|
|
}
|
|
|
|
virtual ~TextureTestGroup (void)
|
|
{
|
|
}
|
|
|
|
virtual void init (void)
|
|
{
|
|
addChild(new TextureFormatTests (m_context));
|
|
addChild(new TextureSizeTests (m_context));
|
|
addChild(new TextureWrapTests (m_context));
|
|
addChild(new TextureFilteringTests (m_context));
|
|
addChild(new TextureMipmapTests (m_context));
|
|
addChild(new TextureSpecificationTests (m_context));
|
|
addChild(new TextureCompletenessTests (m_context));
|
|
addChild(new VertexTextureTests (m_context));
|
|
addChild(new TextureUnitTests (m_context));
|
|
}
|
|
|
|
virtual void deinit (void)
|
|
{
|
|
}
|
|
};
|
|
|
|
class BufferTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
BufferTests (Context& context)
|
|
: TestCaseGroup(context, "buffer", "Buffer object tests")
|
|
{
|
|
}
|
|
|
|
void init (void)
|
|
{
|
|
addChild(new BufferWriteTests(m_context));
|
|
}
|
|
};
|
|
|
|
// FboTestGroup
|
|
|
|
class FboTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
FboTestGroup (Context& context)
|
|
: TestCaseGroup(context, "fbo", "Framebuffer Object Tests")
|
|
{
|
|
}
|
|
|
|
virtual ~FboTestGroup (void)
|
|
{
|
|
}
|
|
|
|
virtual void init (void)
|
|
{
|
|
addChild(new FboApiTestGroup(m_context));
|
|
addChild(new FboRenderTestGroup(m_context));
|
|
addChild(createFboCompletenessTests(m_context));
|
|
}
|
|
};
|
|
|
|
// NegativeApiTestGroup
|
|
|
|
class NegativeApiTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
NegativeApiTestGroup (Context& context)
|
|
: TestCaseGroup(context, "negative_api", "Negative API Tests")
|
|
{
|
|
}
|
|
|
|
virtual ~NegativeApiTestGroup (void)
|
|
{
|
|
}
|
|
|
|
virtual void init (void)
|
|
{
|
|
addChild(new NegativeBufferApiTests (m_context));
|
|
addChild(new NegativeFragmentApiTests (m_context));
|
|
addChild(new NegativeShaderApiTests (m_context));
|
|
addChild(new NegativeStateApiTests (m_context));
|
|
addChild(new NegativeTextureApiTests (m_context));
|
|
addChild(new NegativeVertexArrayApiTests (m_context));
|
|
}
|
|
};
|
|
|
|
// FragmentOpTests
|
|
|
|
class FragmentOpTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
FragmentOpTests (Context& context)
|
|
: TestCaseGroup(context, "fragment_ops", "Per-Fragment Operation Tests")
|
|
{
|
|
}
|
|
|
|
void init (void)
|
|
{
|
|
addChild(new DepthTests (m_context));
|
|
addChild(new StencilTests (m_context));
|
|
addChild(new DepthStencilTests (m_context));
|
|
addChild(new ScissorTests (m_context));
|
|
addChild(new BlendTests (m_context));
|
|
addChild(new RandomFragmentOpTests (m_context));
|
|
addChild(new FragOpInteractionTests (m_context));
|
|
}
|
|
};
|
|
|
|
// StateQueryTests
|
|
|
|
class StateQueryTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
StateQueryTests (Context& context)
|
|
: TestCaseGroup(context, "state_query", "State Query Tests")
|
|
{
|
|
}
|
|
|
|
void init (void)
|
|
{
|
|
addChild(new BooleanStateQueryTests (m_context));
|
|
addChild(new IntegerStateQueryTests (m_context));
|
|
addChild(new FloatStateQueryTests (m_context));
|
|
addChild(new TextureStateQueryTests (m_context));
|
|
addChild(new StringQueryTests (m_context));
|
|
addChild(new BufferObjectQueryTests (m_context));
|
|
addChild(new FboStateQueryTests (m_context));
|
|
addChild(new RboStateQueryTests (m_context));
|
|
addChild(new ShaderStateQueryTests (m_context));
|
|
}
|
|
};
|
|
|
|
// FunctionalTestGroup
|
|
|
|
FunctionalTests::FunctionalTests (Context& context)
|
|
: TestCaseGroup(context, "functional", "Functionality Tests")
|
|
{
|
|
}
|
|
|
|
FunctionalTests::~FunctionalTests (void)
|
|
{
|
|
}
|
|
|
|
void FunctionalTests::init (void)
|
|
{
|
|
addChild(new PrerequisiteTests (m_context));
|
|
addChild(new ImplementationLimitTests (m_context));
|
|
addChild(new ClipControlTests (m_context));
|
|
addChild(new ColorClearTest (m_context));
|
|
addChild(new DepthStencilClearTests (m_context));
|
|
addChild(new BufferTests (m_context));
|
|
addChild(new LightAmountTest (m_context));
|
|
addChild(new MultisampledRenderToTextureTests(m_context));
|
|
addChild(new ShadersTestGroup (m_context));
|
|
addChild(new TextureTestGroup (m_context));
|
|
addChild(new FragmentOpTests (m_context));
|
|
addChild(new FboTestGroup (m_context));
|
|
addChild(new VertexArrayTestGroup (m_context));
|
|
addChild(new ShaderApiTests (m_context));
|
|
addChild(new NegativeApiTestGroup (m_context));
|
|
addChild(new RasterizationTests (m_context));
|
|
addChild(createAttributeLocationTests (m_context));
|
|
addChild(new MultisampleTests (m_context));
|
|
addChild(new UniformApiTests (m_context));
|
|
addChild(new ReadPixelsTests (m_context));
|
|
addChild(new DepthRangeTests (m_context));
|
|
addChild(new DitheringTests (m_context));
|
|
addChild(new StateQueryTests (m_context));
|
|
addChild(new ClippingTests (m_context));
|
|
addChild(new PolygonOffsetTests (m_context));
|
|
addChild(new DrawTests (m_context));
|
|
addChild(new FlushFinishTests (m_context));
|
|
addChild(new DefaultVertexAttributeTests(m_context));
|
|
addChild(createLifetimeTests (m_context));
|
|
addChild(createDebugMarkerTests (m_context));
|
|
}
|
|
|
|
} // Functional
|
|
} // gles2
|
|
} // deqp
|