shell/common/shell_fuchsia_unittests.cc - mirrors/engine - Git at Google

 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // A fuchsia-specific shell test.
 //
 // This test is only supposed to be ran on Fuchsia OS, as it exercises
 // Fuchsia-specific functionality for which no equivalent exists elsewhere.

 #define FML_USED_ON_EMBEDDER

 #include <time.h>
 #include <unistd.h>

 #include <memory>

 #include <fuchsia/intl/cpp/fidl.h>
 #include <fuchsia/settings/cpp/fidl.h>
 #include <lib/sys/cpp/component_context.h>

 #include "flutter/fml/dart/dart_converter.h"
 #include "flutter/fml/logging.h"
 #include "flutter/fml/synchronization/count_down_latch.h"
 #include "flutter/runtime/dart_vm.h"
 #include "flutter/shell/common/shell_test.h"

 namespace flutter {
 namespace testing {

 using fuchsia::intl::TimeZoneId;
 using fuchsia::settings::Intl_Set_Result;
 using fuchsia::settings::IntlSettings;

 class FuchsiaShellTest : public ShellTest {
  protected:
   FuchsiaShellTest()
       : ctx_(sys::ComponentContext::CreateAndServeOutgoingDirectory()),
         intl_() {
     ctx_->svc()->Connect(intl_.NewRequest());
   }

   ~FuchsiaShellTest() {
     // Restore the time zone that matche that of the test harness.  This is
     // the default.
     const std::string local_timezone = GetLocalTimezone();
     SetTimezone(local_timezone);
     AssertTimezone(local_timezone, GetSettings());
   }

   // Gets the international settings from this Fuchsia realm.
   IntlSettings GetSettings() {
     IntlSettings settings;
     zx_status_t status = intl_->Watch(&settings);
     EXPECT_EQ(status, ZX_OK);
     return settings;
   }

   // Sets the timezone of this Fuchsia realm to `timezone_name`.
   void SetTimezone(const std::string& timezone_name) {
     fuchsia::settings::IntlSettings settings;
     settings.set_time_zone_id(TimeZoneId{.id = timezone_name});
     Intl_Set_Result result;
     zx_status_t status = intl_->Set(std::move(settings), &result);
     ASSERT_EQ(status, ZX_OK);
   }

   std::string GetLocalTimezone() {
     const time_t timestamp = time(nullptr);
     const struct tm* local_time = localtime(&timestamp);
     EXPECT_NE(local_time, nullptr)
         << "Could not get local time: errno=" << errno << ": "
         << strerror(errno);
     return std::string(local_time->tm_zone);
   }

   std::string GetLocalTime() {
     const time_t timestamp = time(nullptr);
     const struct tm* local_time = localtime(&timestamp);
     EXPECT_NE(local_time, nullptr)
         << "Could not get local time: errno=" << errno << ": "
         << strerror(errno);
     char buffer[sizeof("2020-08-26 14")];
     const size_t written =
         strftime(buffer, sizeof(buffer), "%Y-%m-%d %H", local_time);
     EXPECT_LT(0UL, written);
     return std::string(buffer);
   }

   // Checks that the timezone name in the `settings` matches what is `expected`.
   void AssertTimezone(const std::string& expected,
                       const IntlSettings& settings) {
     ASSERT_EQ(expected, settings.time_zone_id().id);
   }

   std::unique_ptr<sys::ComponentContext> ctx_;
   fuchsia::settings::IntlSyncPtr intl_;

   fuchsia::settings::IntlSettings save_settings_;
 };

 static bool ValidateShell(Shell* shell) {
   if (!shell) {
     return false;
   }

   if (!shell->IsSetup()) {
     return false;
   }

   ShellTest::PlatformViewNotifyCreated(shell);

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

   return true;
 }

 // Runs the function `f` in lock-step with a Dart isolate until the function
 // returns `true`, or until a certain fixed number of retries is exhausted.
 // Events `tick` and `tock` are used to synchronize the lock-stepping.  The
 // event 'tick' is a signal to the dart isolate to advance a single iteration
 // step.  'tock' is used by the dart isolate to signal that it has completed
 // its step.
 static void RunCoroutineWithRetry(int retries,
                                   fml::AutoResetWaitableEvent* tick,
                                   fml::AutoResetWaitableEvent* tock,
                                   std::function<bool()> f) {
   for (; retries > 0; retries--) {
     // Do a single coroutine step.
     tick->Signal();
     tock->Wait();
     if (f()) {
       break;
     }
     FML_LOG(INFO) << "Retries left: " << retries;
     sleep(1);
   }
 }

 // Verifies that changing the Fuchsia settings timezone through the FIDL
 // settings interface results in a change of the reported local time in the
 // isolate.
 //
 // The test is as follows:
 //
 // - Set an initial timezone, then get a timestamp from the isolate rounded down
 //   to the nearest hour.  The assumption is as long as this test doesn't run
 //   very near the whole hour, which should be very unlikely, the nearest hour
 //   will vary depending on the time zone.
 // - Set a different timezone.  Get a timestamp from the isolate again and
 //   confirm that this time around the timestamps are different.
 // - Set the initial timezone again, and get the timestamp.  This time, the
 //   timestamp rounded down to whole hour should match the timestamp we got
 //   in the initial step.
 TEST_F(FuchsiaShellTest, LocaltimesVaryOnTimezoneChanges) {
   // See fixtures/shell_test.dart, the callback NotifyLocalTime is declared
   // there.
   fml::AutoResetWaitableEvent latch;
   std::string dart_isolate_time_str;
   AddNativeCallback("NotifyLocalTime", CREATE_NATIVE_ENTRY([&](auto args) {
                       dart_isolate_time_str =
                           tonic::DartConverter<std::string>::FromDart(
                               Dart_GetNativeArgument(args, 0));
                       latch.Signal();
                     }));

   // As long as this is set, the isolate will keep rerunning its only task.
   bool continue_fixture = true;
   fml::AutoResetWaitableEvent fixture_latch;
   AddNativeCallback("WaitFixture", CREATE_NATIVE_ENTRY([&](auto args) {
                       // Wait for the test fixture to advance.
                       fixture_latch.Wait();
                       tonic::DartConverter<bool>::SetReturnValue(
                           args, continue_fixture);
                     }));

   auto settings = CreateSettingsForFixture();
   auto configuration = RunConfiguration::InferFromSettings(settings);
   configuration.SetEntrypoint("timezonesChange");

   std::unique_ptr<Shell> shell = CreateShell(settings);
   ASSERT_NE(shell.get(), nullptr);
   ASSERT_TRUE(ValidateShell(shell.get()));
   RunEngine(shell.get(), std::move(configuration));
   latch.Wait();  // After this point, the fixture is at waitFixture().

   // Start with the local timezone, ensure that the isolate and the test
   // fixture are the same.
   SetTimezone(GetLocalTimezone());
   AssertTimezone(GetLocalTimezone(), GetSettings());
   std::string expected = GetLocalTime();
   std::string actual = "undefined";
   RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
     actual = dart_isolate_time_str;
     FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
     return expected == actual;
   });
   ASSERT_EQ(expected, actual)
       << "The Dart isolate was expected to show the same time as the test "
       << "fixture eventually, but that didn't happen after multiple retries.";

   // Set a new timezone, which is hopefully different from the local one.
   SetTimezone("America/New_York");
   AssertTimezone("America/New_York", GetSettings());
   RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
     actual = dart_isolate_time_str;
     FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
     return expected != actual;
   });
   ASSERT_NE(expected, actual)
       << "The Dart isolate was expected to show a time different from the test "
       << "fixture eventually, but that didn't happen after multiple retries.";

   // Set a new isolate timezone, and check that the reported time is eventually
   // different from what it used to be prior to the change.
   SetTimezone("Europe/Amsterdam");
   AssertTimezone("Europe/Amsterdam", GetSettings());
   RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
     actual = dart_isolate_time_str;
     FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
     return expected != actual;
   });
   ASSERT_NE(expected, actual)
       << "The Dart isolate was expected to show a time different from the "
       << "prior timezone eventually, but that didn't happen after multiple "
       << "retries.";

   // Let's try to bring the timezone back to the old one.
   expected = actual;
   SetTimezone("America/New_York");
   AssertTimezone("America/New_York", GetSettings());
   RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
     actual = dart_isolate_time_str;
     FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
     return expected != actual;
   });
   ASSERT_NE(expected, actual)
       << "The Dart isolate was expected to show a time different from the "
       << "prior timezone eventually, but that didn't happen after multiple "
       << "retries.";

   // Tell the isolate to exit its loop.
   ASSERT_FALSE(fixture_latch.IsSignaledForTest());
   continue_fixture = false;
   fixture_latch.Signal();
   DestroyShell(std::move(shell));
 }

 }  // namespace testing
 }  // namespace flutter
	// Copyright 2013 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// A fuchsia-specific shell test.
	//
	// This test is only supposed to be ran on Fuchsia OS, as it exercises
	// Fuchsia-specific functionality for which no equivalent exists elsewhere.

	#define FML_USED_ON_EMBEDDER

	#include <time.h>
	#include <unistd.h>

	#include <memory>

	#include <fuchsia/intl/cpp/fidl.h>
	#include <fuchsia/settings/cpp/fidl.h>
	#include <lib/sys/cpp/component_context.h>

	#include "flutter/fml/dart/dart_converter.h"
	#include "flutter/fml/logging.h"
	#include "flutter/fml/synchronization/count_down_latch.h"
	#include "flutter/runtime/dart_vm.h"
	#include "flutter/shell/common/shell_test.h"

	namespace flutter {
	namespace testing {

	using fuchsia::intl::TimeZoneId;
	using fuchsia::settings::Intl_Set_Result;
	using fuchsia::settings::IntlSettings;

	class FuchsiaShellTest : public ShellTest {
	protected:
	FuchsiaShellTest()
	: ctx_(sys::ComponentContext::CreateAndServeOutgoingDirectory()),
	intl_() {
	ctx_->svc()->Connect(intl_.NewRequest());
	}

	~FuchsiaShellTest() {
	// Restore the time zone that matche that of the test harness. This is
	// the default.
	const std::string local_timezone = GetLocalTimezone();
	SetTimezone(local_timezone);
	AssertTimezone(local_timezone, GetSettings());
	}

	// Gets the international settings from this Fuchsia realm.
	IntlSettings GetSettings() {
	IntlSettings settings;
	zx_status_t status = intl_->Watch(&settings);
	EXPECT_EQ(status, ZX_OK);
	return settings;
	}

	// Sets the timezone of this Fuchsia realm to `timezone_name`.
	void SetTimezone(const std::string& timezone_name) {
	fuchsia::settings::IntlSettings settings;
	settings.set_time_zone_id(TimeZoneId{.id = timezone_name});
	Intl_Set_Result result;
	zx_status_t status = intl_->Set(std::move(settings), &result);
	ASSERT_EQ(status, ZX_OK);
	}

	std::string GetLocalTimezone() {
	const time_t timestamp = time(nullptr);
	const struct tm* local_time = localtime(&timestamp);
	EXPECT_NE(local_time, nullptr)
	<< "Could not get local time: errno=" << errno << ": "
	<< strerror(errno);
	return std::string(local_time->tm_zone);
	}

	std::string GetLocalTime() {
	const time_t timestamp = time(nullptr);
	const struct tm* local_time = localtime(&timestamp);
	EXPECT_NE(local_time, nullptr)
	<< "Could not get local time: errno=" << errno << ": "
	<< strerror(errno);
	char buffer[sizeof("2020-08-26 14")];
	const size_t written =
	strftime(buffer, sizeof(buffer), "%Y-%m-%d %H", local_time);
	EXPECT_LT(0UL, written);
	return std::string(buffer);
	}

	// Checks that the timezone name in the `settings` matches what is `expected`.
	void AssertTimezone(const std::string& expected,
	const IntlSettings& settings) {
	ASSERT_EQ(expected, settings.time_zone_id().id);
	}

	std::unique_ptr<sys::ComponentContext> ctx_;
	fuchsia::settings::IntlSyncPtr intl_;

	fuchsia::settings::IntlSettings save_settings_;
	};

	static bool ValidateShell(Shell* shell) {
	if (!shell) {
	return false;
	}

	if (!shell->IsSetup()) {
	return false;
	}

	ShellTest::PlatformViewNotifyCreated(shell);

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

	return true;
	}

	// Runs the function `f` in lock-step with a Dart isolate until the function
	// returns `true`, or until a certain fixed number of retries is exhausted.
	// Events `tick` and `tock` are used to synchronize the lock-stepping. The
	// event 'tick' is a signal to the dart isolate to advance a single iteration
	// step. 'tock' is used by the dart isolate to signal that it has completed
	// its step.
	static void RunCoroutineWithRetry(int retries,
	fml::AutoResetWaitableEvent* tick,
	fml::AutoResetWaitableEvent* tock,
	std::function<bool()> f) {
	for (; retries > 0; retries--) {
	// Do a single coroutine step.
	tick->Signal();
	tock->Wait();
	if (f()) {
	break;
	}
	FML_LOG(INFO) << "Retries left: " << retries;
	sleep(1);
	}
	}

	// Verifies that changing the Fuchsia settings timezone through the FIDL
	// settings interface results in a change of the reported local time in the
	// isolate.
	//
	// The test is as follows:
	//
	// - Set an initial timezone, then get a timestamp from the isolate rounded down
	// to the nearest hour. The assumption is as long as this test doesn't run
	// very near the whole hour, which should be very unlikely, the nearest hour
	// will vary depending on the time zone.
	// - Set a different timezone. Get a timestamp from the isolate again and
	// confirm that this time around the timestamps are different.
	// - Set the initial timezone again, and get the timestamp. This time, the
	// timestamp rounded down to whole hour should match the timestamp we got
	// in the initial step.
	TEST_F(FuchsiaShellTest, LocaltimesVaryOnTimezoneChanges) {
	// See fixtures/shell_test.dart, the callback NotifyLocalTime is declared
	// there.
	fml::AutoResetWaitableEvent latch;
	std::string dart_isolate_time_str;
	AddNativeCallback("NotifyLocalTime", CREATE_NATIVE_ENTRY([&](auto args) {
	dart_isolate_time_str =
	tonic::DartConverter<std::string>::FromDart(
	Dart_GetNativeArgument(args, 0));
	latch.Signal();
	}));

	// As long as this is set, the isolate will keep rerunning its only task.
	bool continue_fixture = true;
	fml::AutoResetWaitableEvent fixture_latch;
	AddNativeCallback("WaitFixture", CREATE_NATIVE_ENTRY([&](auto args) {
	// Wait for the test fixture to advance.
	fixture_latch.Wait();
	tonic::DartConverter<bool>::SetReturnValue(
	args, continue_fixture);
	}));

	auto settings = CreateSettingsForFixture();
	auto configuration = RunConfiguration::InferFromSettings(settings);
	configuration.SetEntrypoint("timezonesChange");

	std::unique_ptr<Shell> shell = CreateShell(settings);
	ASSERT_NE(shell.get(), nullptr);
	ASSERT_TRUE(ValidateShell(shell.get()));
	RunEngine(shell.get(), std::move(configuration));
	latch.Wait(); // After this point, the fixture is at waitFixture().

	// Start with the local timezone, ensure that the isolate and the test
	// fixture are the same.
	SetTimezone(GetLocalTimezone());
	AssertTimezone(GetLocalTimezone(), GetSettings());
	std::string expected = GetLocalTime();
	std::string actual = "undefined";
	RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
	actual = dart_isolate_time_str;
	FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
	return expected == actual;
	});
	ASSERT_EQ(expected, actual)
	<< "The Dart isolate was expected to show the same time as the test "
	<< "fixture eventually, but that didn't happen after multiple retries.";

	// Set a new timezone, which is hopefully different from the local one.
	SetTimezone("America/New_York");
	AssertTimezone("America/New_York", GetSettings());
	RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
	actual = dart_isolate_time_str;
	FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
	return expected != actual;
	});
	ASSERT_NE(expected, actual)
	<< "The Dart isolate was expected to show a time different from the test "
	<< "fixture eventually, but that didn't happen after multiple retries.";

	// Set a new isolate timezone, and check that the reported time is eventually
	// different from what it used to be prior to the change.
	SetTimezone("Europe/Amsterdam");
	AssertTimezone("Europe/Amsterdam", GetSettings());
	RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
	actual = dart_isolate_time_str;
	FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
	return expected != actual;
	});
	ASSERT_NE(expected, actual)
	<< "The Dart isolate was expected to show a time different from the "
	<< "prior timezone eventually, but that didn't happen after multiple "
	<< "retries.";

	// Let's try to bring the timezone back to the old one.
	expected = actual;
	SetTimezone("America/New_York");
	AssertTimezone("America/New_York", GetSettings());
	RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
	actual = dart_isolate_time_str;
	FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
	return expected != actual;
	});
	ASSERT_NE(expected, actual)
	<< "The Dart isolate was expected to show a time different from the "
	<< "prior timezone eventually, but that didn't happen after multiple "
	<< "retries.";

	// Tell the isolate to exit its loop.
	ASSERT_FALSE(fixture_latch.IsSignaledForTest());
	continue_fixture = false;
	fixture_latch.Signal();
	DestroyShell(std::move(shell));
	}

	} // namespace testing
	} // namespace flutter