text: #ifndef _GL4CGLSPIRVTESTS_HPP
  #define _GL4CGLSPIRVTESTS_HPP
  /*-------------------------------------------------------------------------
   * OpenGL Conformance Test Suite
   * -----------------------------
   *
   * Copyright (c) 2017 The Khronos Group Inc.
   *
   * 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
   */ /*-------------------------------------------------------------------*/
  
  /**
   */ /*!
   * \file  gl4cGlSpirvTests.hpp
   * \brief Conformance tests for the GL_ARB_gl_spirv functionality.
   */ /*-------------------------------------------------------------------*/
  
  #include "../common/glcSpirvUtils.hpp"
  #include "glcTestCase.hpp"
  #include "gluShaderProgram.hpp"
  #include "glwDefs.hpp"
  #include "tcuDefs.hpp"
  #include <map>
  #include <vector>
  
  using namespace glu;
  using namespace glw;
  using namespace glc;
  
  namespace gl4cts
  {
  
  typedef std::vector<std::string> CapabilitiesVec;
  
  /**  Verifies if using SPIR-V modules for each shader stage works as expected. */
  class SpirvModulesPositiveTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvModulesPositiveTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	GLuint m_texture;
  	GLuint m_fbo;
  
  	std::string m_vertex;
  	std::string m_tesselationCtrl;
  	std::string m_tesselationEval;
  	std::string m_geometry;
  	std::string m_fragment;
  };
  
  /**  Verifies if one binary module can be associated with multiple shader objects. */
  class SpirvShaderBinaryMultipleShaderObjectsTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvShaderBinaryMultipleShaderObjectsTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	std::string m_spirv;
  };
  
  /**  Verifies if state queries for new features added by ARB_gl_spirv works as expected. */
  class SpirvModulesStateQueriesTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvModulesStateQueriesTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	std::string m_vertex;
  };
  
  /**  Verifies if new features added by ARB_gl_spirv generate error messages as expected. */
  class SpirvModulesErrorVerificationTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvModulesErrorVerificationTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	std::string m_vertex;
  
  	GLuint m_glslShaderId;
  	GLuint m_spirvShaderId;
  	GLuint m_programId;
  	GLuint m_textureId;
  };
  
  /**  Verifies if GLSL to Spir-V converter supports Spir-V features. */
  class SpirvGlslToSpirVEnableTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvGlslToSpirVEnableTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	std::string m_vertex;
  };
  
  /**  Verifies if GLSL built-in functions are supported by Spir-V. */
  class SpirvGlslToSpirVBuiltInFunctionsTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvGlslToSpirVBuiltInFunctionsTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  	void initMappings();
  
  	/* Private members */
  	SpirVMapping m_mappings;
  
  	std::string				  m_commonVertex;
  	std::string				  m_commonTessEval;
  	std::vector<ShaderSource> m_sources;
  };
  
  /**  Verifies if constant specialization feature works as expected. */
  class SpirvGlslToSpirVSpecializationConstantsTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvGlslToSpirVSpecializationConstantsTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private:
  	/* Private methods */
  
  	/* Private members */
  	GLuint m_texture;
  	GLuint m_fbo;
  
  	std::string m_vertex;
  	std::string m_fragment;
  };
  
  /**  Verifies if Spir-V built in variable decorations works as expected. */
  class SpirvValidationBuiltInVariableDecorationsTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvValidationBuiltInVariableDecorationsTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  private: /* Private structs */
  	struct ValidationOutputStruct
  	{
  		GLubyte x, y, z;
  		GLuint  value;
  
  		ValidationOutputStruct() : x(0), y(0), z(0), value(0)
  		{
  		}
  
  		ValidationOutputStruct(GLubyte _x, GLubyte _y, GLuint _value) : x(_x), y(_y), z(0), value(_value)
  		{
  		}
  
  		ValidationOutputStruct(GLubyte _x, GLubyte _y, GLubyte _z, GLuint _value) : x(_x), y(_y), z(_z), value(_value)
  		{
  		}
  	};
  
  	typedef std::vector<ValidationOutputStruct> ValidationOutputVec;
  
  	typedef bool (SpirvValidationBuiltInVariableDecorationsTest::*ValidationFuncPtr)(ValidationOutputVec& outputs);
  
  	struct ValidationStruct
  	{
  		std::vector<ShaderSource> shaders;
  		ValidationOutputVec		  outputs;
  		ValidationFuncPtr		  validationFuncPtr;
  
  		ValidationStruct() : validationFuncPtr(DE_NULL)
  		{
  		}
  
  		ValidationStruct(ValidationFuncPtr funcPtr) : validationFuncPtr(funcPtr)
  		{
  		}
  	};
  
  	/* Private methods */
  	bool validComputeFunc(ValidationOutputVec& outputs);
  	bool validPerVertexFragFunc(ValidationOutputVec& outputs);
  	bool validPerVertexPointFunc(ValidationOutputVec& outputs);
  	bool validTesselationGeometryFunc(ValidationOutputVec& outputs);
  	bool validMultiSamplingFunc(ValidationOutputVec& outputs);
  
  	/* Private members */
  	SpirVMapping m_mappings;
  
  	std::vector<ValidationStruct> m_validations;
  
  	std::string m_compute;
  	std::string m_vertex;
  	std::string m_tesselationCtrl;
  	std::string m_tesselationEval;
  	std::string m_geometry;
  	std::string m_fragment;
  };
  
  /**  Verifies if Spir-V capabilities works as expected. */
  class SpirvValidationCapabilitiesTest : public deqp::TestCase
  {
  public:
  	/* Public methods */
  	SpirvValidationCapabilitiesTest(deqp::Context& context);
  
  	void init();
  	void deinit();
  
  	tcu::TestNode::IterateResult iterate();
  
  	int spirVCapabilityCutOff(std::string spirVSrcInput, std::string& spirVSrcOutput, CapabilitiesVec& capabilities,
  							  int& currentCapability);
  
  private:
  	typedef std::map<glu::ShaderType, CapabilitiesVec> CapabilitiesMap;
  
  	struct ShaderStage
  	{
  		std::string		name;
  		ShaderSource	source;
  		ShaderBinary	binary;
  		CapabilitiesVec caps;
  
  		ShaderStage()
  		{
  		}
  
  		ShaderStage(std::string _name) : name(_name)
  		{
  		}
  	};
  
  	typedef std::vector<ShaderStage> Pipeline;
  
  	/* Private methods */
  
  	/* Private members */
  	std::vector<Pipeline> m_pipelines;
  };
  
  /** Test group which encapsulates all sparse buffer conformance tests */
  class GlSpirvTests : public deqp::TestCaseGroup
  {
  public:
  	/* Public methods */
  	GlSpirvTests(deqp::Context& context);
  
  	void init();
  
  private:
  	GlSpirvTests(const GlSpirvTests& other);
  	GlSpirvTests& operator=(const GlSpirvTests& other);
  };
  
  } /* glcts namespace */
  
  #endif // _GL4CGLSPIRVTESTS_HPP
  