| // | |
| // 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. | |
| // | |
| // RendererTest: | |
| // These tests are designed to ensure that the various configurations of the test fixtures work as | |
| // expected. If one of these tests fails, then it is likely that some of the other tests are being | |
| // configured incorrectly. For example, they might be using the D3D11 renderer when the test is | |
| // meant to be using the Vulkan renderer. | |
| #include <regex> | |
| #include "common/string_utils.h" | |
| #include "test_utils/ANGLETest.h" | |
| #include "test_utils/gl_raii.h" | |
| #include "util/shader_utils.h" | |
| #include "util/test_utils.h" | |
| using namespace angle; | |
| namespace angle | |
| { | |
| class RendererTest : public ANGLETest<> | |
| { | |
| protected: | |
| RendererTest() | |
| { | |
| setWindowWidth(128); | |
| setWindowHeight(128); | |
| } | |
| }; | |
| // Print vendor, renderer, version and extension strings. Useful for debugging. | |
| TEST_P(RendererTest, Strings) | |
| { | |
| std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl; | |
| std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl; | |
| std::cout << "Version: " << glGetString(GL_VERSION) << std::endl; | |
| std::cout << "Extensions: " << glGetString(GL_EXTENSIONS) << std::endl; | |
| EXPECT_GL_NO_ERROR(); | |
| } | |
| TEST_P(RendererTest, RequestedRendererCreated) | |
| { | |
| std::string rendererString = | |
| std::string(reinterpret_cast<const char *>(glGetString(GL_RENDERER))); | |
| angle::ToLower(&rendererString); | |
| std::string versionString = | |
| std::string(reinterpret_cast<const char *>(glGetString(GL_VERSION))); | |
| angle::ToLower(&versionString); | |
| const EGLPlatformParameters &platform = GetParam().eglParameters; | |
| // Ensure that the renderer string contains D3D11, if we requested a D3D11 renderer. | |
| if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) | |
| { | |
| ASSERT_NE(rendererString.find(std::string("direct3d11")), std::string::npos); | |
| } | |
| // Ensure that the major and minor versions trigger expected behavior in D3D11 | |
| if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE) | |
| { | |
| // Ensure that the renderer uses WARP, if we requested it. | |
| if (platform.deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE) | |
| { | |
| auto basicRenderPos = rendererString.find(std::string("microsoft basic render")); | |
| auto softwareAdapterPos = rendererString.find(std::string("software adapter")); | |
| ASSERT_TRUE(basicRenderPos != std::string::npos || | |
| softwareAdapterPos != std::string::npos); | |
| } | |
| std::vector<std::string> acceptableShaderModels; | |
| // When no specific major/minor version is requested, then ANGLE should return the highest | |
| // possible feature level by default. The current hardware driver might not support Feature | |
| // Level 11_0, but WARP always does. Therefore if WARP is specified but no major/minor | |
| // version is specified, then we test to check that ANGLE returns FL11_0. | |
| if (platform.majorVersion >= 11 || platform.majorVersion == EGL_DONT_CARE) | |
| { | |
| // Feature Level 10_0 corresponds to shader model 5_0 | |
| acceptableShaderModels.push_back("ps_5_0"); | |
| } | |
| if (platform.majorVersion >= 10 || platform.majorVersion == EGL_DONT_CARE) | |
| { | |
| if (platform.minorVersion >= 1 || platform.minorVersion == EGL_DONT_CARE) | |
| { | |
| // Feature Level 10_1 corresponds to shader model 4_1 | |
| acceptableShaderModels.push_back("ps_4_1"); | |
| } | |
| if (platform.minorVersion >= 0 || platform.minorVersion == EGL_DONT_CARE) | |
| { | |
| // Feature Level 10_0 corresponds to shader model 4_0 | |
| acceptableShaderModels.push_back("ps_4_0"); | |
| } | |
| } | |
| bool found = false; | |
| for (const std::string &acceptableShaderModel : acceptableShaderModels) | |
| { | |
| if (rendererString.find(acceptableShaderModel) != std::string::npos) | |
| { | |
| found = true; | |
| } | |
| } | |
| ASSERT_TRUE(found); | |
| } | |
| if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE) | |
| { | |
| ASSERT_TRUE(IsNULL()); | |
| } | |
| if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) | |
| { | |
| ASSERT_TRUE(IsVulkan()); | |
| } | |
| // EGL_ANGLE_create_context_backwards_compatible is required to guarantee the expected context | |
| // version. | |
| EGLint glesMajorVersion; | |
| EGLint glesMinorVersion; | |
| EGLWindow *window = getEGLWindow(); | |
| EGLDisplay display = window->getDisplay(); | |
| if (IsEGLDisplayExtensionEnabled(display, "EGL_ANGLE_create_context_backwards_compatible")) | |
| { | |
| // If the extension is available, verify the requested version matches the returned version. | |
| glesMajorVersion = GetParam().majorVersion; | |
| glesMinorVersion = GetParam().minorVersion; | |
| } | |
| else | |
| { | |
| // Otherwise, get the created context's (maximally conformant) version. | |
| glesMajorVersion = getClientMajorVersion(); | |
| glesMinorVersion = getClientMinorVersion(); | |
| // Verify that the returned version is >= the requested version. | |
| ASSERT_GE(glesMajorVersion, GetParam().majorVersion); | |
| ASSERT_GE(glesMinorVersion, GetParam().minorVersion); | |
| } | |
| std::ostringstream expectedVersionString; | |
| expectedVersionString << "es " << glesMajorVersion << "." << glesMinorVersion; | |
| ASSERT_NE(versionString.find(expectedVersionString.str()), std::string::npos); | |
| ASSERT_GL_NO_ERROR(); | |
| ASSERT_EGL_SUCCESS(); | |
| } | |
| // Perform a simple operation (clear and read pixels) to verify the device is working | |
| TEST_P(RendererTest, SimpleOperation) | |
| { | |
| if (IsNULL()) | |
| { | |
| std::cout << "ANGLE NULL backend clears are not functional" << std::endl; | |
| return; | |
| } | |
| glClearColor(0.0f, 1.0f, 0.0f, 1.0f); | |
| glClear(GL_COLOR_BUFFER_BIT); | |
| EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255); | |
| ASSERT_GL_NO_ERROR(); | |
| } | |
| // Perform a simple buffer operation. | |
| TEST_P(RendererTest, BufferData) | |
| { | |
| constexpr size_t kBufferSize = 1024; | |
| std::array<uint8_t, kBufferSize> data; | |
| for (size_t i = 0; i < kBufferSize; i++) | |
| { | |
| data[i] = static_cast<uint8_t>(i); | |
| } | |
| // All at once in the glBufferData call | |
| { | |
| GLBuffer buffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); | |
| glBufferData(GL_ARRAY_BUFFER, 1024, data.data(), GL_STATIC_DRAW); | |
| } | |
| // Set data with sub data | |
| { | |
| GLBuffer buffer; | |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); | |
| glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW); | |
| glBufferSubData(GL_ARRAY_BUFFER, 0, kBufferSize, data.data()); | |
| } | |
| } | |
| // Compile simple vertex and fragment shaders | |
| TEST_P(RendererTest, CompileShader) | |
| { | |
| GLuint vs = CompileShader(GL_VERTEX_SHADER, essl1_shaders::vs::Zero()); | |
| EXPECT_NE(vs, 0u); | |
| glDeleteShader(vs); | |
| GLuint fs = CompileShader(GL_FRAGMENT_SHADER, essl1_shaders::fs::Red()); | |
| EXPECT_NE(fs, 0u); | |
| glDeleteShader(fs); | |
| } | |
| // Link a simple program | |
| TEST_P(RendererTest, LinkProgram) | |
| { | |
| ANGLE_GL_PROGRAM(prog, essl1_shaders::vs::Zero(), essl1_shaders::fs::Red()); | |
| } | |
| // Draw a triangle using no vertex attributes | |
| TEST_P(RendererTest, Draw) | |
| { | |
| ANGLE_GL_PROGRAM(prog, essl1_shaders::vs::Zero(), essl1_shaders::fs::Red()); | |
| glUseProgram(prog); | |
| glDrawArrays(GL_TRIANGLES, 0, 3); | |
| } | |
| // This test validates that the GL_RENDERER string reported by ANGLE adheres to the | |
| // canonical format: "ANGLE (Vendor, Renderer, Version)". | |
| // This format is a de-facto API contract relied upon by upstream clients like Skia | |
| // to enable workarounds and optimizations. | |
| TEST_P(RendererTest, ValidateCanonicalFormat) | |
| { | |
| // Use the idiomatic IsNULL() check to skip this test on the Null backend. | |
| if (IsNULL()) | |
| { | |
| std::cout << "Skipping canonical format validation for the Null backend." << std::endl; | |
| return; | |
| } | |
| // 1. Query the renderer string from the driver. | |
| const char *rendererCStr = reinterpret_cast<const char *>(glGetString(GL_RENDERER)); | |
| ASSERT_NE(rendererCStr, nullptr); | |
| std::string rendererStr(rendererCStr); | |
| std::cout << "Renderer string: \"" << rendererStr << "\"" << std::endl; | |
| // 2. Validate the entire string structure using a single regular expression. | |
| // This regex enforces the "ANGLE (...)" wrapper and the presence of three | |
| // comma-space-separated components, while allowing components to be empty. | |
| const std::regex kRendererFormat("^ANGLE \\((.*), (.*), (.*)\\)$"); | |
| std::smatch match; | |
| bool matches = std::regex_match(rendererStr, match, kRendererFormat); | |
| // 3. Assert that the string matches the format and contains the correct number of groups. | |
| // match[0] is the full string, match[1-3] are the captured components. | |
| ASSERT_TRUE(matches && match.size() == 4) | |
| << "Renderer string does not match the expected format 'ANGLE (Vendor, Renderer, Version)'." | |
| << "\n Actual string: " << rendererStr; | |
| // 4. For clarity in test logs, print the parsed components. | |
| std::cout << "Successfully parsed renderer string components:" << std::endl; | |
| std::cout << " - Vendor: \"" << match[1].str() << "\"" << std::endl; | |
| std::cout << " - Renderer: \"" << match[2].str() << "\"" << std::endl; | |
| std::cout << " - Version: \"" << match[3].str() << "\"" << std::endl; | |
| EXPECT_GL_NO_ERROR(); | |
| } | |
| // Select configurations (e.g. which renderer, which GLES major version) these tests should be run | |
| // against. | |
| ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND_ES31_AND_NULL(RendererTest); | |
| } // namespace angle |