Add SettingsChannel unit test (#158)

* Take test_binary_messenger.h from Windows implementation

Signed-off-by: Boram Bae <[email protected]>

Author: bbrto21

shell/platform/tizen/BUILD.gn

@@ -268,6 +268,7 @@ executable("flutter_tizen_unittests") {
   testonly = true
 
   sources = [
+    "channels/settings_channel_unittests.cc",
     "flutter_project_bundle_unittests.cc",
     "flutter_tizen_engine_unittest.cc",
     "flutter_tizen_texture_registrar_unittests.cc",
@@ -278,6 +279,7 @@ executable("flutter_tizen_unittests") {
     ":flutter_desktop_source",
     ":flutter_tizen_fixtures",
     "//flutter/runtime:libdart",
+    "//flutter/shell/platform/common:common_cpp",
     "//flutter/shell/platform/common/client_wrapper:client_wrapper",
     "//flutter/shell/platform/embedder:embedder_headers",
     "//flutter/shell/platform/embedder:embedder_test_utils",

shell/platform/tizen/channels/settings_channel_unittests.cc

@@ -0,0 +1,58 @@
+// Copyright 2021 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/common/json_message_codec.h"
+#include "flutter/shell/platform/tizen/channels/settings_channel.h"
+#include "flutter/shell/platform/tizen/testing/test_binary_messenger.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+constexpr char kChannelName[] = "flutter/settings";
+constexpr char kAlwaysUse24HourFormatKey[] = "alwaysUse24HourFormat";
+constexpr char kPlatformBrightnessKey[] = "platformBrightness";
+constexpr char kTextScaleFactorKey[] = "textScaleFactor";
+
+}  // namespace
+
+namespace flutter {
+namespace testing {
+
+TEST(SettingsChannel, SendSettingsEventOnceWhenInitialization) {
+  bool always_use24_hour_format = true;
+  std::string platform_brightness;
+  double scale_factor = 0;
+  int call_count = 0;
+
+  TestBinaryMessenger messenger(
+      [&always_use24_hour_format, &platform_brightness, &scale_factor,
+       &call_count](const std::string& channel, const uint8_t* message,
+                    size_t message_size, BinaryReply reply) {
+        if (channel == kChannelName) {
+          auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
+              message, message_size);
+          always_use24_hour_format =
+              (*message_doc)[kAlwaysUse24HourFormatKey].GetBool();
+          scale_factor = (*message_doc)[kTextScaleFactorKey].GetDouble();
+          platform_brightness =
+              (*message_doc)[kPlatformBrightnessKey].GetString();
+          call_count++;
+        } else {
+          // Should not be reached.
+          EXPECT_TRUE(false);
+        }
+      });
+
+  SettingsChannel setting_channel(&messenger);
+
+  // The Linux implementation always returns false.
+  EXPECT_TRUE(always_use24_hour_format == false);
+
+  EXPECT_TRUE(platform_brightness == "light");
+  EXPECT_TRUE(scale_factor == 1.0);
+  EXPECT_TRUE(call_count == 1);
+}
+
+}  // namespace testing
+}  // namespace flutter

shell/platform/tizen/testing/test_binary_messenger.h

@@ -0,0 +1,81 @@
+// Copyright 2021 Samsung Electronics Co., Ltd. All rights reserved.
+// 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.
+
+#ifndef EMBEDDER_TESTING_TEST_BINARY_MESSENGER_H_
+#define EMBEDDER_TESTING_TEST_BINARY_MESSENGER_H_
+
+#include <cassert>
+#include <functional>
+#include <map>
+#include <string>
+
+#include "flutter/shell/platform/common/client_wrapper/include/flutter/binary_messenger.h"
+
+namespace flutter {
+
+// A trivial BinaryMessenger implementation for use in tests.
+class TestBinaryMessenger : public BinaryMessenger {
+ public:
+  using SendHandler = std::function<void(const std::string& channel,
+                                         const uint8_t* message,
+                                         size_t message_size,
+                                         BinaryReply reply)>;
+
+  // Creates a new messenge that forwards all calls to |send_handler|.
+  explicit TestBinaryMessenger(SendHandler send_handler = nullptr)
+      : send_handler_(std::move(send_handler)) {}
+
+  virtual ~TestBinaryMessenger() = default;
+
+  // Prevent copying.
+  TestBinaryMessenger(TestBinaryMessenger const&) = delete;
+  TestBinaryMessenger& operator=(TestBinaryMessenger const&) = delete;
+
+  // Simulates a message from the engine on the given channel.
+  //
+  // Returns false if no handler is registered on that channel.
+  bool SimulateEngineMessage(const std::string& channel,
+                             const uint8_t* message,
+                             size_t message_size,
+                             BinaryReply reply) {
+    auto handler = registered_handlers_.find(channel);
+    if (handler == registered_handlers_.end()) {
+      return false;
+    }
+    (handler->second)(message, message_size, reply);
+    return true;
+  }
+
+  // |flutter::BinaryMessenger|
+  void Send(const std::string& channel,
+            const uint8_t* message,
+            size_t message_size,
+            BinaryReply reply) const override {
+    // If something under test sends a message, the test should be handling it.
+    assert(send_handler_);
+    send_handler_(channel, message, message_size, reply);
+  }
+
+  // |flutter::BinaryMessenger|
+  void SetMessageHandler(const std::string& channel,
+                         BinaryMessageHandler handler) override {
+    if (handler) {
+      registered_handlers_[channel] = handler;
+    } else {
+      registered_handlers_.erase(channel);
+    }
+  }
+
+ private:
+  // Handler to call for SendMessage.
+  SendHandler send_handler_;
+
+  // Mapping of channel name to registered handlers.
+  std::map<std::string, BinaryMessageHandler> registered_handlers_;
+};
+
+}  // namespace flutter
+
+#endif  // EMBEDDER_TESTING_TEST_BINARY_MESSENGER_H_