kc3-lang/angle/src/tests/gl_tests/StateChangeTest.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Yuly Novikov
  Date : 2019-04-09 09:15:59
  Hash : 0086a8ac
  Message : Skip LineLoopStateChangeTest.DrawElementsThenDrawArrays on Win Vulkan AMD Bug: angleproject:3361 Change-Id: I39c595e1b8ab73520422e2dd3433cd007a1415a1 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1559789 Reviewed-by: Yuly Novikov <ynovikov@chromium.org> Commit-Queue: Yuly Novikov <ynovikov@chromium.org>

• src/tests/gl_tests/StateChangeTest.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.
  //
  // StateChangeTest:
  //   Specifically designed for an ANGLE implementation of GL, these tests validate that
  //   ANGLE's dirty bits systems don't get confused by certain sequences of state changes.
  //
  
  #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  
  using namespace angle;
  
  namespace
  {
  
  class StateChangeTest : public ANGLETest
  {
    protected:
      StateChangeTest()
      {
          setWindowWidth(64);
          setWindowHeight(64);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
  
          // Enable the no error extension to avoid syncing the FBO state on validation.
          setNoErrorEnabled(true);
      }
  
      void SetUp() override
      {
          ANGLETest::SetUp();
  
          glGenFramebuffers(1, &mFramebuffer);
          glGenTextures(2, mTextures.data());
          glGenRenderbuffers(1, &mRenderbuffer);
  
          ASSERT_GL_NO_ERROR();
      }
  
      void TearDown() override
      {
          if (mFramebuffer != 0)
          {
              glDeleteFramebuffers(1, &mFramebuffer);
              mFramebuffer = 0;
          }
  
          if (!mTextures.empty())
          {
              glDeleteTextures(static_cast<GLsizei>(mTextures.size()), mTextures.data());
              mTextures.clear();
          }
  
          glDeleteRenderbuffers(1, &mRenderbuffer);
  
          ANGLETest::TearDown();
      }
  
      GLuint mFramebuffer           = 0;
      GLuint mRenderbuffer          = 0;
      std::vector<GLuint> mTextures = {0, 0};
  };
  
  class StateChangeTestES3 : public StateChangeTest
  {
    protected:
      StateChangeTestES3() {}
  };
  
  // Ensure that CopyTexImage2D syncs framebuffer changes.
  TEST_P(StateChangeTest, CopyTexImage2DSync)
  {
      // TODO(geofflang): Fix on Linux AMD drivers (http://anglebug.com/1291)
      ANGLE_SKIP_TEST_IF(IsAMD() && IsOpenGL());
  
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      // Init first texture to red
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      // Init second texture to green
      glBindTexture(GL_TEXTURE_2D, mTextures[1]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[1], 0);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
  
      // Copy in the red texture to the green one.
      // CopyTexImage should sync the framebuffer attachment change.
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 16, 16, 0);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[1], 0);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Ensure that CopyTexSubImage2D syncs framebuffer changes.
  TEST_P(StateChangeTest, CopyTexSubImage2DSync)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      // Init first texture to red
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      // Init second texture to green
      glBindTexture(GL_TEXTURE_2D, mTextures[1]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[1], 0);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
  
      // Copy in the red texture to the green one.
      // CopyTexImage should sync the framebuffer attachment change.
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 16, 16);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[1], 0);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that Framebuffer completeness caching works when color attachments change.
  TEST_P(StateChangeTest, FramebufferIncompleteColorAttachment)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture at color attachment 0 to be non-color-renderable.
      glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 16, 0, GL_ALPHA, GL_UNSIGNED_BYTE, nullptr);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that caching works when color attachments change with TexStorage.
  TEST_P(StateChangeTest, FramebufferIncompleteWithTexStorage)
  {
      ANGLE_SKIP_TEST_IF(!extensionEnabled("GL_EXT_texture_storage"));
  
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture at color attachment 0 to be non-color-renderable.
      glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_ALPHA8_EXT, 16, 16);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that caching works when color attachments change with CompressedTexImage2D.
  TEST_P(StateChangeTestES3, FramebufferIncompleteWithCompressedTex)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture at color attachment 0 to be non-color-renderable.
      glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, 128, nullptr);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that caching works when color attachments are deleted.
  TEST_P(StateChangeTestES3, FramebufferIncompleteWhenAttachmentDeleted)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Delete the texture at color attachment 0.
      glDeleteTextures(1, &mTextures[0]);
      mTextures[0] = 0;
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that Framebuffer completeness caching works when depth attachments change.
  TEST_P(StateChangeTest, FramebufferIncompleteDepthAttachment)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glBindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 16, 16);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mRenderbuffer);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture at color attachment 0 to be non-depth-renderable.
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that Framebuffer completeness caching works when stencil attachments change.
  TEST_P(StateChangeTest, FramebufferIncompleteStencilAttachment)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glBindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, 16, 16);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                                mRenderbuffer);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture at the stencil attachment to be non-stencil-renderable.
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that Framebuffer completeness caching works when depth-stencil attachments change.
  TEST_P(StateChangeTest, FramebufferIncompleteDepthStencilAttachment)
  {
      ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3 &&
                         !extensionEnabled("GL_OES_packed_depth_stencil"));
  
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glBindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                                mRenderbuffer);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Change the texture the depth-stencil attachment to be non-depth-stencil-renderable.
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  }
  
  const char kSimpleAttributeVS[] = R"(attribute vec2 position;
  attribute vec4 testAttrib;
  varying vec4 testVarying;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      testVarying = testAttrib;
  })";
  
  const char kSimpleAttributeFS[] = R"(precision mediump float;
  varying vec4 testVarying;
  void main()
  {
      gl_FragColor = testVarying;
  })";
  
  // Tests that using a buffered attribute, then disabling it and using current value, works.
  TEST_P(StateChangeTest, DisablingBufferedVertexAttribute)
  {
      ANGLE_GL_PROGRAM(program, kSimpleAttributeVS, kSimpleAttributeFS);
      glUseProgram(program);
      GLint attribLoc   = glGetAttribLocation(program, "testAttrib");
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, attribLoc);
      ASSERT_NE(-1, positionLoc);
  
      // Set up the buffered attribute.
      std::vector<GLColor> red(6, GLColor::red);
      GLBuffer attribBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, attribBuffer);
      glBufferData(GL_ARRAY_BUFFER, red.size() * sizeof(GLColor), red.data(), GL_STATIC_DRAW);
      glEnableVertexAttribArray(attribLoc);
      glVertexAttribPointer(attribLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
  
      // Also set the current value to green now.
      glVertexAttrib4f(attribLoc, 0.0f, 1.0f, 0.0f, 1.0f);
  
      // Set up the position attribute as well.
      setupQuadVertexBuffer(0.5f, 1.0f);
      glEnableVertexAttribArray(positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
  
      // Draw with the buffered attribute. Verify red.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Draw with the disabled "current value attribute". Verify green.
      glDisableVertexAttribArray(attribLoc);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Verify setting buffer data on the disabled buffer doesn't change anything.
      std::vector<GLColor> blue(128, GLColor::blue);
      glBindBuffer(GL_ARRAY_BUFFER, attribBuffer);
      glBufferData(GL_ARRAY_BUFFER, blue.size() * sizeof(GLColor), blue.data(), GL_STATIC_DRAW);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests that setting value for a subset of default attributes doesn't affect others.
  TEST_P(StateChangeTest, SetCurrentAttribute)
  {
      constexpr char kVS[] = R"(attribute vec4 position;
  attribute mat4 testAttrib;  // Note that this generates 4 attributes
  varying vec4 testVarying;
  void main (void)
  {
      gl_Position = position;
  
      testVarying = position.y < 0.0 ?
                      position.x < 0.0 ? testAttrib[0] : testAttrib[1] :
                      position.x < 0.0 ? testAttrib[2] : testAttrib[3];
  })";
  
      ANGLE_GL_PROGRAM(program, kVS, kSimpleAttributeFS);
      glUseProgram(program);
      GLint attribLoc   = glGetAttribLocation(program, "testAttrib");
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, attribLoc);
      ASSERT_NE(-1, positionLoc);
  
      // Set the current value of two of the test attributes, while leaving the other two as default.
      glVertexAttrib4f(attribLoc + 1, 0.0f, 1.0f, 0.0f, 1.0f);
      glVertexAttrib4f(attribLoc + 2, 0.0f, 0.0f, 1.0f, 1.0f);
  
      // Set up the position attribute.
      setupQuadVertexBuffer(0.5f, 1.0f);
      glEnableVertexAttribArray(positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
  
      // Draw and verify the four section in the output:
      //
      //  +---------------+
      //  | Black | Green |
      //  +-------+-------+
      //  | Blue  | Black |
      //  +---------------+
      //
      glDrawArrays(GL_TRIANGLES, 0, 6);
  
      const int w                            = getWindowWidth();
      const int h                            = getWindowHeight();
      constexpr unsigned int kPixelTolerance = 5u;
      EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor::black, kPixelTolerance);
      EXPECT_PIXEL_COLOR_NEAR(w - 1, 0, GLColor::green, kPixelTolerance);
      EXPECT_PIXEL_COLOR_NEAR(0, h - 1, GLColor::blue, kPixelTolerance);
      EXPECT_PIXEL_COLOR_NEAR(w - 1, h - 1, GLColor::black, kPixelTolerance);
  }
  
  // Tests that vertex attribute value is preserved across context switches.
  TEST_P(StateChangeTest, MultiContextVertexAttribute)
  {
      EGLWindow *window   = getEGLWindow();
      EGLDisplay display  = window->getDisplay();
      EGLConfig config    = window->getConfig();
      EGLSurface surface  = window->getSurface();
      EGLContext context1 = window->getContext();
  
      // Set up program in primary context
      ANGLE_GL_PROGRAM(program1, kSimpleAttributeVS, kSimpleAttributeFS);
      glUseProgram(program1);
      GLint attribLoc   = glGetAttribLocation(program1, "testAttrib");
      GLint positionLoc = glGetAttribLocation(program1, "position");
      ASSERT_NE(-1, attribLoc);
      ASSERT_NE(-1, positionLoc);
  
      // Set up the position attribute in primary context
      setupQuadVertexBuffer(0.5f, 1.0f);
      glEnableVertexAttribArray(positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
  
      // Set primary context attribute to green and draw quad
      glVertexAttrib4f(attribLoc, 0.0f, 1.0f, 0.0f, 1.0f);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Set up and switch to secondary context
      EGLint contextAttributes[] = {
          EGL_CONTEXT_MAJOR_VERSION_KHR,
          GetParam().majorVersion,
          EGL_CONTEXT_MINOR_VERSION_KHR,
          GetParam().minorVersion,
          EGL_NONE,
      };
      EGLContext context2 = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttributes);
      ASSERT_NE(context2, EGL_NO_CONTEXT);
      eglMakeCurrent(display, surface, surface, context2);
  
      // Set up program in secondary context
      ANGLE_GL_PROGRAM(program2, kSimpleAttributeVS, kSimpleAttributeFS);
      glUseProgram(program2);
      ASSERT_EQ(attribLoc, glGetAttribLocation(program2, "testAttrib"));
      ASSERT_EQ(positionLoc, glGetAttribLocation(program2, "position"));
  
      // Set up the position attribute in secondary context
      setupQuadVertexBuffer(0.5f, 1.0f);
      glEnableVertexAttribArray(positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
  
      // attribLoc current value should be default - (0,0,0,1)
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
  
      // Restore primary context
      eglMakeCurrent(display, surface, surface, context1);
      // ReadPixels to ensure context is switched
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
  
      // Switch to secondary context second time
      eglMakeCurrent(display, surface, surface, context2);
      // Check that it still draws black
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
  
      // Restore primary context second time
      eglMakeCurrent(display, surface, surface, context1);
      // Check if it still draws green
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Clean up
      eglDestroyContext(display, context2);
  }
  
  // Ensure that CopyTexSubImage3D syncs framebuffer changes.
  TEST_P(StateChangeTestES3, CopyTexSubImage3DSync)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      // Init first texture to red
      glBindTexture(GL_TEXTURE_3D, mTextures[0]);
      glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTextures[0], 0, 0);
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      // Init second texture to green
      glBindTexture(GL_TEXTURE_3D, mTextures[1]);
      glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTextures[1], 0, 0);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
  
      // Copy in the red texture to the green one.
      // CopyTexImage should sync the framebuffer attachment change.
      glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTextures[0], 0, 0);
      glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 16, 16);
      glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTextures[1], 0, 0);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Ensure that BlitFramebuffer syncs framebuffer changes.
  TEST_P(StateChangeTestES3, BlitFramebufferSync)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      // Init first texture to red
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      // Init second texture to green
      glBindTexture(GL_TEXTURE_2D, mTextures[1]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[1], 0);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
  
      // Change to the red textures and blit.
      // BlitFramebuffer should sync the framebuffer attachment change.
      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
      glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0],
                             0);
      glBlitFramebuffer(0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Ensure that ReadBuffer and DrawBuffers sync framebuffer changes.
  TEST_P(StateChangeTestES3, ReadBufferAndDrawBuffersSync)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      // Initialize two FBO attachments
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
      glBindTexture(GL_TEXTURE_2D, mTextures[1]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, mTextures[1], 0);
  
      // Clear first attachment to red
      GLenum bufs1[] = {GL_COLOR_ATTACHMENT0, GL_NONE};
      glDrawBuffers(2, bufs1);
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Clear second texture to green
      GLenum bufs2[] = {GL_NONE, GL_COLOR_ATTACHMENT1};
      glDrawBuffers(2, bufs2);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Verify first attachment is red and second is green
      glReadBuffer(GL_COLOR_ATTACHMENT1);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
  
      glReadBuffer(GL_COLOR_ATTACHMENT0);
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Tests calling invalidate on incomplete framebuffers after switching attachments.
  // Adapted partially from WebGL 2 test "renderbuffers/invalidate-framebuffer"
  TEST_P(StateChangeTestES3, IncompleteRenderbufferAttachmentInvalidateSync)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
      glBindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
      GLint samples = 0;
      glGetInternalformativ(GL_RENDERBUFFER, GL_RGBA8, GL_SAMPLES, 1, &samples);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mRenderbuffer);
      ASSERT_GL_NO_ERROR();
  
      // invalidate the framebuffer when the attachment is incomplete: no storage allocated to the
      // attached renderbuffer
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
                       glCheckFramebufferStatus(GL_FRAMEBUFFER));
      GLenum attachments1[] = {GL_COLOR_ATTACHMENT0};
      glInvalidateFramebuffer(GL_FRAMEBUFFER, 1, attachments1);
      ASSERT_GL_NO_ERROR();
  
      glRenderbufferStorageMultisample(GL_RENDERBUFFER, static_cast<GLsizei>(samples), GL_RGBA8,
                                       getWindowWidth(), getWindowHeight());
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
      glClear(GL_COLOR_BUFFER_BIT);
      ASSERT_GL_NO_ERROR();
  
      GLRenderbuffer renderbuf;
  
      glBindRenderbuffer(GL_RENDERBUFFER, renderbuf.get());
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
                                renderbuf.get());
      ASSERT_GL_NO_ERROR();
  
      // invalidate the framebuffer when the attachment is incomplete: no storage allocated to the
      // attached renderbuffer
      // Note: the bug will only repro *without* a call to checkStatus before the invalidate.
      GLenum attachments2[] = {GL_DEPTH_ATTACHMENT};
      glInvalidateFramebuffer(GL_FRAMEBUFFER, 1, attachments2);
  
      glRenderbufferStorageMultisample(GL_RENDERBUFFER, static_cast<GLsizei>(samples),
                                       GL_DEPTH_COMPONENT16, getWindowWidth(), getWindowHeight());
      EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
      glClear(GL_DEPTH_BUFFER_BIT);
      ASSERT_GL_NO_ERROR();
  }
  
  class StateChangeRenderTest : public StateChangeTest
  {
    protected:
      StateChangeRenderTest() : mProgram(0), mRenderbuffer(0) {}
  
      void SetUp() override
      {
          StateChangeTest::SetUp();
  
          constexpr char kVS[] =
              "attribute vec2 position;\n"
              "void main() {\n"
              "    gl_Position = vec4(position, 0, 1);\n"
              "}";
          constexpr char kFS[] =
              "uniform highp vec4 uniformColor;\n"
              "void main() {\n"
              "    gl_FragColor = uniformColor;\n"
              "}";
  
          mProgram = CompileProgram(kVS, kFS);
          ASSERT_NE(0u, mProgram);
  
          glGenRenderbuffers(1, &mRenderbuffer);
      }
  
      void TearDown() override
      {
          glDeleteProgram(mProgram);
          glDeleteRenderbuffers(1, &mRenderbuffer);
  
          StateChangeTest::TearDown();
      }
  
      void setUniformColor(const GLColor &color)
      {
          glUseProgram(mProgram);
          const Vector4 &normalizedColor = color.toNormalizedVector();
          GLint uniformLocation          = glGetUniformLocation(mProgram, "uniformColor");
          ASSERT_NE(-1, uniformLocation);
          glUniform4fv(uniformLocation, 1, normalizedColor.data());
      }
  
      GLuint mProgram;
      GLuint mRenderbuffer;
  };
  
  // Test that re-creating a currently attached texture works as expected.
  TEST_P(StateChangeRenderTest, RecreateTexture)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Draw with red to the FBO.
      GLColor red(255, 0, 0, 255);
      setUniformColor(red);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, red);
  
      // Recreate the texture with green.
      GLColor green(0, 255, 0, 255);
      std::vector<GLColor> greenPixels(32 * 32, green);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                   greenPixels.data());
      EXPECT_PIXEL_COLOR_EQ(0, 0, green);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Verify drawing blue gives blue. This covers the FBO sync with D3D dirty bits.
      GLColor blue(0, 0, 255, 255);
      setUniformColor(blue);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, blue);
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Test that re-creating a currently attached renderbuffer works as expected.
  TEST_P(StateChangeRenderTest, RecreateRenderbuffer)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      glBindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mRenderbuffer);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Draw with red to the FBO.
      GLColor red(255, 0, 0, 255);
      setUniformColor(red);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, red);
  
      // Recreate the renderbuffer and clear to green.
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 32, 32);
      glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
      GLColor green(0, 255, 0, 255);
      EXPECT_PIXEL_COLOR_EQ(0, 0, green);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Verify drawing blue gives blue. This covers the FBO sync with D3D dirty bits.
      GLColor blue(0, 0, 255, 255);
      setUniformColor(blue);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, blue);
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Test that recreating a texture with GenerateMipmaps signals the FBO is dirty.
  TEST_P(StateChangeRenderTest, GenerateMipmap)
  {
      glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
  
      glBindTexture(GL_TEXTURE_2D, mTextures[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glTexImage2D(GL_TEXTURE_2D, 2, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTextures[0], 0);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Draw once to set the RenderTarget in D3D11
      GLColor red(255, 0, 0, 255);
      setUniformColor(red);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, red);
  
      // This will trigger the texture to be re-created on FL9_3.
      glGenerateMipmap(GL_TEXTURE_2D);
  
      // Explictly check FBO status sync in some versions of ANGLE no_error skips FBO checks.
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Now ensure we don't have a stale render target.
      GLColor blue(0, 0, 255, 255);
      setUniformColor(blue);
      drawQuad(mProgram, "position", 0.5f);
      EXPECT_PIXEL_COLOR_EQ(0, 0, blue);
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Tests that gl_DepthRange syncs correctly after a change.
  TEST_P(StateChangeRenderTest, DepthRangeUpdates)
  {
      // http://anglebug.com/2598: Seems to be an Intel driver bug.
      ANGLE_SKIP_TEST_IF(IsIntel() && IsOpenGL() && IsWindows());
  
      constexpr char kFragCoordShader[] = R"(void main()
  {
      if (gl_DepthRange.near == 0.2)
      {
          gl_FragColor = vec4(1, 0, 0, 1);
      }
      else if (gl_DepthRange.near == 0.5)
      {
          gl_FragColor = vec4(0, 1, 0, 1);
      }
      else
      {
          gl_FragColor = vec4(0, 0, 1, 1);
      }
  })";
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), kFragCoordShader);
      glUseProgram(program);
  
      const auto &quadVertices = GetQuadVertices();
  
      ASSERT_EQ(0, glGetAttribLocation(program, essl1_shaders::PositionAttrib()));
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, quadVertices.size() * sizeof(quadVertices[0]),
                   quadVertices.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(0u, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(0u);
  
      // First, clear.
      glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Draw to left half viewport with a first depth range.
      glDepthRangef(0.2f, 1.0f);
      glViewport(0, 0, getWindowWidth() / 2, getWindowHeight());
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Draw to right half viewport with a second depth range.
      glDepthRangef(0.5f, 1.0f);
      glViewport(getWindowWidth() / 2, 0, getWindowWidth() / 2, getWindowHeight());
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Verify left half of the framebuffer is red and right half is green.
      EXPECT_PIXEL_RECT_EQ(0, 0, getWindowWidth() / 2, getWindowHeight(), GLColor::red);
      EXPECT_PIXEL_RECT_EQ(getWindowWidth() / 2, 0, getWindowWidth() / 2, getWindowHeight(),
                           GLColor::green);
  }
  
  // Tests that D3D11 dirty bit updates don't forget about BufferSubData attrib updates.
  TEST_P(StateChangeTest, VertexBufferUpdatedAfterDraw)
  {
      // TODO(jie.a.chen@intel.com): Re-enable the test once the driver fix is
      // available in public release.
      // http://anglebug.com/2664.
      ANGLE_SKIP_TEST_IF(IsVulkan() && IsIntel());
  
      constexpr char kVS[] =
          "attribute vec2 position;\n"
          "attribute vec4 color;\n"
          "varying vec4 outcolor;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(position, 0, 1);\n"
          "    outcolor = color;\n"
          "}";
      constexpr char kFS[] =
          "varying mediump vec4 outcolor;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = outcolor;\n"
          "}";
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
      glUseProgram(program);
  
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLoc);
  
      setupQuadVertexBuffer(0.5f, 1.0f);
      glEnableVertexAttribArray(positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
  
      GLBuffer colorBuf;
      glBindBuffer(GL_ARRAY_BUFFER, colorBuf);
      glVertexAttribPointer(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(colorLoc);
  
      // Fill with green.
      std::vector<GLColor> colorData(6, GLColor::green);
      glBufferData(GL_ARRAY_BUFFER, colorData.size() * sizeof(GLColor), colorData.data(),
                   GL_STATIC_DRAW);
  
      // Draw, expect green.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
      ASSERT_GL_NO_ERROR();
  
      // Update buffer with red.
      std::fill(colorData.begin(), colorData.end(), GLColor::red);
      glBufferSubData(GL_ARRAY_BUFFER, 0, colorData.size() * sizeof(GLColor), colorData.data());
  
      // Draw, expect red.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that switching VAOs keeps the disabled "current value" attributes up-to-date.
  TEST_P(StateChangeTestES3, VertexArrayObjectAndDisabledAttributes)
  {
      constexpr char kSingleVS[] = "attribute vec4 position; void main() { gl_Position = position; }";
      constexpr char kSingleFS[] = "void main() { gl_FragColor = vec4(1, 0, 0, 1); }";
      ANGLE_GL_PROGRAM(singleProgram, kSingleVS, kSingleFS);
  
      constexpr char kDualVS[] =
          "#version 300 es\n"
          "in vec4 position;\n"
          "in vec4 color;\n"
          "out vec4 varyColor;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = position;\n"
          "    varyColor = color;\n"
          "}";
      constexpr char kDualFS[] =
          "#version 300 es\n"
          "precision mediump float;\n"
          "in vec4 varyColor;\n"
          "out vec4 colorOut;\n"
          "void main()\n"
          "{\n"
          "    colorOut = varyColor;\n"
          "}";
      ANGLE_GL_PROGRAM(dualProgram, kDualVS, kDualFS);
      GLint positionLocation = glGetAttribLocation(dualProgram, "position");
      ASSERT_NE(-1, positionLocation);
      GLint colorLocation = glGetAttribLocation(dualProgram, "color");
      ASSERT_NE(-1, colorLocation);
  
      GLint singlePositionLocation = glGetAttribLocation(singleProgram, "position");
      ASSERT_NE(-1, singlePositionLocation);
  
      glUseProgram(singleProgram);
  
      // Initialize position vertex buffer.
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * 6, quadVertices.data(), GL_STATIC_DRAW);
  
      // Initialize a VAO. Draw with single program.
      GLVertexArray vertexArray;
      glBindVertexArray(vertexArray);
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glVertexAttribPointer(singlePositionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(singlePositionLocation);
  
      // Should draw red.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Draw with a green buffer attribute, without the VAO.
      glBindVertexArray(0);
      glUseProgram(dualProgram);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLocation);
  
      std::vector<GLColor> greenColors(6, GLColor::green);
      GLBuffer greenBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, greenBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(GLColor) * 6, greenColors.data(), GL_STATIC_DRAW);
  
      glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_FALSE, 4, nullptr);
      glEnableVertexAttribArray(colorLocation);
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Re-bind VAO and try to draw with different program, without changing state.
      // Should draw black since current value is not initialized.
      glBindVertexArray(vertexArray);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
  }
  
  const char kSamplerMetadataVertexShader0[] = R"(#version 300 es
  precision mediump float;
  out vec4 color;
  uniform sampler2D texture;
  void main()
  {
      vec2 size = vec2(textureSize(texture, 0));
      color = size.x != 0.0 ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 0.0);
      vec2 pos = vec2(0.0);
      switch (gl_VertexID) {
          case 0: pos = vec2(-1.0, -1.0); break;
          case 1: pos = vec2(3.0, -1.0); break;
          case 2: pos = vec2(-1.0, 3.0); break;
      };
      gl_Position = vec4(pos, 0.0, 1.0);
  })";
  
  const char kSamplerMetadataVertexShader1[] = R"(#version 300 es
  precision mediump float;
  out vec4 color;
  uniform sampler2D texture1;
  uniform sampler2D texture2;
  void main()
  {
      vec2 size1 = vec2(textureSize(texture1, 0));
      vec2 size2 = vec2(textureSize(texture2, 0));
      color = size1.x * size2.x != 0.0 ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 0.0);
      vec2 pos = vec2(0.0);
      switch (gl_VertexID) {
          case 0: pos = vec2(-1.0, -1.0); break;
          case 1: pos = vec2(3.0, -1.0); break;
          case 2: pos = vec2(-1.0, 3.0); break;
      };
      gl_Position = vec4(pos, 0.0, 1.0);
  })";
  
  const char kSamplerMetadataFragmentShader[] = R"(#version 300 es
  precision mediump float;
  in vec4 color;
  out vec4 result;
  void main()
  {
      result = color;
  })";
  
  // Tests that changing an active program invalidates the sampler metadata properly.
  TEST_P(StateChangeTestES3, SamplerMetadataUpdateOnSetProgram)
  {
      GLVertexArray vertexArray;
      glBindVertexArray(vertexArray);
  
      // Create a simple framebuffer.
      GLTexture texture1, texture2;
      glActiveTexture(GL_TEXTURE0);
      glBindTexture(GL_TEXTURE_2D, texture1);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glActiveTexture(GL_TEXTURE1);
      glBindTexture(GL_TEXTURE_2D, texture2);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  
      // Create 2 shader programs differing only in the number of active samplers.
      ANGLE_GL_PROGRAM(program1, kSamplerMetadataVertexShader0, kSamplerMetadataFragmentShader);
      glUseProgram(program1);
      glUniform1i(glGetUniformLocation(program1, "texture"), 0);
      ANGLE_GL_PROGRAM(program2, kSamplerMetadataVertexShader1, kSamplerMetadataFragmentShader);
      glUseProgram(program2);
      glUniform1i(glGetUniformLocation(program2, "texture1"), 0);
      glUniform1i(glGetUniformLocation(program2, "texture2"), 0);
  
      // Draw a solid green color to the framebuffer.
      glUseProgram(program1);
      glDrawArrays(GL_TRIANGLES, 0, 3);
      // Test that our first program is good.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Bind a different program that uses more samplers.
      // Draw another quad that depends on the sampler metadata.
      glUseProgram(program2);
      glDrawArrays(GL_TRIANGLES, 0, 3);
      // Flush via ReadPixels and check that it's still green.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      ASSERT_GL_NO_ERROR();
  }
  
  // Tests that redefining Buffer storage syncs with the Transform Feedback object.
  TEST_P(StateChangeTestES3, RedefineTransformFeedbackBuffer)
  {
      // Create the most simple program possible - simple a passthrough for a float attribute.
      constexpr char kVertexShader[] = R"(#version 300 es
  in float valueIn;
  out float valueOut;
  void main()
  {
      gl_Position = vec4(0, 0, 0, 0);
      valueOut = valueIn;
  })";
  
      constexpr char kFragmentShader[] = R"(#version 300 es
  out mediump float dummy;
  void main()
  {
      dummy = 1.0;
  })";
  
      std::vector<std::string> tfVaryings = {"valueOut"};
      ANGLE_GL_PROGRAM_TRANSFORM_FEEDBACK(program, kVertexShader, kFragmentShader, tfVaryings,
                                          GL_SEPARATE_ATTRIBS);
      glUseProgram(program);
  
      GLint attribLoc = glGetAttribLocation(program, "valueIn");
      ASSERT_NE(-1, attribLoc);
  
      // Disable rasterization - we're not interested in the framebuffer.
      glEnable(GL_RASTERIZER_DISCARD);
  
      // Initialize a float vertex buffer with 1.0.
      std::vector<GLfloat> data1(16, 1.0);
      GLsizei size1 = static_cast<GLsizei>(sizeof(GLfloat) * data1.size());
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, size1, data1.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(attribLoc, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(attribLoc);
  
      ASSERT_GL_NO_ERROR();
  
      // Initialize a same-sized XFB buffer.
      GLBuffer xfbBuffer;
      glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfbBuffer);
      glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, size1, nullptr, GL_STATIC_DRAW);
  
      // Draw with XFB enabled.
      GLTransformFeedback xfb;
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb);
      glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfbBuffer);
  
      glBeginTransformFeedback(GL_POINTS);
      glDrawArrays(GL_POINTS, 0, 16);
      glEndTransformFeedback();
  
      ASSERT_GL_NO_ERROR();
  
      // Verify the XFB stage caught the 1.0 attribute values.
      void *mapped1     = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size1, GL_MAP_READ_BIT);
      GLfloat *asFloat1 = reinterpret_cast<GLfloat *>(mapped1);
      std::vector<GLfloat> actualData1(asFloat1, asFloat1 + data1.size());
      EXPECT_EQ(data1, actualData1);
      glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
  
      // Now, reinitialize the XFB buffer to a larger size, and draw with 2.0.
      std::vector<GLfloat> data2(128, 2.0);
      const GLsizei size2 = static_cast<GLsizei>(sizeof(GLfloat) * data2.size());
      glBufferData(GL_ARRAY_BUFFER, size2, data2.data(), GL_STATIC_DRAW);
      glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, size2, nullptr, GL_STATIC_DRAW);
  
      glBeginTransformFeedback(GL_POINTS);
      glDrawArrays(GL_POINTS, 0, 128);
      glEndTransformFeedback();
  
      ASSERT_GL_NO_ERROR();
  
      // Verify the XFB stage caught the 2.0 attribute values.
      void *mapped2     = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size2, GL_MAP_READ_BIT);
      GLfloat *asFloat2 = reinterpret_cast<GLfloat *>(mapped2);
      std::vector<GLfloat> actualData2(asFloat2, asFloat2 + data2.size());
      EXPECT_EQ(data2, actualData2);
      glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
  }
  
  // Simple state change tests for line loop drawing. There is some very specific handling of line
  // line loops in Vulkan and we need to test switching between drawElements and drawArrays calls to
  // validate every edge cases.
  class LineLoopStateChangeTest : public StateChangeTest
  {
    protected:
      LineLoopStateChangeTest()
      {
          setWindowWidth(32);
          setWindowHeight(32);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      void validateSquareAndHourglass()
      {
          ASSERT_GL_NO_ERROR();
  
          int quarterWidth  = getWindowWidth() / 4;
          int quarterHeight = getWindowHeight() / 4;
  
          // Bottom left
          EXPECT_PIXEL_COLOR_EQ(quarterWidth, quarterHeight, GLColor::blue);
  
          // Top left
          EXPECT_PIXEL_COLOR_EQ(quarterWidth, (quarterHeight * 3), GLColor::blue);
  
          // Top right
          // The last pixel isn't filled on a line loop so we check the pixel right before.
          EXPECT_PIXEL_COLOR_EQ((quarterWidth * 3), (quarterHeight * 3) - 1, GLColor::blue);
  
          // dead center to validate the hourglass.
          EXPECT_PIXEL_COLOR_EQ((quarterWidth * 2), quarterHeight * 2, GLColor::blue);
  
          // Verify line is closed between the 2 last vertices
          EXPECT_PIXEL_COLOR_EQ((quarterWidth * 2), quarterHeight, GLColor::blue);
      }
  
      GLint mPositionLocation;
  };
  
  // Draw an hourglass with a drawElements call followed by a square with drawArrays.
  TEST_P(LineLoopStateChangeTest, DrawElementsThenDrawArrays)
  {
      // http://anglebug.com/3361
      ANGLE_SKIP_TEST_IF(IsAMD() && IsVulkan() && IsWindows());
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Blue());
      glUseProgram(program);
  
      // We expect to draw a square with these 4 vertices with a drawArray call.
      std::vector<Vector3> vertices;
      CreatePixelCenterWindowCoords({{8, 8}, {8, 24}, {24, 8}, {24, 24}}, getWindowWidth(),
                                    getWindowHeight(), &vertices);
  
      // If we use these indices to draw however, we should be drawing an hourglass.
      auto indices = std::vector<GLushort>{0, 2, 1, 3};
  
      mPositionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_NE(-1, mPositionLocation);
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
  
      GLBuffer indexBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLushort), &indices[0],
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(mPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(mPositionLocation);
      glClear(GL_COLOR_BUFFER_BIT);
      glDrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, nullptr);  // hourglass
      glDrawArrays(GL_LINE_LOOP, 0, 4);                             // square
      glDisableVertexAttribArray(mPositionLocation);
  
      validateSquareAndHourglass();
  }
  
  // Draw line loop using a drawArrays followed by an hourglass with drawElements.
  TEST_P(LineLoopStateChangeTest, DrawArraysThenDrawElements)
  {
      // http://anglebug.com/2856: Seems to fail on older drivers and pass on newer.
      // Tested failing on 18.3.3 and passing on 18.9.2.
      ANGLE_SKIP_TEST_IF(IsAMD() && IsVulkan() && IsWindows());
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Blue());
      glUseProgram(program);
  
      // We expect to draw a square with these 4 vertices with a drawArray call.
      std::vector<Vector3> vertices;
      CreatePixelCenterWindowCoords({{8, 8}, {8, 24}, {24, 8}, {24, 24}}, getWindowWidth(),
                                    getWindowHeight(), &vertices);
  
      // If we use these indices to draw however, we should be drawing an hourglass.
      auto indices = std::vector<GLushort>{0, 2, 1, 3};
  
      mPositionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_NE(-1, mPositionLocation);
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
  
      GLBuffer indexBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLushort), &indices[0],
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(mPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(mPositionLocation);
      glClear(GL_COLOR_BUFFER_BIT);
      glDrawArrays(GL_LINE_LOOP, 0, 4);                             // square
      glDrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, nullptr);  // hourglass
      glDisableVertexAttribArray(mPositionLocation);
  
      validateSquareAndHourglass();
  }
  
  // Simple state change tests, primarily focused on basic object lifetime and dependency management
  // with back-ends that don't support that automatically (i.e. Vulkan).
  class SimpleStateChangeTest : public ANGLETest
  {
    protected:
      static constexpr int kWindowSize = 64;
  
      SimpleStateChangeTest()
      {
          setWindowWidth(kWindowSize);
          setWindowHeight(kWindowSize);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      void simpleDrawWithBuffer(GLBuffer *buffer);
      void simpleDrawWithColor(const GLColor &color);
  };
  
  class SimpleStateChangeTestES3 : public SimpleStateChangeTest
  {};
  
  class SimpleStateChangeTestES31 : public SimpleStateChangeTest
  {
    protected:
      void SetUp() override
      {
          ANGLETest::SetUp();
  
          glGenFramebuffers(1, &mFramebuffer);
          glGenTextures(1, &mTexture);
  
          glBindTexture(GL_TEXTURE_2D, mTexture);
          glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
          EXPECT_GL_NO_ERROR();
  
          constexpr char kCS[] = R"(#version 310 es
  layout(local_size_x=2, local_size_y=2) in;
  layout (rgba8, binding = 0) readonly uniform highp image2D srcImage;
  layout (rgba8, binding = 1) writeonly uniform highp image2D dstImage;
  void main()
  {
      imageStore(dstImage, ivec2(gl_LocalInvocationID.xy),
                 imageLoad(srcImage, ivec2(gl_LocalInvocationID.xy)));
  })";
  
          mProgram = CompileComputeProgram(kCS);
          ASSERT_NE(mProgram, 0u);
  
          glBindImageTexture(1, mTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
  
          glBindFramebuffer(GL_READ_FRAMEBUFFER, mFramebuffer);
          glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexture,
                                 0);
  
          ASSERT_GL_NO_ERROR();
      }
  
      void TearDown() override
      {
          if (mFramebuffer != 0)
          {
              glDeleteFramebuffers(1, &mFramebuffer);
              mFramebuffer = 0;
          }
  
          if (mTexture != 0)
          {
              glDeleteTextures(1, &mTexture);
              mTexture = 0;
          }
          glDeleteProgram(mProgram);
          ANGLETest::TearDown();
      }
  
      GLuint mProgram;
      GLuint mFramebuffer = 0;
      GLuint mTexture     = 0;
  };
  
  constexpr char kSimpleVertexShader[] = R"(attribute vec2 position;
  attribute vec4 color;
  varying vec4 vColor;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      vColor = color;
  }
  )";
  
  constexpr char kSimpleFragmentShader[] = R"(precision mediump float;
  varying vec4 vColor;
  void main()
  {
      gl_FragColor = vColor;
  }
  )";
  
  void SimpleStateChangeTest::simpleDrawWithBuffer(GLBuffer *buffer)
  {
      ANGLE_GL_PROGRAM(program, kSimpleVertexShader, kSimpleFragmentShader);
      glUseProgram(program);
  
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
  
      glBindBuffer(GL_ARRAY_BUFFER, *buffer);
      glVertexAttribPointer(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(colorLoc);
  
      drawQuad(program, "position", 0.5f, 1.0f, true);
      ASSERT_GL_NO_ERROR();
  }
  
  void SimpleStateChangeTest::simpleDrawWithColor(const GLColor &color)
  {
      std::vector<GLColor> colors(6, color);
      GLBuffer colorBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
      glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(GLColor), colors.data(), GL_STATIC_DRAW);
      simpleDrawWithBuffer(&colorBuffer);
  }
  
  // Test that we can do a drawElements call successfully after making a drawArrays call in the same
  // frame.
  TEST_P(SimpleStateChangeTest, DrawArraysThenDrawElements)
  {
      // http://anglebug.com/3124: Flaky on Nexus5X.
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Blue());
      glUseProgram(program);
  
      // We expect to draw a triangle with the first 3 points to the left, then another triangle with
      // the last 3 vertices using a drawElements call.
      auto vertices = std::vector<Vector3>{{-1.0f, -1.0f, 0.0f},
                                           {-1.0f, 1.0f, 0.0f},
                                           {0.0f, 0.0f, 0.0f},
                                           {1.0f, 1.0f, 0.0f},
                                           {1.0f, -1.0f, 0.0f}};
  
      // If we use these indices to draw we'll be using the last 2 vertex only to draw.
      auto indices = std::vector<GLushort>{2, 3, 4};
  
      GLint positionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLocation);
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
  
      GLBuffer indexBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLushort), &indices[0],
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLocation);
  
      for (int i = 0; i < 10; i++)
      {
          glClear(GL_COLOR_BUFFER_BIT);
          glDrawArrays(GL_TRIANGLES, 0, 3);                             // triangle to the left
          glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, nullptr);  // triangle to the right
          swapBuffers();
      }
      glDisableVertexAttribArray(positionLocation);
  
      ASSERT_GL_NO_ERROR();
  
      int quarterWidth = getWindowWidth() / 4;
      int halfHeight   = getWindowHeight() / 2;
  
      // Validate triangle to the left
      EXPECT_PIXEL_COLOR_EQ(quarterWidth, halfHeight, GLColor::blue);
  
      // Validate triangle to the right
      EXPECT_PIXEL_COLOR_EQ((quarterWidth * 3), halfHeight, GLColor::blue);
  }
  
  // Handles deleting a Buffer when it's being used.
  TEST_P(SimpleStateChangeTest, DeleteBufferInUse)
  {
      std::vector<GLColor> colorData(6, GLColor::red);
  
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(GLColor) * colorData.size(), colorData.data(),
                   GL_STATIC_DRAW);
  
      simpleDrawWithBuffer(&buffer);
  
      buffer.reset();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  }
  
  // Tests that resizing a Buffer during a draw works as expected.
  TEST_P(SimpleStateChangeTest, RedefineBufferInUse)
  {
      std::vector<GLColor> redColorData(6, GLColor::red);
  
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(GLColor) * redColorData.size(), redColorData.data(),
                   GL_STATIC_DRAW);
  
      // Trigger a pull from the buffer.
      simpleDrawWithBuffer(&buffer);
  
      // Redefine the buffer that's in-flight.
      std::vector<GLColor> greenColorData(1024, GLColor::green);
      glBufferData(GL_ARRAY_BUFFER, sizeof(GLColor) * greenColorData.size(), greenColorData.data(),
                   GL_STATIC_DRAW);
  
      // Trigger the flush and verify the first draw worked.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Draw again and verify the new data is correct.
      simpleDrawWithBuffer(&buffer);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests updating a buffer's contents while in use, without redefining it.
  TEST_P(SimpleStateChangeTest, UpdateBufferInUse)
  {
      // tobine: Started failing w/ custom cmd buffers. http://anglebug.com/3255
      ANGLE_SKIP_TEST_IF(IsAMD() && IsWindows() && IsVulkan());
      std::vector<GLColor> redColorData(6, GLColor::red);
  
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(GLColor) * redColorData.size(), redColorData.data(),
                   GL_STATIC_DRAW);
  
      // Trigger a pull from the buffer.
      simpleDrawWithBuffer(&buffer);
  
      // Update the buffer that's in-flight.
      std::vector<GLColor> greenColorData(6, GLColor::green);
      glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLColor) * greenColorData.size(),
                      greenColorData.data());
  
      // Trigger the flush and verify the first draw worked.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Draw again and verify the new data is correct.
      simpleDrawWithBuffer(&buffer);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests that deleting an in-flight Texture does not immediately delete the resource.
  TEST_P(SimpleStateChangeTest, DeleteTextureInUse)
  {
      std::array<GLColor, 4> colors = {
          {GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      draw2DTexturedQuad(0.5f, 1.0f, true);
      tex.reset();
      EXPECT_GL_NO_ERROR();
  
      int w = getWindowWidth() - 2;
      int h = getWindowHeight() - 2;
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::yellow);
  }
  
  // Tests that modifying a texture parameter in-flight does not cause problems.
  TEST_P(SimpleStateChangeTest, ChangeTextureFilterModeBetweenTwoDraws)
  {
      std::array<GLColor, 4> colors = {
          {GLColor::black, GLColor::white, GLColor::black, GLColor::white}};
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
  
      glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Draw to the left side of the window only with NEAREST.
      glViewport(0, 0, getWindowWidth() / 2, getWindowHeight());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      draw2DTexturedQuad(0.5f, 1.0f, true);
  
      // Draw to the right side of the window only with LINEAR.
      glViewport(getWindowWidth() / 2, 0, getWindowWidth() / 2, getWindowHeight());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      draw2DTexturedQuad(0.5f, 1.0f, true);
      EXPECT_GL_NO_ERROR();
  
      glViewport(0, 0, getWindowWidth(), getWindowHeight());
  
      // The first half (left) should be only black followed by plain white.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
      EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor::black);
      EXPECT_PIXEL_COLOR_EQ((getWindowWidth() / 2) - 3, 0, GLColor::white);
      EXPECT_PIXEL_COLOR_EQ((getWindowWidth() / 2) - 4, 0, GLColor::white);
  
      // The second half (right) should be a gradient so we shouldn't find plain black/white in the
      // middle.
      EXPECT_NE(angle::ReadColor((getWindowWidth() / 4) * 3, 0), GLColor::black);
      EXPECT_NE(angle::ReadColor((getWindowWidth() / 4) * 3, 0), GLColor::white);
  }
  
  // Tests that bind the same texture all the time between different draw calls.
  TEST_P(SimpleStateChangeTest, RebindTextureDrawAgain)
  {
      GLuint program = get2DTexturedQuadProgram();
      glUseProgram(program);
  
      std::array<GLColor, 4> colors = {{GLColor::cyan, GLColor::cyan, GLColor::cyan, GLColor::cyan}};
  
      // Setup the texture
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      // Setup the vertex array to draw a quad.
      GLint positionLocation = glGetAttribLocation(program, "position");
      setupQuadVertexBuffer(1.0f, 1.0f);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(positionLocation);
  
      // Draw quad
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Bind again
      glBindTexture(GL_TEXTURE_2D, tex);
      ASSERT_GL_NO_ERROR();
  
      // Draw again, should still work.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Validate whole surface is filled with cyan.
      int h = getWindowHeight() - 1;
      int w = getWindowWidth() - 1;
  
      EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::cyan);
  }
  
  // Tests that we can draw with a texture, modify the texture with a texSubImage, and then draw again
  // correctly.
  TEST_P(SimpleStateChangeTest, DrawWithTextureTexSubImageThenDrawAgain)
  {
      GLuint program = get2DTexturedQuadProgram();
      ASSERT_NE(0u, program);
      glUseProgram(program);
  
      std::array<GLColor, 4> colors    = {{GLColor::red, GLColor::red, GLColor::red, GLColor::red}};
      std::array<GLColor, 4> subColors = {
          {GLColor::green, GLColor::green, GLColor::green, GLColor::green}};
  
      // Setup the texture
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      // Setup the vertex array to draw a quad.
      GLint positionLocation = glGetAttribLocation(program, "position");
      setupQuadVertexBuffer(1.0f, 1.0f);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(positionLocation);
  
      // Draw quad
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Update bottom-half of texture with green.
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 1, GL_RGBA, GL_UNSIGNED_BYTE, subColors.data());
      ASSERT_GL_NO_ERROR();
  
      // Draw again, should still work.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Validate first half of the screen is red and the bottom is green.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() / 4 * 3, GLColor::red);
  }
  
  // Test that we can alternate between textures between different draws.
  TEST_P(SimpleStateChangeTest, DrawTextureAThenTextureBThenTextureA)
  {
      GLuint program = get2DTexturedQuadProgram();
      glUseProgram(program);
  
      std::array<GLColor, 4> colorsTex1 = {
          {GLColor::cyan, GLColor::cyan, GLColor::cyan, GLColor::cyan}};
  
      std::array<GLColor, 4> colorsTex2 = {
          {GLColor::magenta, GLColor::magenta, GLColor::magenta, GLColor::magenta}};
  
      // Setup the texture
      GLTexture tex1;
      glBindTexture(GL_TEXTURE_2D, tex1);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colorsTex1.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      GLTexture tex2;
      glBindTexture(GL_TEXTURE_2D, tex2);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colorsTex2.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      // Setup the vertex array to draw a quad.
      GLint positionLocation = glGetAttribLocation(program, "position");
      setupQuadVertexBuffer(1.0f, 1.0f);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(positionLocation);
  
      // Draw quad
      glBindTexture(GL_TEXTURE_2D, tex1);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Bind again, draw again
      glBindTexture(GL_TEXTURE_2D, tex2);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Bind again, draw again
      glBindTexture(GL_TEXTURE_2D, tex1);
      glDrawArrays(GL_TRIANGLES, 0, 6);
  
      // Validate whole surface is filled with cyan.
      int h = getWindowHeight() - 1;
      int w = getWindowWidth() - 1;
  
      EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::cyan);
  }
  
  // Tests that redefining an in-flight Texture does not affect the in-flight resource.
  TEST_P(SimpleStateChangeTest, RedefineTextureInUse)
  {
      std::array<GLColor, 4> colors = {
          {GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      // Draw with the first texture.
      draw2DTexturedQuad(0.5f, 1.0f, true);
  
      // Redefine the in-flight texture.
      constexpr int kBigSize = 32;
      std::vector<GLColor> bigColors;
      for (int y = 0; y < kBigSize; ++y)
      {
          for (int x = 0; x < kBigSize; ++x)
          {
              bool xComp = x < kBigSize / 2;
              bool yComp = y < kBigSize / 2;
              if (yComp)
              {
                  bigColors.push_back(xComp ? GLColor::cyan : GLColor::magenta);
              }
              else
              {
                  bigColors.push_back(xComp ? GLColor::yellow : GLColor::white);
              }
          }
      }
  
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, bigColors.data());
      EXPECT_GL_NO_ERROR();
  
      // Verify the first draw had the correct data via ReadPixels.
      int w = getWindowWidth() - 2;
      int h = getWindowHeight() - 2;
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::yellow);
  
      // Draw and verify with the redefined data.
      draw2DTexturedQuad(0.5f, 1.0f, true);
      EXPECT_GL_NO_ERROR();
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::cyan);
      EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::magenta);
      EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::yellow);
      EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::white);
  }
  
  // Test updating a Texture's contents while in use by GL works as expected.
  TEST_P(SimpleStateChangeTest, UpdateTextureInUse)
  {
      std::array<GLColor, 4> rgby = {{GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgby.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      // Draw RGBY to the Framebuffer. The texture is now in-use by GL.
      draw2DTexturedQuad(0.5f, 1.0f, true);
  
      // Update the texture to be YBGR, while the Texture is in-use. Should not affect the draw.
      std::array<GLColor, 4> ybgr = {{GLColor::yellow, GLColor::blue, GLColor::green, GLColor::red}};
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, ybgr.data());
      ASSERT_GL_NO_ERROR();
  
      // Check the Framebuffer. The draw call should have completed with the original RGBY data.
      int w = getWindowWidth() - 2;
      int h = getWindowHeight() - 2;
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::yellow);
  
      // Draw again to the Framebuffer. The second draw call should use the updated YBGR data.
      draw2DTexturedQuad(0.5f, 1.0f, true);
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
      EXPECT_PIXEL_COLOR_EQ(w, 0, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(0, h, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(w, h, GLColor::red);
      ASSERT_GL_NO_ERROR();
  }
  
  // Tests deleting a Framebuffer that is in use.
  TEST_P(SimpleStateChangeTest, DeleteFramebufferInUse)
  {
      constexpr int kSize = 16;
  
      // Create a simple framebuffer.
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      glViewport(0, 0, kSize, kSize);
  
      // Draw a solid red color to the framebuffer.
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
      drawQuad(program, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
  
      // Delete the framebuffer while the call is in flight.
      framebuffer.reset();
  
      // Make a new framebuffer so we can read back the texture.
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Flush via ReadPixels and check red was drawn.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      ASSERT_GL_NO_ERROR();
  }
  
  // This test was made to reproduce a specific issue with our Vulkan backend where were releasing
  // buffers too early. The test has 2 textures, we first create a texture and update it with
  // multiple updates, but we don't use it right away, we instead draw using another texture
  // then we bind the first texture and draw with it.
  TEST_P(SimpleStateChangeTest, DynamicAllocationOfMemoryForTextures)
  {
      constexpr int kSize = 64;
  
      GLuint program = get2DTexturedQuadProgram();
      glUseProgram(program);
  
      std::vector<GLColor> greenPixels(kSize * kSize, GLColor::green);
      std::vector<GLColor> redPixels(kSize * kSize, GLColor::red);
      GLTexture texture1;
      glBindTexture(GL_TEXTURE_2D, texture1);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  
      for (int i = 0; i < 100; i++)
      {
          // We do this a lot of time to make sure we use multiple buffers in the vulkan backend.
          glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kSize, kSize, GL_RGBA, GL_UNSIGNED_BYTE,
                          greenPixels.data());
      }
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      ASSERT_GL_NO_ERROR();
  
      GLTexture texture2;
      glBindTexture(GL_TEXTURE_2D, texture2);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, redPixels.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      // Setup the vertex array to draw a quad.
      GLint positionLocation = glGetAttribLocation(program, "position");
      setupQuadVertexBuffer(1.0f, 1.0f);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(positionLocation);
  
      // Draw quad with texture 2 while texture 1 has "staged" changes that have not been flushed yet.
      glBindTexture(GL_TEXTURE_2D, texture2);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // If we now try to draw with texture1, we should trigger the issue.
      glBindTexture(GL_TEXTURE_2D, texture1);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests deleting a Framebuffer that is in use.
  TEST_P(SimpleStateChangeTest, RedefineFramebufferInUse)
  {
      constexpr int kSize = 16;
  
      // Create a simple framebuffer.
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      glViewport(0, 0, kSize, kSize);
  
      // Draw red to the framebuffer.
      simpleDrawWithColor(GLColor::red);
  
      // Change the framebuffer while the call is in flight to a new texture.
      GLTexture otherTexture;
      glBindTexture(GL_TEXTURE_2D, otherTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, otherTexture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      // Draw green to the framebuffer. Verify the color.
      simpleDrawWithColor(GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Make a new framebuffer so we can read back the first texture and verify red.
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      ASSERT_GL_NO_ERROR();
  }
  
  // Tests that redefining a Framebuffer Texture Attachment works as expected.
  TEST_P(SimpleStateChangeTest, RedefineFramebufferTexture)
  {
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
  
      // Bind a simple 8x8 texture to the framebuffer, draw red.
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
  
      glViewport(0, 0, 8, 8);
      simpleDrawWithColor(GLColor::red);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red) << "first draw should be red";
  
      // Redefine the texture to 32x32, draw green. Verify we get what we expect.
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glViewport(0, 0, 32, 32);
      simpleDrawWithColor(GLColor::green);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green) << "second draw should be green";
  }
  
  // Validates disabling cull face really disables it.
  TEST_P(SimpleStateChangeTest, EnableAndDisableCullFace)
  {
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
      glUseProgram(program);
  
      glClear(GL_COLOR_BUFFER_BIT);
      glEnable(GL_CULL_FACE);
  
      glCullFace(GL_FRONT);
  
      drawQuad(program.get(), essl1_shaders::PositionAttrib(), 0.0f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::transparentBlack);
  
      // Disable cull face and redraw, then make sure we have the quad drawn.
      glDisable(GL_CULL_FACE);
  
      drawQuad(program.get(), essl1_shaders::PositionAttrib(), 0.0f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  }
  
  TEST_P(SimpleStateChangeTest, ScissorTest)
  {
      // This test validates this order of state changes:
      // 1- Set scissor but don't enable it, validate its not used.
      // 2- Enable it and validate its working.
      // 3- Disable the scissor validate its not used anymore.
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
  
      glClear(GL_COLOR_BUFFER_BIT);
  
      // Set the scissor region, but don't enable it yet.
      glScissor(getWindowWidth() / 4, getWindowHeight() / 4, getWindowWidth() / 2,
                getWindowHeight() / 2);
  
      // Fill the whole screen with a quad.
      drawQuad(program.get(), essl1_shaders::PositionAttrib(), 0.0f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
  
      // Test outside, scissor isnt enabled so its red.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Test inside, red of the fragment shader.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, getWindowHeight() / 2, GLColor::red);
  
      // Clear everything and start over with the test enabled.
      glClear(GL_COLOR_BUFFER_BIT);
      glEnable(GL_SCISSOR_TEST);
  
      drawQuad(program.get(), essl1_shaders::PositionAttrib(), 0.0f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
  
      // Test outside the scissor test, pitch black.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::transparentBlack);
  
      // Test inside, red of the fragment shader.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, getWindowHeight() / 2, GLColor::red);
  
      // Now disable the scissor test, do it again, and verify the region isn't used
      // for the scissor test.
      glDisable(GL_SCISSOR_TEST);
  
      // Clear everything and start over with the test enabled.
      glClear(GL_COLOR_BUFFER_BIT);
  
      drawQuad(program.get(), essl1_shaders::PositionAttrib(), 0.0f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
  
      // Test outside, scissor isnt enabled so its red.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  
      // Test inside, red of the fragment shader.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, getWindowHeight() / 2, GLColor::red);
  }
  
  // This test validates we are able to change the valid of a uniform dynamically.
  TEST_P(SimpleStateChangeTest, UniformUpdateTest)
  {
      constexpr char kPositionUniformVertexShader[] = R"(
  precision mediump float;
  attribute vec2 position;
  uniform vec2 uniPosModifier;
  void main()
  {
      gl_Position = vec4(position + uniPosModifier, 0, 1);
  })";
  
      ANGLE_GL_PROGRAM(program, kPositionUniformVertexShader, essl1_shaders::fs::UniformColor());
      glUseProgram(program);
  
      glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      GLint posUniformLocation = glGetUniformLocation(program, "uniPosModifier");
      ASSERT_NE(posUniformLocation, -1);
      GLint colorUniformLocation = glGetUniformLocation(program, essl1_shaders::ColorUniform());
      ASSERT_NE(colorUniformLocation, -1);
  
      // draw a red quad to the left side.
      glUniform2f(posUniformLocation, -0.5, 0.0);
      glUniform4f(colorUniformLocation, 1.0, 0.0, 0.0, 1.0);
      drawQuad(program.get(), "position", 0.0f, 0.5f, true);
  
      // draw a green quad to the right side.
      glUniform2f(posUniformLocation, 0.5, 0.0);
      glUniform4f(colorUniformLocation, 0.0, 1.0, 0.0, 1.0);
      drawQuad(program.get(), "position", 0.0f, 0.5f, true);
  
      ASSERT_GL_NO_ERROR();
  
      // Test the center of the left quad. Should be red.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 4, getWindowHeight() / 2, GLColor::red);
  
      // Test the center of the right quad. Should be green.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 4 * 3, getWindowHeight() / 2, GLColor::green);
  }
  
  // Tests that changing the storage of a Renderbuffer currently in use by GL works as expected.
  TEST_P(SimpleStateChangeTest, RedefineRenderbufferInUse)
  {
      GLRenderbuffer renderbuffer;
      glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
  
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
  
      ASSERT_GL_NO_ERROR();
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ANGLE_GL_PROGRAM(program, kSimpleVertexShader, kSimpleFragmentShader);
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
  
      // Set up and draw red to the left half the screen.
      std::vector<GLColor> redData(6, GLColor::red);
      GLBuffer vertexBufferRed;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBufferRed);
      glBufferData(GL_ARRAY_BUFFER, redData.size() * sizeof(GLColor), redData.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(colorLoc);
  
      glViewport(0, 0, 16, 16);
      drawQuad(program, "position", 0.5f, 1.0f, true);
  
      // Immediately redefine the Renderbuffer.
      glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 64, 64);
  
      // Set up and draw green to the right half of the screen.
      std::vector<GLColor> greenData(6, GLColor::green);
      GLBuffer vertexBufferGreen;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBufferGreen);
      glBufferData(GL_ARRAY_BUFFER, greenData.size() * sizeof(GLColor), greenData.data(),
                   GL_STATIC_DRAW);
      glVertexAttribPointer(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glEnableVertexAttribArray(colorLoc);
  
      glViewport(0, 0, 64, 64);
      drawQuad(program, "position", 0.5f, 1.0f, true);
  
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Validate that we can draw -> change frame buffer size -> draw and we'll be rendering
  // at the full size of the new framebuffer.
  TEST_P(SimpleStateChangeTest, ChangeFramebufferSizeBetweenTwoDraws)
  {
      constexpr size_t kSmallTextureSize = 2;
      constexpr size_t kBigTextureSize   = 4;
  
      // Create 2 textures, one of 2x2 and the other 4x4
      GLTexture texture1;
      glBindTexture(GL_TEXTURE_2D, texture1);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSmallTextureSize, kSmallTextureSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, nullptr);
      ASSERT_GL_NO_ERROR();
  
      GLTexture texture2;
      glBindTexture(GL_TEXTURE_2D, texture2);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kBigTextureSize, kBigTextureSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, nullptr);
      ASSERT_GL_NO_ERROR();
  
      // A framebuffer for each texture to draw on.
      GLFramebuffer framebuffer1;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer1);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture1, 0);
      ASSERT_GL_NO_ERROR();
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      GLFramebuffer framebuffer2;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer2);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture2, 0);
      ASSERT_GL_NO_ERROR();
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::UniformColor());
      glUseProgram(program);
      GLint uniformLocation = glGetUniformLocation(program, essl1_shaders::ColorUniform());
      ASSERT_NE(uniformLocation, -1);
  
      // Bind to the first framebuffer for drawing.
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer1);
  
      // Set a scissor, that will trigger setting the internal scissor state in Vulkan to
      // (0,0,framebuffer.width, framebuffer.height) size since the scissor isn't enabled.
      glScissor(0, 0, 16, 16);
      ASSERT_GL_NO_ERROR();
  
      // Set color to red.
      glUniform4f(uniformLocation, 1.0f, 0.0f, 0.0f, 1.0f);
      glViewport(0, 0, kSmallTextureSize, kSmallTextureSize);
  
      // Draw a full sized red quad
      drawQuad(program, essl1_shaders::PositionAttrib(), 1.0f, 1.0f, true);
      ASSERT_GL_NO_ERROR();
  
      // Bind to the second (bigger) framebuffer
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer2);
      glViewport(0, 0, kBigTextureSize, kBigTextureSize);
  
      ASSERT_GL_NO_ERROR();
  
      // Set color to green.
      glUniform4f(uniformLocation, 0.0f, 1.0f, 0.0f, 1.0f);
  
      // Draw again and we should fill everything with green and expect everything to be green.
      drawQuad(program, essl1_shaders::PositionAttrib(), 1.0f, 1.0f, true);
      ASSERT_GL_NO_ERROR();
  
      EXPECT_PIXEL_RECT_EQ(0, 0, kBigTextureSize, kBigTextureSize, GLColor::green);
  }
  
  // Tries to relink a program in use and use it again to draw something else.
  TEST_P(SimpleStateChangeTest, RelinkProgram)
  {
      const GLuint program = glCreateProgram();
  
      GLuint vs     = CompileShader(GL_VERTEX_SHADER, essl1_shaders::vs::Simple());
      GLuint blueFs = CompileShader(GL_FRAGMENT_SHADER, essl1_shaders::fs::Blue());
      GLuint redFs  = CompileShader(GL_FRAGMENT_SHADER, essl1_shaders::fs::Red());
  
      glAttachShader(program, vs);
      glAttachShader(program, blueFs);
  
      glLinkProgram(program);
      CheckLinkStatusAndReturnProgram(program, true);
  
      glClear(GL_COLOR_BUFFER_BIT);
      std::vector<Vector3> vertices = {{-1.0f, -1.0f, 0.0f}, {1.0f, 1.0f, 0.0f}, {1.0f, -1.0f, 0.0f},
                                       {-1.0f, -1.0f, 0.0f}, {1.0f, 1.0f, 0.0f}, {-1.0, 1.0f, 0.0f}};
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
      const GLint positionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLocation);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLocation);
  
      // Draw a blue triangle to the right
      glUseProgram(program);
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      // Relink to draw red to the left
      glDetachShader(program, blueFs);
      glAttachShader(program, redFs);
  
      glLinkProgram(program);
      CheckLinkStatusAndReturnProgram(program, true);
  
      glDrawArrays(GL_TRIANGLES, 3, 3);
  
      ASSERT_GL_NO_ERROR();
  
      glDisableVertexAttribArray(positionLocation);
  
      // Verify we drew red and green in the right places.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, 0, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() / 2, GLColor::red);
  
      glDeleteShader(vs);
      glDeleteShader(blueFs);
      glDeleteShader(redFs);
      glDeleteProgram(program);
  }
  
  // Creates a program that uses uniforms and then immediately release it and then use it. Should be
  // valid.
  TEST_P(SimpleStateChangeTest, ReleaseShaderInUseThatReadsFromUniforms)
  {
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::UniformColor());
      glUseProgram(program);
  
      const GLint uniformLoc = glGetUniformLocation(program, essl1_shaders::ColorUniform());
      EXPECT_NE(-1, uniformLoc);
  
      // Set color to red.
      glUniform4f(uniformLoc, 1.0f, 0.0f, 0.0f, 1.0f);
  
      glClear(GL_COLOR_BUFFER_BIT);
      std::vector<Vector3> vertices = {{-1.0f, -1.0f, 0.0f}, {1.0f, 1.0f, 0.0f}, {1.0f, -1.0f, 0.0f}};
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
      const GLint positionLocation = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLocation);
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLocation);
  
      // Release program while its in use.
      glDeleteProgram(program);
  
      // Draw a red triangle
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      // Set color to green
      glUniform4f(uniformLoc, 1.0f, 0.0f, 0.0f, 1.0f);
  
      // Draw a green triangle
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      ASSERT_GL_NO_ERROR();
  
      glDisableVertexAttribArray(positionLocation);
  
      glUseProgram(0);
  
      // Verify we drew red in the end since thats the last draw.
      EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, 0, GLColor::red);
  }
  
  // Tests that sampler sync isn't masked by program textures.
  TEST_P(SimpleStateChangeTestES3, SamplerSyncNotTiedToProgram)
  {
      // Create a sampler with NEAREST filtering.
      GLSampler sampler;
      glBindSampler(0, sampler);
      glSamplerParameteri(sampler, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
      glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
      glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      ASSERT_GL_NO_ERROR();
  
      // Draw with a program that uses no textures.
      ANGLE_GL_PROGRAM(program1, essl1_shaders::vs::Simple(), essl1_shaders::fs::Blue());
      drawQuad(program1, essl1_shaders::PositionAttrib(), 0.5f);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
  
      // Create a simple texture with four colors and linear filtering.
      constexpr GLsizei kSize       = 2;
      std::array<GLColor, 4> pixels = {
          {GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
      GLTexture redTex;
      glBindTexture(GL_TEXTURE_2D, redTex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                   pixels.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  
      // Create a program that uses the texture.
      constexpr char kVS[] = R"(attribute vec4 position;
  varying vec2 texCoord;
  void main()
  {
      gl_Position = position;
      texCoord = position.xy * 0.5 + vec2(0.5);
  })";
  
      constexpr char kFS[] = R"(precision mediump float;
  varying vec2 texCoord;
  uniform sampler2D tex;
  void main()
  {
      gl_FragColor = texture2D(tex, texCoord);
  })";
  
      // Draw. The sampler should override the clamp wrap mode with nearest.
      ANGLE_GL_PROGRAM(program2, kVS, kFS);
      ASSERT_EQ(0, glGetUniformLocation(program2, "tex"));
      drawQuad(program2, "position", 0.5f);
      ASSERT_GL_NO_ERROR();
  
      constexpr int kHalfSize = kWindowSize / 2;
  
      EXPECT_PIXEL_RECT_EQ(0, 0, kHalfSize, kHalfSize, GLColor::red);
      EXPECT_PIXEL_RECT_EQ(kHalfSize, 0, kHalfSize, kHalfSize, GLColor::green);
      EXPECT_PIXEL_RECT_EQ(0, kHalfSize, kHalfSize, kHalfSize, GLColor::blue);
      EXPECT_PIXEL_RECT_EQ(kHalfSize, kHalfSize, kHalfSize, kHalfSize, GLColor::yellow);
  }
  
  // Tests that deleting an in-flight image texture does not immediately delete the resource.
  TEST_P(SimpleStateChangeTestES31, DeleteImageTextureInUse)
  {
      std::array<GLColor, 4> colors = {
          {GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
      GLTexture texRead;
      glBindTexture(GL_TEXTURE_2D, texRead);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
      EXPECT_GL_NO_ERROR();
  
      glUseProgram(mProgram);
  
      glBindImageTexture(0, texRead, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
      texRead.reset();
  
      std::array<GLColor, 4> results;
      glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, results.data());
      EXPECT_GL_NO_ERROR();
  
      for (int i = 0; i < 4; i++)
      {
          EXPECT_EQ(colors[i], results[i]);
      }
  }
  
  // Tests that bind the same image texture all the time between different dispatch calls.
  TEST_P(SimpleStateChangeTestES31, RebindImageTextureDispatchAgain)
  {
      std::array<GLColor, 4> colors = {{GLColor::cyan, GLColor::cyan, GLColor::cyan, GLColor::cyan}};
      GLTexture texRead;
      glBindTexture(GL_TEXTURE_2D, texRead);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
  
      glUseProgram(mProgram);
  
      glBindImageTexture(0, texRead, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      // Bind again
      glBindImageTexture(0, texRead, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
      EXPECT_GL_NO_ERROR();
  
      EXPECT_PIXEL_RECT_EQ(0, 0, 2, 2, GLColor::cyan);
  }
  
  // Tests that we can dispatch with an image texture, modify the image texture with a texSubImage,
  // and then dispatch again correctly.
  TEST_P(SimpleStateChangeTestES31, DispatchWithImageTextureTexSubImageThenDispatchAgain)
  {
      std::array<GLColor, 4> colors    = {{GLColor::red, GLColor::red, GLColor::red, GLColor::red}};
      std::array<GLColor, 4> subColors = {
          {GLColor::green, GLColor::green, GLColor::green, GLColor::green}};
  
      GLTexture texRead;
      glBindTexture(GL_TEXTURE_2D, texRead);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
  
      glUseProgram(mProgram);
  
      glBindImageTexture(0, texRead, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      // Update bottom-half of image texture with green.
      glBindTexture(GL_TEXTURE_2D, texRead);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 1, GL_RGBA, GL_UNSIGNED_BYTE, subColors.data());
      ASSERT_GL_NO_ERROR();
  
      // Dispatch again, should still work.
      glDispatchCompute(1, 1, 1);
      ASSERT_GL_NO_ERROR();
  
      // Validate first half of the image is red and the bottom is green.
      std::array<GLColor, 4> results;
      glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, results.data());
      EXPECT_GL_NO_ERROR();
  
      EXPECT_EQ(GLColor::green, results[0]);
      EXPECT_EQ(GLColor::green, results[1]);
      EXPECT_EQ(GLColor::red, results[2]);
      EXPECT_EQ(GLColor::red, results[3]);
  }
  
  // Test updating an image texture's contents while in use by GL works as expected.
  TEST_P(SimpleStateChangeTestES31, UpdateImageTextureInUse)
  {
      std::array<GLColor, 4> rgby = {{GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
  
      GLTexture texRead;
      glBindTexture(GL_TEXTURE_2D, texRead);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, rgby.data());
  
      glUseProgram(mProgram);
  
      glBindImageTexture(0, texRead, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      // Update the texture to be YBGR, while the Texture is in-use. Should not affect the dispatch.
      glBindTexture(GL_TEXTURE_2D, texRead);
      std::array<GLColor, 4> ybgr = {{GLColor::yellow, GLColor::blue, GLColor::green, GLColor::red}};
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, ybgr.data());
      ASSERT_GL_NO_ERROR();
  
      // Check the Framebuffer. The dispatch call should have completed with the original RGBY data.
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
      EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::yellow);
  
      // Dispatch again. The second dispatch call should use the updated YBGR data.
      glDispatchCompute(1, 1, 1);
  
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
      EXPECT_PIXEL_COLOR_EQ(1, 0, GLColor::blue);
      EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::green);
      EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::red);
      ASSERT_GL_NO_ERROR();
  }
  
  // Test that we can alternate between image textures between different dispatchs.
  TEST_P(SimpleStateChangeTestES31, DispatchImageTextureAThenTextureBThenTextureA)
  {
      // TODO(syoussefi): Flaky, needs investigation. http://anglebug.com/3044
      ANGLE_SKIP_TEST_IF(IsLinux() && IsIntel() && IsDesktopOpenGL());
  
      std::array<GLColor, 4> colorsTexA = {
          {GLColor::cyan, GLColor::cyan, GLColor::cyan, GLColor::cyan}};
  
      std::array<GLColor, 4> colorsTexB = {
          {GLColor::magenta, GLColor::magenta, GLColor::magenta, GLColor::magenta}};
  
      GLTexture texA;
      glBindTexture(GL_TEXTURE_2D, texA);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, colorsTexA.data());
      GLTexture texB;
      glBindTexture(GL_TEXTURE_2D, texB);
      glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 2, 2);
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, colorsTexB.data());
  
      glUseProgram(mProgram);
  
      glBindImageTexture(0, texA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      glBindImageTexture(0, texB, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      glBindImageTexture(0, texA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
      glDispatchCompute(1, 1, 1);
  
      EXPECT_PIXEL_RECT_EQ(0, 0, 2, 2, GLColor::cyan);
      ASSERT_GL_NO_ERROR();
  }
  
  static constexpr char kColorVS[] = R"(attribute vec2 position;
  attribute vec4 color;
  varying vec4 vColor;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      vColor = color;
  })";
  
  static constexpr char kColorFS[] = R"(precision mediump float;
  varying vec4 vColor;
  void main()
  {
      gl_FragColor = vColor;
  })";
  
  class ValidationStateChangeTest : public ANGLETest
  {
    protected:
      ValidationStateChangeTest()
      {
          setWindowWidth(64);
          setWindowHeight(64);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  };
  
  class WebGL2ValidationStateChangeTest : public ValidationStateChangeTest
  {
    protected:
      WebGL2ValidationStateChangeTest() { setWebGLCompatibilityEnabled(true); }
  };
  
  class ValidationStateChangeTestES31 : public ANGLETest
  {};
  
  class WebGLComputeValidationStateChangeTest : public ANGLETest
  {
    public:
      WebGLComputeValidationStateChangeTest() { setWebGLCompatibilityEnabled(true); }
  };
  
  // Tests that mapping and unmapping an array buffer in various ways causes rendering to fail.
  // This isn't guaranteed to produce an error by GL. But we assume ANGLE always errors.
  TEST_P(ValidationStateChangeTest, MapBufferAndDraw)
  {
      // Initialize program and set up state.
      ANGLE_GL_PROGRAM(program, kColorVS, kColorFS);
  
      glUseProgram(program);
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLoc);
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
  
      const std::array<Vector3, 6> &quadVertices = GetQuadVertices();
      const size_t posBufferSize                 = quadVertices.size() * sizeof(Vector3);
  
      GLBuffer posBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
      glBufferData(GL_ARRAY_BUFFER, posBufferSize, quadVertices.data(), GL_STATIC_DRAW);
  
      // Start with position enabled.
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      std::vector<GLColor> colorVertices(6, GLColor::blue);
      const size_t colorBufferSize = sizeof(GLColor) * 6;
  
      GLBuffer colorBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
      glBufferData(GL_ARRAY_BUFFER, colorBufferSize, colorVertices.data(), GL_STATIC_DRAW);
  
      // Start with color disabled.
      glVertexAttribPointer(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, nullptr);
      glDisableVertexAttribArray(colorLoc);
  
      ASSERT_GL_NO_ERROR();
  
      // Draw without a mapped buffer. Should succeed.
      glVertexAttrib4f(colorLoc, 0, 1, 0, 1);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Map position buffer and draw. Should fail.
      glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
      glMapBufferRange(GL_ARRAY_BUFFER, 0, posBufferSize, GL_MAP_READ_BIT);
      ASSERT_GL_NO_ERROR();
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Map position buffer and draw should fail.";
      glUnmapBuffer(GL_ARRAY_BUFFER);
  
      // Map then enable color buffer. Should fail.
      glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
      glMapBufferRange(GL_ARRAY_BUFFER, 0, colorBufferSize, GL_MAP_READ_BIT);
      glEnableVertexAttribArray(colorLoc);
      ASSERT_GL_NO_ERROR();
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Map then enable color buffer should fail.";
  
      // Unmap then draw. Should succeed.
      glUnmapBuffer(GL_ARRAY_BUFFER);
      ASSERT_GL_NO_ERROR();
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
  }
  
  // Tests that changing a vertex binding with glVertexAttribDivisor updates the mapped buffer check.
  TEST_P(ValidationStateChangeTestES31, MapBufferAndDrawWithDivisor)
  {
      // Seems to trigger a GL error in some edge cases. http://anglebug.com/2755
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsNVIDIA());
  
      // Initialize program and set up state.
      ANGLE_GL_PROGRAM(program, kColorVS, kColorFS);
  
      glUseProgram(program);
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLoc);
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
  
      // Create a user vertex array.
      GLVertexArray vao;
      glBindVertexArray(vao);
  
      const std::array<Vector3, 6> &quadVertices = GetQuadVertices();
      const size_t posBufferSize                 = quadVertices.size() * sizeof(Vector3);
  
      GLBuffer posBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
      glBufferData(GL_ARRAY_BUFFER, posBufferSize, quadVertices.data(), GL_STATIC_DRAW);
  
      // Start with position enabled.
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      std::vector<GLColor> blueVertices(6, GLColor::blue);
      const size_t blueBufferSize = sizeof(GLColor) * 6;
  
      GLBuffer blueBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, blueBuffer);
      glBufferData(GL_ARRAY_BUFFER, blueBufferSize, blueVertices.data(), GL_STATIC_DRAW);
  
      // Start with color enabled at an unused binding.
      constexpr GLint kUnusedBinding = 3;
      ASSERT_NE(colorLoc, kUnusedBinding);
      ASSERT_NE(positionLoc, kUnusedBinding);
      glVertexAttribFormat(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0);
      glVertexAttribBinding(colorLoc, kUnusedBinding);
      glBindVertexBuffer(kUnusedBinding, blueBuffer, 0, sizeof(GLColor));
      glEnableVertexAttribArray(colorLoc);
  
      // Make binding 'colorLoc' use a mapped buffer.
      std::vector<GLColor> greenVertices(6, GLColor::green);
      const size_t greenBufferSize = sizeof(GLColor) * 6;
      GLBuffer greenBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, greenBuffer);
      glBufferData(GL_ARRAY_BUFFER, greenBufferSize, greenVertices.data(), GL_STATIC_DRAW);
      glMapBufferRange(GL_ARRAY_BUFFER, 0, greenBufferSize, GL_MAP_READ_BIT);
      glBindVertexBuffer(colorLoc, greenBuffer, 0, sizeof(GLColor));
  
      ASSERT_GL_NO_ERROR();
  
      // Draw without a mapped buffer. Should succeed.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
  
      // Change divisor with VertexAttribDivisor. Should fail.
      glVertexAttribDivisor(colorLoc, 0);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "draw with mapped buffer should fail.";
  
      // Unmap the buffer. Should succeed.
      glUnmapBuffer(GL_ARRAY_BUFFER);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests that changing a vertex binding with glVertexAttribDivisor updates the buffer size check.
  TEST_P(WebGLComputeValidationStateChangeTest, DrawPastEndOfBufferWithDivisor)
  {
      // Initialize program and set up state.
      ANGLE_GL_PROGRAM(program, kColorVS, kColorFS);
  
      glUseProgram(program);
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLoc);
      GLint colorLoc = glGetAttribLocation(program, "color");
      ASSERT_NE(-1, colorLoc);
  
      // Create a user vertex array.
      GLVertexArray vao;
      glBindVertexArray(vao);
  
      const std::array<Vector3, 6> &quadVertices = GetQuadVertices();
      const size_t posBufferSize                 = quadVertices.size() * sizeof(Vector3);
  
      GLBuffer posBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
      glBufferData(GL_ARRAY_BUFFER, posBufferSize, quadVertices.data(), GL_STATIC_DRAW);
  
      // Start with position enabled.
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      std::vector<GLColor> blueVertices(6, GLColor::blue);
      const size_t blueBufferSize = sizeof(GLColor) * 6;
  
      GLBuffer blueBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, blueBuffer);
      glBufferData(GL_ARRAY_BUFFER, blueBufferSize, blueVertices.data(), GL_STATIC_DRAW);
  
      // Start with color enabled at an unused binding.
      constexpr GLint kUnusedBinding = 3;
      ASSERT_NE(colorLoc, kUnusedBinding);
      ASSERT_NE(positionLoc, kUnusedBinding);
      glVertexAttribFormat(colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0);
      glVertexAttribBinding(colorLoc, kUnusedBinding);
      glBindVertexBuffer(kUnusedBinding, blueBuffer, 0, sizeof(GLColor));
      glEnableVertexAttribArray(colorLoc);
  
      // Make binding 'colorLoc' use a small buffer.
      std::vector<GLColor> greenVertices(6, GLColor::green);
      const size_t greenBufferSize = sizeof(GLColor) * 3;
      GLBuffer greenBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, greenBuffer);
      glBufferData(GL_ARRAY_BUFFER, greenBufferSize, greenVertices.data(), GL_STATIC_DRAW);
      glBindVertexBuffer(colorLoc, greenBuffer, 0, sizeof(GLColor));
  
      ASSERT_GL_NO_ERROR();
  
      // Draw without a mapped buffer. Should succeed.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
  
      // Change divisor with VertexAttribDivisor. Should fail.
      glVertexAttribDivisor(colorLoc, 0);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "draw with small buffer should fail.";
  
      // Do a small draw. Should succeed.
      glDrawArrays(GL_TRIANGLES, 0, 3);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests state changes with uniform block validation.
  TEST_P(ValidationStateChangeTest, UniformBlockNegativeAPI)
  {
      constexpr char kVS[] = R"(#version 300 es
  in vec2 position;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
  })";
  
      constexpr char kFS[] = R"(#version 300 es
  precision mediump float;
  uniform uni { vec4 vec; };
  out vec4 color;
  void main()
  {
      color = vec;
  })";
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
      glUseProgram(program);
  
      GLuint blockIndex = glGetUniformBlockIndex(program, "uni");
      ASSERT_NE(GL_INVALID_INDEX, blockIndex);
  
      glUniformBlockBinding(program, blockIndex, 0);
  
      GLBuffer uniformBuffer;
      glBindBuffer(GL_UNIFORM_BUFFER, uniformBuffer);
      glBufferData(GL_UNIFORM_BUFFER, sizeof(GLColor32F), &kFloatGreen.R, GL_STATIC_DRAW);
      glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniformBuffer);
  
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer positionBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
      glBufferData(GL_ARRAY_BUFFER, quadVertices.size() * sizeof(Vector3), quadVertices.data(),
                   GL_STATIC_DRAW);
  
      GLint positionLocation = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLocation);
  
      glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLocation);
      ASSERT_GL_NO_ERROR();
  
      // First draw should succeed.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Change the uniform block binding. Should fail.
      glUniformBlockBinding(program, blockIndex, 1);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_ERROR(GL_INVALID_OPERATION) << "Invalid uniform block binding should fail";
  
      // Reset to a correct state.
      glUniformBlockBinding(program, blockIndex, 0);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Change the buffer binding. Should fail.
      glBindBufferBase(GL_UNIFORM_BUFFER, 0, 0);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_ERROR(GL_INVALID_OPERATION) << "Setting invalid uniform buffer should fail";
  
      // Reset to a correct state.
      glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniformBuffer);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Resize the buffer to be too small. Should fail.
      glBufferData(GL_UNIFORM_BUFFER, 1, nullptr, GL_STATIC_DRAW);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Invalid buffer size should fail";
  }
  
  // Tests various state change effects on draw framebuffer validation.
  TEST_P(WebGL2ValidationStateChangeTest, DrawFramebufferNegativeAPI)
  {
      // Set up a simple draw from a Texture to a user Framebuffer.
      GLuint program = get2DTexturedQuadProgram();
      ASSERT_NE(0u, program);
      glUseProgram(program);
  
      GLint posLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, posLoc);
  
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer positionBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * quadVertices.size(), quadVertices.data(),
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(posLoc);
  
      constexpr size_t kSize = 2;
  
      GLTexture colorBufferTexture;
      glBindTexture(GL_TEXTURE_2D, colorBufferTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBufferTexture,
                             0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      std::vector<GLColor> greenColor(kSize * kSize, GLColor::green);
  
      GLTexture greenTexture;
      glBindTexture(GL_TEXTURE_2D, greenTexture);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                   greenColor.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      // Second framebuffer with a feedback loop. Initially unbound.
      GLFramebuffer loopedFramebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, loopedFramebuffer);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, greenTexture, 0);
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
  
      ASSERT_GL_NO_ERROR();
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Create a rendering feedback loop. Should fail.
      glBindTexture(GL_TEXTURE_2D, colorBufferTexture);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  
      // Reset to a valid state.
      glBindTexture(GL_TEXTURE_2D, greenTexture);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Bind a second framebuffer with a feedback loop.
      glBindFramebuffer(GL_FRAMEBUFFER, loopedFramebuffer);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  
      // Update the framebuffer texture attachment. Should succeed.
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBufferTexture,
                             0);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  }
  
  // Tests various state change effects on draw framebuffer validation with MRT.
  TEST_P(WebGL2ValidationStateChangeTest, MultiAttachmentDrawFramebufferNegativeAPI)
  {
      // Set up a program that writes to two outputs: one int and one float.
      constexpr char kVS[] = R"(#version 300 es
  layout(location = 0) in vec2 position;
  out vec2 texCoord;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      texCoord = position * 0.5 + vec2(0.5);
  })";
  
      constexpr char kFS[] = R"(#version 300 es
  precision mediump float;
  in vec2 texCoord;
  layout(location = 0) out vec4 outFloat;
  layout(location = 1) out uvec4 outInt;
  void main()
  {
      outFloat = vec4(0, 1, 0, 1);
      outInt = uvec4(0, 1, 0, 1);
  })";
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
      glUseProgram(program);
  
      constexpr GLint kPosLoc = 0;
  
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer positionBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * quadVertices.size(), quadVertices.data(),
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(kPosLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(kPosLoc);
  
      constexpr size_t kSize = 2;
  
      GLFramebuffer floatFramebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, floatFramebuffer);
  
      GLTexture floatTextures[2];
      for (int i = 0; i < 2; ++i)
      {
          glBindTexture(GL_TEXTURE_2D, floatTextures[i]);
          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                       nullptr);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
                                 floatTextures[i], 0);
          ASSERT_GL_NO_ERROR();
      }
  
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      GLFramebuffer intFramebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, intFramebuffer);
  
      GLTexture intTextures[2];
      for (int i = 0; i < 2; ++i)
      {
          glBindTexture(GL_TEXTURE_2D, intTextures[i]);
          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, kSize, kSize, 0, GL_RGBA_INTEGER,
                       GL_UNSIGNED_BYTE, nullptr);
          glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
                                 intTextures[i], 0);
          ASSERT_GL_NO_ERROR();
      }
  
      ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
  
      ASSERT_GL_NO_ERROR();
  
      constexpr GLenum kColor0Enabled[]     = {GL_COLOR_ATTACHMENT0, GL_NONE};
      constexpr GLenum kColor1Enabled[]     = {GL_NONE, GL_COLOR_ATTACHMENT1};
      constexpr GLenum kColor0And1Enabled[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
  
      // Draw float. Should work.
      glBindFramebuffer(GL_FRAMEBUFFER, floatFramebuffer);
      glDrawBuffers(2, kColor0Enabled);
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR() << "Draw to float texture with correct mask";
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Set an invalid component write.
      glDrawBuffers(2, kColor0And1Enabled);
      ASSERT_GL_NO_ERROR() << "Draw to float texture with invalid mask";
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  
      // Restore state.
      glDrawBuffers(2, kColor0Enabled);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR() << "Draw to float texture with correct mask";
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Bind an invalid framebuffer. Validate failure.
      glBindFramebuffer(GL_FRAMEBUFFER, intFramebuffer);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Draw to int texture with default mask";
  
      // Set draw mask to a valid mask. Validate success.
      glDrawBuffers(2, kColor1Enabled);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR() << "Draw to int texture with correct mask";
  }
  
  // Tests negative API state change cases with Transform Feedback bindings.
  TEST_P(WebGL2ValidationStateChangeTest, TransformFeedbackNegativeAPI)
  {
      ANGLE_SKIP_TEST_IF(IsAMD() && IsOSX());
  
      constexpr char kFS[] = R"(#version 300 es
  precision mediump float;
  uniform block { vec4 color; };
  out vec4 colorOut;
  void main()
  {
      colorOut = color;
  })";
  
      std::vector<std::string> tfVaryings = {"gl_Position"};
      ANGLE_GL_PROGRAM_TRANSFORM_FEEDBACK(program, essl3_shaders::vs::Simple(), kFS, tfVaryings,
                                          GL_INTERLEAVED_ATTRIBS);
      glUseProgram(program);
  
      std::vector<Vector4> positionData;
      for (const Vector3 &quadVertex : GetQuadVertices())
      {
          positionData.emplace_back(quadVertex.x(), quadVertex.y(), quadVertex.z(), 1.0f);
      }
  
      GLBuffer arrayBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
      glBufferData(GL_ARRAY_BUFFER, positionData.size() * sizeof(Vector4), positionData.data(),
                   GL_STATIC_DRAW);
  
      GLint positionLoc = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLoc);
  
      glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      EXPECT_GL_NO_ERROR();
  
      // Set up transform feedback.
      GLTransformFeedback transformFeedback;
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
  
      constexpr size_t kTransformFeedbackSize = 6 * sizeof(Vector4);
  
      GLBuffer transformFeedbackBuffer;
      glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, transformFeedbackBuffer);
      glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, kTransformFeedbackSize * 2, nullptr, GL_STATIC_DRAW);
      glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, transformFeedbackBuffer);
  
      // Set up uniform buffer.
      GLBuffer uniformBuffer;
      glBindBuffer(GL_UNIFORM_BUFFER, uniformBuffer);
      glBufferData(GL_UNIFORM_BUFFER, sizeof(GLColor32F), &kFloatGreen.R, GL_STATIC_DRAW);
      glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniformBuffer);
  
      ASSERT_GL_NO_ERROR();
  
      // Do the draw operation. Should succeed.
      glBeginTransformFeedback(GL_TRIANGLES);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      glEndTransformFeedback();
  
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      const GLvoid *mapPointer =
          glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, kTransformFeedbackSize, GL_MAP_READ_BIT);
      ASSERT_GL_NO_ERROR();
      ASSERT_NE(nullptr, mapPointer);
      const Vector4 *typedMapPointer = reinterpret_cast<const Vector4 *>(mapPointer);
      std::vector<Vector4> actualData(typedMapPointer, typedMapPointer + 6);
      EXPECT_EQ(positionData, actualData);
      glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
  
      // Draw once to update validation cache.
      glBeginTransformFeedback(GL_TRIANGLES);
      glDrawArrays(GL_TRIANGLES, 0, 6);
  
      // Bind transform feedback buffer to another binding point. Should cause a conflict.
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, transformFeedbackBuffer);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      glEndTransformFeedback();
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Simultaneous element buffer binding should fail";
  
      // Reset to valid state.
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
      glBeginTransformFeedback(GL_TRIANGLES);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      glEndTransformFeedback();
      ASSERT_GL_NO_ERROR();
  
      // Simultaneous non-vertex-array binding. Should fail.
      glBeginTransformFeedback(GL_TRIANGLES);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      glBindBuffer(GL_PIXEL_PACK_BUFFER, transformFeedbackBuffer);
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      glEndTransformFeedback();
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Simultaneous pack buffer binding should fail";
  }
  
  // Test sampler format validation caching works.
  TEST_P(WebGL2ValidationStateChangeTest, SamplerFormatCache)
  {
      constexpr char kFS[] = R"(#version 300 es
  precision mediump float;
  uniform sampler2D sampler;
  out vec4 colorOut;
  void main()
  {
      colorOut = texture(sampler, vec2(0));
  })";
  
      std::vector<std::string> tfVaryings = {"gl_Position"};
      ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), kFS);
      glUseProgram(program);
  
      std::array<GLColor, 4> colors = {
          {GLColor::red, GLColor::green, GLColor::blue, GLColor::yellow}};
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
  
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer arrayBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
      glBufferData(GL_ARRAY_BUFFER, quadVertices.size() * sizeof(Vector3), quadVertices.data(),
                   GL_STATIC_DRAW);
  
      GLint samplerLoc = glGetUniformLocation(program, "sampler");
      ASSERT_NE(-1, samplerLoc);
      glUniform1i(samplerLoc, 0);
  
      GLint positionLoc = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      ASSERT_GL_NO_ERROR();
  
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // TexImage2D should update the sampler format cache.
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, 2, 2, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE,
                   colors.data());
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Sampling integer texture with a float sampler.";
  
      glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 2, 2, 0, GL_DEPTH_COMPONENT,
                   GL_UNSIGNED_INT, colors.data());
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR() << "Depth texture with no compare mode.";
  
      // TexParameteri should update the sampler format cache.
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Depth texture with compare mode set.";
  }
  
  // Tests that we retain the correct draw mode settings with transform feedback changes.
  TEST_P(ValidationStateChangeTest, TransformFeedbackDrawModes)
  {
      ANGLE_SKIP_TEST_IF(IsAMD() && IsOSX());
  
      std::vector<std::string> tfVaryings = {"gl_Position"};
      ANGLE_GL_PROGRAM_TRANSFORM_FEEDBACK(program, essl3_shaders::vs::Simple(),
                                          essl3_shaders::fs::Red(), tfVaryings,
                                          GL_INTERLEAVED_ATTRIBS);
      glUseProgram(program);
  
      std::vector<Vector4> positionData;
      for (const Vector3 &quadVertex : GetQuadVertices())
      {
          positionData.emplace_back(quadVertex.x(), quadVertex.y(), quadVertex.z(), 1.0f);
      }
  
      GLBuffer arrayBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
      glBufferData(GL_ARRAY_BUFFER, positionData.size() * sizeof(Vector4), positionData.data(),
                   GL_STATIC_DRAW);
  
      GLint positionLoc = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLoc);
  
      glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      // Set up transform feedback.
      GLTransformFeedback transformFeedback;
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
  
      constexpr size_t kTransformFeedbackSize = 6 * sizeof(Vector4);
  
      GLBuffer transformFeedbackBuffer;
      glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, transformFeedbackBuffer);
      glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, kTransformFeedbackSize * 2, nullptr, GL_STATIC_DRAW);
      glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, transformFeedbackBuffer);
  
      GLTransformFeedback pointsXFB;
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, pointsXFB);
      GLBuffer pointsXFBBuffer;
      glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, pointsXFBBuffer);
      glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, nullptr, GL_STREAM_DRAW);
      glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, pointsXFBBuffer);
  
      // Begin TRIANGLES, switch to paused POINTS, should be valid.
      glBeginTransformFeedback(GL_POINTS);
      glPauseTransformFeedback();
      ASSERT_GL_NO_ERROR() << "Starting point transform feedback should succeed";
  
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
      glBeginTransformFeedback(GL_TRIANGLES);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_NO_ERROR() << "Triangle rendering should succeed";
      glDrawArrays(GL_POINTS, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Point rendering should fail";
      glDrawArrays(GL_LINES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Lines rendering should fail";
      glPauseTransformFeedback();
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, pointsXFB);
      glResumeTransformFeedback();
      glDrawArrays(GL_POINTS, 0, 6);
      EXPECT_GL_NO_ERROR() << "Point rendering should succeed";
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Triangle rendering should fail";
      glDrawArrays(GL_LINES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "Lines rendering should fail";
  
      glEndTransformFeedback();
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
      glEndTransformFeedback();
      ASSERT_GL_NO_ERROR() << "Ending transform feeback should pass";
  
      glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
  
      glDrawArrays(GL_POINTS, 0, 6);
      EXPECT_GL_NO_ERROR() << "Point rendering should succeed";
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_NO_ERROR() << "Triangle rendering should succeed";
      glDrawArrays(GL_LINES, 0, 6);
      EXPECT_GL_NO_ERROR() << "Line rendering should succeed";
  }
  
  // Tests a valid rendering setup with two textures. Followed by a draw with conflicting samplers.
  TEST_P(ValidationStateChangeTest, TextureConflict)
  {
      ANGLE_SKIP_TEST_IF(!extensionEnabled("GL_EXT_texture_storage"));
  
      GLint maxTextures = 0;
      glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextures);
      ANGLE_SKIP_TEST_IF(maxTextures < 2);
  
      // Set up state.
      constexpr GLint kSize = 2;
  
      std::vector<GLColor> greenData(4, GLColor::green);
  
      GLTexture textureA;
      glBindTexture(GL_TEXTURE_2D, textureA);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                   greenData.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      glActiveTexture(GL_TEXTURE1);
  
      GLTexture textureB;
      glBindTexture(GL_TEXTURE_CUBE_MAP, textureB);
      glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA8, kSize, kSize, 0, GL_RGBA,
                   GL_UNSIGNED_BYTE, greenData.data());
      glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  
      constexpr char kVS[] = R"(attribute vec2 position;
  varying mediump vec2 texCoord;
  void main()
  {
      gl_Position = vec4(position, 0, 1);
      texCoord = position * 0.5 + vec2(0.5);
  })";
  
      constexpr char kFS[] = R"(varying mediump vec2 texCoord;
  uniform sampler2D texA;
  uniform samplerCube texB;
  void main()
  {
      gl_FragColor = texture2D(texA, texCoord) + textureCube(texB, vec3(1, 0, 0));
  })";
  
      ANGLE_GL_PROGRAM(program, kVS, kFS);
      glUseProgram(program);
  
      const auto &quadVertices = GetQuadVertices();
  
      GLBuffer arrayBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
      glBufferData(GL_ARRAY_BUFFER, quadVertices.size() * sizeof(Vector3), quadVertices.data(),
                   GL_STATIC_DRAW);
  
      GLint positionLoc = glGetAttribLocation(program, "position");
      ASSERT_NE(-1, positionLoc);
  
      GLint texALoc = glGetUniformLocation(program, "texA");
      ASSERT_NE(-1, texALoc);
  
      GLint texBLoc = glGetUniformLocation(program, "texB");
      ASSERT_NE(-1, texBLoc);
  
      glUniform1i(texALoc, 0);
      glUniform1i(texBLoc, 1);
  
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      ASSERT_GL_NO_ERROR();
  
      // First draw. Should succeed.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
  
      // Second draw to ensure all state changes are flushed.
      glDrawArrays(GL_TRIANGLES, 0, 6);
      ASSERT_GL_NO_ERROR();
  
      // Make the uniform use an invalid texture binding.
      glUniform1i(texBLoc, 0);
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  }
  
  // Tests that mapping the element array buffer triggers errors.
  TEST_P(ValidationStateChangeTest, MapElementArrayBuffer)
  {
      ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
      glUseProgram(program);
  
      std::array<GLushort, 6> quadIndices = GetQuadIndices();
      std::array<Vector3, 4> quadVertices = GetIndexedQuadVertices();
  
      GLsizei elementBufferSize = sizeof(quadIndices[0]) * quadIndices.size();
  
      GLBuffer elementArrayBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBuffer);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBufferSize, quadIndices.data(), GL_STATIC_DRAW);
  
      GLBuffer arrayBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices[0]) * quadVertices.size(),
                   quadVertices.data(), GL_STATIC_DRAW);
  
      GLint positionLoc = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
      ASSERT_NE(-1, positionLoc);
      glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(positionLoc);
  
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
      ASSERT_GL_NO_ERROR();
  
      void *ptr = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, elementBufferSize, GL_MAP_READ_BIT);
      ASSERT_NE(nullptr, ptr);
  
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  
      glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
  
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
  }
  
  // Tests that deleting a texture successfully binds the zero texture.
  TEST_P(SimpleStateChangeTest, DeleteTextureThenDraw)
  {
      constexpr char kFS[] =
          "uniform sampler2D us; void main() { gl_FragColor = texture2D(us, vec2(0)); }";
      ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), kFS);
      glUseProgram(program);
      GLint loc = glGetUniformLocation(program, "us");
      ASSERT_EQ(0, loc);
  
      auto quadVertices = GetQuadVertices();
      GLint posLoc      = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
      ASSERT_EQ(0, posLoc);
  
      GLBuffer buffer;
      glBindBuffer(GL_ARRAY_BUFFER, buffer);
      glBufferData(GL_ARRAY_BUFFER, quadVertices.size() * sizeof(quadVertices[0]),
                   quadVertices.data(), GL_STATIC_DRAW);
      glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
      glEnableVertexAttribArray(posLoc);
  
      constexpr size_t kSize = 2;
      std::vector<GLColor> red(kSize * kSize, GLColor::red);
  
      GLTexture tex;
      glBindTexture(GL_TEXTURE_2D, tex);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, red.data());
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glUniform1i(loc, 1);
      tex.reset();
  
      glDrawArrays(GL_TRIANGLES, 0, 3);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
  }
  }  // anonymous namespace
  
  ANGLE_INSTANTIATE_TEST(StateChangeTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_VULKAN());
  ANGLE_INSTANTIATE_TEST(LineLoopStateChangeTest,
                         ES2_D3D9(),
                         ES2_D3D11(),
                         ES2_OPENGL(),
                         ES2_VULKAN());
  ANGLE_INSTANTIATE_TEST(StateChangeRenderTest,
                         ES2_D3D9(),
                         ES2_D3D11(),
                         ES2_OPENGL(),
                         ES2_D3D11_FL9_3(),
                         ES2_VULKAN());
  ANGLE_INSTANTIATE_TEST(StateChangeTestES3, ES3_D3D11(), ES3_OPENGL());
  ANGLE_INSTANTIATE_TEST(SimpleStateChangeTest, ES2_VULKAN(), ES2_OPENGL());
  ANGLE_INSTANTIATE_TEST(SimpleStateChangeTestES3, ES3_OPENGL(), ES3_D3D11());
  ANGLE_INSTANTIATE_TEST(SimpleStateChangeTestES31, ES31_OPENGL(), ES31_D3D11());
  ANGLE_INSTANTIATE_TEST(ValidationStateChangeTest, ES3_D3D11(), ES3_OPENGL());
  ANGLE_INSTANTIATE_TEST(WebGL2ValidationStateChangeTest, ES3_D3D11(), ES3_OPENGL());
  ANGLE_INSTANTIATE_TEST(ValidationStateChangeTestES31, ES31_OPENGL(), ES31_D3D11());
  ANGLE_INSTANTIATE_TEST(WebGLComputeValidationStateChangeTest, ES31_D3D11(), ES31_OPENGL());