| // | |
| // Copyright 2016 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. | |
| // | |
| // RobustClientMemoryTest.cpp : Tests of the GL_ANGLE_robust_client_memory extension. | |
| #include "test_utils/ANGLETest.h" | |
| #include "test_utils/gl_raii.h" | |
| namespace angle | |
| { | |
| constexpr GLsizei kWindowSize = 128; | |
| class RobustClientMemoryTest : public ANGLETest<> | |
| { | |
| protected: | |
| RobustClientMemoryTest() | |
| { | |
| setWindowWidth(kWindowSize); | |
| setWindowHeight(kWindowSize); | |
| setConfigRedBits(8); | |
| setConfigGreenBits(8); | |
| setConfigBlueBits(8); | |
| setConfigAlphaBits(8); | |
| } | |
| }; | |
| // Test basic usage and validation of glGetIntegervRobustANGLE | |
| TEST_P(RobustClientMemoryTest, GetInteger) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| // Verify that the robust and regular entry points return the same values | |
| GLint resultRobust; | |
| GLsizei length; | |
| glGetIntegervRobustANGLE(GL_MAX_VERTEX_ATTRIBS, 1, &length, &resultRobust); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(1, length); | |
| GLint resultRegular; | |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &resultRegular); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(resultRegular, resultRobust); | |
| // Query a dynamic value | |
| GLint numCompressedFormats; | |
| glGetIntegervRobustANGLE(GL_NUM_COMPRESSED_TEXTURE_FORMATS, 1, &length, &numCompressedFormats); | |
| ASSERT_GL_NO_ERROR(); | |
| EXPECT_EQ(1, length); | |
| if (numCompressedFormats > 0) | |
| { | |
| std::vector<GLint> resultBuf(numCompressedFormats * 2, 0); | |
| // Test when the bufSize is too low | |
| glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, numCompressedFormats - 1, &length, | |
| resultBuf.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(), | |
| [](GLint value) { return value == 0; })); | |
| // Make sure the GL doesn't touch the end of the buffer | |
| glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, | |
| static_cast<GLsizei>(resultBuf.size()), &length, resultBuf.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(numCompressedFormats, length); | |
| EXPECT_TRUE(std::none_of(resultBuf.begin(), resultBuf.begin() + length, | |
| [](GLint value) { return value == 0; })); | |
| EXPECT_TRUE(std::all_of(resultBuf.begin() + length, resultBuf.end(), | |
| [](GLint value) { return value == 0; })); | |
| } | |
| // Test with null length | |
| glGetIntegervRobustANGLE(GL_MAX_VARYING_VECTORS, 1, nullptr, &resultRobust); | |
| EXPECT_GL_NO_ERROR(); | |
| glGetIntegervRobustANGLE(GL_MAX_VIEWPORT_DIMS, 1, nullptr, &resultRobust); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| GLint maxViewportDims[2]; | |
| glGetIntegervRobustANGLE(GL_MAX_VIEWPORT_DIMS, 2, nullptr, maxViewportDims); | |
| EXPECT_GL_NO_ERROR(); | |
| } | |
| // Test basic usage and validation of glGetInteger64vRobustANGLE | |
| TEST_P(RobustClientMemoryTest, GetInteger64) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3); | |
| constexpr GLint64 kMinRequiredMaxElementIndex = 16777215; | |
| // Verify that the regular and robust entry points return the same values | |
| GLint64 resultRegular; | |
| glGetInteger64v(GL_MAX_ELEMENT_INDEX, &resultRegular); | |
| ASSERT_GL_NO_ERROR(); | |
| ASSERT_GE(resultRegular, kMinRequiredMaxElementIndex); | |
| GLsizei length; | |
| GLint64 resultRobust; | |
| glGetInteger64vRobustANGLE(GL_MAX_ELEMENT_INDEX, 1, &length, &resultRobust); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(1, length); | |
| EXPECT_EQ(resultRegular, resultRobust); | |
| } | |
| // Test basic usage and validation of glTexImage2DRobustANGLE and glTexSubImage2DRobustANGLE | |
| TEST_P(RobustClientMemoryTest, TexImage2D) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| GLTexture tex; | |
| glBindTexture(GL_TEXTURE_2D, tex); | |
| GLsizei dataDimension = 1024; | |
| std::vector<GLubyte> rgbaData(dataDimension * dataDimension * 4); | |
| // Test the regular case | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()), | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| glTexSubImage2DRobustANGLE(GL_TEXTURE_2D, 0, 0, 0, dataDimension, dataDimension, GL_RGBA, | |
| GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()), | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| // Test with no data and zero size | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, 0, nullptr); | |
| EXPECT_GL_NO_ERROR(); | |
| // Test with data and negative size | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, -1, rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); | |
| // Test with no data and negative size | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, -1, nullptr); | |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); | |
| // Test with no data and positive size | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, 1, nullptr); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| // Test with a data size that is too small | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()) / 2, | |
| rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| glTexSubImage2DRobustANGLE(GL_TEXTURE_2D, 0, 0, 0, dataDimension, dataDimension, GL_RGBA, | |
| GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()) / 2, | |
| rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| if (getClientMajorVersion() >= 3) | |
| { | |
| { | |
| // Test bufSize when a PBO is bound | |
| GLBuffer buffer; | |
| glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer); | |
| glBufferData(GL_PIXEL_UNPACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY); | |
| // Zero bufSize must be accepted | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, | |
| GL_RGBA, GL_UNSIGNED_BYTE, 0, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_NO_ERROR(); | |
| // Positive bufSize must be rejected | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, | |
| GL_RGBA, GL_UNSIGNED_BYTE, 1, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| // Negative bufSize is invalid | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, | |
| GL_RGBA, GL_UNSIGNED_BYTE, -1, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); | |
| glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); | |
| } | |
| // Set an unpack parameter that would cause the driver to read past the end of the buffer | |
| glPixelStorei(GL_UNPACK_ROW_LENGTH, dataDimension + 1); | |
| glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA, | |
| GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()), | |
| rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| } | |
| } | |
| // Test basic usage and validation of glReadPixelsRobustANGLE | |
| TEST_P(RobustClientMemoryTest, ReadPixels) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| // TODO(ynovikov): Looks like a driver bug on Intel HD 530 http://anglebug.com/42260689 | |
| ANGLE_SKIP_TEST_IF(IsLinux() && IsIntel() && IsDesktopOpenGL()); | |
| GLsizei dataDimension = 16; | |
| std::vector<GLubyte> rgbaData(dataDimension * dataDimension * 4); | |
| // Test the regular case | |
| GLsizei length = -1; | |
| GLsizei columns = -1; | |
| GLsizei rows = -1; | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), &length, &columns, &rows, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(static_cast<GLsizei>(rgbaData.size()), length); | |
| EXPECT_EQ(dataDimension, columns); | |
| EXPECT_EQ(dataDimension, rows); | |
| // Test a case that would be partially clipped | |
| length = -1; | |
| columns = -1; | |
| rows = -1; | |
| glReadPixelsRobustANGLE(-1, kWindowSize - dataDimension + 3, dataDimension, dataDimension, | |
| GL_RGBA, GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()), | |
| &length, &columns, &rows, rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(static_cast<GLsizei>(rgbaData.size()), length); | |
| EXPECT_EQ(dataDimension - 1, columns); | |
| EXPECT_EQ(dataDimension - 3, rows); | |
| length = 123; | |
| columns = 456; | |
| rows = 789; | |
| // Test with a data size that is too small, the output params must not be updated | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()) - 1, &length, &columns, &rows, | |
| rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| EXPECT_EQ(length, 123); | |
| EXPECT_EQ(columns, 456); | |
| EXPECT_EQ(rows, 789); | |
| // Test that all output parameters may be null | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), nullptr, nullptr, nullptr, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| if (getClientMajorVersion() >= 3) | |
| { | |
| { | |
| // Test that non-negative bufSize is ignored when a PBO is bound | |
| GLBuffer buffer; | |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer); | |
| glBufferData(GL_PIXEL_PACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY); | |
| // Zero bufSize must be accepted | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| 0, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_NO_ERROR(); | |
| // Small bufSize must be accepted | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| 16, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_NO_ERROR(); | |
| // Test that negative bufSize is still invalid when a PBO is bound | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| -1, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0)); | |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); | |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); | |
| } | |
| // Set a pack parameter that would cause the driver to write past the end of the buffer | |
| glPixelStorei(GL_PACK_ROW_LENGTH, dataDimension + 1); | |
| glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr, | |
| rgbaData.data()); | |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); | |
| } | |
| } | |
| // Test the output length parameter | |
| TEST_P(RobustClientMemoryTest, ReadPixelsLengthOutput) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| // Buffer twice as large as the window | |
| std::vector<GLubyte> rgbaData(2 * kWindowSize * kWindowSize * 4); | |
| // Test that output length is computed based on the input dimensions | |
| { | |
| // Input x, y, width, height, output length | |
| const int testValues[7][5] = { | |
| {0, 0, 0, 0, 0}, // Zero input area | |
| {0, 0, 128, 0, 0}, // Zero input height | |
| {0, 0, 0, 128, 0}, // Zero input width | |
| {0, 0, 128, 128, 65536}, // Full size | |
| {64, 0, 64, 128, 32768}, // Half width with positive offset | |
| {0, -128, 128, 256, 131072}, // Full width, double height with negative offset | |
| {128, 128, 128, 256, 131072}, // Origin OOB, zero intersection | |
| }; | |
| for (auto &test : testValues) | |
| { | |
| GLsizei length = -1; | |
| glReadPixelsRobustANGLE(test[0], test[1], test[2], test[3], GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), &length, nullptr, | |
| nullptr, rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(length, test[4]); | |
| } | |
| } | |
| // Test that output length is zero when reading to PBO | |
| if (getClientMajorVersion() >= 3) | |
| { | |
| GLsizei length = -1; | |
| GLBuffer buffer; | |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer); | |
| glBufferData(GL_PIXEL_PACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY); | |
| glReadPixelsRobustANGLE(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr, | |
| reinterpret_cast<void *>(0)); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(length, 0); | |
| // Unbind and repeat | |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); | |
| glReadPixelsRobustANGLE(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(length, 128 * 128 * 4); | |
| } | |
| } | |
| // Test edge cases of the returned image dimensions | |
| TEST_P(RobustClientMemoryTest, ReadPixelsClipping) | |
| { | |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| // Buffer twice as large as the window | |
| std::vector<GLubyte> rgbaData(2 * kWindowSize * kWindowSize * 4); | |
| // Origin, input dimension, output dimension | |
| const int testValues[16][3] = { | |
| {-15, 0, 0}, // Negative origin with zero length | |
| {-15, 16, 1}, // Negative origin with overlapping region | |
| {-16, 16, 0}, // Negative origin with adjacent region | |
| {-17, 16, 0}, // Negative origin with non-overlapping region | |
| {-16, 144, 128}, // Negative origin with exact length | |
| {-16, 160, 128}, // Negative origin with large length | |
| {0, 0, 0}, // Zero origin with zero length | |
| {0, 128, 128}, // Zero origin with exact length | |
| {0, 16, 16}, // Zero origin with small length | |
| {0, 144, 128}, // Zero origin with large length | |
| {16, 0, 0}, // Positive origin with zero length | |
| {16, 112, 112}, // Positive origin with exact length | |
| {16, 32, 32}, // Positive origin with small length | |
| {16, 128, 112}, // Positive origin with large width | |
| {144, 0, 0}, // Out of range origin with zero length | |
| {144, 16, 0}, // Out of range origin with non-zero length | |
| }; | |
| for (auto &test : testValues) | |
| { | |
| // Test columns and rows separately | |
| { | |
| GLsizei columns = -1; | |
| glReadPixelsRobustANGLE(test[0], 0, test[1], 128, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), nullptr, &columns, | |
| nullptr, rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(columns, test[2]); | |
| GLsizei rows = -1; | |
| glReadPixelsRobustANGLE(0, test[0], 128, test[1], GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), nullptr, nullptr, &rows, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(rows, test[2]); | |
| } | |
| // Test that if one output is zero, then the other output is also zero | |
| if (test[2] == 0) | |
| { | |
| GLsizei columns = -1; | |
| GLsizei rows = -1; | |
| glReadPixelsRobustANGLE(test[0], 0, test[1], 128, GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), nullptr, &columns, &rows, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(columns, 0); | |
| EXPECT_EQ(rows, 0); | |
| columns = -1; | |
| rows = -1; | |
| glReadPixelsRobustANGLE(0, test[0], 128, test[1], GL_RGBA, GL_UNSIGNED_BYTE, | |
| static_cast<GLsizei>(rgbaData.size()), nullptr, &columns, &rows, | |
| rgbaData.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| EXPECT_EQ(columns, 0); | |
| EXPECT_EQ(rows, 0); | |
| } | |
| } | |
| } | |
| class RobustClientMemoryNoExtensionsTest : public RobustClientMemoryTest | |
| { | |
| protected: | |
| RobustClientMemoryNoExtensionsTest() : RobustClientMemoryTest() { setExtensionsEnabled(false); } | |
| }; | |
| // Test with empty result | |
| TEST_P(RobustClientMemoryNoExtensionsTest, GetEmpty) | |
| { | |
| // GL_NUM_COMPRESSED_TEXTURE_FORMATS is core in ES 3.0. | |
| ANGLE_SKIP_TEST_IF(isAtLeastClientVersion(3, 0)); | |
| GLint numFormats = 10; | |
| glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats); | |
| ASSERT_GL_NO_ERROR(); | |
| ASSERT_EQ(numFormats, 0); // Must be zero on unextended OpenGL ES 2.0 | |
| GLsizei length = 1; | |
| std::vector<GLint> resultBuf(2, 3); | |
| // Test non-robust with empty response | |
| { | |
| glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| // Must not touch the buffer | |
| EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(), | |
| [](GLint value) { return value == 3; })); | |
| } | |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_robust_client_memory")); | |
| // Test robust with empty response | |
| { | |
| glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.size(), &length, | |
| resultBuf.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| // Must update length | |
| EXPECT_EQ(length, 0); | |
| // Must not touch the buffer | |
| EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(), | |
| [](GLint value) { return value == 3; })); | |
| } | |
| // Test robust with empty response and null length | |
| { | |
| glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.size(), nullptr, | |
| resultBuf.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| // Must not touch the buffer | |
| EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(), | |
| [](GLint value) { return value == 3; })); | |
| } | |
| // Test robust with empty response, zero buffer size, and null length | |
| { | |
| glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, 0, nullptr, resultBuf.data()); | |
| EXPECT_GL_NO_ERROR(); | |
| // Must not touch the buffer | |
| EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(), | |
| [](GLint value) { return value == 3; })); | |
| } | |
| } | |
| // Use this to select which configurations (e.g. which renderer, which GLES major version) these | |
| // tests should be run against. | |
| ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(RobustClientMemoryTest); | |
| ANGLE_INSTANTIATE_TEST_ES2(RobustClientMemoryNoExtensionsTest); | |
| } // namespace angle |