fl_windowing_handler_test.cc File Reference

#include "flutter/shell/platform/linux/fl_windowing_handler.h"
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/testing/fl_mock_binary_messenger.h"
#include "flutter/shell/platform/linux/testing/fl_test_gtk_logs.h"
#include "flutter/shell/platform/linux/testing/mock_gtk.h"
#include "flutter/testing/testing.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Functions
static void	set_size_arg (FlValue *args, const gchar *name, double width, double height)
static FlValue *	make_create_regular_args (double width, double height)
static int64_t	parse_create_regular_response (FlMethodResponse *response)
static FlValue *	make_modify_regular_args (int64_t view_id)
static FlValue *	make_destroy_window_args (int64_t view_id)
	TEST (FlWindowingHandlerTest, CreateRegular)
	TEST (FlWindowingHandlerTest, CreateRegularMinSize)
	TEST (FlWindowingHandlerTest, CreateRegularMaxSize)
	TEST (FlWindowingHandlerTest, CreateRegularWithTitle)
	TEST (FlWindowingHandlerTest, CreateRegularMaximized)
	TEST (FlWindowingHandlerTest, CreateRegularMinimized)
	TEST (FlWindowingHandlerTest, ModifyRegularSize)
	TEST (FlWindowingHandlerTest, ModifyRegularTitle)
	TEST (FlWindowingHandlerTest, ModifyRegularMaximize)
	TEST (FlWindowingHandlerTest, ModifyRegularUnmaximize)
	TEST (FlWindowingHandlerTest, ModifyRegularMinimize)
	TEST (FlWindowingHandlerTest, ModifyRegularUnminimize)
	TEST (FlWindowingHandlerTest, ModifyUnknownWindow)
	TEST (FlWindowingHandlerTest, DestroyWindow)
	TEST (FlWindowingHandlerTest, DestroyUnknownWindow)

Function Documentation

make_create_regular_args()

static FlValue* make_create_regular_args ( double  width, double  height  )

static

Definition at line 26 of file fl_windowing_handler_test.cc.

                                                                      {
  FlValue* args = fl_value_new_map();
  set_size_arg(args, "size", width, height);
  return args;
}

References args, fl_value_new_map(), height, set_size_arg(), and width.

Referenced by TEST().

make_destroy_window_args()

static FlValue* make_destroy_window_args ( int64_t  view_id )

static

Definition at line 67 of file fl_windowing_handler_test.cc.

                                                          {
  FlValue* args = fl_value_new_map();
  fl_value_set_string_take(args, "viewId", fl_value_new_int(view_id));
  return args;
}

References args, fl_value_new_int(), fl_value_new_map(), fl_value_set_string_take(), and view_id.

Referenced by TEST().

make_modify_regular_args()

static FlValue* make_modify_regular_args ( int64_t  view_id )

static

Definition at line 61 of file fl_windowing_handler_test.cc.

                                                          {
  FlValue* args = fl_value_new_map();
  fl_value_set_string_take(args, "viewId", fl_value_new_int(view_id));
  return args;
}

References args, fl_value_new_int(), fl_value_new_map(), fl_value_set_string_take(), and view_id.

Referenced by TEST().

parse_create_regular_response()

static int64_t parse_create_regular_response ( FlMethodResponse *  response )

static

Definition at line 32 of file fl_windowing_handler_test.cc.

                                                                         {
  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
  FlValue* result = fl_method_success_response_get_result(
      FL_METHOD_SUCCESS_RESPONSE(response));
  EXPECT_EQ(fl_value_get_type(result), FL_VALUE_TYPE_MAP);
 
  FlValue* view_id_value = fl_value_lookup_string(result, "viewId");
  EXPECT_NE(view_id_value, nullptr);
  EXPECT_EQ(fl_value_get_type(view_id_value), FL_VALUE_TYPE_INT);
  int64_t view_id = fl_value_get_int(view_id_value);
  EXPECT_GT(view_id, 0);
 
  FlValue* size_value = fl_value_lookup_string(result, "size");
  EXPECT_NE(size_value, nullptr);
  EXPECT_EQ(fl_value_get_type(size_value), FL_VALUE_TYPE_LIST);
  EXPECT_EQ(fl_value_get_length(size_value), 2u);
  EXPECT_EQ(fl_value_get_type(fl_value_get_list_value(size_value, 0)),
            FL_VALUE_TYPE_FLOAT);
  EXPECT_EQ(fl_value_get_type(fl_value_get_list_value(size_value, 1)),
            FL_VALUE_TYPE_FLOAT);
 
  FlValue* state_value = fl_value_lookup_string(result, "state");
  EXPECT_NE(state_value, nullptr);
  EXPECT_EQ(fl_value_get_type(state_value), FL_VALUE_TYPE_STRING);
 
  return view_id;
}

References fl_method_success_response_get_result(), fl_value_get_int(), fl_value_get_length(), fl_value_get_list_value(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_INT, FL_VALUE_TYPE_LIST, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_STRING, and view_id.

Referenced by TEST().

set_size_arg()

static void set_size_arg ( FlValue *  args, const gchar *  name, double  width, double  height  )

static

Definition at line 16 of file fl_windowing_handler_test.cc.

                                        {
  g_autoptr(FlValue) size_value = fl_value_new_list();
  fl_value_append_take(size_value, fl_value_new_float(width));
  fl_value_append_take(size_value, fl_value_new_float(height));
  fl_value_set_string(args, name, size_value);
}

References args, fl_value_append_take(), fl_value_new_float(), fl_value_new_list(), fl_value_set_string(), height, and width.

Referenced by make_create_regular_args(), and TEST().

TEST() [1/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegular
	)

Definition at line 73 of file fl_windowing_handler_test.cc.

                                            {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_set_default_size(::testing::_, 800, 600));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), TRUE, and user_data.

TEST() [2/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegularMaximized
	)

Definition at line 205 of file fl_windowing_handler_test.cc.

                                                     {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
  fl_value_set_string_take(args, "state",
                           fl_value_new_string("WindowState.maximized"));
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), TRUE, and user_data.

TEST() [3/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegularMaxSize
	)

Definition at line 138 of file fl_windowing_handler_test.cc.

                                                   {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk,
              gtk_window_set_geometry_hints(
                  ::testing::_, nullptr,
                  ::testing::Pointee(::testing::AllOf(
                      ::testing::Field(&GdkGeometry::max_width, 1000),
                      ::testing::Field(&GdkGeometry::max_height, 2000))),
                  GDK_HINT_MAX_SIZE));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
  set_size_arg(args, "maxSize", 1000, 2000);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), set_size_arg(), TRUE, and user_data.

TEST() [4/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegularMinimized
	)

Definition at line 236 of file fl_windowing_handler_test.cc.

                                                     {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
  fl_value_set_string_take(args, "state",
                           fl_value_new_string("WindowState.minimized"));
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), TRUE, and user_data.

TEST() [5/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegularMinSize
	)

Definition at line 102 of file fl_windowing_handler_test.cc.

                                                   {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk,
              gtk_window_set_geometry_hints(
                  ::testing::_, nullptr,
                  ::testing::Pointee(::testing::AllOf(
                      ::testing::Field(&GdkGeometry::min_width, 100),
                      ::testing::Field(&GdkGeometry::min_height, 200))),
                  GDK_HINT_MIN_SIZE));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
  set_size_arg(args, "minSize", 100, 200);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), set_size_arg(), TRUE, and user_data.

TEST() [6/15]

TEST	(	FlWindowingHandlerTest	,
		CreateRegularWithTitle
	)

Definition at line 174 of file fl_windowing_handler_test.cc.

                                                     {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk,
              gtk_window_set_title(::testing::_, ::testing::StrEq("TITLE")));
 
  g_autoptr(FlValue) args = make_create_regular_args(800, 600);
  fl_value_set_string_take(args, "title", fl_value_new_string("TITLE"));
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        parse_create_regular_response(response);
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), parse_create_regular_response(), TRUE, and user_data.

TEST() [7/15]

TEST	(	FlWindowingHandlerTest	,
		DestroyUnknownWindow
	)

Definition at line 614 of file fl_windowing_handler_test.cc.

                                                   {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  g_autoptr(FlValue) args = make_destroy_window_args(99);
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "destroyWindow", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
        EXPECT_STREQ(fl_method_error_response_get_code(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "Bad Arguments");
        EXPECT_STREQ(fl_method_error_response_get_message(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "No window with given view ID");
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_method_error_response_get_code(), fl_method_error_response_get_message(), fl_windowing_handler_new(), make_destroy_window_args(), TRUE, and user_data.

TEST() [8/15]

TEST	(	FlWindowingHandlerTest	,
		DestroyWindow
	)

Definition at line 573 of file fl_windowing_handler_test.cc.

                                            {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_widget_destroy);
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  g_autoptr(FlValue) destroy_args = make_destroy_window_args(view_id);
  gboolean destroy_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "destroyWindow", destroy_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &destroy_called);
  EXPECT_TRUE(destroy_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_windowing_handler_new(), make_create_regular_args(), make_destroy_window_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [9/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularMaximize
	)

Definition at line 354 of file fl_windowing_handler_test.cc.

                                                    {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  fl_value_set_string_take(modify_args, "state",
                           fl_value_new_string("WindowState.maximized"));
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [10/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularMinimize
	)

Definition at line 449 of file fl_windowing_handler_test.cc.

                                                    {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  fl_value_set_string_take(modify_args, "state",
                           fl_value_new_string("WindowState.minimized"));
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [11/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularSize
	)

Definition at line 267 of file fl_windowing_handler_test.cc.

                                                {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_resize(::testing::_, 1024, 768));
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  set_size_arg(modify_args, "size", 1024, 768);
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), set_size_arg(), TRUE, user_data, and view_id.

TEST() [12/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularTitle
	)

Definition at line 310 of file fl_windowing_handler_test.cc.

                                                 {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk,
              gtk_window_set_title(::testing::_, ::testing::StrEq("TITLE")));
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  fl_value_set_string_take(modify_args, "title", fl_value_new_string("TITLE"));
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [13/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularUnmaximize
	)

Definition at line 399 of file fl_windowing_handler_test.cc.

                                                      {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_maximize(::testing::_));
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
  fl_value_set_string_take(create_args, "state",
                           fl_value_new_string("WindowState.maximized"));
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  EXPECT_CALL(mock_gtk, gtk_window_is_maximized(::testing::_))
      .WillOnce(::testing::Return(TRUE));
  EXPECT_CALL(mock_gtk, gtk_window_unmaximize(::testing::_));
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  fl_value_set_string_take(modify_args, "state",
                           fl_value_new_string("WindowState.restored"));
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [14/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyRegularUnminimize
	)

Definition at line 494 of file fl_windowing_handler_test.cc.

                                                      {
  flutter::testing::fl_ensure_gtk_init();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  EXPECT_CALL(mock_gtk, gtk_window_new);
  EXPECT_CALL(mock_gtk, gtk_window_iconify(::testing::_));
 
  g_autoptr(FlValue) create_args = make_create_regular_args(800, 600);
  fl_value_set_string_take(create_args, "state",
                           fl_value_new_string("WindowState.minimized"));
 
  int64_t view_id = -1;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "createRegular", create_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        int64_t* view_id = static_cast<int64_t*>(user_data);
        *view_id = parse_create_regular_response(response);
      },
      &view_id);
  EXPECT_GT(view_id, 0);
 
  EXPECT_CALL(mock_gtk, gdk_window_get_state(::testing::_))
      .WillOnce(::testing::Return(GDK_WINDOW_STATE_ICONIFIED));
  EXPECT_CALL(mock_gtk, gtk_window_deiconify(::testing::_));
 
  g_autoptr(FlValue) modify_args = make_modify_regular_args(view_id);
  fl_value_set_string_take(modify_args, "state",
                           fl_value_new_string("WindowState.restored"));
 
  gboolean modify_called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", modify_args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &modify_called);
  EXPECT_TRUE(modify_called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_value_new_string(), fl_value_set_string_take(), fl_windowing_handler_new(), make_create_regular_args(), make_modify_regular_args(), parse_create_regular_response(), TRUE, user_data, and view_id.

TEST() [15/15]

TEST	(	FlWindowingHandlerTest	,
		ModifyUnknownWindow
	)

Definition at line 544 of file fl_windowing_handler_test.cc.

                                                  {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  g_autoptr(FlEngine) engine =
      fl_engine_new_with_binary_messenger(FL_BINARY_MESSENGER(messenger));
  g_autoptr(FlWindowingHandler) handler = fl_windowing_handler_new(engine);
 
  g_autoptr(FlValue) args = make_modify_regular_args(99);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_standard_method(
      messenger, "flutter/windowing", "modifyRegular", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        EXPECT_TRUE(FL_IS_METHOD_ERROR_RESPONSE(response));
        EXPECT_STREQ(fl_method_error_response_get_code(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "Bad Arguments");
        EXPECT_STREQ(fl_method_error_response_get_message(
                         FL_METHOD_ERROR_RESPONSE(response)),
                     "No window with given view ID");
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, fl_binary_messenger_shutdown(), fl_engine_new_with_binary_messenger(), fl_method_error_response_get_code(), fl_method_error_response_get_message(), fl_windowing_handler_new(), make_modify_regular_args(), TRUE, and user_data.