12#include "gtest/gtest.h"
37class FakeTexture :
public Texture {
39 explicit FakeTexture(
const TextureDescriptor& desc) : Texture(
desc) {}
41 ~FakeTexture()
override {}
43 void SetLabel(std::string_view label) {}
45 bool IsValid()
const override {
return true; }
47 ISize GetSize()
const override {
return {1, 1}; }
49 Scalar GetYCoordScale()
const override {
return 1.0; }
51 bool OnSetContents(
const uint8_t* contents,
53 size_t slice)
override {
54 if (GetTextureDescriptor().GetByteSizeOfBaseMipLevel() !=
length) {
61 bool OnSetContents(std::shared_ptr<const fml::Mapping> mapping,
62 size_t slice)
override {
71 public BackendCast<FakeAllocator, Allocator> {
75 uint16_t MinimumBytesPerRow(PixelFormat
format)
const override {
return 0; }
76 ISize GetMaxTextureSizeSupported()
const override {
return ISize(1, 1); }
78 std::shared_ptr<DeviceBuffer> OnCreateBuffer(
79 const DeviceBufferDescriptor& desc)
override {
82 std::shared_ptr<Texture> OnCreateTexture(
83 const TextureDescriptor& desc)
override {
85 auto result = std::make_shared<FakeTexture>(desc);
92 std::vector<std::shared_ptr<FakeTexture>>
textures = {};
95class FakePipeline :
public Pipeline<PipelineDescriptor> {
97 FakePipeline(std::weak_ptr<PipelineLibrary> library,
98 const PipelineDescriptor& desc)
99 : Pipeline(
std::move(library),
desc) {}
101 ~FakePipeline()
override {}
103 bool IsValid()
const override {
return true; }
106class FakeComputePipeline :
public Pipeline<ComputePipelineDescriptor> {
108 FakeComputePipeline(std::weak_ptr<PipelineLibrary> library,
109 const ComputePipelineDescriptor& desc)
110 : Pipeline(
std::move(library),
desc) {}
112 ~FakeComputePipeline()
override {}
114 bool IsValid()
const override {
return true; }
117class FakePipelineLibrary :
public PipelineLibrary {
119 FakePipelineLibrary() {}
121 ~FakePipelineLibrary()
override {}
123 bool IsValid()
const override {
return true; }
125 PipelineFuture<PipelineDescriptor> GetPipeline(
126 PipelineDescriptor descriptor)
override {
128 std::make_shared<FakePipeline>(weak_from_this(), descriptor);
129 std::promise<std::shared_ptr<Pipeline<PipelineDescriptor>>> promise;
130 promise.set_value(std::move(pipeline));
131 return PipelineFuture<PipelineDescriptor>{
132 .descriptor = descriptor,
134 std::shared_future<std::shared_ptr<Pipeline<PipelineDescriptor>>>(
135 promise.get_future())};
138 PipelineFuture<ComputePipelineDescriptor> GetPipeline(
139 ComputePipelineDescriptor descriptor)
override {
141 std::make_shared<FakeComputePipeline>(weak_from_this(), descriptor);
142 std::promise<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>> promise;
143 promise.set_value(std::move(pipeline));
144 return PipelineFuture<ComputePipelineDescriptor>{
145 .descriptor = descriptor,
146 .future = std::shared_future<
147 std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>(
148 promise.get_future())};
151 void RemovePipelinesWithEntryPoint(
152 std::shared_ptr<const ShaderFunction>
function) {}
155class FakeShaderFunction :
public ShaderFunction {
157 FakeShaderFunction(UniqueID parent_library_id,
160 : ShaderFunction(parent_library_id,
std::move(
name), stage){};
162 ~FakeShaderFunction()
override {}
165class FakeShaderLibrary :
public ShaderLibrary {
167 ~FakeShaderLibrary()
override {}
169 bool IsValid()
const override {
return true; }
171 std::shared_ptr<const ShaderFunction>
GetFunction(std::string_view
name,
173 return std::make_shared<FakeShaderFunction>(UniqueID{}, std::string(
name),
177 void RegisterFunction(std::string
name,
179 std::shared_ptr<fml::Mapping> code,
180 RegistrationCallback
callback)
override {}
182 void UnregisterFunction(std::string
name,
ShaderStage stage)
override {}
185class FakeCommandBuffer :
public CommandBuffer {
187 explicit FakeCommandBuffer(std::weak_ptr<const Context> context)
188 : CommandBuffer(
std::move(context)) {}
190 ~FakeCommandBuffer() {}
192 bool IsValid()
const override {
return true; }
194 void SetLabel(
const std::string& label)
const override {}
196 std::shared_ptr<RenderPass> OnCreateRenderPass(
197 RenderTarget render_target)
override {
198 return std::make_shared<RecordingRenderPass>(
nullptr, context_.lock(),
202 std::shared_ptr<BlitPass> OnCreateBlitPass()
override {
FML_UNREACHABLE() }
204 virtual bool OnSubmitCommands(CompletionCallback
callback) {
return true; }
206 void OnWaitUntilScheduled() {}
208 std::shared_ptr<ComputePass> OnCreateComputePass()
override {
213class FakeContext :
public Context,
214 public std::enable_shared_from_this<FakeContext> {
216 explicit FakeContext(
217 const std::string& gpu_model =
"",
220 allocator_(
std::make_shared<FakeAllocator>()),
221 capabilities_(
std::shared_ptr<Capabilities>(
222 CapabilitiesBuilder()
223 .SetDefaultColorFormat(default_color_format)
225 pipelines_(
std::make_shared<FakePipelineLibrary>()),
226 queue_(
std::make_shared<CommandQueue>()),
227 shader_library_(
std::make_shared<FakeShaderLibrary>()),
228 gpu_model_(gpu_model) {}
230 BackendType GetBackendType()
const override {
return BackendType::kVulkan; }
231 std::string DescribeGpuModel()
const override {
return gpu_model_; }
232 bool IsValid()
const override {
return true; }
233 const std::shared_ptr<const Capabilities>& GetCapabilities()
const override {
234 return capabilities_;
236 std::shared_ptr<Allocator> GetResourceAllocator()
const override {
239 std::shared_ptr<ShaderLibrary> GetShaderLibrary()
const {
240 return shader_library_;
242 std::shared_ptr<SamplerLibrary> GetSamplerLibrary()
const {
return nullptr; }
243 std::shared_ptr<PipelineLibrary> GetPipelineLibrary()
const {
246 std::shared_ptr<CommandQueue> GetCommandQueue()
const {
return queue_; }
248 return std::make_shared<FakeCommandBuffer>(shared_from_this());
253 std::shared_ptr<Allocator> allocator_;
254 std::shared_ptr<const Capabilities> capabilities_;
255 std::shared_ptr<FakePipelineLibrary> pipelines_;
256 std::shared_ptr<CommandQueue> queue_;
257 std::shared_ptr<ShaderLibrary> shader_library_;
258 std::string gpu_model_;
263 auto context = std::make_shared<FakeContext>();
265 auto create_callback = [&]() {
266 return std::make_shared<FakePipeline>(context->GetPipelineLibrary(),
275 "A", optionsA, create_callback);
278 "A", optionsA, create_callback);
281 "A", optionsB, create_callback);
284 "B", optionsB, create_callback);
286 ASSERT_EQ(pipelineA.get(), pipelineA2.get());
287 ASSERT_NE(pipelineA.get(), pipelineA3.get());
288 ASSERT_NE(pipelineB.get(), pipelineA.get());
292 auto context = std::make_shared<FakeContext>();
297 auto create_callback = [&]() {
298 return std::make_shared<FakePipeline>(context->GetPipelineLibrary(),
303 "A", optionsA, create_callback);
306 "A", optionsB, create_callback);
309 "B", optionsB, create_callback);
311 ASSERT_TRUE(pipelineA);
312 ASSERT_TRUE(pipelineA2);
313 ASSERT_TRUE(pipelineB);
316 "A", optionsA, create_callback));
318 "A", optionsB, create_callback));
320 "B", optionsB, create_callback));
325 "A", optionsA, create_callback));
327 "A", optionsB, create_callback));
329 "B", optionsB, create_callback));
334 "B", optionsB, create_callback));
340 auto context = std::make_shared<FakeContext>(
"Mali G70",
344 FakeAllocator& fake_allocator =
345 FakeAllocator::Cast(*context->GetResourceAllocator());
347#if IMPELLER_ENABLE_3D
348 EXPECT_EQ(fake_allocator.textures.size(), 2u);
350 EXPECT_EQ(fake_allocator.textures.size(), 1u);
#define TEST(S, s, D, expected)
void ClearCachedRuntimeEffectPipeline(const std::string &unique_entrypoint_name) const
std::shared_ptr< Pipeline< PipelineDescriptor > > GetCachedRuntimeEffectPipeline(const std::string &unique_entrypoint_name, const ContentContextOptions &options, const std::function< std::shared_ptr< Pipeline< PipelineDescriptor > >()> &create_callback) const
std::vector< std::shared_ptr< FakeTexture > > textures
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
uint32_t uint32_t * format
#define FML_UNREACHABLE()
Dart_NativeFunction function
Build(configs, env, options)
FunctionPtr GetFunction(const Library &lib, const char *name)
DlSurfaceProvider::BackendType BackendType
static id< MTLCommandBuffer > CreateCommandBuffer(id< MTLCommandQueue > queue)