flutter::testing::ShellTest Class Reference

#include <shell_test.h>

Inheritance diagram for flutter::testing::ShellTest:

Classes
struct	Config

Public Types
enum	ServiceProtocolEnum {   kGetSkSLs , kEstimateRasterCacheMemory , kSetAssetBundlePath , kRunInView ,   kRenderFrameWithRasterStats }

Public Member Functions
	ShellTest ()
Settings	CreateSettingsForFixture () override
std::unique_ptr< Shell >	CreateShell (const Settings &settings, std::optional< TaskRunners > task_runners={})
std::unique_ptr< Shell >	CreateShell (const Config &config)
void	DestroyShell (std::unique_ptr< Shell > shell)
void	DestroyShell (std::unique_ptr< Shell > shell, const TaskRunners &task_runners)
TaskRunners	GetTaskRunnersForFixture ()
fml::TimePoint	GetLatestFrameTargetTime (Shell *shell) const
void	SendPlatformMessage (Shell *shell, std::unique_ptr< PlatformMessage > message)
void	SendEnginePlatformMessage (Shell *shell, std::unique_ptr< PlatformMessage > message)
std::shared_ptr< txt::FontCollection >	GetFontCollection (Shell *shell)
Public Member Functions inherited from flutter::testing::FixtureTest
	FixtureTest ()
	FixtureTest (std::string kernel_filename, std::string elf_filename, std::string elf_split_filename)
Public Member Functions inherited from flutter::testing::DartFixture
	DartFixture ()
	DartFixture (std::string kernel_filename, std::string elf_filename, std::string elf_split_filename)
void	AddNativeCallback (const std::string &name, Dart_NativeFunction callback)
void	AddFfiNativeCallback (const std::string &name, void *callback_ptr)
Public Member Functions inherited from flutter::testing::ThreadTest
	ThreadTest ()
fml::RefPtr< fml::TaskRunner >	GetCurrentTaskRunner ()
	Get the task runner for the thread that the current unit-test is running on. This creates a message loop as necessary.
fml::RefPtr< fml::TaskRunner >	CreateNewThread (const std::string &name="")
	Creates a new thread, initializes a message loop on it, and, returns its task runner to the unit-test. The message loop is terminated (and its thread joined) when the test ends. This allows tests to create multiple named threads as necessary.

Static Public Member Functions
static void	PlatformViewNotifyCreated (Shell *shell)
static void	PlatformViewNotifyDestroyed (Shell *shell)
static void	RunEngine (Shell *shell, RunConfiguration configuration)
static void	RestartEngine (Shell *shell, RunConfiguration configuration)
static void	VSyncFlush (Shell *shell, bool *will_draw_new_frame=nullptr)
static void	SetViewportMetrics (Shell *shell, double width, double height)
static void	NotifyIdle (Shell *shell, fml::TimeDelta deadline)
static void	PumpOneFrame (Shell *shell)
static void	PumpOneFrame (Shell *shell, FrameContent frame_content)
static void	DispatchFakePointerData (Shell *shell)
static void	DispatchPointerData (Shell *shell, std::unique_ptr< PointerDataPacket > packet)
static bool	GetNeedsReportTimings (Shell *shell)
static void	SetNeedsReportTimings (Shell *shell, bool value)
static void	StorePersistentCache (PersistentCache *cache, const SkData &key, const SkData &value)
static bool	IsAnimatorRunning (Shell *shell)
static void	OnServiceProtocol (Shell *shell, ServiceProtocolEnum some_protocol, const fml::RefPtr< fml::TaskRunner > &task_runner, const ServiceProtocol::Handler::ServiceProtocolMap &params, rapidjson::Document *response)
static int	UnreportedTimingsCount (Shell *shell)
static size_t	GetLiveTrackedPathCount (const std::shared_ptr< VolatilePathTracker > &tracker)
static void	TurnOffGPU (Shell *shell, bool value)

Additional Inherited Members
Protected Member Functions inherited from flutter::testing::DartFixture
void	SetSnapshotsAndAssets (Settings &settings)
Protected Attributes inherited from flutter::testing::DartFixture
std::shared_ptr< TestDartNativeResolver >	native_resolver_
ELFAOTSymbols	split_aot_symbols_
std::string	kernel_filename_
std::string	elf_filename_
fml::UniqueFD	assets_dir_
ELFAOTSymbols	aot_symbols_

Detailed Description

Definition at line 64 of file shell_test.h.

Member Enumeration Documentation

ServiceProtocolEnum

enum flutter::testing::ShellTest::ServiceProtocolEnum

Enumerator
kGetSkSLs
kEstimateRasterCacheMemory
kSetAssetBundlePath
kRunInView
kRenderFrameWithRasterStats

Definition at line 132 of file shell_test.h.

                           {
    kGetSkSLs,
    kEstimateRasterCacheMemory,
    kSetAssetBundlePath,
    kRunInView,
    kRenderFrameWithRasterStats,
  };

Constructor & Destructor Documentation

ShellTest()

flutter::testing::ShellTest::ShellTest

(

)

Definition at line 58 of file shell_test.cc.

    : thread_host_("io.flutter.test." + GetCurrentTestName() + ".",
                   ThreadHost::Type::kPlatform | ThreadHost::Type::kIo |
                       ThreadHost::Type::kUi | ThreadHost::Type::kRaster) {}

Member Function Documentation

CreateSettingsForFixture()

Settings flutter::testing::ShellTest::CreateSettingsForFixture ( )

overridevirtual

Reimplemented from flutter::testing::DartFixture.

Definition at line 332 of file shell_test.cc.

                                             {
  Settings settings;
  settings.leak_vm = false;
  settings.task_observer_add = [](intptr_t key, const fml::closure& handler) {
    fml::MessageLoop::GetCurrent().AddTaskObserver(key, handler);
  };
  settings.task_observer_remove = [](intptr_t key) {
    fml::MessageLoop::GetCurrent().RemoveTaskObserver(key);
  };
  settings.isolate_create_callback = [this]() {
    native_resolver_->SetNativeResolverForIsolate();
  };
#if OS_FUCHSIA
  settings.verbose_logging = true;
#endif
  SetSnapshotsAndAssets(settings);
  return settings;
}

CreateShell() [1/2]

std::unique_ptr< Shell > flutter::testing::ShellTest::CreateShell

(

const Config &

config

)

Definition at line 374 of file shell_test.cc.

                                                                {
  TaskRunners task_runners = config.task_runners.has_value()
                                 ? config.task_runners.value()
                                 : GetTaskRunnersForFixture();
  Shell::CreateCallback<PlatformView> platform_view_create_callback =
      config.platform_view_create_callback;
  if (!platform_view_create_callback) {
    platform_view_create_callback = ShellTestPlatformViewBuilder({});
  }
 
  Shell::CreateCallback<Rasterizer> rasterizer_create_callback =
      [](Shell& shell) { return std::make_unique<Rasterizer>(shell); };
 
  return Shell::Create(flutter::PlatformData(),        //
                       task_runners,                   //
                       config.settings,                //
                       platform_view_create_callback,  //
                       rasterizer_create_callback,     //
                       config.is_gpu_disabled          //
  );
}

CreateShell() [2/2]

std::unique_ptr< Shell > flutter::testing::ShellTest::CreateShell	(	const Settings &	settings,
		std::optional< TaskRunners >	task_runners = {}
	)

Definition at line 365 of file shell_test.cc.

                                           {
  return CreateShell({
      .settings = settings,
      .task_runners = std::move(task_runners),
  });
}

DestroyShell() [1/2]

void flutter::testing::ShellTest::DestroyShell

(

std::unique_ptr< Shell >

shell

)

Definition at line 396 of file shell_test.cc.

                                                       {
  DestroyShell(std::move(shell), GetTaskRunnersForFixture());
}

DestroyShell() [2/2]

void flutter::testing::ShellTest::DestroyShell	(	std::unique_ptr< Shell >	shell,
		const TaskRunners &	task_runners
	)

Definition at line 400 of file shell_test.cc.

                                                              {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(task_runners.GetPlatformTaskRunner(),
                                    [&shell, &latch]() mutable {
                                      shell.reset();
                                      latch.Signal();
                                    });
  latch.Wait();
}

DispatchFakePointerData()

void flutter::testing::ShellTest::DispatchFakePointerData ( Shell *  shell )

static

Definition at line 261 of file shell_test.cc.

                                                    {
  auto packet = std::make_unique<PointerDataPacket>(1);
  DispatchPointerData(shell, std::move(packet));
}

DispatchPointerData()

void flutter::testing::ShellTest::DispatchPointerData ( Shell *  shell, std::unique_ptr< PointerDataPacket >  packet  )

static

Definition at line 266 of file shell_test.cc.

                                                                             {
  fml::AutoResetWaitableEvent latch;
  shell->GetTaskRunners().GetPlatformTaskRunner()->PostTask(
      [&latch, shell, &packet]() {
        // Goes through PlatformView to ensure packet is corrected converted.
        shell->GetPlatformView()->DispatchPointerDataPacket(std::move(packet));
        latch.Signal();
      });
  latch.Wait();
}

GetFontCollection()

std::shared_ptr< txt::FontCollection > flutter::testing::ShellTest::GetFontCollection

(

Shell *

shell

)

Definition at line 327 of file shell_test.cc.

                  {
  return shell->weak_engine_->GetFontCollection().GetFontCollection();
}

GetLatestFrameTargetTime()

fml::TimePoint flutter::testing::ShellTest::GetLatestFrameTargetTime

(

Shell *

shell

)

const

Definition at line 361 of file shell_test.cc.

                                                                   {
  return shell->GetLatestFrameTargetTime();
}

GetLiveTrackedPathCount()

size_t flutter::testing::ShellTest::GetLiveTrackedPathCount ( const std::shared_ptr< VolatilePathTracker > &  tracker )

static

Definition at line 411 of file shell_test.cc.

                                                       {
  return std::count_if(
      tracker->paths_.begin(), tracker->paths_.end(),
      [](const std::weak_ptr<VolatilePathTracker::TrackedPath>& path) {
        return path.lock();
      });
}

GetNeedsReportTimings()

bool flutter::testing::ShellTest::GetNeedsReportTimings ( Shell *  shell )

static

Definition at line 286 of file shell_test.cc.

                                                  {
  return shell->needs_report_timings_;
}

GetTaskRunnersForFixture()

TaskRunners flutter::testing::ShellTest::GetTaskRunnersForFixture

(

)

Definition at line 351 of file shell_test.cc.

                                                {
  return {
      "test",
      thread_host_.platform_thread->GetTaskRunner(),  // platform
      thread_host_.raster_thread->GetTaskRunner(),    // raster
      thread_host_.ui_thread->GetTaskRunner(),        // ui
      thread_host_.io_thread->GetTaskRunner()         // io
  };
}

IsAnimatorRunning()

static bool flutter::testing::ShellTest::IsAnimatorRunning ( Shell *  shell )

static

NotifyIdle()

void flutter::testing::ShellTest::NotifyIdle ( Shell *  shell, fml::TimeDelta  deadline  )

static

Definition at line 199 of file shell_test.cc.

                                                              {
  fml::AutoResetWaitableEvent latch;
  shell->GetTaskRunners().GetUITaskRunner()->PostTask(
      [&latch, engine = shell->weak_engine_, deadline]() {
        if (engine) {
          engine->NotifyIdle(deadline);
        }
        latch.Signal();
      });
  latch.Wait();
}

OnServiceProtocol()

void flutter::testing::ShellTest::OnServiceProtocol ( Shell *  shell, ServiceProtocolEnum  some_protocol, const fml::RefPtr< fml::TaskRunner > &  task_runner, const ServiceProtocol::Handler::ServiceProtocolMap &  params, rapidjson::Document *  response  )

static

Definition at line 296 of file shell_test.cc.

                                 {
  std::promise<bool> finished;
  fml::TaskRunner::RunNowOrPostTask(task_runner, [shell, some_protocol, params,
                                                  response, &finished]() {
    switch (some_protocol) {
      case ServiceProtocolEnum::kGetSkSLs:
        shell->OnServiceProtocolGetSkSLs(params, response);
        break;
      case ServiceProtocolEnum::kEstimateRasterCacheMemory:
        shell->OnServiceProtocolEstimateRasterCacheMemory(params, response);
        break;
      case ServiceProtocolEnum::kSetAssetBundlePath:
        shell->OnServiceProtocolSetAssetBundlePath(params, response);
        break;
      case ServiceProtocolEnum::kRunInView:
        shell->OnServiceProtocolRunInView(params, response);
        break;
      case ServiceProtocolEnum::kRenderFrameWithRasterStats:
        shell->OnServiceProtocolRenderFrameWithRasterStats(params, response);
        break;
    }
    finished.set_value(true);
  });
  finished.get_future().wait();
}

PlatformViewNotifyCreated()

void flutter::testing::ShellTest::PlatformViewNotifyCreated ( Shell *  shell )

static

Definition at line 84 of file shell_test.cc.

                                                      {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [shell, &latch]() {
        shell->GetPlatformView()->NotifyCreated();
        latch.Signal();
      });
  latch.Wait();
}

PlatformViewNotifyDestroyed()

void flutter::testing::ShellTest::PlatformViewNotifyDestroyed ( Shell *  shell )

static

Definition at line 94 of file shell_test.cc.

                                                        {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [shell, &latch]() {
        shell->GetPlatformView()->NotifyDestroyed();
        latch.Signal();
      });
  latch.Wait();
}

PumpOneFrame() [1/2]

void flutter::testing::ShellTest::PumpOneFrame ( Shell *  shell )

static

Definition at line 211 of file shell_test.cc.

                                         {
  PumpOneFrame(shell, ViewContent::DummyView());
}

PumpOneFrame() [2/2]

void flutter::testing::ShellTest::PumpOneFrame ( Shell *  shell, FrameContent  frame_content  )

static

Definition at line 215 of file shell_test.cc.

                                                                     {
  // Set viewport to nonempty, and call Animator::BeginFrame to make the layer
  // tree pipeline nonempty. Without either of this, the layer tree below
  // won't be rasterized.
  fml::AutoResetWaitableEvent latch;
  fml::WeakPtr<RuntimeDelegate> runtime_delegate = shell->weak_engine_;
  shell->GetTaskRunners().GetUITaskRunner()->PostTask(
      [&latch, engine = shell->weak_engine_, &frame_content,
       runtime_delegate]() {
        for (auto& [view_id, view_content] : frame_content) {
          engine->SetViewportMetrics(view_id, view_content.viewport_metrics);
        }
        const auto frame_begin_time = fml::TimePoint::Now();
        const auto frame_end_time =
            frame_begin_time + fml::TimeDelta::FromSecondsF(1.0 / 60.0);
        std::unique_ptr<FrameTimingsRecorder> recorder =
            std::make_unique<FrameTimingsRecorder>();
        recorder->RecordVsync(frame_begin_time, frame_end_time);
        engine->animator_->BeginFrame(std::move(recorder));
 
        // The BeginFrame phase and the EndFrame phase must be performed in a
        // single task, otherwise a normal vsync might be inserted in between,
        // causing flaky assertion errors.
 
        for (auto& [view_id, view_content] : frame_content) {
          SkMatrix identity;
          identity.setIdentity();
          auto root_layer = std::make_shared<TransformLayer>(identity);
          auto layer_tree = std::make_unique<LayerTree>(
              LayerTree::Config{.root_layer = root_layer},
              SkISize::Make(view_content.viewport_metrics.physical_width,
                            view_content.viewport_metrics.physical_height));
          float device_pixel_ratio = static_cast<float>(
              view_content.viewport_metrics.device_pixel_ratio);
          if (view_content.builder) {
            view_content.builder(root_layer);
          }
          runtime_delegate->Render(view_id, std::move(layer_tree),
                                   device_pixel_ratio);
        }
        engine->animator_->EndFrame();
        latch.Signal();
      });
  latch.Wait();
}

RestartEngine()

void flutter::testing::ShellTest::RestartEngine ( Shell *  shell, RunConfiguration  configuration  )

static

Definition at line 118 of file shell_test.cc.

                                                                          {
  std::promise<bool> restarted;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetUITaskRunner(),
      [shell, &restarted, &configuration]() {
        restarted.set_value(shell->engine_->Restart(std::move(configuration)));
      });
  ASSERT_TRUE(restarted.get_future().get());
}

RunEngine()

void flutter::testing::ShellTest::RunEngine ( Shell *  shell, RunConfiguration  configuration  )

static

Definition at line 104 of file shell_test.cc.

                                                                      {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [shell, &latch, &configuration]() {
        shell->RunEngine(std::move(configuration),
                         [&latch](Engine::RunStatus run_status) {
                           ASSERT_EQ(run_status, Engine::RunStatus::Success);
                           latch.Signal();
                         });
      });
  latch.Wait();
}

SendEnginePlatformMessage()

void flutter::testing::ShellTest::SendEnginePlatformMessage	(	Shell *	shell,
		std::unique_ptr< PlatformMessage >	message
	)

Definition at line 68 of file shell_test.cc.

                                            {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      fml::MakeCopyable(
          [shell, &latch, message = std::move(message)]() mutable {
            if (auto engine = shell->weak_engine_) {
              engine->HandlePlatformMessage(std::move(message));
            }
            latch.Signal();
          }));
  latch.Wait();
}

SendPlatformMessage()

void flutter::testing::ShellTest::SendPlatformMessage	(	Shell *	shell,
		std::unique_ptr< PlatformMessage >	message
	)

Definition at line 63 of file shell_test.cc.

                                                                            {
  shell->OnPlatformViewDispatchPlatformMessage(std::move(message));
}

SetNeedsReportTimings()

void flutter::testing::ShellTest::SetNeedsReportTimings ( Shell *  shell, bool  value  )

static

Definition at line 282 of file shell_test.cc.

                                                              {
  shell->SetNeedsReportTimings(value);
}

SetViewportMetrics()

void flutter::testing::ShellTest::SetViewportMetrics ( Shell *  shell, double  width, double  height  )

static

Definition at line 154 of file shell_test.cc.

                                                                            {
  flutter::ViewportMetrics viewport_metrics = {
      1,                      // device pixel ratio
      width,                  // physical width
      height,                 // physical height
      0,                      // padding top
      0,                      // padding right
      0,                      // padding bottom
      0,                      // padding left
      0,                      // view inset top
      0,                      // view inset right
      0,                      // view inset bottom
      0,                      // view inset left
      0,                      // gesture inset top
      0,                      // gesture inset right
      0,                      // gesture inset bottom
      0,                      // gesture inset left
      22,                     // physical touch slop
      std::vector<double>(),  // display features bounds
      std::vector<int>(),     // display features type
      std::vector<int>(),     // display features state
      0                       // Display ID
  };
  // Set viewport to nonempty, and call Animator::BeginFrame to make the layer
  // tree pipeline nonempty. Without either of this, the layer tree below
  // won't be rasterized.
  fml::AutoResetWaitableEvent latch;
  shell->GetTaskRunners().GetUITaskRunner()->PostTask(
      [&latch, engine = shell->weak_engine_, viewport_metrics]() {
        if (engine) {
          engine->SetViewportMetrics(kImplicitViewId, viewport_metrics);
          const auto frame_begin_time = fml::TimePoint::Now();
          const auto frame_end_time =
              frame_begin_time + fml::TimeDelta::FromSecondsF(1.0 / 60.0);
          std::unique_ptr<FrameTimingsRecorder> recorder =
              std::make_unique<FrameTimingsRecorder>();
          recorder->RecordVsync(frame_begin_time, frame_end_time);
          engine->animator_->BeginFrame(std::move(recorder));
          engine->animator_->EndFrame();
        }
        latch.Signal();
      });
  latch.Wait();
}

StorePersistentCache()

void flutter::testing::ShellTest::StorePersistentCache ( PersistentCache *  cache, const SkData &  key, const SkData &  value  )

static

Definition at line 290 of file shell_test.cc.

                                                          {
  cache->store(key, value);
}

TurnOffGPU()

void flutter::testing::ShellTest::TurnOffGPU ( Shell *  shell, bool  value  )

static

Definition at line 420 of file shell_test.cc.

                                                   {
  shell->is_gpu_disabled_sync_switch_->SetSwitch(value);
}

UnreportedTimingsCount()

int flutter::testing::ShellTest::UnreportedTimingsCount ( Shell *  shell )

static

Definition at line 278 of file shell_test.cc.

                                                  {
  return shell->unreported_timings_.size();
}

VSyncFlush()

void flutter::testing::ShellTest::VSyncFlush ( Shell *  shell, bool *  will_draw_new_frame = nullptr  )

static

Issue as many VSYNC as needed to flush the UI tasks so far, and reset the content of will_draw_new_frame to true if it's not nullptr.

Definition at line 128 of file shell_test.cc.

                                                                  {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [shell, will_draw_new_frame, &latch] {
        // The following UI task ensures that all previous UI tasks are flushed.
        fml::AutoResetWaitableEvent ui_latch;
        shell->GetTaskRunners().GetUITaskRunner()->PostTask(
            [&ui_latch, will_draw_new_frame]() {
              if (will_draw_new_frame != nullptr) {
                *will_draw_new_frame = true;
              }
              ui_latch.Signal();
            });
 
        ShellTestPlatformView* test_platform_view =
            static_cast<ShellTestPlatformView*>(shell->GetPlatformView().get());
        do {
          test_platform_view->SimulateVSync();
        } while (ui_latch.WaitWithTimeout(fml::TimeDelta::FromMilliseconds(1)));
 
        latch.Signal();
      });
  latch.Wait();
}

---

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

• shell/common/shell_test.h
• shell/common/shell_test.cc