kc3-lang/angle/src/tests/compiler_tests/EXT_YUV_target_test.cpp

• Show log

  Commit

• Hash : ffd39978
  Author :
  Date : 2019-02-20T10:45:24
  

  test: Replace _TEST_CASE_ with _TEST_SUITE_.
  
  Googletest is (at last) converging with industry-standard terminology
  [1]. We previously called test suites "test cases", which was rather
  confusing for folks coming from any other testing framework.
  
  Chrome now has a googletest version that supports _TEST_SUITE_ macros
  instead of _TEST_CASE_, so this CL cleans up some of the outdated usage.
  
  [1] https://github.com/google/googletest/blob/master/googletest/docs/primer.md#beware-of-the-nomenclature
  
  Bug: chromium:925652
  Change-Id: Ia0deec0bc4216ef1adabc33985a7cbda89682608
  Reviewed-on: https://chromium-review.googlesource.com/c/1477418
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Victor Costan <pwnall@chromium.org>
  

Download

• src/tests/compiler_tests/EXT_YUV_target_test.cpp

• //
  // Copyright (c) 2017 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // EXT_YUV_target.cpp:
  //   Test for EXT_YUV_target implementation.
  //
  
  #include "tests/test_utils/ShaderExtensionTest.h"
  
  using EXTYUVTargetTest = sh::ShaderExtensionTest;
  
  namespace
  {
  const char EXTYTPragma[] = "#extension GL_EXT_YUV_target : require\n";
  
  const char ESSL300_SimpleShader[] =
      "precision mediump float;\n"
      "uniform __samplerExternal2DY2YEXT uSampler;\n"
      "out vec4 fragColor;\n"
      "void main() { \n"
      "    fragColor = vec4(1.0);\n"
      "}\n";
  
  // Shader that samples the texture and writes to FragColor.
  const char ESSL300_FragColorShader[] =
      "precision mediump float;\n"
      "uniform __samplerExternal2DY2YEXT uSampler;\n"
      "layout(yuv) out vec4 fragColor;\n"
      "void main() { \n"
      "    fragColor = texture(uSampler, vec2(0.0));\n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier multiple times.
  const char ESSL300_YUVQualifierMultipleTimesShader[] =
      "precision mediump float;\n"
      "layout(yuv, yuv, yuv) out vec4 fragColor;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier for not output fails to compile.
  const char ESSL300_YUVQualifierFailureShader1[] =
      "precision mediump float;\n"
      "layout(yuv) in vec4 fragColor;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YUVQualifierFailureShader2[] =
      "precision mediump float;\n"
      "layout(yuv) uniform;\n"
      "layout(yuv) uniform Transform {\n"
      "     mat4 M1;\n"
      "}\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier with location fails to compile.
  const char ESSL300_LocationAndYUVFailureShader[] =
      "precision mediump float;\n"
      "layout(location = 0, yuv) out vec4 fragColor;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier with multiple color outputs fails to compile.
  const char ESSL300_MultipleColorAndYUVOutputsFailureShader1[] =
      "precision mediump float;\n"
      "layout(yuv) out vec4 fragColor;\n"
      "layout out vec4 fragColor1;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_MultipleColorAndYUVOutputsFailureShader2[] =
      "precision mediump float;\n"
      "layout(yuv) out vec4 fragColor;\n"
      "layout(location = 1) out vec4 fragColor1;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier with depth output fails to compile.
  const char ESSL300_DepthAndYUVOutputsFailureShader[] =
      "precision mediump float;\n"
      "layout(yuv) out vec4 fragColor;\n"
      "void main() { \n"
      "    gl_FragDepth = 1.0f;\n"
      "}\n";
  
  // Shader that specifies yuv layout qualifier with multiple outputs fails to compile.
  const char ESSL300_MultipleYUVOutputsFailureShader[] =
      "precision mediump float;\n"
      "layout(yuv) out vec4 fragColor;\n"
      "layout(yuv) out vec4 fragColor1;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuvCscStandartEXT type and associated values.
  const char ESSL300_YuvCscStandardEXTShader[] =
      R"(precision mediump float;
      yuvCscStandardEXT;
      yuvCscStandardEXT conv;
      yuvCscStandardEXT conv1 = itu_601;
      yuvCscStandardEXT conv2 = itu_601_full_range;
      yuvCscStandardEXT conv3 = itu_709;
      const yuvCscStandardEXT conv4 = itu_709;
  
      uniform int u;
      out vec4 my_color;
  
      yuvCscStandardEXT conv_standard()
      {
          switch(u)
          {
              case 1:
                  return conv1;
              case 2:
                  return conv2;
              case 3:
                  return conv3;
              default:
                  return conv;
          }
      }
      bool is_itu_601(inout yuvCscStandardEXT csc)
      {
          csc = itu_601;
          return csc == itu_601;
      }
      bool is_itu_709(yuvCscStandardEXT csc)
      {
          return csc == itu_709;
      }
      void main()
      {
          yuvCscStandardEXT conv = conv_standard();
          bool csc_check1 = is_itu_601(conv);
          bool csc_check2 = is_itu_709(itu_709);
          if (csc_check1 && csc_check2) {
              my_color = vec4(0, 1, 0, 1);
          }
      })";
  
  // Shader that specifies yuvCscStandartEXT type constructor fails to compile.
  const char ESSL300_YuvCscStandartdEXTConstructFailureShader1[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = yuvCscStandardEXT();\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTConstructFailureShader2[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = yuvCscStandardEXT(itu_601);\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuvCscStandartEXT type conversion fails to compile.
  const char ESSL300_YuvCscStandartdEXTConversionFailureShader1[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = false;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTConversionFailureShader2[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = 0;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTConversionFailureShader3[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = 2.0f;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTConversionFailureShader4[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = itu_601 | itu_709;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTConversionFailureShader5[] =
      "precision mediump float;\n"
      "yuvCscStandardEXT conv = itu_601 & 3.0f;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuvCscStandartEXT type qualifiers fails to compile.
  const char ESSL300_YuvCscStandartdEXTQualifiersFailureShader1[] =
      "precision mediump float;\n"
      "in yuvCscStandardEXT conv = itu_601;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTQualifiersFailureShader2[] =
      "precision mediump float;\n"
      "out yuvCscStandardEXT conv = itu_601;\n"
      "void main() { \n"
      "}\n";
  
  const char ESSL300_YuvCscStandartdEXTQualifiersFailureShader3[] =
      "precision mediump float;\n"
      "uniform yuvCscStandardEXT conv = itu_601;\n"
      "void main() { \n"
      "}\n";
  
  // Shader that specifies yuv_to_rgb() and rgb_to_yuv() built-in functions.
  const char ESSL300_BuiltInFunctionsShader[] =
      R"(precision mediump float;
      yuvCscStandardEXT conv = itu_601;
  
      out vec4 my_color;
  
      void main()
      {
          vec3 yuv = rgb_2_yuv(vec3(0.0f), conv);
          vec3 rgb = yuv_2_rgb(yuv, itu_601);
          my_color = vec4(rgb, 1.0);
      })";
  
  const char ESSL300_OverloadRgb2Yuv[] =
      R"(precision mediump float;
      float rgb_2_yuv(float x) { return x + 1.0; }
  
      in float i;
      out float o;
  
      void main()
      {
          o = rgb_2_yuv(i);
      })";
  
  const char ESSL300_OverloadYuv2Rgb[] =
      R"(precision mediump float;
      float yuv_2_rgb(float x) { return x + 1.0; }
  
      in float i;
      out float o;
  
      void main()
      {
          o = yuv_2_rgb(i);
      })";
  
  // Extension flag is required to compile properly. Expect failure when it is
  // not present.
  TEST_P(EXTYUVTargetTest, CompileFailsWithoutExtension)
  {
      mResources.EXT_YUV_target = 0;
      InitializeCompiler();
      EXPECT_FALSE(TestShaderCompile(EXTYTPragma));
  }
  
  // Extension directive is required to compile properly. Expect failure when
  // it is not present.
  TEST_P(EXTYUVTargetTest, CompileFailsWithExtensionWithoutPragma)
  {
      mResources.EXT_YUV_target = 1;
      InitializeCompiler();
      EXPECT_FALSE(TestShaderCompile(""));
  }
  
  // With extension flag and extension directive, compiling succeeds.
  // Also test that the extension directive state is reset correctly.
  TEST_P(EXTYUVTargetTest, CompileSucceedsWithExtensionAndPragma)
  {
      mResources.EXT_YUV_target = 1;
      InitializeCompiler();
      EXPECT_TRUE(TestShaderCompile(EXTYTPragma));
      // Test reset functionality.
      EXPECT_FALSE(TestShaderCompile(""));
      EXPECT_TRUE(TestShaderCompile(EXTYTPragma));
  }
  
  INSTANTIATE_TEST_SUITE_P(CorrectVariantsWithExtensionAndPragma,
                           EXTYUVTargetTest,
                           Combine(Values(SH_GLES3_SPEC),
                                   Values(sh::ESSLVersion300),
                                   Values(ESSL300_SimpleShader, ESSL300_FragColorShader)));
  
  class EXTYUVTargetCompileSuccessTest : public EXTYUVTargetTest
  {};
  
  TEST_P(EXTYUVTargetCompileSuccessTest, CompileSucceeds)
  {
      // Expect compile success.
      mResources.EXT_YUV_target = 1;
      InitializeCompiler();
      EXPECT_TRUE(TestShaderCompile(EXTYTPragma));
  }
  
  INSTANTIATE_TEST_SUITE_P(CorrectESSL300Shaders,
                           EXTYUVTargetCompileSuccessTest,
                           Combine(Values(SH_GLES3_SPEC),
                                   Values(sh::ESSLVersion300),
                                   Values(ESSL300_FragColorShader,
                                          ESSL300_YUVQualifierMultipleTimesShader,
                                          ESSL300_YuvCscStandardEXTShader,
                                          ESSL300_BuiltInFunctionsShader)));
  
  class EXTYUVTargetCompileFailureTest : public EXTYUVTargetTest
  {};
  
  TEST_P(EXTYUVTargetCompileFailureTest, CompileFails)
  {
      // Expect compile failure due to shader error, with shader having correct pragma.
      mResources.EXT_YUV_target = 1;
      InitializeCompiler();
      EXPECT_FALSE(TestShaderCompile(EXTYTPragma));
  }
  
  INSTANTIATE_TEST_SUITE_P(IncorrectESSL300Shaders,
                           EXTYUVTargetCompileFailureTest,
                           Combine(Values(SH_GLES3_SPEC),
                                   Values(sh::ESSLVersion300),
                                   Values(ESSL300_YUVQualifierFailureShader1,
                                          ESSL300_YUVQualifierFailureShader2,
                                          ESSL300_LocationAndYUVFailureShader,
                                          ESSL300_MultipleColorAndYUVOutputsFailureShader1,
                                          ESSL300_MultipleColorAndYUVOutputsFailureShader2,
                                          ESSL300_DepthAndYUVOutputsFailureShader,
                                          ESSL300_MultipleYUVOutputsFailureShader,
                                          ESSL300_YuvCscStandartdEXTConstructFailureShader1,
                                          ESSL300_YuvCscStandartdEXTConstructFailureShader2,
                                          ESSL300_YuvCscStandartdEXTConversionFailureShader1,
                                          ESSL300_YuvCscStandartdEXTConversionFailureShader2,
                                          ESSL300_YuvCscStandartdEXTConversionFailureShader3,
                                          ESSL300_YuvCscStandartdEXTConversionFailureShader4,
                                          ESSL300_YuvCscStandartdEXTConversionFailureShader5,
                                          ESSL300_YuvCscStandartdEXTQualifiersFailureShader1,
                                          ESSL300_YuvCscStandartdEXTQualifiersFailureShader2,
                                          ESSL300_YuvCscStandartdEXTQualifiersFailureShader3)));
  
  class EXTYUVNotEnabledTest : public EXTYUVTargetTest
  {};
  
  TEST_P(EXTYUVNotEnabledTest, CanOverloadConversions)
  {
      // Expect compile success with a shader that overloads functions in the EXT_YUV_target
      // extension.
      mResources.EXT_YUV_target = 0;
      InitializeCompiler();
      EXPECT_TRUE(TestShaderCompile(""));
  }
  
  INSTANTIATE_TEST_SUITE_P(CoreESSL300Shaders,
                           EXTYUVNotEnabledTest,
                           Combine(Values(SH_GLES3_SPEC),
                                   Values(sh::ESSLVersion300),
                                   Values(ESSL300_OverloadRgb2Yuv, ESSL300_OverloadYuv2Rgb)));
  
  }  // namespace
  

Download