message_loop_unittests.cc File Reference

#include "flutter/fml/message_loop.h"
#include <iostream>
#include <thread>
#include "flutter/fml/build_config.h"
#include "flutter/fml/concurrent_message_loop.h"
#include "flutter/fml/synchronization/count_down_latch.h"
#include "flutter/fml/synchronization/waitable_event.h"
#include "flutter/fml/task_runner.h"
#include "flutter/fml/time/chrono_timestamp_provider.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Macros
#define	FML_USED_ON_EMBEDDER

Functions
	TEST (MessageLoop, GetCurrent)
	TEST (MessageLoop, DifferentThreadsHaveDifferentLoops)
	TEST (MessageLoop, CanRunAndTerminate)
	TEST (MessageLoop, NonDelayedTasksAreRunInOrder)
	TEST (MessageLoop, DelayedTasksAtSameTimeAreRunInOrder)
	TEST (MessageLoop, CheckRunsTaskOnCurrentThread)
	TEST (MessageLoop, TaskObserverFire)
	TEST (MessageLoop, ConcurrentMessageLoopHasNonZeroWorkers)
	TEST (MessageLoop, CanCreateAndShutdownConcurrentMessageLoopsOverAndOver)
	TEST (MessageLoop, CanCreateConcurrentMessageLoop)

Macro Definition Documentation

FML_USED_ON_EMBEDDER

#define FML_USED_ON_EMBEDDER

Definition at line 5 of file message_loop_unittests.cc.

Function Documentation

TEST() [1/10]

TEST	(	MessageLoop	,
		CanCreateAndShutdownConcurrentMessageLoopsOverAndOver
	)

Definition at line 187 of file message_loop_unittests.cc.

                                                                         {
  for (size_t i = 0; i < 10; ++i) {
    auto loop = fml::ConcurrentMessageLoop::Create(i + 1);
    ASSERT_EQ(loop->GetWorkerCount(), i + 1);
  }
}

References fml::ConcurrentMessageLoop::Create(), and i.

TEST() [2/10]

TEST	(	MessageLoop	,
		CanCreateConcurrentMessageLoop
	)

Definition at line 194 of file message_loop_unittests.cc.

                                                  {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto task_runner = loop->GetTaskRunner();
  const size_t kCount = 10;
  fml::CountDownLatch latch(kCount);
  std::mutex thread_ids_mutex;
  std::set<std::thread::id> thread_ids;
  for (size_t i = 0; i < kCount; ++i) {
    task_runner->PostTask([&]() {
      std::this_thread::sleep_for(std::chrono::seconds(1));
      std::cout << "Ran on thread: " << std::this_thread::get_id() << std::endl;
      {
        std::scoped_lock lock(thread_ids_mutex);
        thread_ids.insert(std::this_thread::get_id());
      }
      latch.CountDown();
    });
  }
  latch.Wait();
  ASSERT_GE(thread_ids.size(), 1u);
}

References fml::CountDownLatch::CountDown(), fml::ConcurrentMessageLoop::Create(), i, and fml::CountDownLatch::Wait().

TEST() [3/10]

TEST	(	MessageLoop	,
		CanRunAndTerminate
	)

Definition at line 57 of file message_loop_unittests.cc.

                                      {
  bool started = false;
  bool terminated = false;
  std::thread thread([&started, &terminated]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    auto& loop = fml::MessageLoop::GetCurrent();
    ASSERT_TRUE(loop.GetTaskRunner());
    loop.GetTaskRunner()->PostTask([&terminated]() {
      fml::MessageLoop::GetCurrent().Terminate();
      terminated = true;
    });
    loop.Run();
    started = true;
  });
  thread.join();
  ASSERT_TRUE(started);
  ASSERT_TRUE(terminated);
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), and fml::MessageLoop::Terminate().

TEST() [4/10]

TEST	(	MessageLoop	,
		CheckRunsTaskOnCurrentThread
	)

Definition at line 134 of file message_loop_unittests.cc.

                                                {
  fml::RefPtr<fml::TaskRunner> runner;
  fml::AutoResetWaitableEvent latch;
  std::thread thread([&runner, &latch]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    auto& loop = fml::MessageLoop::GetCurrent();
    runner = loop.GetTaskRunner();
    latch.Signal();
    ASSERT_TRUE(loop.GetTaskRunner()->RunsTasksOnCurrentThread());
  });
  latch.Wait();
  ASSERT_TRUE(runner);
  ASSERT_FALSE(runner->RunsTasksOnCurrentThread());
  thread.join();
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

TEST() [5/10]

TEST	(	MessageLoop	,
		ConcurrentMessageLoopHasNonZeroWorkers
	)

Definition at line 181 of file message_loop_unittests.cc.

                                                          {
  auto loop = fml::ConcurrentMessageLoop::Create(
      0u /* explicitly specify zero workers */);
  ASSERT_GT(loop->GetWorkerCount(), 0u);
}

References fml::ConcurrentMessageLoop::Create().

TEST() [6/10]

TEST	(	MessageLoop	,
		DelayedTasksAtSameTimeAreRunInOrder
	)

Definition at line 103 of file message_loop_unittests.cc.

                                                       {
  const size_t count = 100;
  bool started = false;
  bool terminated = false;
  std::thread thread([&started, &terminated, count]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    auto& loop = fml::MessageLoop::GetCurrent();
    size_t current = 0;
    const auto now_plus_some =
        fml::ChronoTicksSinceEpoch() + fml::TimeDelta::FromMilliseconds(2);
    for (size_t i = 0; i < count; i++) {
      loop.GetTaskRunner()->PostTaskForTime(
          [&terminated, i, &current]() {
            ASSERT_EQ(current, i);
            current++;
            if (count == i + 1) {
              fml::MessageLoop::GetCurrent().Terminate();
              terminated = true;
            }
          },
          now_plus_some);
    }
    loop.Run();
    ASSERT_EQ(current, count);
    started = true;
  });
  thread.join();
  ASSERT_TRUE(started);
  ASSERT_TRUE(terminated);
}

References fml::ChronoTicksSinceEpoch(), fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::TimeDelta::FromMilliseconds(), fml::MessageLoop::GetCurrent(), i, and fml::MessageLoop::Terminate().

TEST() [7/10]

TEST	(	MessageLoop	,
		DifferentThreadsHaveDifferentLoops
	)

Definition at line 28 of file message_loop_unittests.cc.

                                                      {
  fml::MessageLoop* loop1 = nullptr;
  fml::AutoResetWaitableEvent latch1;
  fml::AutoResetWaitableEvent term1;
  std::thread thread1([&loop1, &latch1, &term1]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    loop1 = &fml::MessageLoop::GetCurrent();
    latch1.Signal();
    term1.Wait();
  });
 
  fml::MessageLoop* loop2 = nullptr;
  fml::AutoResetWaitableEvent latch2;
  fml::AutoResetWaitableEvent term2;
  std::thread thread2([&loop2, &latch2, &term2]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    loop2 = &fml::MessageLoop::GetCurrent();
    latch2.Signal();
    term2.Wait();
  });
  latch1.Wait();
  latch2.Wait();
  ASSERT_FALSE(loop1 == loop2);
  term1.Signal();
  term2.Signal();
  thread1.join();
  thread2.join();
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

TEST() [8/10]

TEST	(	MessageLoop	,
		GetCurrent
	)

Definition at line 20 of file message_loop_unittests.cc.

                              {
  std::thread thread([]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    ASSERT_TRUE(fml::MessageLoop::GetCurrent().GetTaskRunner());
  });
  thread.join();
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), and fml::MessageLoop::GetCurrent().

TEST() [9/10]

TEST	(	MessageLoop	,
		NonDelayedTasksAreRunInOrder
	)

Definition at line 76 of file message_loop_unittests.cc.

                                                {
  const size_t count = 100;
  bool started = false;
  bool terminated = false;
  std::thread thread([&started, &terminated, count]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    auto& loop = fml::MessageLoop::GetCurrent();
    size_t current = 0;
    for (size_t i = 0; i < count; i++) {
      loop.GetTaskRunner()->PostTask([&terminated, i, &current]() {
        ASSERT_EQ(current, i);
        current++;
        if (count == i + 1) {
          fml::MessageLoop::GetCurrent().Terminate();
          terminated = true;
        }
      });
    }
    loop.Run();
    ASSERT_EQ(current, count);
    started = true;
  });
  thread.join();
  ASSERT_TRUE(started);
  ASSERT_TRUE(terminated);
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), i, and fml::MessageLoop::Terminate().

TEST() [10/10]

TEST	(	MessageLoop	,
		TaskObserverFire
	)

Definition at line 150 of file message_loop_unittests.cc.

                                    {
  bool started = false;
  bool terminated = false;
  std::thread thread([&started, &terminated]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    const size_t count = 25;
    auto& loop = fml::MessageLoop::GetCurrent();
    size_t task_count = 0;
    size_t obs_count = 0;
    auto obs = [&obs_count]() { obs_count++; };
    for (size_t i = 0; i < count; i++) {
      loop.GetTaskRunner()->PostTask([&terminated, i, &task_count]() {
        ASSERT_EQ(task_count, i);
        task_count++;
        if (count == i + 1) {
          fml::MessageLoop::GetCurrent().Terminate();
          terminated = true;
        }
      });
    }
    loop.AddTaskObserver(0, obs);
    loop.Run();
    ASSERT_EQ(task_count, count);
    ASSERT_EQ(obs_count, count);
    started = true;
  });
  thread.join();
  ASSERT_TRUE(started);
  ASSERT_TRUE(terminated);
}

References fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), i, and fml::MessageLoop::Terminate().