src/gpu/command_buffer/service/shader_translator_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/shader_translator.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7
   8 namespace gpu {
   9 namespace gles2 {
  10
  11 class ShaderTranslatorTest : public testing::Test {
  12  public:
  13   ShaderTranslatorTest() {
  14   }
  15
  16   virtual ~ShaderTranslatorTest() {
  17   }
  18
  19  protected:
  20   virtual void SetUp() {
  21     ShBuiltInResources resources;
  22     resources.MaxExpressionComplexity = 32;
  23     resources.MaxCallStackDepth = 32;
  24     ShInitBuiltInResources(&resources);
  25     vertex_translator_ = new ShaderTranslator();
  26     fragment_translator_ = new ShaderTranslator();
  27
  28     ASSERT_TRUE(vertex_translator_->Init(
  29         SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
  30         ShaderTranslatorInterface::kGlsl,
  31         SH_EMULATE_BUILT_IN_FUNCTIONS));
  32     ASSERT_TRUE(fragment_translator_->Init(
  33         SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
  34         ShaderTranslatorInterface::kGlsl,
  35         static_cast<ShCompileOptions>(0)));
  36     // Post-init the results must be empty.
  37     // Vertex translator results.
  38     EXPECT_TRUE(vertex_translator_->translated_shader() == NULL);
  39     EXPECT_TRUE(vertex_translator_->info_log() == NULL);
  40     EXPECT_TRUE(vertex_translator_->attrib_map().empty());
  41     EXPECT_TRUE(vertex_translator_->uniform_map().empty());
  42     // Fragment translator results.
  43     EXPECT_TRUE(fragment_translator_->translated_shader() == NULL);
  44     EXPECT_TRUE(fragment_translator_->info_log() == NULL);
  45     EXPECT_TRUE(fragment_translator_->attrib_map().empty());
  46     EXPECT_TRUE(fragment_translator_->uniform_map().empty());
  47   }
  48   virtual void TearDown() {
  49     vertex_translator_ = NULL;
  50     fragment_translator_ = NULL;
  51   }
  52
  53   scoped_refptr<ShaderTranslator> vertex_translator_;
  54   scoped_refptr<ShaderTranslator> fragment_translator_;
  55 };
  56
  57 TEST_F(ShaderTranslatorTest, ValidVertexShader) {
  58   const char* shader =
  59       "void main() {\n"
  60       "  gl_Position = vec4(1.0);\n"
  61       "}";
  62
  63   // A valid shader should be successfully translated.
  64   EXPECT_TRUE(vertex_translator_->Translate(shader));
  65   // Info log must be NULL.
  66   EXPECT_TRUE(vertex_translator_->info_log() == NULL);
  67   // Translated shader must be valid and non-empty.
  68   ASSERT_TRUE(vertex_translator_->translated_shader() != NULL);
  69   EXPECT_GT(strlen(vertex_translator_->translated_shader()), 0u);
  70   // There should be no attributes or uniforms.
  71   EXPECT_TRUE(vertex_translator_->attrib_map().empty());
  72   EXPECT_TRUE(vertex_translator_->uniform_map().empty());
  73 }
  74
  75 TEST_F(ShaderTranslatorTest, InvalidVertexShader) {
  76   const char* bad_shader = "foo-bar";
  77   const char* good_shader =
  78       "void main() {\n"
  79       "  gl_Position = vec4(1.0);\n"
  80       "}";
  81
  82   // An invalid shader should fail.
  83   EXPECT_FALSE(vertex_translator_->Translate(bad_shader));
  84   // Info log must be valid and non-empty.
  85   ASSERT_TRUE(vertex_translator_->info_log() != NULL);
  86   EXPECT_GT(strlen(vertex_translator_->info_log()), 0u);
  87   // Translated shader must be NULL.
  88   EXPECT_TRUE(vertex_translator_->translated_shader() == NULL);
  89   // There should be no attributes or uniforms.
  90   EXPECT_TRUE(vertex_translator_->attrib_map().empty());
  91   EXPECT_TRUE(vertex_translator_->uniform_map().empty());
  92
  93   // Try a good shader after bad.
  94   EXPECT_TRUE(vertex_translator_->Translate(good_shader));
  95   EXPECT_TRUE(vertex_translator_->info_log() == NULL);
  96   ASSERT_TRUE(vertex_translator_->translated_shader() != NULL);
  97   EXPECT_GT(strlen(vertex_translator_->translated_shader()), 0u);
  98 }
  99
 100 TEST_F(ShaderTranslatorTest, ValidFragmentShader) {
 101   const char* shader =
 102       "void main() {\n"
 103       "  gl_FragColor = vec4(1.0);\n"
 104       "}";
 105
 106   // A valid shader should be successfully translated.
 107   EXPECT_TRUE(fragment_translator_->Translate(shader));
 108   // Info log must be NULL.
 109   EXPECT_TRUE(fragment_translator_->info_log() == NULL);
 110   // Translated shader must be valid and non-empty.
 111   ASSERT_TRUE(fragment_translator_->translated_shader() != NULL);
 112   EXPECT_GT(strlen(fragment_translator_->translated_shader()), 0u);
 113   // There should be no attributes or uniforms.
 114   EXPECT_TRUE(fragment_translator_->attrib_map().empty());
 115   EXPECT_TRUE(fragment_translator_->uniform_map().empty());
 116 }
 117
 118 TEST_F(ShaderTranslatorTest, InvalidFragmentShader) {
 119   const char* shader = "foo-bar";
 120
 121   // An invalid shader should fail.
 122   EXPECT_FALSE(fragment_translator_->Translate(shader));
 123   // Info log must be valid and non-empty.
 124   ASSERT_TRUE(fragment_translator_->info_log() != NULL);
 125   EXPECT_GT(strlen(fragment_translator_->info_log()), 0u);
 126   // Translated shader must be NULL.
 127   EXPECT_TRUE(fragment_translator_->translated_shader() == NULL);
 128   // There should be no attributes or uniforms.
 129   EXPECT_TRUE(fragment_translator_->attrib_map().empty());
 130   EXPECT_TRUE(fragment_translator_->uniform_map().empty());
 131 }
 132
 133 TEST_F(ShaderTranslatorTest, GetAttributes) {
 134   const char* shader =
 135       "attribute vec4 vPosition;\n"
 136       "void main() {\n"
 137       "  gl_Position = vPosition;\n"
 138       "}";
 139
 140   EXPECT_TRUE(vertex_translator_->Translate(shader));
 141   // Info log must be NULL.
 142   EXPECT_TRUE(vertex_translator_->info_log() == NULL);
 143   // Translated shader must be valid and non-empty.
 144   ASSERT_TRUE(vertex_translator_->translated_shader() != NULL);
 145   EXPECT_GT(strlen(vertex_translator_->translated_shader()), 0u);
 146   // There should be no uniforms.
 147   EXPECT_TRUE(vertex_translator_->uniform_map().empty());
 148   // There should be one attribute with following characteristics:
 149   // name:vPosition type:SH_FLOAT_VEC4 size:1.
 150   const ShaderTranslator::VariableMap& attrib_map =
 151       vertex_translator_->attrib_map();
 152   EXPECT_EQ(1u, attrib_map.size());
 153   ShaderTranslator::VariableMap::const_iterator iter =
 154       attrib_map.find("vPosition");
 155   EXPECT_TRUE(iter != attrib_map.end());
 156   EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
 157   EXPECT_EQ(1, iter->second.size);
 158   EXPECT_EQ("vPosition", iter->second.name);
 159 }
 160
 161 TEST_F(ShaderTranslatorTest, GetUniforms) {
 162   const char* shader =
 163       "precision mediump float;\n"
 164       "struct Foo {\n"
 165       "  vec4 color[1];\n"
 166       "};\n"
 167       "struct Bar {\n"
 168       "  Foo foo;\n"
 169       "};\n"
 170       "uniform Bar bar[2];\n"
 171       "void main() {\n"
 172       "  gl_FragColor = bar[0].foo.color[0] + bar[1].foo.color[0];\n"
 173       "}";
 174
 175   EXPECT_TRUE(fragment_translator_->Translate(shader));
 176   // Info log must be NULL.
 177   EXPECT_TRUE(fragment_translator_->info_log() == NULL);
 178   // Translated shader must be valid and non-empty.
 179   ASSERT_TRUE(fragment_translator_->translated_shader() != NULL);
 180   EXPECT_GT(strlen(fragment_translator_->translated_shader()), 0u);
 181   // There should be no attributes.
 182   EXPECT_TRUE(fragment_translator_->attrib_map().empty());
 183   // There should be two uniforms with following characteristics:
 184   // 1. name:bar[0].foo.color[0] type:SH_FLOAT_VEC4 size:1
 185   // 2. name:bar[1].foo.color[0] type:SH_FLOAT_VEC4 size:1
 186   const ShaderTranslator::VariableMap& uniform_map =
 187       fragment_translator_->uniform_map();
 188   EXPECT_EQ(2u, uniform_map.size());
 189   // First uniform.
 190   ShaderTranslator::VariableMap::const_iterator iter =
 191       uniform_map.find("bar[0].foo.color[0]");
 192   EXPECT_TRUE(iter != uniform_map.end());
 193   EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
 194   EXPECT_EQ(1, iter->second.size);
 195   EXPECT_EQ("bar[0].foo.color[0]", iter->second.name);
 196   // Second uniform.
 197   iter = uniform_map.find("bar[1].foo.color[0]");
 198   EXPECT_TRUE(iter != uniform_map.end());
 199   EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
 200   EXPECT_EQ(1, iter->second.size);
 201   EXPECT_EQ("bar[1].foo.color[0]", iter->second.name);
 202 }
 203
 204 #if defined(OS_MACOSX)
 205 TEST_F(ShaderTranslatorTest, BuiltInFunctionEmulation) {
 206   // This test might become invalid in the future when ANGLE Translator is no
 207   // longer emulate dot(float, float) in Mac, or the emulated function name is
 208   // no longer webgl_dot_emu.
 209   const char* shader =
 210       "void main() {\n"
 211       "  gl_Position = vec4(dot(1.0, 1.0), 1.0, 1.0, 1.0);\n"
 212       "}";
 213
 214   EXPECT_TRUE(vertex_translator_->Translate(shader));
 215   // Info log must be NULL.
 216   EXPECT_TRUE(vertex_translator_->info_log() == NULL);
 217   // Translated shader must be valid and non-empty.
 218   ASSERT_TRUE(vertex_translator_->translated_shader() != NULL);
 219   EXPECT_TRUE(strstr(vertex_translator_->translated_shader(),
 220                      "webgl_dot_emu") != NULL);
 221 }
 222 #endif
 223
 224 TEST_F(ShaderTranslatorTest, OptionsString) {
 225   scoped_refptr<ShaderTranslator> translator_1 = new ShaderTranslator();
 226   scoped_refptr<ShaderTranslator> translator_2 = new ShaderTranslator();
 227   scoped_refptr<ShaderTranslator> translator_3 = new ShaderTranslator();
 228
 229   ShBuiltInResources resources;
 230   ShInitBuiltInResources(&resources);
 231
 232   ASSERT_TRUE(translator_1->Init(
 233       SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
 234       ShaderTranslatorInterface::kGlsl,
 235       SH_EMULATE_BUILT_IN_FUNCTIONS));
 236   ASSERT_TRUE(translator_2->Init(
 237       SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
 238       ShaderTranslatorInterface::kGlsl,
 239       static_cast<ShCompileOptions>(0)));
 240   resources.EXT_draw_buffers = 1;
 241   ASSERT_TRUE(translator_3->Init(
 242       SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
 243       ShaderTranslatorInterface::kGlsl,
 244       SH_EMULATE_BUILT_IN_FUNCTIONS));
 245
 246   std::string options_1(
 247       translator_1->GetStringForOptionsThatWouldEffectCompilation());
 248   std::string options_2(
 249       translator_1->GetStringForOptionsThatWouldEffectCompilation());
 250   std::string options_3(
 251       translator_2->GetStringForOptionsThatWouldEffectCompilation());
 252   std::string options_4(
 253       translator_3->GetStringForOptionsThatWouldEffectCompilation());
 254
 255   EXPECT_EQ(options_1, options_2);
 256   EXPECT_NE(options_1, options_3);
 257   EXPECT_NE(options_1, options_4);
 258   EXPECT_NE(options_3, options_4);
 259 }
 260
 261 }  // namespace gles2
 262 }  // namespace gpu
 263