Implements glGetVertexAttribPointerv

gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

 // Copyright (c) 2009 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/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 32 matching lines @@
   static const GLuint kServiceTextureId = 304;
   static const GLuint kServiceProgramId = 305;
   static const GLuint kServiceShaderId = 306;
   static const GLuint kServiceElementBufferId = 307;
 
   static const int32 kSharedMemoryId = 401;
   static const size_t kSharedBufferSize = 2048;
   static const uint32 kSharedMemoryOffset = 132;
   static const int32 kInvalidSharedMemoryId = 402;
   static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
+  static const uint32 kInitialResult = 0xDEADBEEFu;
 
   static const uint32 kNewClientId = 501;
   static const uint32 kNewServiceId = 502;
   static const uint32 kInvalidClientId = 601;
 
   // Template to call glGenXXX functions.
   template <typename T>
   void GenHelper(GLuint client_id) {
     int8 buffer[sizeof(T) + sizeof(client_id)];
     T& cmd = *reinterpret_cast<T*>(&buffer);
@@ skipping 74 matching lines @@
       EXPECT_CALL(*gl_, CreateShader(_))
           .Times(1)
           .WillOnce(Return(kServiceShaderId))
           .RetiresOnSaturation();
       CreateShader cmd;
       cmd.Init(GL_VERTEX_SHADER, client_shader_id_);
       EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
     }
 
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
+
+    result_ = GetSharedMemoryAs<SizedResult*>();
+    GLuint* result_value = result_->GetDataAs<GLuint*>();
+    result_->size = kInitialResult;
+    *result_value = kInitialResult;
   }
 
   virtual void TearDown() {
     decoder_->Destroy();
     decoder_.reset();
     engine_.reset();
     ::gles2::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
@@ skipping 39 matching lines @@
   GLuint client_framebuffer_id_;
   GLuint client_program_id_;
   GLuint client_renderbuffer_id_;
   GLuint client_shader_id_;
   GLuint client_texture_id_;
   GLuint client_element_buffer_id_;
 
   uint32 shared_memory_id_;
   uint32 shared_memory_offset_;
   void* shared_memory_address_;
+  SizedResult* result_;
 
   int8 immediate_buffer_[256];
 
  private:
   class MockCommandBufferEngine : public CommandBufferEngine {
    public:
     MockCommandBufferEngine() {
       data_.reset(new int8[kSharedBufferSize]);
       valid_buffer_.ptr = data_.get();
       valid_buffer_.size = kSharedBufferSize;
@@ skipping 460 matching lines @@
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT,
            kInvalidIndexRangeStart);
   EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 #endif
 
+TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
+  const float dummy = 0;
+  const GLuint kOffsetToTestFor = sizeof(dummy) * 4;
+  const GLuint kIndexToTest = 1;
+  const GLuint* result_value = result_->GetDataAs<const GLuint*>();
+  // Test that initial value is 0.
+  GetVertexAttribPointerv cmd;
+  cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
+           shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(sizeof(*result_value), result_->size);
+  EXPECT_EQ(0u, *result_value);
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+
+  // Set the value and see that we get it.
+  SetupVertexBuffer();
+  DoVertexAttribPointer(kIndexToTest, 2, GL_FLOAT, 0, kOffsetToTestFor);
+  EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(sizeof(*result_value), result_->size);
+  EXPECT_EQ(kOffsetToTestFor, *result_value);
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
+  const GLuint kIndexToTest = 1;
+  const GLuint* result_value = result_->GetDataAs<const GLuint*>();
+  // Test pname invalid fails.
+  GetVertexAttribPointerv cmd;
+  cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER + 1,
+           shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(0u, result_->size);
+  EXPECT_EQ(kInitialResult, *result_value);
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
+
+  // Test index out of range fails.
+  cmd.Init(kNumVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_POINTER,
+           shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(parse_error::kParseNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(0u, result_->size);
+  EXPECT_EQ(kInitialResult, *result_value);
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+
+  // Test memory id bad fails.
+  cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
+           kInvalidSharedMemoryId, shared_memory_offset_);
+  EXPECT_NE(parse_error::kParseNoError, ExecuteCmd(cmd));
+
+  // Test memory offset bad fails.
+  cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
+           shared_memory_id_, kInvalidSharedMemoryOffset);
+  EXPECT_NE(parse_error::kParseNoError, ExecuteCmd(cmd));
+}
+
+
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu