kc3-lang/angle/src/libANGLE/validationES_unittest.cpp

• Show log

  Commit

• Hash : 9c9b40ac
  Author :
  Date : 2017-04-26T16:31:57
  

  Use parameter cache to skip passing IndexRange.
  
  For DrawElements et al., we can use a simple design to store
  entry point parameters and compute index ranges lazily. This allows
  us to compute the index range outside of the validation layer.
  
  Fixing this will let us implement a few things, such as the no error
  extension. It will also allow auto-generation of the entry points,
  since we won't have to have special cases for certain entry
  points. It will also help fix the syncState layering problem. Now the
  cached parameter helper (which is owned by the Context) can make the
  impl layer calls, instead of the validation layer calling the impl
  directly.
  
  We use a small array in Context to gather parameters in a generic
  way without reallocation on call. We also check type safety by storing
  a type info struct which can handle inheritance between type classes.
  Optional variables for the cache determine when to re-compute values.
  
  The intent with gatherParams is to call this in every entry point, and
  have in most cases be a no-op. In some cases like for IndexRange, we
  store some parameters for later use. The inheritance scheme enables
  auto-generation of the entry points by keeping signatures similar.
  
  BUG=angleproject:747
  
  Change-Id: I871e99e1334cf6e61ef8da62fde3ced094903f8a
  Reviewed-on: https://chromium-review.googlesource.com/474119
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/validationES_unittest.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.
  //
  // validationES unit tests:
  //   Unit tests for general ES validation functions.
  //
  
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
  
  #include "libANGLE/ContextState.h"
  #include "libANGLE/VaryingPacking.h"
  #include "libANGLE/renderer/FramebufferImpl_mock.h"
  #include "libANGLE/renderer/ProgramImpl_mock.h"
  #include "libANGLE/renderer/TextureImpl_mock.h"
  #include "libANGLE/validationES.h"
  #include "tests/angle_unittests_utils.h"
  
  using namespace gl;
  using namespace rx;
  using testing::_;
  using testing::NiceMock;
  using testing::Return;
  
  namespace
  {
  
  class MockValidationContext : public ValidationContext
  {
    public:
      MockValidationContext(const ValidationContext *shareContext,
                            TextureManager *shareTextures,
                            const Version &version,
                            State *state,
                            const Caps &caps,
                            const TextureCapsMap &textureCaps,
                            const Extensions &extensions,
                            const Limitations &limitations,
                            bool skipValidation)
          : ValidationContext(shareContext,
                              shareTextures,
                              version,
                              state,
                              caps,
                              textureCaps,
                              extensions,
                              limitations,
                              skipValidation)
      {
      }
  
      MOCK_METHOD1(handleError, void(const Error &));
  };
  
  // Test that ANGLE generates an INVALID_OPERATION when validating index data that uses a value
  // larger than MAX_ELEMENT_INDEX. Not specified in the GLES 3 spec, it's undefined behaviour,
  // but we want a test to ensure we maintain this behaviour.
  // TODO(jmadill): Re-enable when framebuffer sync state doesn't happen in validation.
  TEST(ValidationESTest, DISABLED_DrawElementsWithMaxIndexGivesError)
  {
      auto framebufferImpl = MakeFramebufferMock();
      auto programImpl     = MakeProgramMock();
  
      // TODO(jmadill): Generalize some of this code so we can re-use it for other tests.
      NiceMock<MockGLFactory> mockFactory;
      EXPECT_CALL(mockFactory, createFramebuffer(_)).WillOnce(Return(framebufferImpl));
      EXPECT_CALL(mockFactory, createProgram(_)).WillOnce(Return(programImpl));
      EXPECT_CALL(mockFactory, createVertexArray(_)).WillOnce(Return(nullptr));
  
      State state;
      Caps caps;
      TextureCapsMap textureCaps;
      Extensions extensions;
      Limitations limitations;
  
      // Set some basic caps.
      caps.maxElementIndex     = 100;
      caps.maxDrawBuffers      = 1;
      caps.maxColorAttachments = 1;
      state.initialize(caps, extensions, Version(3, 0), false, true, true, false);
  
      NiceMock<MockTextureImpl> *textureImpl = new NiceMock<MockTextureImpl>();
      EXPECT_CALL(mockFactory, createTexture(_)).WillOnce(Return(textureImpl));
      EXPECT_CALL(*textureImpl, setStorage(_, _, _, _, _)).WillOnce(Return(NoError()));
      EXPECT_CALL(*textureImpl, destructor()).Times(1).RetiresOnSaturation();
  
      Texture *texture = new Texture(&mockFactory, 0, GL_TEXTURE_2D);
      texture->addRef();
      texture->setStorage(nullptr, GL_TEXTURE_2D, 1, GL_RGBA8, Extents(1, 1, 0));
  
      VertexArray *vertexArray = new VertexArray(&mockFactory, 0, 1, 1);
      Framebuffer *framebuffer = new Framebuffer(caps, &mockFactory, 1);
      framebuffer->setAttachment(nullptr, GL_FRAMEBUFFER_DEFAULT, GL_BACK, ImageIndex::Make2D(0),
                                 texture);
  
      Program *program = new Program(&mockFactory, nullptr, 1);
  
      state.setVertexArrayBinding(vertexArray);
      state.setDrawFramebufferBinding(framebuffer);
      state.setProgram(nullptr, program);
  
      NiceMock<MockValidationContext> testContext(nullptr, nullptr, Version(3, 0), &state, caps,
                                                  textureCaps, extensions, limitations, false);
  
      // Set the expectation for the validation error here.
      Error expectedError(GL_INVALID_OPERATION, g_ExceedsMaxElementErrorMessage);
      EXPECT_CALL(testContext, handleError(expectedError)).Times(1);
  
      // Call once with maximum index, and once with an excessive index.
      GLuint indexData[] = {0, 1, static_cast<GLuint>(caps.maxElementIndex - 1),
                            3, 4, static_cast<GLuint>(caps.maxElementIndex)};
      EXPECT_TRUE(
          ValidateDrawElementsCommon(&testContext, GL_TRIANGLES, 3, GL_UNSIGNED_INT, indexData, 1));
      EXPECT_FALSE(
          ValidateDrawElementsCommon(&testContext, GL_TRIANGLES, 6, GL_UNSIGNED_INT, indexData, 2));
  
      texture->release();
  
      state.setVertexArrayBinding(nullptr);
      state.setDrawFramebufferBinding(nullptr);
      state.setProgram(nullptr, nullptr);
  
      SafeDelete(vertexArray);
      SafeDelete(framebuffer);
      SafeDelete(program);
  }
  
  }  // anonymous namespace
  

Download