fl_task_runner_test.cc File Reference

#include "gtest/gtest.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_task_runner.h"
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include <vector>

Go to the source code of this file.

Classes
class	FlTaskRunnerTest
struct	StopWaitData

Functions
static FlutterTask	make_task (uint64_t id)
template<typename Predicate >
static void	pump_main_loop_until (Predicate predicate, gint64 timeout=kDefaultPumpTimeoutMicros)
	TEST_F (FlTaskRunnerTest, PostTaskExecutedOnMainLoop)
	TEST_F (FlTaskRunnerTest, MultipleTasksExecuted)
	TEST_F (FlTaskRunnerTest, DelayedTaskExecuted)
	TEST_F (FlTaskRunnerTest, WaitRunsExpiredTask)
static gpointer	stop_wait_thread (gpointer user_data)
	TEST_F (FlTaskRunnerTest, StopWaitInterruptsWait)
	TEST_F (FlTaskRunnerTest, StopWaitWithoutWaitIsNoOp)

Variables
static constexpr gint64	kDefaultPumpTimeoutMicros = 10 * G_USEC_PER_SEC

Function Documentation

make_task()

static FlutterTask make_task ( uint64_t  id )

static

Definition at line 23 of file fl_task_runner_test.cc.

                                          {
  FlutterTask task = {};
  task.runner = nullptr;
  task.task = id;
  return task;
}

References id, FlutterTask::runner, and FlutterTask::task.

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

pump_main_loop_until()

template<typename Predicate >

static void pump_main_loop_until ( Predicate  predicate, gint64  timeout = kDefaultPumpTimeoutMicros  )

static

Definition at line 37 of file fl_task_runner_test.cc.

                                                                             {
  gint64 deadline = g_get_monotonic_time() + timeout;
  while (!predicate() && g_get_monotonic_time() < deadline) {
    g_main_context_iteration(nullptr, TRUE);
  }
}

References TRUE.

Referenced by TEST_F(), TEST_F(), and TEST_F().

stop_wait_thread()

static gpointer stop_wait_thread ( gpointer  user_data )

static

Definition at line 142 of file fl_task_runner_test.cc.

                                                     {
  StopWaitData* data = static_cast<StopWaitData*>(user_data);
  while (g_atomic_int_get(&data->done) == 0) {
    g_usleep(10 * G_TIME_SPAN_MILLISECOND);
    fl_task_runner_stop_wait(data->task_runner);
  }
  return nullptr;
}

References fl_task_runner_stop_wait(), and user_data.

Referenced by TEST_F().

TEST_F() [1/6]

TEST_F	(	FlTaskRunnerTest	,
		DelayedTaskExecuted
	)

Definition at line 89 of file fl_task_runner_test.cc.

                                              {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  gboolean executed = FALSE;
  fl_engine_get_embedder_api(engine)->RunTask = MOCK_ENGINE_PROC(
      RunTask, ([&executed](auto engine, const FlutterTask* task) {
        executed = TRUE;
        return kSuccess;
      }));
 
  // Schedule roughly 20ms into the future (target time is in nanoseconds).
  uint64_t target_time_nanos =
      (g_get_monotonic_time() + 20 * G_TIME_SPAN_MILLISECOND) * 1000;
  fl_task_runner_post_flutter_task(task_runner, make_task(7),
                                   target_time_nanos);
 
  // Not run before its time.
  EXPECT_FALSE(executed);
 
  pump_main_loop_until([&executed]() { return executed; });
 
  EXPECT_TRUE(executed);
}

References engine, fl_engine_get_embedder_api(), fl_task_runner_new(), fl_task_runner_post_flutter_task(), g_autoptr(), kSuccess, make_task(), MOCK_ENGINE_PROC, pump_main_loop_until(), FlutterEngineProcTable::RunTask, and TRUE.

TEST_F() [2/6]

TEST_F	(	FlTaskRunnerTest	,
		MultipleTasksExecuted
	)

Definition at line 66 of file fl_task_runner_test.cc.

                                                {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  std::vector<uint64_t> executed;
  fl_engine_get_embedder_api(engine)->RunTask = MOCK_ENGINE_PROC(
      RunTask, ([&executed](auto engine, const FlutterTask* task) {
        executed.push_back(task->task);
        return kSuccess;
      }));
 
  fl_task_runner_post_flutter_task(task_runner, make_task(1), 0);
  fl_task_runner_post_flutter_task(task_runner, make_task(2), 0);
  fl_task_runner_post_flutter_task(task_runner, make_task(3), 0);
 
  pump_main_loop_until([&executed]() { return executed.size() >= 3; });
 
  ASSERT_EQ(executed.size(), 3u);
  EXPECT_EQ(executed[0], 1u);
  EXPECT_EQ(executed[1], 2u);
  EXPECT_EQ(executed[2], 3u);
}

References engine, fl_engine_get_embedder_api(), fl_task_runner_new(), fl_task_runner_post_flutter_task(), g_autoptr(), kSuccess, make_task(), MOCK_ENGINE_PROC, pump_main_loop_until(), FlutterEngineProcTable::RunTask, and FlutterTask::task.

TEST_F() [3/6]

TEST_F	(	FlTaskRunnerTest	,
		PostTaskExecutedOnMainLoop
	)

Definition at line 46 of file fl_task_runner_test.cc.

                                                     {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  std::vector<uint64_t> executed;
  fl_engine_get_embedder_api(engine)->RunTask = MOCK_ENGINE_PROC(
      RunTask, ([&executed](auto engine, const FlutterTask* task) {
        executed.push_back(task->task);
        return kSuccess;
      }));
 
  // A target time in the past means the task is due immediately.
  fl_task_runner_post_flutter_task(task_runner, make_task(42), 0);
 
  pump_main_loop_until([&executed]() { return !executed.empty(); });
 
  ASSERT_EQ(executed.size(), 1u);
  EXPECT_EQ(executed[0], 42u);
}

References engine, fl_engine_get_embedder_api(), fl_task_runner_new(), fl_task_runner_post_flutter_task(), g_autoptr(), kSuccess, make_task(), MOCK_ENGINE_PROC, pump_main_loop_until(), FlutterEngineProcTable::RunTask, and FlutterTask::task.

TEST_F() [4/6]

TEST_F	(	FlTaskRunnerTest	,
		StopWaitInterruptsWait
	)

Definition at line 152 of file fl_task_runner_test.cc.

                                                 {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  StopWaitData data = {task_runner, 0};
  GThread* thread = g_thread_new("stop-wait", stop_wait_thread, &data);
 
  // With no tasks scheduled this would otherwise block until the far-future
  // expiry time.
  gint64 start = g_get_monotonic_time();
  fl_task_runner_wait(task_runner, start + 30 * G_USEC_PER_SEC);
  gint64 elapsed = g_get_monotonic_time() - start;
 
  g_atomic_int_set(&data.done, 1);
  g_thread_join(thread);
 
  // The wait returned because of stop_wait, well before the 30s expiry.
  EXPECT_LT(elapsed, 5 * G_USEC_PER_SEC);
}

References engine, fl_task_runner_new(), fl_task_runner_wait(), g_autoptr(), start, and stop_wait_thread().

TEST_F() [5/6]

TEST_F	(	FlTaskRunnerTest	,
		StopWaitWithoutWaitIsNoOp
	)

Definition at line 174 of file fl_task_runner_test.cc.

                                                    {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  std::vector<uint64_t> executed;
  fl_engine_get_embedder_api(engine)->RunTask = MOCK_ENGINE_PROC(
      RunTask, ([&executed](auto engine, const FlutterTask* task) {
        executed.push_back(task->task);
        return kSuccess;
      }));
 
  // No wait is in progress, so this should do nothing.
  fl_task_runner_stop_wait(task_runner);
 
  // The runner is still functional: a due task is run by a subsequent wait.
  fl_task_runner_post_flutter_task(task_runner, make_task(123), 0);
  fl_task_runner_wait(task_runner, g_get_monotonic_time() + G_USEC_PER_SEC);
 
  ASSERT_EQ(executed.size(), 1u);
  EXPECT_EQ(executed[0], 123u);
}

References engine, fl_engine_get_embedder_api(), fl_task_runner_new(), fl_task_runner_post_flutter_task(), fl_task_runner_stop_wait(), fl_task_runner_wait(), g_autoptr(), kSuccess, make_task(), MOCK_ENGINE_PROC, FlutterEngineProcTable::RunTask, and FlutterTask::task.

TEST_F() [6/6]

TEST_F	(	FlTaskRunnerTest	,
		WaitRunsExpiredTask
	)

Definition at line 115 of file fl_task_runner_test.cc.

                                              {
  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
 
  std::vector<uint64_t> executed;
  fl_engine_get_embedder_api(engine)->RunTask = MOCK_ENGINE_PROC(
      RunTask, ([&executed](auto engine, const FlutterTask* task) {
        executed.push_back(task->task);
        return kSuccess;
      }));
 
  fl_task_runner_post_flutter_task(task_runner, make_task(99), 0);
 
  // The task is already due, so wait processes it and returns immediately.
  fl_task_runner_wait(task_runner, g_get_monotonic_time() + G_USEC_PER_SEC);
 
  ASSERT_EQ(executed.size(), 1u);
  EXPECT_EQ(executed[0], 99u);
}

References engine, fl_engine_get_embedder_api(), fl_task_runner_new(), fl_task_runner_post_flutter_task(), fl_task_runner_wait(), g_autoptr(), kSuccess, make_task(), MOCK_ENGINE_PROC, FlutterEngineProcTable::RunTask, and FlutterTask::task.

Variable Documentation

kDefaultPumpTimeoutMicros

constexpr gint64 kDefaultPumpTimeoutMicros = 10 * G_USEC_PER_SEC

staticconstexpr

Definition at line 32 of file fl_task_runner_test.cc.