Consolidate GPU unit test expectiation functions.

gpu/command_buffer/service/program_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/mocks.h"
+#include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ skipping 165 matching lines @@
   static const GLenum kUniform1Type = GL_FLOAT_VEC4;
   static const GLenum kUniform2Type = GL_INT_VEC2;
   static const GLenum kUniform3Type = GL_FLOAT_VEC3;
   static const GLint kInvalidUniformLocation = 30;
   static const GLint kBadUniformIndex = 1000;
 
   static const size_t kNumAttribs;
   static const size_t kNumUniforms;
 
  protected:
-  struct AttribInfo {
-    const char* name;
-    GLint size;
-    GLenum type;
-    GLint location;
-  };
-
-  struct UniformInfo {
-    const char* name;
-    const char* good_name;
-    GLint size;
-    GLenum type;
-    GLint fake_location;
-    GLint real_location;
-  };
+  typedef TestHelper::AttribInfo AttribInfo;
+  typedef TestHelper::UniformInfo UniformInfo;
 
   virtual void SetUp() {
     gl_.reset(new StrictMock<gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
 
     SetupDefaultShaderExpectations();
 
     ShaderManager::ShaderInfo* vertex_shader = shader_manager_.CreateShaderInfo(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     ShaderManager::ShaderInfo* fragment_shader =
@@ skipping 10 matching lines @@
     ASSERT_TRUE(program_info_ != NULL);
 
     program_info_->AttachShader(&shader_manager_, vertex_shader);
     program_info_->AttachShader(&shader_manager_, fragment_shader);
     program_info_->Link();
   }
 
   void SetupShader(AttribInfo* attribs, size_t num_attribs,
                    UniformInfo* uniforms, size_t num_uniforms,
                    GLuint service_id) {
-    InSequence s;
-
-    EXPECT_CALL(*gl_,
-        LinkProgram(service_id))
-        .Times(1)
-        .RetiresOnSaturation();
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_LINK_STATUS, _))
-        .WillOnce(SetArgumentPointee<2>(1))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_INFO_LOG_LENGTH, _))
-        .WillOnce(SetArgumentPointee<2>(0))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTES, _))
-        .WillOnce(SetArgumentPointee<2>(num_attribs))
-        .RetiresOnSaturation();
-    size_t max_attrib_len = 0;
-    for (size_t ii = 0; ii < num_attribs; ++ii) {
-      size_t len = strlen(attribs[ii].name) + 1;
-      max_attrib_len = std::max(max_attrib_len, len);
-    }
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
-        .WillOnce(SetArgumentPointee<2>(max_attrib_len))
-        .RetiresOnSaturation();
-    for (size_t ii = 0; ii < num_attribs; ++ii) {
-      const AttribInfo& info = attribs[ii];
-      EXPECT_CALL(*gl_,
-          GetActiveAttrib(service_id, ii,
-                          max_attrib_len, _, _, _, _))
-          .WillOnce(DoAll(
-              SetArgumentPointee<3>(strlen(info.name)),
-              SetArgumentPointee<4>(info.size),
-              SetArgumentPointee<5>(info.type),
-              SetArrayArgument<6>(info.name,
-                                  info.name + strlen(info.name) + 1)))
-          .RetiresOnSaturation();
-      if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
-        EXPECT_CALL(*gl_, GetAttribLocation(service_id,
-                                            StrEq(info.name)))
-            .WillOnce(Return(info.location))
-            .RetiresOnSaturation();
-      }
-    }
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_ACTIVE_UNIFORMS, _))
-        .WillOnce(SetArgumentPointee<2>(num_uniforms))
-        .RetiresOnSaturation();
-    size_t max_uniform_len = 0;
-    for (size_t ii = 0; ii < num_uniforms; ++ii) {
-      size_t len = strlen(uniforms[ii].name) + 1;
-      max_uniform_len = std::max(max_uniform_len, len);
-    }
-    EXPECT_CALL(*gl_,
-        GetProgramiv(service_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, _))
-        .WillOnce(SetArgumentPointee<2>(max_uniform_len))
-        .RetiresOnSaturation();
-    for (size_t ii = 0; ii < num_uniforms; ++ii) {
-      const UniformInfo& info = uniforms[ii];
-      EXPECT_CALL(*gl_,
-          GetActiveUniform(service_id, ii,
-                           max_uniform_len, _, _, _, _))
-          .WillOnce(DoAll(
-              SetArgumentPointee<3>(strlen(info.name)),
-              SetArgumentPointee<4>(info.size),
-              SetArgumentPointee<5>(info.type),
-              SetArrayArgument<6>(info.name,
-                                  info.name + strlen(info.name) + 1)))
-          .RetiresOnSaturation();
-      if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
-        EXPECT_CALL(*gl_, GetUniformLocation(service_id,
-                                             StrEq(info.name)))
-            .WillOnce(Return(info.real_location))
-            .RetiresOnSaturation();
-        if (info.size > 1) {
-          std::string base_name = info.name;
-          size_t array_pos = base_name.rfind("[0]");
-          if (base_name.size() > 3 && array_pos == base_name.size() - 3) {
-            base_name = base_name.substr(0, base_name.size() - 3);
-          }
-          for (GLsizei jj = 1; jj < info.size; ++jj) {
-            std::string element_name(
-                std::string(base_name) + "[" + base::IntToString(jj) + "]");
-            EXPECT_CALL(*gl_, GetUniformLocation(service_id,
-                                                 StrEq(element_name)))
-                .WillOnce(Return(info.real_location + jj * 2))
-                .RetiresOnSaturation();
-          }
-        }
-      }
-    }
+    TestHelper::SetupShader(
+        gl_.get(), attribs, num_attribs, uniforms, num_uniforms, service_id);
   }
 
   void SetupDefaultShaderExpectations() {
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
   }
 
   void SetupExpectationsForClearingUniforms(
       UniformInfo* uniforms, size_t num_uniforms) {
-    for (size_t ii = 0; ii < num_uniforms; ++ii) {
-      const UniformInfo& info = uniforms[ii];
-      switch (info.type) {
-      case GL_FLOAT:
-        EXPECT_CALL(*gl_, Uniform1fv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_VEC2:
-        EXPECT_CALL(*gl_, Uniform2fv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_VEC3:
-        EXPECT_CALL(*gl_, Uniform3fv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_VEC4:
-        EXPECT_CALL(*gl_, Uniform4fv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_INT:
-      case GL_BOOL:
-      case GL_SAMPLER_2D:
-      case GL_SAMPLER_CUBE:
-      case GL_SAMPLER_EXTERNAL_OES:
-      case GL_SAMPLER_3D_OES:
-      case GL_SAMPLER_2D_RECT_ARB:
-        EXPECT_CALL(*gl_, Uniform1iv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_INT_VEC2:
-      case GL_BOOL_VEC2:
-        EXPECT_CALL(*gl_, Uniform2iv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_INT_VEC3:
-      case GL_BOOL_VEC3:
-        EXPECT_CALL(*gl_, Uniform3iv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_INT_VEC4:
-      case GL_BOOL_VEC4:
-        EXPECT_CALL(*gl_, Uniform4iv(info.real_location, info.size, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_MAT2:
-        EXPECT_CALL(*gl_, UniformMatrix2fv(
-            info.real_location, info.size, false, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_MAT3:
-        EXPECT_CALL(*gl_, UniformMatrix3fv(
-            info.real_location, info.size, false, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      case GL_FLOAT_MAT4:
-        EXPECT_CALL(*gl_, UniformMatrix4fv(
-            info.real_location, info.size, false, _))
-            .Times(1)
-            .RetiresOnSaturation();
-        break;
-      default:
-        NOTREACHED();
-        break;
-      }
-    }
+    TestHelper::SetupExpectationsForClearingUniforms(
+        gl_.get(), uniforms, num_uniforms);
   }
 
   virtual void TearDown() {
     ::gfx::GLInterface::SetGLInterface(NULL);
   }
 
   // Return true if link status matches expected_link_status
   bool LinkAsExpected(ProgramManager::ProgramInfo* program_info,
                       bool expected_link_status) {
     GLuint service_id = program_info->service_id();
@@ skipping 59 matching lines @@
 const GLint ProgramManagerWithShaderTest::kInvalidUniformLocation;
 const GLint ProgramManagerWithShaderTest::kBadUniformIndex;
 #endif
 
 const size_t ProgramManagerWithShaderTest::kNumAttribs =
     arraysize(ProgramManagerWithShaderTest::kAttribs);
 
 ProgramManagerWithShaderTest::UniformInfo
     ProgramManagerWithShaderTest::kUniforms[] = {
   { kUniform1Name,
-    kUniform1Name,
     kUniform1Size,
     kUniform1Type,
     kUniform1FakeLocation,
     kUniform1RealLocation,
+    kUniform1Name,
   },
   { kUniform2Name,
-    kUniform2Name,
     kUniform2Size,
     kUniform2Type,
     kUniform2FakeLocation,
     kUniform2RealLocation,
+    kUniform2Name,
   },
   { kUniform3BadName,
-    kUniform3GoodName,
     kUniform3Size,
     kUniform3Type,
     kUniform3FakeLocation,
     kUniform3RealLocation,
+    kUniform3GoodName,
   },
 };
 
 const size_t ProgramManagerWithShaderTest::kNumUniforms =
     arraysize(ProgramManagerWithShaderTest::kUniforms);
 
 const char* ProgramManagerWithShaderTest::kAttrib1Name = "attrib1";
 const char* ProgramManagerWithShaderTest::kAttrib2Name = "attrib2";
 const char* ProgramManagerWithShaderTest::kAttrib3Name = "attrib3";
 const char* ProgramManagerWithShaderTest::kUniform1Name = "uniform1";
@@ skipping 180 matching lines @@
   EXPECT_EQ(2, array_index);
 }
 
 // Some GL drivers incorrectly return gl_DepthRange and possibly other uniforms
 // that start with "gl_". Our implementation catches these and does not allow
 // them back to client.
 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsGLUnderscoreUniform) {
   static const char* kUniform2Name = "gl_longNameWeCanCheckFor";
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
-      kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
       kUniform1RealLocation,
+      kUniform1Name,
     },
     { kUniform2Name,
-      kUniform2Name,
       kUniform2Size,
       kUniform2Type,
       kUniform2FakeLocation,
       kUniform2RealLocation,
+      kUniform2Name,
     },
     { kUniform3BadName,
-      kUniform3GoodName,
       kUniform3Size,
       kUniform3Type,
       kUniform3FakeLocation,
       kUniform3RealLocation,
+      kUniform3GoodName,
     },
   };
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   SetupShader(
@@ skipping 63 matching lines @@
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", &shader_translator);
   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
-      kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
       kUniform1RealLocation,
+      kUniform1Name,
     },
     { kUniform2Name,
-      kUniform2Name,
       kUniform2Size,
       kUniform2BadType,
       kUniform2FakeLocation,
       kUniform2RealLocation,
+      kUniform2Name,
     },
     { kUniform3BadName,
-      kUniform3GoodName,
       kUniform3Size,
       kUniform3Type,
       kUniform3FakeLocation,
       kUniform3RealLocation,
+      kUniform3GoodName,
     },
   };
   const size_t kNumAttribs= arraysize(kAttribs);
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
   ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
       kClientProgramId, kServiceProgramId);
@@ skipping 285 matching lines @@
   };
   const size_t kNumSamplerTypes = arraysize(kSamplerTypes);
   for (size_t ii = 0; ii < kNumSamplerTypes; ++ii) {
     static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
     };
     ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
       { kUniform1Name,
-        kUniform1Name,
         kUniform1Size,
         kUniform1Type,
         kUniform1FakeLocation,
         kUniform1RealLocation,
+        kUniform1Name,
       },
       { kUniform2Name,
-        kUniform2Name,
         kUniform2Size,
         kSamplerTypes[ii],
         kUniform2FakeLocation,
         kUniform2RealLocation,
+        kUniform2Name,
       },
       { kUniform3BadName,
-        kUniform3GoodName,
         kUniform3Size,
         kUniform3Type,
         kUniform3FakeLocation,
         kUniform3RealLocation,
+        kUniform3GoodName,
       },
     };
     const size_t kNumAttribs = arraysize(kAttribs);
     const size_t kNumUniforms = arraysize(kUniforms);
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
     program_info->Link();
     SetupExpectationsForClearingUniforms(kUniforms, kNumUniforms);
     manager_.ClearUniforms(program_info);
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu