Merge aosp/upstream-vulkan-cts-1.0-dev into aosp/master

Change-Id: I8c82777d467d18369f7e461fd2da1dc2045fc52b

diff --combined Android.mk
index 952394b,6cedb9c..f8488ac
--- 1/Android.mk
--- 2/Android.mk
+++ b/Android.mk
@@@ -67,6 -67,7 +67,7 @@@ LOCAL_SRC_FILES := 
        framework/common/tcuSeedBuilder.cpp \
        framework/common/tcuStringTemplate.cpp \
        framework/common/tcuSurface.cpp \
+       framework/common/tcuSurfaceAccess.cpp \
        framework/common/tcuTestCase.cpp \
        framework/common/tcuTestContext.cpp \
        framework/common/tcuTestHierarchyIterator.cpp \
@@@ -188,6 -189,7 +189,7 @@@
        framework/opengl/gluStateReset.cpp \
        framework/opengl/gluStrUtil.cpp \
        framework/opengl/gluTexture.cpp \
+       framework/opengl/gluTextureTestUtil.cpp \
        framework/opengl/gluTextureUtil.cpp \
        framework/opengl/gluVarType.cpp \
        framework/opengl/gluVarTypeUtil.cpp \
@@@ -976,4 -978,4 +978,4 @@@ include $(BUILD_SHARED_LIBRARY
  # Build the test APKs using their own makefiles
  # include $(call all-makefiles-under,$(LOCAL_PATH)/android)
  
 -include $(LOCAL_PATH)/android/package/Android.mk
 +include $(LOCAL_PATH)/android/package/Android.mk $(LOCAL_PATH)/android/cts/Android.mk

diff --combined modules/gles31/functional/es31fNegativeShaderImageLoadStoreTests.cpp
index eb6e6c8,e0622f2..25f59ef
--- 1/modules/gles31/functional/es31fNegativeShaderImageLoadStoreTests.cpp
--- 2/modules/gles31/functional/es31fNegativeShaderImageLoadStoreTests.cpp
+++ b/modules/gles31/functional/es31fNegativeShaderImageLoadStoreTests.cpp
@@@ -82,6 -82,16 +82,6 @@@ static const glu::ShaderType s_shaders[
        glu::SHADERTYPE_COMPUTE
  };
  
 -static const glu::TextureTestUtil::TextureType s_imageTypes[] =
 -{
 -      glu::TextureTestUtil::TEXTURETYPE_2D,
 -      glu::TextureTestUtil::TEXTURETYPE_3D,
 -      glu::TextureTestUtil::TEXTURETYPE_CUBE,
 -      glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY,
 -      glu::TextureTestUtil::TEXTURETYPE_BUFFER,
 -      glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY
 -};
 -
  std::string getShaderImageLayoutQualifier (const tcu::TextureFormat& format)
  {
        std::ostringstream qualifier;
@@@ -115,7 -125,7 +115,7 @@@
        return qualifier.str();
  }
  
- std::string getShaderImageTypeDeclaration (const tcu::TextureFormat& format, gls::TextureTestUtil::TextureType imageType)
+ std::string getShaderImageTypeDeclaration (const tcu::TextureFormat& format, glu::TextureTestUtil::TextureType imageType)
  {
        std::ostringstream declaration;
  
@@@ -143,12 -153,12 +143,12 @@@
  
        switch(imageType)
        {
-               case gls::TextureTestUtil::TEXTURETYPE_2D:                      declaration << "2D";                    break;
-               case gls::TextureTestUtil::TEXTURETYPE_3D:                      declaration << "3D";                    break;
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE:            declaration << "Cube";                  break;
-               case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY:        declaration << "2DArray";               break;
-               case gls::TextureTestUtil::TEXTURETYPE_BUFFER:          declaration << "Buffer";                break;
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:      declaration << "CubeArray";             break;
+               case glu::TextureTestUtil::TEXTURETYPE_2D:                      declaration << "2D";                    break;
+               case glu::TextureTestUtil::TEXTURETYPE_3D:                      declaration << "3D";                    break;
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE:            declaration << "Cube";                  break;
+               case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:        declaration << "2DArray";               break;
+               case glu::TextureTestUtil::TEXTURETYPE_BUFFER:          declaration << "Buffer";                break;
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:      declaration << "CubeArray";             break;
                default:
                        DE_ASSERT(false);
                        return std::string("");
@@@ -157,24 -167,24 +157,24 @@@
        return declaration.str();
  }
  
- std::string getShaderImageTypeExtensionString (gls::TextureTestUtil::TextureType imageType)
+ std::string getShaderImageTypeExtensionString (glu::TextureTestUtil::TextureType imageType)
  {
        std::string extension;
  
        switch(imageType)
        {
-               case gls::TextureTestUtil::TEXTURETYPE_2D:
-               case gls::TextureTestUtil::TEXTURETYPE_3D:
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE:
-               case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
+               case glu::TextureTestUtil::TEXTURETYPE_2D:
+               case glu::TextureTestUtil::TEXTURETYPE_3D:
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE:
+               case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
                        extension = "";
                        break;
  
-               case gls::TextureTestUtil::TEXTURETYPE_BUFFER:
+               case glu::TextureTestUtil::TEXTURETYPE_BUFFER:
                        extension = "#extension GL_EXT_texture_buffer : enable";
                        break;
  
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
                        extension = "#extension GL_EXT_texture_cube_map_array : enable";
                        break;
  
@@@ -186,20 -196,20 +186,20 @@@
        return extension;
  }
  
- std::string getShaderImageParamP (gls::TextureTestUtil::TextureType imageType)
+ std::string getShaderImageParamP (glu::TextureTestUtil::TextureType imageType)
  {
        switch(imageType)
        {
-               case gls::TextureTestUtil::TEXTURETYPE_2D:
+               case glu::TextureTestUtil::TEXTURETYPE_2D:
                        return "ivec2(1, 1)";
  
-               case gls::TextureTestUtil::TEXTURETYPE_3D:
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE:
-               case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
-               case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
+               case glu::TextureTestUtil::TEXTURETYPE_3D:
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE:
+               case glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY:
+               case glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY:
                        return "ivec3(1, 1, 1)";
  
-               case gls::TextureTestUtil::TEXTURETYPE_BUFFER:
+               case glu::TextureTestUtil::TEXTURETYPE_BUFFER:
                        return "1";
  
                default:
@@@ -339,7 -349,7 +339,7 @@@ std::string getFunctionName (ImageOpera
        return std::string("");
  }
  
- std::string generateShaderSource (ImageOperation function, MemoryQualifier memory, gls::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format, glu::ShaderType shaderType)
+ std::string generateShaderSource (ImageOperation function, MemoryQualifier memory, glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format, glu::ShaderType shaderType)
  {
        const char* shaderTemplate =    "${GLSL_VERSION_DECL}\n"
                                                                        "${GLSL_TYPE_EXTENSION}\n"
@@@ -367,7 -377,7 +367,7 @@@
        return tcu::StringTemplate(shaderTemplate).specialize(params);
  }
  
- void testShader (NegativeTestContext& ctx, ImageOperation function, MemoryQualifier memory, gls::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format)
+ void testShader (NegativeTestContext& ctx, ImageOperation function, MemoryQualifier memory, glu::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format)
  {
        tcu::TestLog& log = ctx.getLog();
        ctx.beginSection(getFunctionName(function) + " " + getMemoryQualifier(memory) + " " + getShaderImageLayoutQualifier(format));
@@@ -390,7 -400,7 +390,7 @@@
        ctx.endSection();
  }
  
- void image_store (NegativeTestContext& ctx, gls::TextureTestUtil::TextureType imageType)
 -void image_store (NegativeTestContext& ctx)
++void image_store (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
  {
        const tcu::TextureFormat formats[] =
        {
@@@ -422,13 -432,16 +422,13 @@@
        {
                for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
                {
 -                      for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx)
 -                      {
 -                              testShader(ctx, IMAGE_OPERATION_STORE, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]);
 -                      }
 +                      testShader(ctx, IMAGE_OPERATION_STORE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
                }
        }
        ctx.endSection();
  }
  
- void image_load (NegativeTestContext& ctx, gls::TextureTestUtil::TextureType imageType)
 -void image_load (NegativeTestContext& ctx)
++void image_load (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
  {
        const tcu::TextureFormat formats[] =
        {
@@@ -460,13 -473,16 +460,13 @@@
        {
                for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
                {
 -                      for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx)
 -                      {
 -                              testShader(ctx, IMAGE_OPERATION_LOAD, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]);
 -                      }
 +                      testShader(ctx, IMAGE_OPERATION_LOAD, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
                }
        }
        ctx.endSection();
  }
  
- void image_atomic (NegativeTestContext& ctx, gls::TextureTestUtil::TextureType imageType)
 -void image_atomic (NegativeTestContext& ctx)
++void image_atomic (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
  {
        const tcu::TextureFormat formats[] =
        {
@@@ -504,16 -520,19 +504,16 @@@
        {
                for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
                {
 -                      for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx)
 +                      for (int functionNdx = 0; functionNdx < DE_LENGTH_OF_ARRAY(imageOperations); ++functionNdx)
                        {
 -                              for (int functionNdx = 0; functionNdx < DE_LENGTH_OF_ARRAY(imageOperations); ++functionNdx)
 -                              {
 -                                      testShader(ctx, imageOperations[functionNdx], memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]);
 -                              }
 +                              testShader(ctx, imageOperations[functionNdx], memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
                        }
                }
        }
        ctx.endSection();
  }
  
- void image_atomic_exchange (NegativeTestContext& ctx, gls::TextureTestUtil::TextureType imageType)
 -void image_atomic_exchange (NegativeTestContext& ctx)
++void image_atomic_exchange (NegativeTestContext& ctx, glu::TextureTestUtil::TextureType imageType)
  {
        const tcu::TextureFormat formats[] =
        {
@@@ -546,73 -565,27 +546,73 @@@
        {
                for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx)
                {
 -                      for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx)
 -                      {
 -                              testShader(ctx, IMAGE_OPERATION_ATOMIC_EXCHANGE, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]);
 -                      }
 +                      testShader(ctx, IMAGE_OPERATION_ATOMIC_EXCHANGE, memoryOptions[memoryNdx], imageType, formats[fmtNdx]);
                }
        }
        ctx.endSection();
  }
  
-       image_load(ctx, (gls::TextureTestUtil::TextureType)Type);
 +// Re-routing function template for generating the standard negative
 +// test function signature with texture type added.
 +
 +template <int Type>
 +void loadFuncWrapper (NegativeTestContext& ctx)
 +{
-       image_store(ctx, (gls::TextureTestUtil::TextureType)Type);
++      image_load(ctx, (glu::TextureTestUtil::TextureType)Type);
 +}
 +
 +template <int Type>
 +void storeFuncWrapper (NegativeTestContext& ctx)
 +{
-       image_atomic(ctx, (gls::TextureTestUtil::TextureType)Type);
++      image_store(ctx, (glu::TextureTestUtil::TextureType)Type);
 +}
 +
 +template <int Type>
 +void atomicFuncWrapper (NegativeTestContext& ctx)
 +{
-       image_atomic_exchange(ctx, (gls::TextureTestUtil::TextureType)Type);
++      image_atomic(ctx, (glu::TextureTestUtil::TextureType)Type);
 +}
 +
 +template <int Type>
 +void atomicExchangeFuncWrapper (NegativeTestContext& ctx)
 +{
++      image_atomic_exchange(ctx, (glu::TextureTestUtil::TextureType)Type);
 +}
 +
  } // anonymous
  
 -std::vector<FunctionContainer> getNegativeShaderImageLoadStoreTestFunctions (void)
 +// Set of texture types to create tests for.
 +#define CREATE_TEST_FUNC_PER_TEXTURE_TYPE(NAME, FUNC) const FunctionContainer NAME[] =                                                                        \
 +      {                                                                                                                                                                                                                                       \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_2D>,                    "texture_2d",   "Texture2D negative tests."},                   \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_3D>,                    "texture_3d",   "Texture3D negative tests."},                   \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_CUBE>,                  "cube",                 "Cube texture negative tests."},                \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY>,              "2d_array",             "2D array texture negative tests."},    \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_BUFFER>,                "buffer",               "Buffer negative tests."},                              \
-               {FUNC<gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY>,    "cube_array",   "Cube array texture negative tests."}   \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_2D>,                    "texture_2d",   "Texture2D negative tests."},                   \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_3D>,                    "texture_3d",   "Texture3D negative tests."},                   \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE>,                  "cube",                 "Cube texture negative tests."},                \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY>,              "2d_array",             "2D array texture negative tests."},    \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_BUFFER>,                "buffer",               "Buffer negative tests."},                              \
++              {FUNC<glu::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY>,    "cube_array",   "Cube array texture negative tests."}   \
 +      }
 +
 +std::vector<FunctionContainer> getNegativeShaderImageLoadTestFunctions (void)
  {
 -      const FunctionContainer funcs[] =
 -      {
 -              {image_store,                           "image_store",                          "Test incorrect usage of imageStore()"                  },
 -              {image_load,                            "image_load",                           "Test incorrect usage of imageLoad()"                   },
 -              {image_atomic,                          "image_atomic",                         "Test incorrect usage of imageAtomic*()"                },
 -              {image_atomic_exchange,         "image_atomic_exchange",        "Test incorrect usage of imageAtomicExchange()" },
 -      };
 +      CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, loadFuncWrapper);
 +      return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
 +}
  
 +std::vector<FunctionContainer> getNegativeShaderImageStoreTestFunctions (void)
 +{
 +      CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, storeFuncWrapper);
 +      return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
 +}
 +
 +std::vector<FunctionContainer> getNegativeShaderImageAtomicTestFunctions (void)
 +{
 +      CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicFuncWrapper);
 +      return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
 +}
 +
 +std::vector<FunctionContainer> getNegativeShaderImageAtomicExchangeTestFunctions (void)
 +{
 +      CREATE_TEST_FUNC_PER_TEXTURE_TYPE(funcs, atomicExchangeFuncWrapper);
        return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
  }