src/tests/gl_tests/WebGLCompatibilityTest.cpp - platform/external/angle - Gitiles

 //
 // 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.
 //

 // WebGLCompatibilityTest.cpp : Tests of the GL_ANGLE_webgl_compatibility extension.

 #include "test_utils/ANGLETest.h"

 #include "test_utils/gl_raii.h"

 namespace angle
 {

 class WebGLCompatibilityTest : public ANGLETest
 {
   protected:
     WebGLCompatibilityTest()
     {
         setWindowWidth(128);
         setWindowHeight(128);
         setConfigRedBits(8);
         setConfigGreenBits(8);
         setConfigBlueBits(8);
         setConfigAlphaBits(8);
         setWebGLCompatibilityEnabled(true);
     }

     void SetUp() override
     {
         ANGLETest::SetUp();
         glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
             eglGetProcAddress("glRequestExtensionANGLE"));
     }

     void TearDown() override { ANGLETest::TearDown(); }

     PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
 };

 // Context creation would fail if EGL_ANGLE_create_context_webgl_compatibility was not available so
 // the GL extension should always be present
 TEST_P(WebGLCompatibilityTest, ExtensionStringExposed)
 {
     EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));
 }

 // Verify that all extension entry points are available
 TEST_P(WebGLCompatibilityTest, EntryPoints)
 {
     if (extensionEnabled("GL_ANGLE_request_extension"))
     {
         EXPECT_NE(nullptr, eglGetProcAddress("glRequestExtensionANGLE"));
     }
 }

 // WebGL 1 allows GL_DEPTH_STENCIL_ATTACHMENT as a valid binding point.  Make sure it is usable,
 // even in ES2 contexts.
 TEST_P(WebGLCompatibilityTest, DepthStencilBindingPoint)
 {
     GLRenderbuffer renderbuffer;
     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get());
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);

     GLFramebuffer framebuffer;
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get());
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                               renderbuffer.get());

     EXPECT_GL_NO_ERROR();
 }

 // Test that attempting to enable an extension that doesn't exist generates GL_INVALID_OPERATION
 TEST_P(WebGLCompatibilityTest, EnableExtensionValidation)
 {
     glRequestExtensionANGLE("invalid_extension_string");
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }

 // Test enabling the GL_OES_element_index_uint extension
 TEST_P(WebGLCompatibilityTest, EnableExtensionUintIndices)
 {
     if (getClientMajorVersion() != 2)
     {
         // This test only works on ES2 where uint indices are not available by default
         return;
     }

     EXPECT_FALSE(extensionEnabled("GL_OES_element_index_uint"));

     GLBuffer indexBuffer;
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get());

     GLuint data[] = {0, 1, 2, 1, 3, 2};
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

     ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }",
                      "void main() { gl_FragColor = vec4(0, 1, 0, 1); }")
     glUseProgram(program.get());

     glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
     EXPECT_GL_ERROR(GL_INVALID_ENUM);

     if (extensionRequestable("GL_OES_element_index_uint"))
     {
         glRequestExtensionANGLE("GL_OES_element_index_uint");
         EXPECT_GL_NO_ERROR();
         EXPECT_TRUE(extensionEnabled("GL_OES_element_index_uint"));

         glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
         EXPECT_GL_NO_ERROR();
     }
 }

 // Verify that shaders are of a compatible spec when the extension is enabled.
 TEST_P(WebGLCompatibilityTest, ExtensionCompilerSpec)
 {
     EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));

     // Use of reserved _webgl prefix should fail when the shader specification is for WebGL.
     const std::string &vert =
         "struct Foo {\n"
         "    int _webgl_bar;\n"
         "};\n"
         "void main()\n"
         "{\n"
         "    Foo foo = Foo(1);\n"
         "}";

     // Default fragement shader.
     const std::string &frag =
         "void main()\n"
         "{\n"
         "    gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
         "}";

     GLuint program = CompileProgram(vert, frag);
     EXPECT_EQ(0u, program);
     glDeleteProgram(program);
 }

 // Test that client-side array buffers are forbidden in WebGL mode
 TEST_P(WebGLCompatibilityTest, ForbidsClientSideArrayBuffer)
 {
     const std::string &vert =
         "attribute vec3 a_pos;\n"
         "void main()\n"
         "{\n"
         "    gl_Position = vec4(a_pos, 1.0);\n"
         "}\n";

     const std::string &frag =
         "precision highp float;\n"
         "void main()\n"
         "{\n"
         "    gl_FragColor = vec4(1.0);\n"
         "}\n";

     ANGLE_GL_PROGRAM(program, vert, frag);

     GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
     ASSERT_NE(-1, posLocation);
     glUseProgram(program.get());

     const auto &vertices = GetQuadVertices();
     glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices.data());
     glEnableVertexAttribArray(posLocation);

     ASSERT_GL_NO_ERROR();
     glDrawArrays(GL_TRIANGLES, 0, 6);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }

 // Test that client-side element array buffers are forbidden in WebGL mode
 TEST_P(WebGLCompatibilityTest, ForbidsClientSideElementBuffer)
 {
     const std::string &vert =
         "attribute vec3 a_pos;\n"
         "void main()\n"
         "{\n"
         "    gl_Position = vec4(a_pos, 1.0);\n"
         "}\n";

     const std::string &frag =
         "precision highp float;\n"
         "void main()\n"
         "{\n"
         "    gl_FragColor = vec4(1.0);\n"
         "}\n";

     ANGLE_GL_PROGRAM(program, vert, frag);

     GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
     ASSERT_NE(-1, posLocation);
     glUseProgram(program.get());

     const auto &vertices = GetQuadVertices();

     GLBuffer vertexBuffer;
     glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get());
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                  GL_STATIC_DRAW);

     glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
     glEnableVertexAttribArray(posLocation);

     const GLubyte indices[] = {0, 1, 2, 3, 4, 5};

     ASSERT_GL_NO_ERROR();
     glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }

 // Tests the WebGL requirement of having the same stencil mask, writemask and ref for fron and back
 TEST_P(WebGLCompatibilityTest, RequiresSameStencilMaskAndRef)
 {
     // Run the test in an FBO to make sure we have some stencil bits.
     GLRenderbuffer renderbuffer;
     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get());
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);

     GLFramebuffer framebuffer;
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get());
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                               renderbuffer.get());

     ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }",
                      "void main() { gl_FragColor = vec4(0, 1, 0, 1); }")
     glUseProgram(program.get());
     ASSERT_GL_NO_ERROR();

     // Having ref and mask the same for front and back is valid.
     glStencilMask(255);
     glStencilFunc(GL_ALWAYS, 0, 255);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     ASSERT_GL_NO_ERROR();

     // Having a different front - back write mask generates an error.
     glStencilMaskSeparate(GL_FRONT, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);

     // Setting both write masks separately to the same value is valid.
     glStencilMaskSeparate(GL_BACK, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     ASSERT_GL_NO_ERROR();

     // Having a different stencil front - back mask generates an error
     glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 0, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);

     // Setting both masks separately to the same value is valid.
     glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 0, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     ASSERT_GL_NO_ERROR();

     // Having a different stencil front - back reference generates an error
     glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 255, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);

     // Setting both references separately to the same value is valid.
     glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 255, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     ASSERT_GL_NO_ERROR();

     // Using different stencil funcs, everything being equal is valid.
     glStencilFuncSeparate(GL_BACK, GL_NEVER, 255, 1);
     glDrawArrays(GL_TRIANGLES, 0, 6);
     ASSERT_GL_NO_ERROR();
 }

 // Test that GL_FIXED is forbidden
 TEST_P(WebGLCompatibilityTest, ForbidsGLFixed)
 {
     GLBuffer buffer;
     glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
     glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW);

     glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
     ASSERT_GL_NO_ERROR();

     glVertexAttribPointer(0, 1, GL_FIXED, GL_FALSE, 0, nullptr);
     EXPECT_GL_ERROR(GL_INVALID_ENUM);
 }

 // Test the WebGL limit of 255 for the attribute stride
 TEST_P(WebGLCompatibilityTest, MaxStride)
 {
     GLBuffer buffer;
     glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
     glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW);

     glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 255, nullptr);
     ASSERT_GL_NO_ERROR();

     glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 256, nullptr);
     EXPECT_GL_ERROR(GL_INVALID_VALUE);
 }

 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
 ANGLE_INSTANTIATE_TEST(WebGLCompatibilityTest,
                        ES2_D3D9(),
                        ES2_D3D11(),
                        ES3_D3D11(),
                        ES2_D3D11_FL9_3(),
                        ES2_OPENGL(),
                        ES3_OPENGL(),
                        ES2_OPENGLES(),
                        ES3_OPENGLES());

 }  // namespace
	//
	// 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.
	//

	// WebGLCompatibilityTest.cpp : Tests of the GL_ANGLE_webgl_compatibility extension.

	#include "test_utils/ANGLETest.h"

	#include "test_utils/gl_raii.h"

	namespace angle
	{

	class WebGLCompatibilityTest : public ANGLETest
	{
	protected:
	WebGLCompatibilityTest()
	{
	setWindowWidth(128);
	setWindowHeight(128);
	setConfigRedBits(8);
	setConfigGreenBits(8);
	setConfigBlueBits(8);
	setConfigAlphaBits(8);
	setWebGLCompatibilityEnabled(true);
	}

	void SetUp() override
	{
	ANGLETest::SetUp();
	glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
	eglGetProcAddress("glRequestExtensionANGLE"));
	}

	void TearDown() override { ANGLETest::TearDown(); }

	PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
	};

	// Context creation would fail if EGL_ANGLE_create_context_webgl_compatibility was not available so
	// the GL extension should always be present
	TEST_P(WebGLCompatibilityTest, ExtensionStringExposed)
	{
	EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));
	}

	// Verify that all extension entry points are available
	TEST_P(WebGLCompatibilityTest, EntryPoints)
	{
	if (extensionEnabled("GL_ANGLE_request_extension"))
	{
	EXPECT_NE(nullptr, eglGetProcAddress("glRequestExtensionANGLE"));
	}
	}

	// WebGL 1 allows GL_DEPTH_STENCIL_ATTACHMENT as a valid binding point. Make sure it is usable,
	// even in ES2 contexts.
	TEST_P(WebGLCompatibilityTest, DepthStencilBindingPoint)
	{
	GLRenderbuffer renderbuffer;
	glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get());
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);

	GLFramebuffer framebuffer;
	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get());
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
	renderbuffer.get());

	EXPECT_GL_NO_ERROR();
	}

	// Test that attempting to enable an extension that doesn't exist generates GL_INVALID_OPERATION
	TEST_P(WebGLCompatibilityTest, EnableExtensionValidation)
	{
	glRequestExtensionANGLE("invalid_extension_string");
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);
	}

	// Test enabling the GL_OES_element_index_uint extension
	TEST_P(WebGLCompatibilityTest, EnableExtensionUintIndices)
	{
	if (getClientMajorVersion() != 2)
	{
	// This test only works on ES2 where uint indices are not available by default
	return;
	}

	EXPECT_FALSE(extensionEnabled("GL_OES_element_index_uint"));

	GLBuffer indexBuffer;
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get());

	GLuint data[] = {0, 1, 2, 1, 3, 2};
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

	ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }",
	"void main() { gl_FragColor = vec4(0, 1, 0, 1); }")
	glUseProgram(program.get());

	glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
	EXPECT_GL_ERROR(GL_INVALID_ENUM);

	if (extensionRequestable("GL_OES_element_index_uint"))
	{
	glRequestExtensionANGLE("GL_OES_element_index_uint");
	EXPECT_GL_NO_ERROR();
	EXPECT_TRUE(extensionEnabled("GL_OES_element_index_uint"));

	glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
	EXPECT_GL_NO_ERROR();
	}
	}

	// Verify that shaders are of a compatible spec when the extension is enabled.
	TEST_P(WebGLCompatibilityTest, ExtensionCompilerSpec)
	{
	EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));

	// Use of reserved _webgl prefix should fail when the shader specification is for WebGL.
	const std::string &vert =
	"struct Foo {\n"
	" int _webgl_bar;\n"
	"};\n"
	"void main()\n"
	"{\n"
	" Foo foo = Foo(1);\n"
	"}";

	// Default fragement shader.
	const std::string &frag =
	"void main()\n"
	"{\n"
	" gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
	"}";

	GLuint program = CompileProgram(vert, frag);
	EXPECT_EQ(0u, program);
	glDeleteProgram(program);
	}

	// Test that client-side array buffers are forbidden in WebGL mode
	TEST_P(WebGLCompatibilityTest, ForbidsClientSideArrayBuffer)
	{
	const std::string &vert =
	"attribute vec3 a_pos;\n"
	"void main()\n"
	"{\n"
	" gl_Position = vec4(a_pos, 1.0);\n"
	"}\n";

	const std::string &frag =
	"precision highp float;\n"
	"void main()\n"
	"{\n"
	" gl_FragColor = vec4(1.0);\n"
	"}\n";

	ANGLE_GL_PROGRAM(program, vert, frag);

	GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
	ASSERT_NE(-1, posLocation);
	glUseProgram(program.get());

	const auto &vertices = GetQuadVertices();
	glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices.data());
	glEnableVertexAttribArray(posLocation);

	ASSERT_GL_NO_ERROR();
	glDrawArrays(GL_TRIANGLES, 0, 6);
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);
	}

	// Test that client-side element array buffers are forbidden in WebGL mode
	TEST_P(WebGLCompatibilityTest, ForbidsClientSideElementBuffer)
	{
	const std::string &vert =
	"attribute vec3 a_pos;\n"
	"void main()\n"
	"{\n"
	" gl_Position = vec4(a_pos, 1.0);\n"
	"}\n";

	const std::string &frag =
	"precision highp float;\n"
	"void main()\n"
	"{\n"
	" gl_FragColor = vec4(1.0);\n"
	"}\n";

	ANGLE_GL_PROGRAM(program, vert, frag);

	GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
	ASSERT_NE(-1, posLocation);
	glUseProgram(program.get());

	const auto &vertices = GetQuadVertices();

	GLBuffer vertexBuffer;
	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get());
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
	GL_STATIC_DRAW);

	glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(posLocation);

	const GLubyte indices[] = {0, 1, 2, 3, 4, 5};

	ASSERT_GL_NO_ERROR();
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices);
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);
	}

	// Tests the WebGL requirement of having the same stencil mask, writemask and ref for fron and back
	TEST_P(WebGLCompatibilityTest, RequiresSameStencilMaskAndRef)
	{
	// Run the test in an FBO to make sure we have some stencil bits.
	GLRenderbuffer renderbuffer;
	glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get());
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);

	GLFramebuffer framebuffer;
	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get());
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
	renderbuffer.get());

	ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }",
	"void main() { gl_FragColor = vec4(0, 1, 0, 1); }")
	glUseProgram(program.get());
	ASSERT_GL_NO_ERROR();

	// Having ref and mask the same for front and back is valid.
	glStencilMask(255);
	glStencilFunc(GL_ALWAYS, 0, 255);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	ASSERT_GL_NO_ERROR();

	// Having a different front - back write mask generates an error.
	glStencilMaskSeparate(GL_FRONT, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);

	// Setting both write masks separately to the same value is valid.
	glStencilMaskSeparate(GL_BACK, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	ASSERT_GL_NO_ERROR();

	// Having a different stencil front - back mask generates an error
	glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 0, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);

	// Setting both masks separately to the same value is valid.
	glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 0, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	ASSERT_GL_NO_ERROR();

	// Having a different stencil front - back reference generates an error
	glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 255, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	EXPECT_GL_ERROR(GL_INVALID_OPERATION);

	// Setting both references separately to the same value is valid.
	glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 255, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	ASSERT_GL_NO_ERROR();

	// Using different stencil funcs, everything being equal is valid.
	glStencilFuncSeparate(GL_BACK, GL_NEVER, 255, 1);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	ASSERT_GL_NO_ERROR();
	}

	// Test that GL_FIXED is forbidden
	TEST_P(WebGLCompatibilityTest, ForbidsGLFixed)
	{
	GLBuffer buffer;
	glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
	glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW);

	glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
	ASSERT_GL_NO_ERROR();

	glVertexAttribPointer(0, 1, GL_FIXED, GL_FALSE, 0, nullptr);
	EXPECT_GL_ERROR(GL_INVALID_ENUM);
	}

	// Test the WebGL limit of 255 for the attribute stride
	TEST_P(WebGLCompatibilityTest, MaxStride)
	{
	GLBuffer buffer;
	glBindBuffer(GL_ARRAY_BUFFER, buffer.get());
	glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW);

	glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 255, nullptr);
	ASSERT_GL_NO_ERROR();

	glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 256, nullptr);
	EXPECT_GL_ERROR(GL_INVALID_VALUE);
	}

	// Use this to select which configurations (e.g. which renderer, which GLES major version) these
	// tests should be run against.
	ANGLE_INSTANTIATE_TEST(WebGLCompatibilityTest,
	ES2_D3D9(),
	ES2_D3D11(),
	ES3_D3D11(),
	ES2_D3D11_FL9_3(),
	ES2_OPENGL(),
	ES3_OPENGL(),
	ES2_OPENGLES(),
	ES3_OPENGLES());

	} // namespace