From 3e5e7086d5fdc411c12db8d34ec6e5193b77bbb1 Mon Sep 17 00:00:00 2001 From: "auto-submit[bot]" <98614782+auto-submit[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 18:01:35 +0000 Subject: [PATCH] Reverts "Replaces bespoke call captures from mock gles with gmock (#56995)" (flutter/engine#57016) Reverts: flutter/engine#56995 Initiated by: jonahwilliams Reason for reverting: compilation error at head. Original PR Author: gaaclarke Reviewed By: {jonahwilliams} This change reverts the following previous change: test exempt: test only code [C++, Objective-C, Java style guides]: https://github.com/flutter/engine/blob/main/CONTRIBUTING.md#style --- .../gles/buffer_bindings_gles_unittests.cc | 11 +- .../gles/test/capabilities_unittests.cc | 19 ++-- .../gles/test/gpu_tracer_gles_unittests.cc | 56 ++++------ .../renderer/backend/gles/test/mock_gles.cc | 104 +++++++++--------- .../renderer/backend/gles/test/mock_gles.h | 78 +++---------- .../backend/gles/test/mock_gles_unittests.cc | 13 +++ .../backend/gles/test/reactor_unittests.cc | 56 ++++------ .../gles/unique_handle_gles_unittests.cc | 13 +-- 8 files changed, 146 insertions(+), 204 deletions(-) diff --git a/engine/src/flutter/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc index 45a342bfcb..9078447433 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc @@ -12,18 +12,12 @@ namespace impeller { namespace testing { -using ::testing::_; - TEST(BufferBindingsGLESTest, BindUniformData) { BufferBindingsGLES bindings; absl::flat_hash_map uniform_bindings; uniform_bindings["SHADERMETADATA.FOOBAR"] = 1; bindings.SetUniformBindings(std::move(uniform_bindings)); - auto mock_gles_impl = std::make_unique(); - - EXPECT_CALL(*mock_gles_impl, Uniform1fv(_, _, _)).Times(1); - - std::shared_ptr mock_gl = MockGLES::Init(std::move(mock_gles_impl)); + std::shared_ptr mock_gl = MockGLES::Init(); std::vector bound_buffers; std::vector bound_textures; @@ -45,6 +39,9 @@ TEST(BufferBindingsGLESTest, BindUniformData) { EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures, bound_buffers, Range{0, 0}, Range{0, 1})); + std::vector captured_calls = mock_gl->GetCapturedCalls(); + EXPECT_TRUE(std::find(captured_calls.begin(), captured_calls.end(), + "glUniform1fv") != captured_calls.end()); } } // namespace testing diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/capabilities_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/capabilities_unittests.cc index f78d63afb3..4fd30fff77 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/capabilities_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/capabilities_unittests.cc @@ -33,9 +33,9 @@ TEST(CapabilitiesGLES, CanInitializeWithDefaults) { } TEST(CapabilitiesGLES, SupportsDecalSamplerAddressMode) { - auto const extensions = std::vector{ - "GL_KHR_debug", // - "GL_EXT_texture_border_clamp", // + auto const extensions = std::vector{ + reinterpret_cast("GL_KHR_debug"), // + reinterpret_cast("GL_EXT_texture_border_clamp"), // }; auto mock_gles = MockGLES::Init(extensions); auto capabilities = mock_gles->GetProcTable().GetCapabilities(); @@ -43,9 +43,9 @@ TEST(CapabilitiesGLES, SupportsDecalSamplerAddressMode) { } TEST(CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES) { - auto const extensions = std::vector{ - "GL_KHR_debug", // - "GL_OES_texture_border_clamp", // + auto const extensions = std::vector{ + reinterpret_cast("GL_KHR_debug"), // + reinterpret_cast("GL_OES_texture_border_clamp"), // }; auto mock_gles = MockGLES::Init(extensions); auto capabilities = mock_gles->GetProcTable().GetCapabilities(); @@ -53,9 +53,10 @@ TEST(CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES) { } TEST(CapabilitiesGLES, SupportsFramebufferFetch) { - auto const extensions = std::vector{ - "GL_KHR_debug", // - "GL_EXT_shader_framebuffer_fetch", // + auto const extensions = std::vector{ + reinterpret_cast("GL_KHR_debug"), // + reinterpret_cast( + "GL_EXT_shader_framebuffer_fetch"), // }; auto mock_gles = MockGLES::Init(extensions); auto capabilities = mock_gles->GetProcTable().GetCapabilities(); diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc index 2ee1da6c1b..d0579a2091 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc @@ -10,48 +10,38 @@ namespace impeller { namespace testing { -using ::testing::_; - #ifdef IMPELLER_DEBUG TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) { - auto const extensions = std::vector{ - "GL_KHR_debug", // - "GL_EXT_disjoint_timer_query", // + auto const extensions = std::vector{ + reinterpret_cast("GL_KHR_debug"), // + reinterpret_cast("GL_EXT_disjoint_timer_query"), // }; - auto mock_gles_impl = std::make_unique(); - - { - ::testing::InSequence seq; - auto gen_queries = [](GLsizei n, GLuint* ids) { - for (int i = 0; i < n; ++i) { - ids[i] = i + 1; - } - }; - EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _)).WillOnce(gen_queries); - EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _)); - EXPECT_CALL(*mock_gles_impl, EndQueryEXT(GL_TIME_ELAPSED_EXT)); - EXPECT_CALL(*mock_gles_impl, - GetQueryObjectuivEXT(_, GL_QUERY_RESULT_AVAILABLE_EXT, _)) - .WillOnce([](GLuint id, GLenum target, GLuint* result) { - *result = GL_TRUE; - }); - EXPECT_CALL(*mock_gles_impl, - GetQueryObjectui64vEXT(_, GL_QUERY_RESULT_EXT, _)) - .WillOnce([](GLuint id, GLenum target, GLuint64* result) { - *result = 1000u; - }); - EXPECT_CALL(*mock_gles_impl, DeleteQueriesEXT(_, _)); - EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _)).WillOnce(gen_queries); - EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _)); - } - std::shared_ptr mock_gles = - MockGLES::Init(std::move(mock_gles_impl), extensions); + auto mock_gles = MockGLES::Init(extensions); auto tracer = std::make_shared(mock_gles->GetProcTable(), true); tracer->RecordRasterThread(); tracer->MarkFrameStart(mock_gles->GetProcTable()); tracer->MarkFrameEnd(mock_gles->GetProcTable()); + + auto calls = mock_gles->GetCapturedCalls(); + + std::vector expected = {"glGenQueriesEXT", "glBeginQueryEXT", + "glEndQueryEXT"}; + for (auto i = 0; i < 3; i++) { + EXPECT_EQ(calls[i], expected[i]); + } + + // Begin second frame, which prompts the tracer to query the result + // from the previous frame. tracer->MarkFrameStart(mock_gles->GetProcTable()); + + calls = mock_gles->GetCapturedCalls(); + std::vector expected_b = {"glGetQueryObjectuivEXT", + "glGetQueryObjectui64vEXT", + "glDeleteQueriesEXT"}; + for (auto i = 0; i < 3; i++) { + EXPECT_EQ(calls[i], expected_b[i]); + } } #endif // IMPELLER_DEBUG diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.cc index 5b890d989f..9b1965ab2b 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.cc @@ -19,9 +19,18 @@ static std::mutex g_test_lock; static std::weak_ptr g_mock_gles; -static std::vector g_extensions; +static ProcTableGLES::Resolver g_resolver; -static const char* g_version; +static std::vector g_extensions; + +static const unsigned char* g_version; + +// Has friend visibility into MockGLES to record calls. +void RecordGLCall(const char* name) { + if (auto mock_gles = g_mock_gles.lock()) { + mock_gles->RecordCall(name); + } +} template struct CheckSameSignature : std::false_type {}; @@ -32,34 +41,22 @@ struct CheckSameSignature : std::true_type {}; // This is a stub function that does nothing/records nothing. void doNothing() {} -auto const kMockVendor = "MockGLES"; -const auto kMockShadingLanguageVersion = "GLSL ES 1.0"; -auto const kExtensions = std::vector{ - "GL_KHR_debug" // +auto const kMockVendor = (unsigned char*)"MockGLES"; +const auto kMockShadingLanguageVersion = (unsigned char*)"GLSL ES 1.0"; +auto const kExtensions = std::vector{ + (unsigned char*)"GL_KHR_debug" // }; -namespace { -template -void CallMockMethod(Func func, Args&&... args) { - if (auto mock_gles = g_mock_gles.lock()) { - if (mock_gles->GetImpl()) { - (mock_gles->GetImpl()->*func)(std::forward(args)...); - } - } -} -} // namespace - const unsigned char* mockGetString(GLenum name) { switch (name) { case GL_VENDOR: - return reinterpret_cast(kMockVendor); + return kMockVendor; case GL_VERSION: - return reinterpret_cast(g_version); + return g_version; case GL_SHADING_LANGUAGE_VERSION: - return reinterpret_cast( - kMockShadingLanguageVersion); + return kMockShadingLanguageVersion; default: - return reinterpret_cast(""); + return (unsigned char*)""; } } @@ -69,9 +66,9 @@ static_assert(CheckSameSignature(g_extensions[index]); + return g_extensions[index]; default: - return reinterpret_cast(""); + return (unsigned char*)""; } } @@ -105,7 +102,9 @@ GLenum mockGetError() { static_assert(CheckSameSignature::value); -void mockPopDebugGroupKHR() {} +void mockPopDebugGroupKHR() { + RecordGLCall("PopDebugGroupKHR"); +} static_assert(CheckSameSignature::value); @@ -113,65 +112,79 @@ static_assert(CheckSameSignature::value); void mockGenQueriesEXT(GLsizei n, GLuint* ids) { - CallMockMethod(&IMockGLESImpl::GenQueriesEXT, n, ids); + RecordGLCall("glGenQueriesEXT"); + for (auto i = 0; i < n; i++) { + ids[i] = i + 1; + } } static_assert(CheckSameSignature::value); void mockBeginQueryEXT(GLenum target, GLuint id) { - CallMockMethod(&IMockGLESImpl::BeginQueryEXT, target, id); + RecordGLCall("glBeginQueryEXT"); } static_assert(CheckSameSignature::value); void mockEndQueryEXT(GLuint id) { - CallMockMethod(&IMockGLESImpl::EndQueryEXT, id); + RecordGLCall("glEndQueryEXT"); } static_assert(CheckSameSignature::value); void mockGetQueryObjectuivEXT(GLuint id, GLenum target, GLuint* result) { - CallMockMethod(&IMockGLESImpl::GetQueryObjectuivEXT, id, target, result); + RecordGLCall("glGetQueryObjectuivEXT"); + *result = GL_TRUE; } static_assert(CheckSameSignature::value); void mockGetQueryObjectui64vEXT(GLuint id, GLenum target, GLuint64* result) { - CallMockMethod(&IMockGLESImpl::GetQueryObjectui64vEXT, id, target, result); + RecordGLCall("glGetQueryObjectui64vEXT"); + *result = 1000u; } static_assert(CheckSameSignature::value); void mockDeleteQueriesEXT(GLsizei size, const GLuint* queries) { - CallMockMethod(&IMockGLESImpl::DeleteQueriesEXT, size, queries); + RecordGLCall("glDeleteQueriesEXT"); } void mockDeleteTextures(GLsizei size, const GLuint* queries) { - CallMockMethod(&IMockGLESImpl::DeleteTextures, size, queries); + RecordGLCall("glDeleteTextures"); } static_assert(CheckSameSignature::value); void mockUniform1fv(GLint location, GLsizei count, const GLfloat* value) { - CallMockMethod(&IMockGLESImpl::Uniform1fv, location, count, value); + RecordGLCall("glUniform1fv"); } static_assert(CheckSameSignature::value); void mockGenTextures(GLsizei n, GLuint* textures) { - CallMockMethod(&IMockGLESImpl::GenTextures, n, textures); + RecordGLCall("glGenTextures"); + if (auto mock_gles = g_mock_gles.lock()) { + std::optional next_texture; + std::swap(mock_gles->next_texture_, next_texture); + if (next_texture.has_value()) { + textures[0] = next_texture.value(); + } + } } static_assert(CheckSameSignature::value); -// static std::shared_ptr MockGLES::Init( - std::unique_ptr impl, - const std::optional>& extensions) { - FML_CHECK(g_test_lock.try_lock()) - << "MockGLES is already being used by another test."; - g_extensions = extensions.value_or(kExtensions); - g_version = "OpenGL ES 3.0"; - auto mock_gles = std::shared_ptr(new MockGLES()); - mock_gles->impl_ = std::move(impl); - g_mock_gles = mock_gles; - return mock_gles; -} - -std::shared_ptr MockGLES::Init( - const std::optional>& extensions, + const std::optional>& extensions, const char* version_string, ProcTableGLES::Resolver resolver) { // If we cannot obtain a lock, MockGLES is already being used elsewhere. FML_CHECK(g_test_lock.try_lock()) << "MockGLES is already being used by another test."; + g_version = (unsigned char*)version_string; g_extensions = extensions.value_or(kExtensions); - g_version = version_string; auto mock_gles = std::shared_ptr(new MockGLES(std::move(resolver))); g_mock_gles = mock_gles; return mock_gles; diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.h b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.h index 35b041b13d..aa5a66c296 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.h +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles.h @@ -8,7 +8,6 @@ #include #include -#include "gmock/gmock.h" #include "impeller/renderer/backend/gles/proc_table_gles.h" namespace impeller { @@ -16,60 +15,6 @@ namespace testing { extern const ProcTableGLES::Resolver kMockResolverGLES; -class IMockGLESImpl { - public: - virtual ~IMockGLESImpl() = default; - virtual void DeleteTextures(GLsizei size, const GLuint* queries) {} - virtual void GenTextures(GLsizei n, GLuint* textures) {} - virtual void ObjectLabelKHR(GLenum identifier, - GLuint name, - GLsizei length, - const GLchar* label) {} - virtual void Uniform1fv(GLint location, GLsizei count, const GLfloat* value) { - } - virtual void GenQueriesEXT(GLsizei n, GLuint* ids) {} - virtual void BeginQueryEXT(GLenum target, GLuint id) {} - virtual void EndQueryEXT(GLuint id) {} - virtual void GetQueryObjectuivEXT(GLuint id, GLenum target, GLuint* result) {} - virtual void GetQueryObjectui64vEXT(GLuint id, - GLenum target, - GLuint64* result) {} - virtual void DeleteQueriesEXT(GLsizei size, const GLuint* queries) {} -}; - -class MockGLESImpl : public IMockGLESImpl { - public: - MOCK_METHOD(void, - DeleteTextures, - (GLsizei size, const GLuint* queries), - (override)); - MOCK_METHOD(void, GenTextures, (GLsizei n, GLuint* textures), (override)); - MOCK_METHOD( - void, - ObjectLabelKHR, - (GLenum identifier, GLuint name, GLsizei length, const GLchar* label), - (override)); - MOCK_METHOD(void, - Uniform1fv, - (GLint location, GLsizei count, const GLfloat* value), - (override)); - MOCK_METHOD(void, GenQueriesEXT, (GLsizei n, GLuint* ids), (override)); - MOCK_METHOD(void, BeginQueryEXT, (GLenum target, GLuint id), (override)); - MOCK_METHOD(void, EndQueryEXT, (GLuint id), (override)); - MOCK_METHOD(void, - GetQueryObjectuivEXT, - (GLuint id, GLenum target, GLuint* result), - (override)); - MOCK_METHOD(void, - GetQueryObjectui64vEXT, - (GLuint id, GLenum target, GLuint64* result), - (override)); - MOCK_METHOD(void, - DeleteQueriesEXT, - (GLsizei size, const GLuint* queries), - (override)); -}; - /// @brief Provides a mocked version of the |ProcTableGLES| class. /// /// Typically, Open GLES at runtime will be provided the host's GLES bindings @@ -80,26 +25,32 @@ class MockGLESImpl : public IMockGLESImpl { /// See `README.md` for more information. class MockGLES final { public: - static std::shared_ptr Init( - std::unique_ptr impl, - const std::optional>& extensions = std::nullopt); - /// @brief Returns an initialized |MockGLES| instance. /// /// This method overwrites mocked global GLES function pointers to record /// invocations on this instance of |MockGLES|. As such, it should only be /// called once per test. static std::shared_ptr Init( - const std::optional>& extensions = std::nullopt, + const std::optional>& extensions = + std::nullopt, const char* version_string = "OpenGL ES 3.0", ProcTableGLES::Resolver resolver = kMockResolverGLES); /// @brief Returns a configured |ProcTableGLES| instance. const ProcTableGLES& GetProcTable() const { return proc_table_; } + /// @brief Returns a vector of the names of all recorded calls. + /// + /// Calls are cleared after this method is called. + std::vector GetCapturedCalls() { + std::vector calls = captured_calls_; + captured_calls_.clear(); + return calls; + } + ~MockGLES(); - IMockGLESImpl* GetImpl() { return impl_.get(); } + void SetNextTexture(uint64_t next_texture) { next_texture_ = next_texture; } private: friend void RecordGLCall(const char* name); @@ -107,8 +58,11 @@ class MockGLES final { explicit MockGLES(ProcTableGLES::Resolver resolver = kMockResolverGLES); + void RecordCall(const char* name) { captured_calls_.emplace_back(name); } + ProcTableGLES proc_table_; - std::unique_ptr impl_; + std::vector captured_calls_; + std::optional next_texture_; MockGLES(const MockGLES&) = delete; diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles_unittests.cc index 96dea6bffc..5345cdbd00 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/mock_gles_unittests.cc @@ -21,6 +21,19 @@ TEST(MockGLES, CanInitialize) { EXPECT_EQ(vendor, "MockGLES"); } +// Tests we can call two functions and capture the calls. +TEST(MockGLES, CapturesPushAndPopDebugGroup) { + auto mock_gles = MockGLES::Init(); + + auto& gl = mock_gles->GetProcTable(); + gl.PushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 0, -1, "test"); + gl.PopDebugGroupKHR(); + + auto calls = mock_gles->GetCapturedCalls(); + EXPECT_EQ(calls, std::vector( + {"PushDebugGroupKHR", "PopDebugGroupKHR"})); +} + // Tests that if we call a function we have not mocked, it's OK. TEST(MockGLES, CanCallUnmockedFunction) { auto mock_gles = MockGLES::Init(); diff --git a/engine/src/flutter/impeller/renderer/backend/gles/test/reactor_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/test/reactor_unittests.cc index 48ee45dd3a..e2c49fb27c 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/test/reactor_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/test/reactor_unittests.cc @@ -6,7 +6,6 @@ #include #include "flutter/fml/synchronization/waitable_event.h" #include "flutter/testing/testing.h" // IWYU pragma: keep -#include "gmock/gmock.h" #include "gtest/gtest.h" #include "impeller/renderer/backend/gles/handle_gles.h" #include "impeller/renderer/backend/gles/proc_table_gles.h" @@ -16,8 +15,6 @@ namespace impeller { namespace testing { -using ::testing::_; - class TestWorker : public ReactorGLES::Worker { public: bool CanReactorReactOnCurrentThreadNow( @@ -49,40 +46,31 @@ TEST(ReactorGLES, CanAttachCleanupCallbacksToHandles) { } TEST(ReactorGLES, DeletesHandlesDuringShutdown) { - auto mock_gles_impl = std::make_unique(); - - EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)) - .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; }); - EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234))) - .Times(1); - - std::shared_ptr mock_gles = - MockGLES::Init(std::move(mock_gles_impl)); + auto mock_gles = MockGLES::Init(); ProcTableGLES::Resolver resolver = kMockResolverGLES; auto proc_table = std::make_unique(resolver); auto worker = std::make_shared(); auto reactor = std::make_shared(std::move(proc_table)); reactor->AddWorker(worker); - reactor->CreateHandle(HandleType::kTexture); + + reactor->CreateHandle(HandleType::kTexture, 123); + reactor.reset(); + + auto calls = mock_gles->GetCapturedCalls(); + EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glDeleteTextures") != + calls.end()); } TEST(ReactorGLES, UntrackedHandle) { - auto mock_gles_impl = std::make_unique(); - - EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)) - .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; }); - EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234))) - .Times(1); - - std::shared_ptr mock_gles = - MockGLES::Init(std::move(mock_gles_impl)); + std::shared_ptr mock_gles = MockGLES::Init(); ProcTableGLES::Resolver resolver = kMockResolverGLES; auto proc_table = std::make_unique(resolver); auto worker = std::make_shared(); auto reactor = std::make_shared(std::move(proc_table)); reactor->AddWorker(worker); + mock_gles->SetNextTexture(1234u); HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture); EXPECT_FALSE(handle.IsDead()); std::optional glint = reactor->GetGLHandle(handle); @@ -90,30 +78,34 @@ TEST(ReactorGLES, UntrackedHandle) { if (glint.has_value()) { EXPECT_EQ(1234u, *glint); } + mock_gles->GetCapturedCalls(); reactor->CollectHandle(handle); + std::vector calls = mock_gles->GetCapturedCalls(); + EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glDeleteTextures") == + calls.end()); + // Without an operation nothing is cleaned up. EXPECT_TRUE(reactor->AddOperation([&](const ReactorGLES&) {})); EXPECT_TRUE(reactor->React()); + calls = mock_gles->GetCapturedCalls(); + EXPECT_FALSE(std::find(calls.begin(), calls.end(), "glDeleteTextures") == + calls.end()); } TEST(ReactorGLES, NameUntrackedHandle) { - auto mock_gles_impl = std::make_unique(); - - EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)) - .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; }); - EXPECT_CALL(*mock_gles_impl, - ObjectLabelKHR(_, 1234, _, ::testing::StrEq("hello, joe!"))) - .Times(1); - - std::shared_ptr mock_gles = - MockGLES::Init(std::move(mock_gles_impl)); + std::shared_ptr mock_gles = MockGLES::Init(); ProcTableGLES::Resolver resolver = kMockResolverGLES; auto proc_table = std::make_unique(resolver); auto worker = std::make_shared(); auto reactor = std::make_shared(std::move(proc_table)); reactor->AddWorker(worker); + mock_gles->SetNextTexture(1234u); HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture); + mock_gles->GetCapturedCalls(); reactor->SetDebugLabel(handle, "hello, joe!"); + std::vector calls = mock_gles->GetCapturedCalls(); + EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glObjectLabelKHR") != + calls.end()); } TEST(ReactorGLES, PerThreadOperationQueues) { diff --git a/engine/src/flutter/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc b/engine/src/flutter/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc index 01ddf037f1..6a01fefbc4 100644 --- a/engine/src/flutter/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc +++ b/engine/src/flutter/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc @@ -11,8 +11,6 @@ namespace impeller { namespace testing { -using ::testing::_; - namespace { class TestWorker : public ReactorGLES::Worker { public: @@ -24,21 +22,20 @@ class TestWorker : public ReactorGLES::Worker { } // namespace TEST(UniqueHandleGLES, MakeUntracked) { - auto mock_gles_impl = std::make_unique(); - - EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)).Times(1); - - std::shared_ptr mock_gled = - MockGLES::Init(std::move(mock_gles_impl)); + auto mock_gles = MockGLES::Init(); ProcTableGLES::Resolver resolver = kMockResolverGLES; auto proc_table = std::make_unique(resolver); auto worker = std::make_shared(); auto reactor = std::make_shared(std::move(proc_table)); reactor->AddWorker(worker); + mock_gles->GetCapturedCalls(); UniqueHandleGLES handle = UniqueHandleGLES::MakeUntracked(reactor, HandleType::kTexture); EXPECT_FALSE(handle.Get().IsDead()); + std::vector calls = mock_gles->GetCapturedCalls(); + EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glGenTextures") != + calls.end()); } } // namespace testing