gl_api_unittest.cc 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <stdint.h>
  5. #include <memory>
  6. #include "base/command_line.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. #include "ui/gl/gl_context.h"
  9. #include "ui/gl/gl_gl_api_implementation.h"
  10. #include "ui/gl/gl_implementation.h"
  11. #include "ui/gl/gl_switches.h"
  12. #include "ui/gl/gl_version_info.h"
  13. #include "ui/gl/gpu_timing.h"
  14. namespace gl {
  15. class GLApiTest : public testing::Test {
  16. public:
  17. void SetUp() override {
  18. fake_extension_string_ = "";
  19. fake_version_string_ = "";
  20. num_fake_extension_strings_ = 0;
  21. fake_extension_strings_ = nullptr;
  22. SetGLGetProcAddressProc(
  23. static_cast<GLGetProcAddressProc>(&FakeGLGetProcAddress));
  24. }
  25. static GLFunctionPointerType GL_BINDING_CALL
  26. FakeGLGetProcAddress(const char* proc) {
  27. return reinterpret_cast<GLFunctionPointerType>(0x1);
  28. }
  29. void TearDown() override {
  30. api_.reset(nullptr);
  31. driver_.reset(nullptr);
  32. SetGLImplementation(kGLImplementationNone);
  33. fake_extension_string_ = "";
  34. fake_version_string_ = "";
  35. num_fake_extension_strings_ = 0;
  36. fake_extension_strings_ = nullptr;
  37. }
  38. void InitializeAPI(const char* disabled_extensions) {
  39. driver_ = std::make_unique<DriverGL>();
  40. driver_->fn.glGetStringFn = &FakeGetString;
  41. driver_->fn.glGetStringiFn = &FakeGetStringi;
  42. driver_->fn.glGetIntegervFn = &FakeGetIntegervFn;
  43. api_ = std::make_unique<RealGLApi>();
  44. if (disabled_extensions) {
  45. api_->SetDisabledExtensions(disabled_extensions);
  46. }
  47. api_->Initialize(driver_.get());
  48. std::string extensions_string =
  49. GetGLExtensionsFromCurrentContext(api_.get());
  50. gfx::ExtensionSet extension_set = gfx::MakeExtensionSet(extensions_string);
  51. auto version = std::make_unique<GLVersionInfo>(
  52. reinterpret_cast<const char*>(api_->glGetStringFn(GL_VERSION)),
  53. reinterpret_cast<const char*>(api_->glGetStringFn(GL_RENDERER)),
  54. extension_set);
  55. driver_->InitializeDynamicBindings(version.get(), extension_set);
  56. api_->set_version(std::move(version));
  57. }
  58. void SetFakeExtensionString(const char* fake_string) {
  59. SetGLImplementation(kGLImplementationDesktopGL);
  60. fake_extension_string_ = fake_string;
  61. fake_version_string_ = "2.1";
  62. }
  63. void SetFakeExtensionStrings(const char** fake_strings, uint32_t count) {
  64. SetGLImplementation(kGLImplementationDesktopGL);
  65. num_fake_extension_strings_ = count;
  66. fake_extension_strings_ = fake_strings;
  67. fake_version_string_ = "3.0";
  68. }
  69. static const GLubyte* GL_BINDING_CALL FakeGetString(GLenum name) {
  70. if (name == GL_VERSION)
  71. return reinterpret_cast<const GLubyte*>(fake_version_string_);
  72. return reinterpret_cast<const GLubyte*>(fake_extension_string_);
  73. }
  74. static void GL_BINDING_CALL FakeGetIntegervFn(GLenum pname, GLint* params) {
  75. *params = num_fake_extension_strings_;
  76. }
  77. static const GLubyte* GL_BINDING_CALL FakeGetStringi(GLenum name,
  78. GLuint index) {
  79. return (index < num_fake_extension_strings_) ?
  80. reinterpret_cast<const GLubyte*>(fake_extension_strings_[index]) :
  81. nullptr;
  82. }
  83. const char* GetExtensions() {
  84. return reinterpret_cast<const char*>(api_->glGetStringFn(GL_EXTENSIONS));
  85. }
  86. uint32_t GetNumExtensions() {
  87. GLint num_extensions = 0;
  88. api_->glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
  89. return static_cast<uint32_t>(num_extensions);
  90. }
  91. const char* GetExtensioni(uint32_t index) {
  92. return reinterpret_cast<const char*>(api_->glGetStringiFn(GL_EXTENSIONS,
  93. index));
  94. }
  95. protected:
  96. static const char* fake_extension_string_;
  97. static const char* fake_version_string_;
  98. static uint32_t num_fake_extension_strings_;
  99. static const char** fake_extension_strings_;
  100. std::unique_ptr<DriverGL> driver_;
  101. std::unique_ptr<RealGLApi> api_;
  102. };
  103. const char* GLApiTest::fake_extension_string_ = "";
  104. const char* GLApiTest::fake_version_string_ = "";
  105. uint32_t GLApiTest::num_fake_extension_strings_ = 0;
  106. const char** GLApiTest::fake_extension_strings_ = nullptr;
  107. TEST_F(GLApiTest, DisabledExtensionStringTest) {
  108. static const char* kFakeExtensions = "GL_EXT_1 GL_EXT_2 GL_EXT_3 GL_EXT_4";
  109. static const char* kFakeDisabledExtensions = "GL_EXT_1,GL_EXT_2,GL_FAKE";
  110. static const char* kFilteredExtensions = "GL_EXT_3 GL_EXT_4";
  111. SetFakeExtensionString(kFakeExtensions);
  112. InitializeAPI(nullptr);
  113. EXPECT_STREQ(kFakeExtensions, GetExtensions());
  114. InitializeAPI(kFakeDisabledExtensions);
  115. EXPECT_STREQ(kFilteredExtensions, GetExtensions());
  116. }
  117. TEST_F(GLApiTest, DisabledExtensionBitTest) {
  118. static const char* kFakeExtensions[] = {
  119. "GL_ARB_timer_query"
  120. };
  121. static const char* kFakeDisabledExtensions = "GL_ARB_timer_query";
  122. SetFakeExtensionStrings(kFakeExtensions, std::size(kFakeExtensions));
  123. InitializeAPI(nullptr);
  124. EXPECT_TRUE(driver_->ext.b_GL_ARB_timer_query);
  125. InitializeAPI(kFakeDisabledExtensions);
  126. EXPECT_FALSE(driver_->ext.b_GL_ARB_timer_query);
  127. }
  128. TEST_F(GLApiTest, DisabledExtensionStringIndexTest) {
  129. static const char* kFakeExtensions[] = {
  130. "GL_EXT_1",
  131. "GL_EXT_2",
  132. "GL_EXT_3",
  133. "GL_EXT_4"
  134. };
  135. static const char* kFakeDisabledExtensions = "GL_EXT_1,GL_EXT_2,GL_FAKE";
  136. static const char* kFilteredExtensions[] = {
  137. "GL_EXT_3",
  138. "GL_EXT_4"
  139. };
  140. SetFakeExtensionStrings(kFakeExtensions, std::size(kFakeExtensions));
  141. InitializeAPI(nullptr);
  142. EXPECT_EQ(std::size(kFakeExtensions), GetNumExtensions());
  143. for (uint32_t i = 0; i < std::size(kFakeExtensions); ++i) {
  144. EXPECT_STREQ(kFakeExtensions[i], GetExtensioni(i));
  145. }
  146. InitializeAPI(kFakeDisabledExtensions);
  147. EXPECT_EQ(std::size(kFilteredExtensions), GetNumExtensions());
  148. for (uint32_t i = 0; i < std::size(kFilteredExtensions); ++i) {
  149. EXPECT_STREQ(kFilteredExtensions[i], GetExtensioni(i));
  150. }
  151. }
  152. } // namespace gl