impeller::testing::ContextSpy Class Reference

#include <context_spy.h>

Inheritance diagram for impeller::testing::ContextSpy:

Public Member Functions
std::shared_ptr< ContextMock >	MakeContext (const std::shared_ptr< Context > &real_context)

Static Public Member Functions
static std::shared_ptr< ContextSpy >	Make ()

Public Attributes
std::vector< std::shared_ptr< RecordingRenderPass > >	render_passes_
std::shared_ptr< CommandQueue >	command_queue_

Detailed Description

Forwards calls to a real Context but can store information about how the Context was used.

Definition at line 26 of file context_spy.h.

Member Function Documentation

Make()

std::shared_ptr< ContextSpy > impeller::testing::ContextSpy::Make ( )

static

Definition at line 23 of file context_spy.cc.

                                           {
  return std::shared_ptr<ContextSpy>(new ContextSpy());
}

MakeContext()

std::shared_ptr< ContextMock > impeller::testing::ContextSpy::MakeContext

(

const std::shared_ptr< Context > &

real_context

)

Definition at line 27 of file context_spy.cc.

                                                {
  std::shared_ptr<ContextMock> mock_context =
      std::make_shared<::testing::NiceMock<ContextMock>>();
  std::shared_ptr<ContextSpy> shared_this = shared_from_this();
 
  ON_CALL(*mock_context, IsValid).WillByDefault([real_context]() {
    return real_context->IsValid();
  });
 
  ON_CALL(*mock_context, GetBackendType)
      .WillByDefault([real_context]() -> Context::BackendType {
        return real_context->GetBackendType();
      });
 
  ON_CALL(*mock_context, GetCapabilities)
      .WillByDefault(
          [real_context]() -> const std::shared_ptr<const Capabilities>& {
            return real_context->GetCapabilities();
          });
 
  ON_CALL(*mock_context, UpdateOffscreenLayerPixelFormat)
      .WillByDefault([real_context](PixelFormat format) {
        return real_context->UpdateOffscreenLayerPixelFormat(format);
      });
 
  ON_CALL(*mock_context, GetResourceAllocator).WillByDefault([real_context]() {
    return real_context->GetResourceAllocator();
  });
 
  ON_CALL(*mock_context, GetShaderLibrary).WillByDefault([real_context]() {
    return real_context->GetShaderLibrary();
  });
 
  ON_CALL(*mock_context, GetSamplerLibrary).WillByDefault([real_context]() {
    return real_context->GetSamplerLibrary();
  });
 
  ON_CALL(*mock_context, GetPipelineLibrary).WillByDefault([real_context]() {
    return real_context->GetPipelineLibrary();
  });
 
  ON_CALL(*mock_context, GetCommandQueue).WillByDefault([shared_this]() {
    return shared_this->command_queue_;
  });
 
  ON_CALL(*mock_context, CreateCommandBuffer)
      .WillByDefault([real_context, shared_this]() {
        auto real_buffer = real_context->CreateCommandBuffer();
        auto spy = std::make_shared<::testing::NiceMock<CommandBufferMock>>(
            real_context);
 
        ON_CALL(*spy, IsValid).WillByDefault([real_buffer]() {
          return real_buffer->IsValid();
        });
 
        ON_CALL(*spy, SetLabel)
            .WillByDefault([real_buffer](const std::string& label) {
              return real_buffer->SetLabel(label);
            });
 
        ON_CALL(*spy, OnCreateRenderPass)
            .WillByDefault([real_buffer, shared_this,
                            real_context](const RenderTarget& render_target) {
              std::shared_ptr<RenderPass> result =
                  CommandBufferMock::ForwardOnCreateRenderPass(
                      real_buffer.get(), render_target);
              std::shared_ptr<RecordingRenderPass> recorder =
                  std::make_shared<RecordingRenderPass>(result, real_context,
                                                        render_target);
              shared_this->render_passes_.push_back(recorder);
              return recorder;
            });
 
        ON_CALL(*spy, OnCreateBlitPass).WillByDefault([real_buffer]() {
          return CommandBufferMock::ForwardOnCreateBlitPass(real_buffer.get());
        });
 
        ON_CALL(*spy, OnSubmitCommands)
            .WillByDefault(
                [real_buffer](CommandBuffer::CompletionCallback callback) {
                  return CommandBufferMock::ForwardOnSubmitCommands(
                      real_buffer.get(), std::move(callback));
                });
 
        ON_CALL(*spy, OnWaitUntilScheduled).WillByDefault([real_buffer]() {
          return CommandBufferMock::ForwardOnWaitUntilScheduled(
              real_buffer.get());
        });
 
        ON_CALL(*spy, OnCreateComputePass).WillByDefault([real_buffer]() {
          return CommandBufferMock::ForwardOnCreateComputePass(
              real_buffer.get());
        });
 
        return spy;
      });
 
  return mock_context;
}

Member Data Documentation

command_queue_

std::shared_ptr<CommandQueue> impeller::testing::ContextSpy::command_queue_

Initial value:

=
      std::make_shared<NoopCommandQueue>()

Definition at line 34 of file context_spy.h.

render_passes_

std::vector<std::shared_ptr<RecordingRenderPass> > impeller::testing::ContextSpy::render_passes_

Definition at line 33 of file context_spy.h.

---

The documentation for this class was generated from the following files:

• impeller/aiks/testing/context_spy.h
• impeller/aiks/testing/context_spy.cc