kc3-lang/angle/src/tests/end2end_tests/IndexedPointsTest.cpp

• Show log

  Commit

• Hash : fa05f607
  Author :
  Date : 2015-05-07T13:47:11
  

  Use value-paramaterized tests instead of by type.
  
  This should fix our non-standard template use, which causes compile
  errors for the tests on GCC/Clang.
  
  BUG=angleproject:997
  
  Change-Id: Id1bb15231eda445f37e53a5b33d4684ec6618d8e
  Reviewed-on: https://chromium-review.googlesource.com/269858
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/end2end_tests/IndexedPointsTest.cpp

• //
  // Copyright 2015 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.
  //
  
  #include "ANGLETest.h"
  
  #include <array>
  
  using namespace angle;
  
  template <typename IndexType, GLenum IndexTypeName>
  class IndexedPointsTest : public ANGLETest
  {
    protected:
      IndexedPointsTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
      }
  
      float getIndexPositionX(size_t idx)
      {
          return (idx == 0 || idx == 3) ? -0.5f : 0.5f;
      }
  
      float getIndexPositionY(size_t idx)
      {
          return (idx == 2 || idx == 3) ? -0.5f : 0.5f;
      }
  
      virtual void SetUp()
      {
          ANGLETest::SetUp();
  
          const std::string vertexShaderSource = SHADER_SOURCE
          (
              precision highp float;
              attribute vec2 position;
  
              void main()
              {
                  gl_PointSize = 5.0;
                  gl_Position = vec4(position, 0.0, 1.0);
              }
          );
  
          const std::string fragmentShaderSource = SHADER_SOURCE
          (
              precision highp float;
  
              void main()
              {
                  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
              }
          );
  
          mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
          if (mProgram == 0)
          {
              FAIL() << "shader compilation failed.";
          }
  
          std::array<GLfloat, mPointCount * 2> vertices =
          {
              getIndexPositionX(0), getIndexPositionY(0),
              getIndexPositionX(1), getIndexPositionY(1),
              getIndexPositionX(2), getIndexPositionY(2),
              getIndexPositionX(3), getIndexPositionY(3),
          };
          glGenBuffers(1, &mVertexBuffer);
          glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
          glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(GLfloat), &vertices[0], GL_STATIC_DRAW);
  
          std::array<IndexType, mPointCount> indices = { 0, 1, 2, 3 };
          glGenBuffers(1, &mIndexBuffer);
          glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
          glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(IndexType), &indices[0], GL_STATIC_DRAW);
      }
  
      virtual void TearDown()
      {
          glDeleteProgram(mProgram);
  
          ANGLETest::TearDown();
      }
  
      void runTest(GLuint firstIndex)
      {
          glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
          glClear(GL_COLOR_BUFFER_BIT);
  
          GLint viewportSize[4];
          glGetIntegerv(GL_VIEWPORT, viewportSize);
  
          glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
          GLint vertexLocation = glGetAttribLocation(mProgram, "position");
          glVertexAttribPointer(vertexLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
          glEnableVertexAttribArray(vertexLocation);
  
          glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
  
          glUseProgram(mProgram);
  
          glDrawElements(GL_POINTS, mPointCount - firstIndex, IndexTypeName, reinterpret_cast<void*>(firstIndex * sizeof(IndexType)));
  
          for (size_t i = 0; i < mPointCount; i++)
          {
              GLuint x = static_cast<GLuint>(viewportSize[0] + (getIndexPositionX(i) * 0.5f + 0.5f) * (viewportSize[2] - viewportSize[0]));
              GLuint y = static_cast<GLuint>(viewportSize[1] + (getIndexPositionY(i) * 0.5f + 0.5f) * (viewportSize[3] - viewportSize[1]));
  
              if (i < firstIndex)
              {
                  EXPECT_PIXEL_EQ(x, y, 0, 0, 0, 255);
              }
              else
              {
                  EXPECT_PIXEL_EQ(x, y, 255, 0, 0, 255);
              }
          }
      }
  
      GLuint mProgram;
      GLuint mVertexBuffer;
      GLuint mIndexBuffer;
      static const GLuint mPointCount = 4;
  };
  
  typedef IndexedPointsTest<GLubyte, GL_UNSIGNED_BYTE> IndexedPointsTestUByte;
  
  TEST_P(IndexedPointsTestUByte, UnsignedByteOffset0)
  {
      runTest(0);
  }
  
  TEST_P(IndexedPointsTestUByte, UnsignedByteOffset1)
  {
      runTest(1);
  }
  
  TEST_P(IndexedPointsTestUByte, UnsignedByteOffset2)
  {
      runTest(2);
  }
  
  TEST_P(IndexedPointsTestUByte, UnsignedByteOffset3)
  {
      runTest(3);
  }
  
  typedef IndexedPointsTest<GLushort, GL_UNSIGNED_SHORT> IndexedPointsTestUShort;
  
  TEST_P(IndexedPointsTestUShort, UnsignedShortOffset0)
  {
      runTest(0);
  }
  
  TEST_P(IndexedPointsTestUShort, UnsignedShortOffset1)
  {
      runTest(1);
  }
  
  TEST_P(IndexedPointsTestUShort, UnsignedShortOffset2)
  {
      runTest(2);
  }
  
  TEST_P(IndexedPointsTestUShort, UnsignedShortOffset3)
  {
      runTest(3);
  }
  
  typedef IndexedPointsTest<GLuint, GL_UNSIGNED_INT> IndexedPointsTestUInt;
  
  TEST_P(IndexedPointsTestUInt, UnsignedIntOffset0)
  {
      if (getClientVersion() < 3 && !extensionEnabled("GL_OES_element_index_uint"))
      {
          return;
      }
  
      runTest(0);
  }
  
  TEST_P(IndexedPointsTestUInt, UnsignedIntOffset1)
  {
      if (getClientVersion() < 3 && !extensionEnabled("GL_OES_element_index_uint"))
      {
          return;
      }
  
      runTest(1);
  }
  
  TEST_P(IndexedPointsTestUInt, UnsignedIntOffset2)
  {
      if (getClientVersion() < 3 && !extensionEnabled("GL_OES_element_index_uint"))
      {
          return;
      }
  
      runTest(2);
  }
  
  TEST_P(IndexedPointsTestUInt, UnsignedIntOffset3)
  {
      if (getClientVersion() < 3 && !extensionEnabled("GL_OES_element_index_uint"))
      {
          return;
      }
  
      runTest(3);
  }
  
  ANGLE_INSTANTIATE_TEST(IndexedPointsTestUByte, ES2_D3D11());
  ANGLE_INSTANTIATE_TEST(IndexedPointsTestUShort, ES2_D3D11());
  ANGLE_INSTANTIATE_TEST(IndexedPointsTestUInt, ES2_D3D11());
  

Download