From 648c92d10782ee0849c01e9683642d2d355e5e54 Mon Sep 17 00:00:00 2001 From: David Iglesias Date: Wed, 24 Jul 2024 12:48:06 -0700 Subject: [PATCH 1/4] [gis_web] Allow package:web 1.0.0 (#7203) Brackets the package:web dependency in gis_web to allow for `">=0.5.1 <2.0.0"`. ## Issues This is needed so we can rebase and land: * Part of: #7202 --- packages/google_identity_services_web/CHANGELOG.md | 5 +++++ .../google_identity_services_web/example/pubspec.yaml | 8 ++++---- packages/google_identity_services_web/pubspec.yaml | 6 +++--- 3 files changed, 12 insertions(+), 7 deletions(-) diff --git a/packages/google_identity_services_web/CHANGELOG.md b/packages/google_identity_services_web/CHANGELOG.md index d7ed98a3c8cd..f5752cbad972 100644 --- a/packages/google_identity_services_web/CHANGELOG.md +++ b/packages/google_identity_services_web/CHANGELOG.md @@ -1,3 +1,8 @@ +## 0.3.1+2 + +* Updates web code to package `web: >=0.5.1 <2.0.0`. +* Updates SDK version to Dart `^3.4.0`. Flutter `^3.22.0`. + ## 0.3.1+1 * Uses `TrustedTypes` from `web: ^0.5.1`. diff --git a/packages/google_identity_services_web/example/pubspec.yaml b/packages/google_identity_services_web/example/pubspec.yaml index fa625a5edd69..e2011307e939 100644 --- a/packages/google_identity_services_web/example/pubspec.yaml +++ b/packages/google_identity_services_web/example/pubspec.yaml @@ -3,16 +3,16 @@ description: An example for the google_identity_services_web package, OneTap. publish_to: 'none' environment: - sdk: ^3.3.0 - flutter: ">=3.19.0" + sdk: ^3.4.0 + flutter: ">=3.22.0" dependencies: flutter: sdk: flutter google_identity_services_web: path: ../ - http: ">=0.13.0 <2.0.0" - web: ^0.5.1 + http: ^1.2.2 + web: ^1.0.0 dev_dependencies: build_runner: ^2.1.10 # To extract README excerpts only. diff --git a/packages/google_identity_services_web/pubspec.yaml b/packages/google_identity_services_web/pubspec.yaml index 0c61580d79e2..160c50f16ce3 100644 --- a/packages/google_identity_services_web/pubspec.yaml +++ b/packages/google_identity_services_web/pubspec.yaml @@ -2,14 +2,14 @@ name: google_identity_services_web description: A Dart JS-interop layer for Google Identity Services. Google's new sign-in SDK for Web that supports multiple types of credentials. repository: https://github.com/flutter/packages/tree/main/packages/google_identity_services_web issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_identiy_services_web%22 -version: 0.3.1+1 +version: 0.3.1+2 environment: - sdk: ^3.3.0 + sdk: ^3.4.0 dependencies: meta: ^1.3.0 - web: ^0.5.1 + web: ">=0.5.1 <2.0.0" dev_dependencies: path: ^1.8.1 From 2c1f71345113a1ac88d50283c4f895a5b9d3acdb Mon Sep 17 00:00:00 2001 From: Robert Ancell Date: Thu, 25 Jul 2024 22:11:13 +1200 Subject: [PATCH 2/4] Add Linux support to Pigeon (#5100) Add Linux support for Pigeon. This has minimal work porting the generator and some manually written generated code so we can review this before implementing the generator support. https://github.com/flutter/flutter/issues/73740 --- packages/pigeon/CHANGELOG.md | 4 + packages/pigeon/README.md | 8 + packages/pigeon/example/README.md | 77 + packages/pigeon/example/app/lib/main.dart | 1 + packages/pigeon/example/app/linux/.gitignore | 1 + .../pigeon/example/app/linux/CMakeLists.txt | 140 + .../example/app/linux/flutter/CMakeLists.txt | 88 + .../app/linux/flutter/generated_plugins.cmake | 23 + packages/pigeon/example/app/linux/main.cc | 10 + .../pigeon/example/app/linux/messages.g.cc | 898 + .../pigeon/example/app/linux/messages.g.h | 349 + .../example/app/linux/my_application.cc | 187 + .../pigeon/example/app/linux/my_application.h | 22 + .../pigeon/example/app/pigeons/messages.dart | 3 + packages/pigeon/lib/generator_tools.dart | 2 +- packages/pigeon/lib/gobject_generator.dart | 2109 ++ packages/pigeon/lib/pigeon.dart | 1 + packages/pigeon/lib/pigeon_lib.dart | 96 + .../lib/integration_tests.dart | 3 + .../example/integration_test/test.dart | 3 + .../test_plugin/example/linux/.gitignore | 1 + .../test_plugin/example/linux/CMakeLists.txt | 151 + .../example/linux/flutter/CMakeLists.txt | 88 + .../linux/flutter/generated_plugins.cmake | 24 + .../test_plugin/example/linux/main.cc | 10 + .../example/linux/my_application.cc | 131 + .../example/linux/my_application.h | 22 + .../test_plugin/linux/CMakeLists.txt | 119 + .../linux/include/test_plugin/test_plugin.h | 25 + .../test_plugin/linux/pigeon/.gitignore | 6 + .../linux/pigeon/core_tests.gen.cc | 19101 ++++++++++++++++ .../test_plugin/linux/pigeon/core_tests.gen.h | 6847 ++++++ .../linux/test/multiple_arity_test.cc | 44 + .../linux/test/non_null_fields_test.cc | 17 + .../linux/test/null_fields_test.cc | 63 + .../linux/test/nullable_returns_test.cc | 132 + .../test_plugin/linux/test/primitive_test.cc | 216 + .../linux/test/utils/fake_host_messenger.cc | 183 + .../linux/test/utils/fake_host_messenger.h | 28 + .../test_plugin/linux/test_plugin.cc | 1864 ++ .../test_plugin/linux/test_plugin_private.h | 14 + .../platform_tests/test_plugin/pubspec.yaml | 2 + packages/pigeon/pubspec.yaml | 2 +- .../pigeon/test/gobject_generator_test.dart | 774 + packages/pigeon/tool/run_tests.dart | 6 +- packages/pigeon/tool/shared/generation.dart | 21 +- .../tool/shared/native_project_runners.dart | 11 +- packages/pigeon/tool/shared/test_runner.dart | 3 +- packages/pigeon/tool/shared/test_suites.dart | 100 +- packages/pigeon/tool/test.dart | 5 + 50 files changed, 33996 insertions(+), 39 deletions(-) create mode 100644 packages/pigeon/example/app/linux/.gitignore create mode 100644 packages/pigeon/example/app/linux/CMakeLists.txt create mode 100644 packages/pigeon/example/app/linux/flutter/CMakeLists.txt create mode 100644 packages/pigeon/example/app/linux/flutter/generated_plugins.cmake create mode 100644 packages/pigeon/example/app/linux/main.cc create mode 100644 packages/pigeon/example/app/linux/messages.g.cc create mode 100644 packages/pigeon/example/app/linux/messages.g.h create mode 100644 packages/pigeon/example/app/linux/my_application.cc create mode 100644 packages/pigeon/example/app/linux/my_application.h create mode 100644 packages/pigeon/lib/gobject_generator.dart create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/.gitignore create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/CMakeLists.txt create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/flutter/CMakeLists.txt create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/flutter/generated_plugins.cmake create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/main.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/my_application.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/example/linux/my_application.h create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/CMakeLists.txt create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/include/test_plugin/test_plugin.h create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/pigeon/.gitignore create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.h create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/multiple_arity_test.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/non_null_fields_test.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/null_fields_test.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/nullable_returns_test.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/primitive_test.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.h create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test_plugin.cc create mode 100644 packages/pigeon/platform_tests/test_plugin/linux/test_plugin_private.h create mode 100644 packages/pigeon/test/gobject_generator_test.dart diff --git a/packages/pigeon/CHANGELOG.md b/packages/pigeon/CHANGELOG.md index ec34f493dbcf..f501b5cd23f9 100644 --- a/packages/pigeon/CHANGELOG.md +++ b/packages/pigeon/CHANGELOG.md @@ -1,3 +1,7 @@ +## 21.1.0 + +* Adds GObject (Linux) support. + ## 21.0.0 * **Breaking Change** [cpp] Fixes style of enum names. References to enum values diff --git a/packages/pigeon/README.md b/packages/pigeon/README.md index 3a46c9707c68..a3c4f341ade7 100644 --- a/packages/pigeon/README.md +++ b/packages/pigeon/README.md @@ -17,6 +17,7 @@ Currently pigeon supports generating: * Kotlin and Java code for Android * Swift and Objective-C code for iOS and macOS * C++ code for Windows +* GObject code for Linux ### Supported Datatypes @@ -136,6 +137,13 @@ to the api to allow for multiple instances to be created and operate in parallel 1) Implement the generated protocol for handling the calls on macOS, set it up as the handler for the messages. +### Flutter calling into Linux steps + +1) Add the generated GObject code to your `./linux` directory for compilation, and + to your `linux/CMakeLists.txt` file. +1) Implement the generated protocol for handling the calls on Linux, set it up + as the vtable for the API object. + ### Calling into Flutter from the host platform Pigeon also supports calling in the opposite direction. The steps are similar diff --git a/packages/pigeon/example/README.md b/packages/pigeon/example/README.md index 4aa23db934f1..448b65a489ef 100644 --- a/packages/pigeon/example/README.md +++ b/packages/pigeon/example/README.md @@ -19,6 +19,9 @@ needed for your project. cppOptions: CppOptions(namespace: 'pigeon_example'), cppHeaderOut: 'windows/runner/messages.g.h', cppSourceOut: 'windows/runner/messages.g.cpp', + gobjectHeaderOut: 'linux/messages.g.h', + gobjectSourceOut: 'linux/messages.g.cc', + gobjectOptions: GObjectOptions(), kotlinOut: 'android/app/src/main/kotlin/dev/flutter/pigeon_example_app/Messages.g.kt', kotlinOptions: KotlinOptions(), @@ -191,6 +194,49 @@ class PigeonApiImplementation : public ExampleHostApi { }; ``` +### GObject + +```c++ +static PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +handle_get_host_language(gpointer user_data) { + return pigeon_example_package_example_host_api_get_host_language_response_new( + "C++"); +} + +static PigeonExamplePackageExampleHostApiAddResponse* handle_add( + int64_t a, int64_t b, gpointer user_data) { + if (a < 0 || b < 0) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + return pigeon_example_package_example_host_api_add_response_new_error( + "code", "message", details); + } + + return pigeon_example_package_example_host_api_add_response_new(a + b); +} + +static void handle_send_message( + PigeonExamplePackageMessageData* message, + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + gpointer user_data) { + PigeonExamplePackageCode code = + pigeon_example_package_message_data_get_code(message); + if (code == PIGEON_EXAMPLE_PACKAGE_CODE_ONE) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + pigeon_example_package_example_host_api_respond_error_send_message( + response_handle, "code", "message", details); + return; + } + + pigeon_example_package_example_host_api_respond_send_message(response_handle, + TRUE); +} + +static PigeonExamplePackageExampleHostApiVTable example_host_api_vtable = { + .get_host_language = handle_get_host_language, + .add = handle_add, + .send_message = handle_send_message}; +``` + ## FlutterApi Example This example gives an overview of how to use Pigeon to call into the Flutter @@ -274,6 +320,37 @@ void TestPlugin::CallFlutterMethod( } ``` +### GObject + + +```c++ +static void flutter_method_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(GError) error = nullptr; + g_autoptr( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse) response = + pigeon_example_package_message_flutter_api_flutter_method_finish( + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API(object), result, &error); + if (response == nullptr) { + g_warning("Failed to call Flutter method: %s", error->message); + return; + } + + g_printerr( + "Got result from Flutter method: %s\n", + pigeon_example_package_message_flutter_api_flutter_method_response_get_return_value( + response)); +} +``` + + +```c++ +self->flutter_api = + pigeon_example_package_message_flutter_api_new(messenger, nullptr); +pigeon_example_package_message_flutter_api_flutter_method( + self->flutter_api, "hello", nullptr, flutter_method_cb, self); +``` + ## Swift / Kotlin Plugin Example A downloadable example of using Pigeon to create a Flutter Plugin with Swift and diff --git a/packages/pigeon/example/app/lib/main.dart b/packages/pigeon/example/app/lib/main.dart index 7f318d63d50d..48138f9e950a 100644 --- a/packages/pigeon/example/app/lib/main.dart +++ b/packages/pigeon/example/app/lib/main.dart @@ -19,6 +19,7 @@ class _ExampleFlutterApi implements MessageFlutterApi { // #enddocregion main-dart-flutter void main() { + WidgetsFlutterBinding.ensureInitialized(); // #docregion main-dart-flutter MessageFlutterApi.setUp(_ExampleFlutterApi()); // #enddocregion main-dart-flutter diff --git a/packages/pigeon/example/app/linux/.gitignore b/packages/pigeon/example/app/linux/.gitignore new file mode 100644 index 000000000000..d3896c98444f --- /dev/null +++ b/packages/pigeon/example/app/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/packages/pigeon/example/app/linux/CMakeLists.txt b/packages/pigeon/example/app/linux/CMakeLists.txt new file mode 100644 index 000000000000..340076b55677 --- /dev/null +++ b/packages/pigeon/example/app/linux/CMakeLists.txt @@ -0,0 +1,140 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "pigeon_example_app") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "dev.flutter.pigeon_example_app") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "messages.g.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/packages/pigeon/example/app/linux/flutter/CMakeLists.txt b/packages/pigeon/example/app/linux/flutter/CMakeLists.txt new file mode 100644 index 000000000000..d5bd01648a96 --- /dev/null +++ b/packages/pigeon/example/app/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/packages/pigeon/example/app/linux/flutter/generated_plugins.cmake b/packages/pigeon/example/app/linux/flutter/generated_plugins.cmake new file mode 100644 index 000000000000..2e1de87a7eb6 --- /dev/null +++ b/packages/pigeon/example/app/linux/flutter/generated_plugins.cmake @@ -0,0 +1,23 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/packages/pigeon/example/app/linux/main.cc b/packages/pigeon/example/app/linux/main.cc new file mode 100644 index 000000000000..1507d02825e7 --- /dev/null +++ b/packages/pigeon/example/app/linux/main.cc @@ -0,0 +1,10 @@ +// 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. + +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/packages/pigeon/example/app/linux/messages.g.cc b/packages/pigeon/example/app/linux/messages.g.cc new file mode 100644 index 000000000000..2d9ede7877d9 --- /dev/null +++ b/packages/pigeon/example/app/linux/messages.g.cc @@ -0,0 +1,898 @@ +// 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. +// Autogenerated from Pigeon, do not edit directly. +// See also: https://pub.dev/packages/pigeon + +#include "messages.g.h" + +struct _PigeonExamplePackageMessageData { + GObject parent_instance; + + gchar* name; + gchar* description; + PigeonExamplePackageCode code; + FlValue* data; +}; + +G_DEFINE_TYPE(PigeonExamplePackageMessageData, + pigeon_example_package_message_data, G_TYPE_OBJECT) + +static void pigeon_example_package_message_data_dispose(GObject* object) { + PigeonExamplePackageMessageData* self = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_DATA(object); + g_clear_pointer(&self->name, g_free); + g_clear_pointer(&self->description, g_free); + g_clear_pointer(&self->data, fl_value_unref); + G_OBJECT_CLASS(pigeon_example_package_message_data_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_message_data_init( + PigeonExamplePackageMessageData* self) {} + +static void pigeon_example_package_message_data_class_init( + PigeonExamplePackageMessageDataClass* klass) { + G_OBJECT_CLASS(klass)->dispose = pigeon_example_package_message_data_dispose; +} + +PigeonExamplePackageMessageData* pigeon_example_package_message_data_new( + const gchar* name, const gchar* description, PigeonExamplePackageCode code, + FlValue* data) { + PigeonExamplePackageMessageData* self = PIGEON_EXAMPLE_PACKAGE_MESSAGE_DATA( + g_object_new(pigeon_example_package_message_data_get_type(), nullptr)); + if (name != nullptr) { + self->name = g_strdup(name); + } else { + self->name = nullptr; + } + if (description != nullptr) { + self->description = g_strdup(description); + } else { + self->description = nullptr; + } + self->code = code; + self->data = fl_value_ref(data); + return self; +} + +const gchar* pigeon_example_package_message_data_get_name( + PigeonExamplePackageMessageData* self) { + g_return_val_if_fail(PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_DATA(self), nullptr); + return self->name; +} + +const gchar* pigeon_example_package_message_data_get_description( + PigeonExamplePackageMessageData* self) { + g_return_val_if_fail(PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_DATA(self), nullptr); + return self->description; +} + +PigeonExamplePackageCode pigeon_example_package_message_data_get_code( + PigeonExamplePackageMessageData* self) { + g_return_val_if_fail(PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_DATA(self), + static_cast(0)); + return self->code; +} + +FlValue* pigeon_example_package_message_data_get_data( + PigeonExamplePackageMessageData* self) { + g_return_val_if_fail(PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_DATA(self), nullptr); + return self->data; +} + +static FlValue* pigeon_example_package_message_data_to_list( + PigeonExamplePackageMessageData* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, self->name != nullptr + ? fl_value_new_string(self->name) + : fl_value_new_null()); + fl_value_append_take(values, self->description != nullptr + ? fl_value_new_string(self->description) + : fl_value_new_null()); + fl_value_append_take(values, + fl_value_new_custom(130, fl_value_new_int(self->code), + (GDestroyNotify)fl_value_unref)); + fl_value_append_take(values, fl_value_ref(self->data)); + return values; +} + +static PigeonExamplePackageMessageData* +pigeon_example_package_message_data_new_from_list(FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + const gchar* name = nullptr; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + name = fl_value_get_string(value0); + } + FlValue* value1 = fl_value_get_list_value(values, 1); + const gchar* description = nullptr; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + description = fl_value_get_string(value1); + } + FlValue* value2 = fl_value_get_list_value(values, 2); + PigeonExamplePackageCode code = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value2))))); + FlValue* value3 = fl_value_get_list_value(values, 3); + FlValue* data = value3; + return pigeon_example_package_message_data_new(name, description, code, data); +} + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageMessageCodec, + pigeon_example_package_message_codec, + PIGEON_EXAMPLE_PACKAGE, MESSAGE_CODEC, + FlStandardMessageCodec) + +struct _PigeonExamplePackageMessageCodec { + FlStandardMessageCodec parent_instance; +}; + +G_DEFINE_TYPE(PigeonExamplePackageMessageCodec, + pigeon_example_package_message_codec, + fl_standard_message_codec_get_type()) + +static gboolean +pigeon_example_package_message_codec_write_pigeon_example_package_message_data( + FlStandardMessageCodec* codec, GByteArray* buffer, + PigeonExamplePackageMessageData* value, GError** error) { + uint8_t type = 129; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = + pigeon_example_package_message_data_to_list(value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +pigeon_example_package_message_codec_write_pigeon_example_package_code( + FlStandardMessageCodec* codec, GByteArray* buffer, FlValue* value, + GError** error) { + uint8_t type = 130; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + return fl_standard_message_codec_write_value(codec, buffer, value, error); +} + +static gboolean pigeon_example_package_message_codec_write_value( + FlStandardMessageCodec* codec, GByteArray* buffer, FlValue* value, + GError** error) { + if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM) { + switch (fl_value_get_custom_type(value)) { + case 129: + return pigeon_example_package_message_codec_write_pigeon_example_package_message_data( + codec, buffer, + PIGEON_EXAMPLE_PACKAGE_MESSAGE_DATA( + fl_value_get_custom_value_object(value)), + error); + case 130: + return pigeon_example_package_message_codec_write_pigeon_example_package_code( + codec, buffer, + reinterpret_cast( + const_cast(fl_value_get_custom_value(value))), + error); + } + } + + return FL_STANDARD_MESSAGE_CODEC_CLASS( + pigeon_example_package_message_codec_parent_class) + ->write_value(codec, buffer, value, error); +} + +static FlValue* +pigeon_example_package_message_codec_read_pigeon_example_package_message_data( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(PigeonExamplePackageMessageData) value = + pigeon_example_package_message_data_new_from_list(values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(129, G_OBJECT(value)); +} + +static FlValue* +pigeon_example_package_message_codec_read_pigeon_example_package_code( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + return fl_value_new_custom( + 130, fl_standard_message_codec_read_value(codec, buffer, offset, error), + (GDestroyNotify)fl_value_unref); +} + +static FlValue* pigeon_example_package_message_codec_read_value_of_type( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, int type, + GError** error) { + switch (type) { + case 129: + return pigeon_example_package_message_codec_read_pigeon_example_package_message_data( + codec, buffer, offset, error); + case 130: + return pigeon_example_package_message_codec_read_pigeon_example_package_code( + codec, buffer, offset, error); + default: + return FL_STANDARD_MESSAGE_CODEC_CLASS( + pigeon_example_package_message_codec_parent_class) + ->read_value_of_type(codec, buffer, offset, type, error); + } +} + +static void pigeon_example_package_message_codec_init( + PigeonExamplePackageMessageCodec* self) {} + +static void pigeon_example_package_message_codec_class_init( + PigeonExamplePackageMessageCodecClass* klass) { + FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value = + pigeon_example_package_message_codec_write_value; + FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type = + pigeon_example_package_message_codec_read_value_of_type; +} + +static PigeonExamplePackageMessageCodec* +pigeon_example_package_message_codec_new() { + PigeonExamplePackageMessageCodec* self = PIGEON_EXAMPLE_PACKAGE_MESSAGE_CODEC( + g_object_new(pigeon_example_package_message_codec_get_type(), nullptr)); + return self; +} + +struct _PigeonExamplePackageExampleHostApiResponseHandle { + GObject parent_instance; + + FlBasicMessageChannel* channel; + FlBasicMessageChannelResponseHandle* response_handle; +}; + +G_DEFINE_TYPE(PigeonExamplePackageExampleHostApiResponseHandle, + pigeon_example_package_example_host_api_response_handle, + G_TYPE_OBJECT) + +static void pigeon_example_package_example_host_api_response_handle_dispose( + GObject* object) { + PigeonExamplePackageExampleHostApiResponseHandle* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_RESPONSE_HANDLE(object); + g_clear_object(&self->channel); + g_clear_object(&self->response_handle); + G_OBJECT_CLASS( + pigeon_example_package_example_host_api_response_handle_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_example_host_api_response_handle_init( + PigeonExamplePackageExampleHostApiResponseHandle* self) {} + +static void pigeon_example_package_example_host_api_response_handle_class_init( + PigeonExamplePackageExampleHostApiResponseHandleClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_example_host_api_response_handle_dispose; +} + +static PigeonExamplePackageExampleHostApiResponseHandle* +pigeon_example_package_example_host_api_response_handle_new( + FlBasicMessageChannel* channel, + FlBasicMessageChannelResponseHandle* response_handle) { + PigeonExamplePackageExampleHostApiResponseHandle* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_RESPONSE_HANDLE(g_object_new( + pigeon_example_package_example_host_api_response_handle_get_type(), + nullptr)); + self->channel = FL_BASIC_MESSAGE_CHANNEL(g_object_ref(channel)); + self->response_handle = + FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_ref(response_handle)); + return self; +} + +struct _PigeonExamplePackageExampleHostApiGetHostLanguageResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + PigeonExamplePackageExampleHostApiGetHostLanguageResponse, + pigeon_example_package_example_host_api_get_host_language_response, + G_TYPE_OBJECT) + +static void +pigeon_example_package_example_host_api_get_host_language_response_dispose( + GObject* object) { + PigeonExamplePackageExampleHostApiGetHostLanguageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_GET_HOST_LANGUAGE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + pigeon_example_package_example_host_api_get_host_language_response_parent_class) + ->dispose(object); +} + +static void +pigeon_example_package_example_host_api_get_host_language_response_init( + PigeonExamplePackageExampleHostApiGetHostLanguageResponse* self) {} + +static void +pigeon_example_package_example_host_api_get_host_language_response_class_init( + PigeonExamplePackageExampleHostApiGetHostLanguageResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_example_host_api_get_host_language_response_dispose; +} + +PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +pigeon_example_package_example_host_api_get_host_language_response_new( + const gchar* return_value) { + PigeonExamplePackageExampleHostApiGetHostLanguageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_GET_HOST_LANGUAGE_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_get_host_language_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +pigeon_example_package_example_host_api_get_host_language_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + PigeonExamplePackageExampleHostApiGetHostLanguageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_GET_HOST_LANGUAGE_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_get_host_language_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _PigeonExamplePackageExampleHostApiAddResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(PigeonExamplePackageExampleHostApiAddResponse, + pigeon_example_package_example_host_api_add_response, + G_TYPE_OBJECT) + +static void pigeon_example_package_example_host_api_add_response_dispose( + GObject* object) { + PigeonExamplePackageExampleHostApiAddResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_ADD_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + pigeon_example_package_example_host_api_add_response_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_example_host_api_add_response_init( + PigeonExamplePackageExampleHostApiAddResponse* self) {} + +static void pigeon_example_package_example_host_api_add_response_class_init( + PigeonExamplePackageExampleHostApiAddResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_example_host_api_add_response_dispose; +} + +PigeonExamplePackageExampleHostApiAddResponse* +pigeon_example_package_example_host_api_add_response_new(int64_t return_value) { + PigeonExamplePackageExampleHostApiAddResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_ADD_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_add_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_int(return_value)); + return self; +} + +PigeonExamplePackageExampleHostApiAddResponse* +pigeon_example_package_example_host_api_add_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + PigeonExamplePackageExampleHostApiAddResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_ADD_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_add_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + PigeonExamplePackageExampleHostApiSendMessageResponse, + pigeon_example_package_example_host_api_send_message_response, + PIGEON_EXAMPLE_PACKAGE, EXAMPLE_HOST_API_SEND_MESSAGE_RESPONSE, GObject) + +struct _PigeonExamplePackageExampleHostApiSendMessageResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(PigeonExamplePackageExampleHostApiSendMessageResponse, + pigeon_example_package_example_host_api_send_message_response, + G_TYPE_OBJECT) + +static void +pigeon_example_package_example_host_api_send_message_response_dispose( + GObject* object) { + PigeonExamplePackageExampleHostApiSendMessageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_SEND_MESSAGE_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + pigeon_example_package_example_host_api_send_message_response_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_example_host_api_send_message_response_init( + PigeonExamplePackageExampleHostApiSendMessageResponse* self) {} + +static void +pigeon_example_package_example_host_api_send_message_response_class_init( + PigeonExamplePackageExampleHostApiSendMessageResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_example_host_api_send_message_response_dispose; +} + +static PigeonExamplePackageExampleHostApiSendMessageResponse* +pigeon_example_package_example_host_api_send_message_response_new( + gboolean return_value) { + PigeonExamplePackageExampleHostApiSendMessageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_SEND_MESSAGE_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_send_message_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_bool(return_value)); + return self; +} + +static PigeonExamplePackageExampleHostApiSendMessageResponse* +pigeon_example_package_example_host_api_send_message_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + PigeonExamplePackageExampleHostApiSendMessageResponse* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API_SEND_MESSAGE_RESPONSE(g_object_new( + pigeon_example_package_example_host_api_send_message_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageExampleHostApi, + pigeon_example_package_example_host_api, + PIGEON_EXAMPLE_PACKAGE, EXAMPLE_HOST_API, GObject) + +struct _PigeonExamplePackageExampleHostApi { + GObject parent_instance; + + const PigeonExamplePackageExampleHostApiVTable* vtable; + gpointer user_data; + GDestroyNotify user_data_free_func; +}; + +G_DEFINE_TYPE(PigeonExamplePackageExampleHostApi, + pigeon_example_package_example_host_api, G_TYPE_OBJECT) + +static void pigeon_example_package_example_host_api_dispose(GObject* object) { + PigeonExamplePackageExampleHostApi* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API(object); + if (self->user_data != nullptr) { + self->user_data_free_func(self->user_data); + } + self->user_data = nullptr; + G_OBJECT_CLASS(pigeon_example_package_example_host_api_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_example_host_api_init( + PigeonExamplePackageExampleHostApi* self) {} + +static void pigeon_example_package_example_host_api_class_init( + PigeonExamplePackageExampleHostApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_example_host_api_dispose; +} + +static PigeonExamplePackageExampleHostApi* +pigeon_example_package_example_host_api_new( + const PigeonExamplePackageExampleHostApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + PigeonExamplePackageExampleHostApi* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API(g_object_new( + pigeon_example_package_example_host_api_get_type(), nullptr)); + self->vtable = vtable; + self->user_data = user_data; + self->user_data_free_func = user_data_free_func; + return self; +} + +static void pigeon_example_package_example_host_api_get_host_language_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + PigeonExamplePackageExampleHostApi* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API(user_data); + + if (self->vtable == nullptr || self->vtable->get_host_language == nullptr) { + return; + } + + g_autoptr(PigeonExamplePackageExampleHostApiGetHostLanguageResponse) + response = self->vtable->get_host_language(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "ExampleHostApi", + "getHostLanguage"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "ExampleHostApi", + "getHostLanguage", error->message); + } +} + +static void pigeon_example_package_example_host_api_add_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + PigeonExamplePackageExampleHostApi* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API(user_data); + + if (self->vtable == nullptr || self->vtable->add == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t a = fl_value_get_int(value0); + FlValue* value1 = fl_value_get_list_value(message_, 1); + int64_t b = fl_value_get_int(value1); + g_autoptr(PigeonExamplePackageExampleHostApiAddResponse) response = + self->vtable->add(a, b, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "ExampleHostApi", "add"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "ExampleHostApi", "add", + error->message); + } +} + +static void pigeon_example_package_example_host_api_send_message_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + PigeonExamplePackageExampleHostApi* self = + PIGEON_EXAMPLE_PACKAGE_EXAMPLE_HOST_API(user_data); + + if (self->vtable == nullptr || self->vtable->send_message == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + PigeonExamplePackageMessageData* message = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_DATA( + fl_value_get_custom_value_object(value0)); + g_autoptr(PigeonExamplePackageExampleHostApiResponseHandle) handle = + pigeon_example_package_example_host_api_response_handle_new( + channel, response_handle); + self->vtable->send_message(message, handle, self->user_data); +} + +void pigeon_example_package_example_host_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const PigeonExamplePackageExampleHostApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + g_autoptr(PigeonExamplePackageExampleHostApi) api_data = + pigeon_example_package_example_host_api_new(vtable, user_data, + user_data_free_func); + + g_autoptr(PigeonExamplePackageMessageCodec) codec = + pigeon_example_package_message_codec_new(); + g_autofree gchar* get_host_language_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi." + "getHostLanguage%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) get_host_language_channel = + fl_basic_message_channel_new(messenger, get_host_language_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + get_host_language_channel, + pigeon_example_package_example_host_api_get_host_language_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* add_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi.add%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) add_channel = fl_basic_message_channel_new( + messenger, add_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + add_channel, pigeon_example_package_example_host_api_add_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* send_message_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi.sendMessage%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) send_message_channel = + fl_basic_message_channel_new(messenger, send_message_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + send_message_channel, + pigeon_example_package_example_host_api_send_message_cb, + g_object_ref(api_data), g_object_unref); +} + +void pigeon_example_package_example_host_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + + g_autoptr(PigeonExamplePackageMessageCodec) codec = + pigeon_example_package_message_codec_new(); + g_autofree gchar* get_host_language_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi." + "getHostLanguage%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) get_host_language_channel = + fl_basic_message_channel_new(messenger, get_host_language_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(get_host_language_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* add_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi.add%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) add_channel = fl_basic_message_channel_new( + messenger, add_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(add_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* send_message_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.ExampleHostApi.sendMessage%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) send_message_channel = + fl_basic_message_channel_new(messenger, send_message_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(send_message_channel, nullptr, + nullptr, nullptr); +} + +void pigeon_example_package_example_host_api_respond_send_message( + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + gboolean return_value) { + g_autoptr(PigeonExamplePackageExampleHostApiSendMessageResponse) response = + pigeon_example_package_example_host_api_send_message_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "ExampleHostApi", + "sendMessage", error->message); + } +} + +void pigeon_example_package_example_host_api_respond_error_send_message( + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(PigeonExamplePackageExampleHostApiSendMessageResponse) response = + pigeon_example_package_example_host_api_send_message_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "ExampleHostApi", + "sendMessage", error->message); + } +} + +struct _PigeonExamplePackageMessageFlutterApi { + GObject parent_instance; + + FlBinaryMessenger* messenger; + gchar* suffix; +}; + +G_DEFINE_TYPE(PigeonExamplePackageMessageFlutterApi, + pigeon_example_package_message_flutter_api, G_TYPE_OBJECT) + +static void pigeon_example_package_message_flutter_api_dispose( + GObject* object) { + PigeonExamplePackageMessageFlutterApi* self = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API(object); + g_clear_object(&self->messenger); + g_clear_pointer(&self->suffix, g_free); + G_OBJECT_CLASS(pigeon_example_package_message_flutter_api_parent_class) + ->dispose(object); +} + +static void pigeon_example_package_message_flutter_api_init( + PigeonExamplePackageMessageFlutterApi* self) {} + +static void pigeon_example_package_message_flutter_api_class_init( + PigeonExamplePackageMessageFlutterApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_message_flutter_api_dispose; +} + +PigeonExamplePackageMessageFlutterApi* +pigeon_example_package_message_flutter_api_new(FlBinaryMessenger* messenger, + const gchar* suffix) { + PigeonExamplePackageMessageFlutterApi* self = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API(g_object_new( + pigeon_example_package_message_flutter_api_get_type(), nullptr)); + self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger)); + self->suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + return self; +} + +struct _PigeonExamplePackageMessageFlutterApiFlutterMethodResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse, + pigeon_example_package_message_flutter_api_flutter_method_response, + G_TYPE_OBJECT) + +static void +pigeon_example_package_message_flutter_api_flutter_method_response_dispose( + GObject* object) { + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + pigeon_example_package_message_flutter_api_flutter_method_response_parent_class) + ->dispose(object); +} + +static void +pigeon_example_package_message_flutter_api_flutter_method_response_init( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) {} + +static void +pigeon_example_package_message_flutter_api_flutter_method_response_class_init( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + pigeon_example_package_message_flutter_api_flutter_method_response_dispose; +} + +static PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* +pigeon_example_package_message_flutter_api_flutter_method_response_new( + FlValue* response) { + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self = + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE(g_object_new( + pigeon_example_package_message_flutter_api_flutter_method_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) { + g_return_val_if_fail( + PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_code( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) { + g_return_val_if_fail( + PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + self), + nullptr); + g_assert( + pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_message( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) { + g_return_val_if_fail( + PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + self), + nullptr); + g_assert( + pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_details( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) { + g_return_val_if_fail( + PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + self), + nullptr); + g_assert( + pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_return_value( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* self) { + g_return_val_if_fail( + PIGEON_EXAMPLE_PACKAGE_IS_MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE( + self), + nullptr); + g_assert( + !pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + self)); + return fl_value_get_string(self->return_value); +} + +static void pigeon_example_package_message_flutter_api_flutter_method_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void pigeon_example_package_message_flutter_api_flutter_method( + PigeonExamplePackageMessageFlutterApi* self, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_string != nullptr ? fl_value_new_string(a_string) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_example_package.MessageFlutterApi." + "flutterMethod%s", + self->suffix); + g_autoptr(PigeonExamplePackageMessageCodec) codec = + pigeon_example_package_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + pigeon_example_package_message_flutter_api_flutter_method_cb, task); +} + +PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* +pigeon_example_package_message_flutter_api_flutter_method_finish( + PigeonExamplePackageMessageFlutterApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return pigeon_example_package_message_flutter_api_flutter_method_response_new( + response); +} diff --git a/packages/pigeon/example/app/linux/messages.g.h b/packages/pigeon/example/app/linux/messages.g.h new file mode 100644 index 000000000000..0f784ab1a1fc --- /dev/null +++ b/packages/pigeon/example/app/linux/messages.g.h @@ -0,0 +1,349 @@ +// 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. +// Autogenerated from Pigeon, do not edit directly. +// See also: https://pub.dev/packages/pigeon + +#ifndef PIGEON_MESSAGES_G_H_ +#define PIGEON_MESSAGES_G_H_ + +#include + +G_BEGIN_DECLS + +/** + * PigeonExamplePackageCode: + * PIGEON_EXAMPLE_PACKAGE_CODE_ONE: + * PIGEON_EXAMPLE_PACKAGE_CODE_TWO: + * + */ +typedef enum { + PIGEON_EXAMPLE_PACKAGE_CODE_ONE = 0, + PIGEON_EXAMPLE_PACKAGE_CODE_TWO = 1 +} PigeonExamplePackageCode; + +/** + * PigeonExamplePackageMessageData: + * + */ + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageMessageData, + pigeon_example_package_message_data, + PIGEON_EXAMPLE_PACKAGE, MESSAGE_DATA, GObject) + +/** + * pigeon_example_package_message_data_new: + * name: field in this object. + * description: field in this object. + * code: field in this object. + * data: field in this object. + * + * Creates a new #MessageData object. + * + * Returns: a new #PigeonExamplePackageMessageData + */ +PigeonExamplePackageMessageData* pigeon_example_package_message_data_new( + const gchar* name, const gchar* description, PigeonExamplePackageCode code, + FlValue* data); + +/** + * pigeon_example_package_message_data_get_name + * @object: a #PigeonExamplePackageMessageData. + * + * Gets the value of the name field of @object. + * + * Returns: the field value. + */ +const gchar* pigeon_example_package_message_data_get_name( + PigeonExamplePackageMessageData* object); + +/** + * pigeon_example_package_message_data_get_description + * @object: a #PigeonExamplePackageMessageData. + * + * Gets the value of the description field of @object. + * + * Returns: the field value. + */ +const gchar* pigeon_example_package_message_data_get_description( + PigeonExamplePackageMessageData* object); + +/** + * pigeon_example_package_message_data_get_code + * @object: a #PigeonExamplePackageMessageData. + * + * Gets the value of the code field of @object. + * + * Returns: the field value. + */ +PigeonExamplePackageCode pigeon_example_package_message_data_get_code( + PigeonExamplePackageMessageData* object); + +/** + * pigeon_example_package_message_data_get_data + * @object: a #PigeonExamplePackageMessageData. + * + * Gets the value of the data field of @object. + * + * Returns: the field value. + */ +FlValue* pigeon_example_package_message_data_get_data( + PigeonExamplePackageMessageData* object); + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageExampleHostApiResponseHandle, + pigeon_example_package_example_host_api_response_handle, + PIGEON_EXAMPLE_PACKAGE, EXAMPLE_HOST_API_RESPONSE_HANDLE, + GObject) + +G_DECLARE_FINAL_TYPE( + PigeonExamplePackageExampleHostApiGetHostLanguageResponse, + pigeon_example_package_example_host_api_get_host_language_response, + PIGEON_EXAMPLE_PACKAGE, EXAMPLE_HOST_API_GET_HOST_LANGUAGE_RESPONSE, + GObject) + +/** + * pigeon_example_package_example_host_api_get_host_language_response_new: + * + * Creates a new response to ExampleHostApi.getHostLanguage. + * + * Returns: a new #PigeonExamplePackageExampleHostApiGetHostLanguageResponse + */ +PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +pigeon_example_package_example_host_api_get_host_language_response_new( + const gchar* return_value); + +/** + * pigeon_example_package_example_host_api_get_host_language_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to ExampleHostApi.getHostLanguage. + * + * Returns: a new #PigeonExamplePackageExampleHostApiGetHostLanguageResponse + */ +PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +pigeon_example_package_example_host_api_get_host_language_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageExampleHostApiAddResponse, + pigeon_example_package_example_host_api_add_response, + PIGEON_EXAMPLE_PACKAGE, EXAMPLE_HOST_API_ADD_RESPONSE, + GObject) + +/** + * pigeon_example_package_example_host_api_add_response_new: + * + * Creates a new response to ExampleHostApi.add. + * + * Returns: a new #PigeonExamplePackageExampleHostApiAddResponse + */ +PigeonExamplePackageExampleHostApiAddResponse* +pigeon_example_package_example_host_api_add_response_new(int64_t return_value); + +/** + * pigeon_example_package_example_host_api_add_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to ExampleHostApi.add. + * + * Returns: a new #PigeonExamplePackageExampleHostApiAddResponse + */ +PigeonExamplePackageExampleHostApiAddResponse* +pigeon_example_package_example_host_api_add_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +/** + * PigeonExamplePackageExampleHostApiVTable: + * + * Table of functions exposed by ExampleHostApi to be implemented by the API + * provider. + */ +typedef struct { + PigeonExamplePackageExampleHostApiGetHostLanguageResponse* ( + *get_host_language)(gpointer user_data); + PigeonExamplePackageExampleHostApiAddResponse* (*add)(int64_t a, int64_t b, + gpointer user_data); + void (*send_message)( + PigeonExamplePackageMessageData* message, + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + gpointer user_data); +} PigeonExamplePackageExampleHostApiVTable; + +/** + * pigeon_example_package_example_host_api_set_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * @vtable: implementations of the methods in this API. + * @user_data: (closure): user data to pass to the functions in @vtable. + * @user_data_free_func: (allow-none): a function which gets called to free + * @user_data, or %NULL. + * + * Connects the method handlers in the ExampleHostApi API. + */ +void pigeon_example_package_example_host_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const PigeonExamplePackageExampleHostApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func); + +/** + * pigeon_example_package_example_host_api_clear_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Clears the method handlers in the ExampleHostApi API. + */ +void pigeon_example_package_example_host_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix); + +/** + * pigeon_example_package_example_host_api_respond_send_message: + * @response_handle: a #PigeonExamplePackageExampleHostApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to ExampleHostApi.sendMessage. + */ +void pigeon_example_package_example_host_api_respond_send_message( + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + gboolean return_value); + +/** + * pigeon_example_package_example_host_api_respond_error_send_message: + * @response_handle: a #PigeonExamplePackageExampleHostApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to ExampleHostApi.sendMessage. + */ +void pigeon_example_package_example_host_api_respond_error_send_message( + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse, + pigeon_example_package_message_flutter_api_flutter_method_response, + PIGEON_EXAMPLE_PACKAGE, MESSAGE_FLUTTER_API_FLUTTER_METHOD_RESPONSE, + GObject) + +/** + * pigeon_example_package_message_flutter_api_flutter_method_response_is_error: + * @response: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse. + * + * Checks if a response to MessageFlutterApi.flutterMethod is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +pigeon_example_package_message_flutter_api_flutter_method_response_is_error( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* response); + +/** + * pigeon_example_package_message_flutter_api_flutter_method_response_get_error_code: + * @response: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_code( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* response); + +/** + * pigeon_example_package_message_flutter_api_flutter_method_response_get_error_message: + * @response: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_message( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* response); + +/** + * pigeon_example_package_message_flutter_api_flutter_method_response_get_error_details: + * @response: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +pigeon_example_package_message_flutter_api_flutter_method_response_get_error_details( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* response); + +/** + * pigeon_example_package_message_flutter_api_flutter_method_response_get_return_value: + * @response: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +const gchar* +pigeon_example_package_message_flutter_api_flutter_method_response_get_return_value( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* response); + +/** + * PigeonExamplePackageMessageFlutterApi: + * + */ + +G_DECLARE_FINAL_TYPE(PigeonExamplePackageMessageFlutterApi, + pigeon_example_package_message_flutter_api, + PIGEON_EXAMPLE_PACKAGE, MESSAGE_FLUTTER_API, GObject) + +/** + * pigeon_example_package_message_flutter_api_new: + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Creates a new object to access the MessageFlutterApi API. + * + * Returns: a new #PigeonExamplePackageMessageFlutterApi + */ +PigeonExamplePackageMessageFlutterApi* +pigeon_example_package_message_flutter_api_new(FlBinaryMessenger* messenger, + const gchar* suffix); + +/** + * pigeon_example_package_message_flutter_api_flutter_method: + * @api: a #PigeonExamplePackageMessageFlutterApi. + * @a_string: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + */ +void pigeon_example_package_message_flutter_api_flutter_method( + PigeonExamplePackageMessageFlutterApi* api, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * pigeon_example_package_message_flutter_api_flutter_method_finish: + * @api: a #PigeonExamplePackageMessageFlutterApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a pigeon_example_package_message_flutter_api_flutter_method() call. + * + * Returns: a #PigeonExamplePackageMessageFlutterApiFlutterMethodResponse or + * %NULL on error. + */ +PigeonExamplePackageMessageFlutterApiFlutterMethodResponse* +pigeon_example_package_message_flutter_api_flutter_method_finish( + PigeonExamplePackageMessageFlutterApi* api, GAsyncResult* result, + GError** error); + +G_END_DECLS + +#endif // PIGEON_MESSAGES_G_H_ diff --git a/packages/pigeon/example/app/linux/my_application.cc b/packages/pigeon/example/app/linux/my_application.cc new file mode 100644 index 000000000000..812b96a8ceec --- /dev/null +++ b/packages/pigeon/example/app/linux/my_application.cc @@ -0,0 +1,187 @@ +// 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. + +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" +#include "messages.g.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; + + PigeonExamplePackageMessageFlutterApi* flutter_api; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// #docregion vtable +static PigeonExamplePackageExampleHostApiGetHostLanguageResponse* +handle_get_host_language(gpointer user_data) { + return pigeon_example_package_example_host_api_get_host_language_response_new( + "C++"); +} + +static PigeonExamplePackageExampleHostApiAddResponse* handle_add( + int64_t a, int64_t b, gpointer user_data) { + if (a < 0 || b < 0) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + return pigeon_example_package_example_host_api_add_response_new_error( + "code", "message", details); + } + + return pigeon_example_package_example_host_api_add_response_new(a + b); +} + +static void handle_send_message( + PigeonExamplePackageMessageData* message, + PigeonExamplePackageExampleHostApiResponseHandle* response_handle, + gpointer user_data) { + PigeonExamplePackageCode code = + pigeon_example_package_message_data_get_code(message); + if (code == PIGEON_EXAMPLE_PACKAGE_CODE_ONE) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + pigeon_example_package_example_host_api_respond_error_send_message( + response_handle, "code", "message", details); + return; + } + + pigeon_example_package_example_host_api_respond_send_message(response_handle, + TRUE); +} + +static PigeonExamplePackageExampleHostApiVTable example_host_api_vtable = { + .get_host_language = handle_get_host_language, + .add = handle_add, + .send_message = handle_send_message}; +// #enddocregion vtable + +// #docregion flutter-method-callback +static void flutter_method_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(GError) error = nullptr; + g_autoptr( + PigeonExamplePackageMessageFlutterApiFlutterMethodResponse) response = + pigeon_example_package_message_flutter_api_flutter_method_finish( + PIGEON_EXAMPLE_PACKAGE_MESSAGE_FLUTTER_API(object), result, &error); + if (response == nullptr) { + g_warning("Failed to call Flutter method: %s", error->message); + return; + } + + g_printerr( + "Got result from Flutter method: %s\n", + pigeon_example_package_message_flutter_api_flutter_method_response_get_return_value( + response)); +} +// #enddocregion flutter-method-callback + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "pigeon_example_app"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "pigeon_example_app"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments( + project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + FlBinaryMessenger* messenger = + fl_engine_get_binary_messenger(fl_view_get_engine(view)); + pigeon_example_package_example_host_api_set_method_handlers( + messenger, nullptr, &example_host_api_vtable, self, nullptr); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); + + // #docregion flutter-method + self->flutter_api = + pigeon_example_package_message_flutter_api_new(messenger, nullptr); + pigeon_example_package_message_flutter_api_flutter_method( + self->flutter_api, "hello", nullptr, flutter_method_cb, self); + // #enddocregion flutter-method +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, + gchar*** arguments, + int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = + my_application_local_command_line; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, "flags", + G_APPLICATION_NON_UNIQUE, nullptr)); +} diff --git a/packages/pigeon/example/app/linux/my_application.h b/packages/pigeon/example/app/linux/my_application.h new file mode 100644 index 000000000000..6e9f0c3ff665 --- /dev/null +++ b/packages/pigeon/example/app/linux/my_application.h @@ -0,0 +1,22 @@ +// 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 FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/packages/pigeon/example/app/pigeons/messages.dart b/packages/pigeon/example/app/pigeons/messages.dart index da66c0e8553d..8c18cc87e81d 100644 --- a/packages/pigeon/example/app/pigeons/messages.dart +++ b/packages/pigeon/example/app/pigeons/messages.dart @@ -11,6 +11,9 @@ import 'package:pigeon/pigeon.dart'; cppOptions: CppOptions(namespace: 'pigeon_example'), cppHeaderOut: 'windows/runner/messages.g.h', cppSourceOut: 'windows/runner/messages.g.cpp', + gobjectHeaderOut: 'linux/messages.g.h', + gobjectSourceOut: 'linux/messages.g.cc', + gobjectOptions: GObjectOptions(), kotlinOut: 'android/app/src/main/kotlin/dev/flutter/pigeon_example_app/Messages.g.kt', kotlinOptions: KotlinOptions(), diff --git a/packages/pigeon/lib/generator_tools.dart b/packages/pigeon/lib/generator_tools.dart index 6b83633d68da..8771001ca6a9 100644 --- a/packages/pigeon/lib/generator_tools.dart +++ b/packages/pigeon/lib/generator_tools.dart @@ -13,7 +13,7 @@ import 'ast.dart'; /// The current version of pigeon. /// /// This must match the version in pubspec.yaml. -const String pigeonVersion = '21.0.0'; +const String pigeonVersion = '21.1.0'; /// Prefix for all local variables in methods. /// diff --git a/packages/pigeon/lib/gobject_generator.dart b/packages/pigeon/lib/gobject_generator.dart new file mode 100644 index 000000000000..bee03804f53b --- /dev/null +++ b/packages/pigeon/lib/gobject_generator.dart @@ -0,0 +1,2109 @@ +// 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. + +import 'ast.dart'; +import 'generator.dart'; +import 'generator_tools.dart'; + +/// Documentation comment spec. +const DocumentCommentSpecification _docCommentSpec = + DocumentCommentSpecification('/**', + closeCommentToken: ' */', blockContinuationToken: ' *'); + +/// Name for codec class. +const String _codecBaseName = 'MessageCodec'; + +/// Options that control how GObject code will be generated. +class GObjectOptions { + /// Creates a [GObjectOptions] object + const GObjectOptions({ + this.headerIncludePath, + this.module, + this.copyrightHeader, + this.headerOutPath, + }); + + /// The path to the header that will get placed in the source filed (example: + /// "foo.h"). + final String? headerIncludePath; + + /// The module where the generated class will live. + final String? module; + + /// A copyright header that will get prepended to generated code. + final Iterable? copyrightHeader; + + /// The path to the output header file location. + final String? headerOutPath; + + /// Creates a [GObjectOptions] from a Map representation where: + /// `x = GObjectOptions.fromMap(x.toMap())`. + static GObjectOptions fromMap(Map map) { + final Iterable? copyrightHeader = + map['copyrightHeader'] as Iterable?; + return GObjectOptions( + headerIncludePath: map['header'] as String?, + module: map['module'] as String?, + copyrightHeader: copyrightHeader?.cast(), + headerOutPath: map['gobjectHeaderOut'] as String?, + ); + } + + /// Converts a [GObjectOptions] to a Map representation where: + /// `x = GObjectOptions.fromMap(x.toMap())`. + Map toMap() { + final Map result = { + if (headerIncludePath != null) 'header': headerIncludePath!, + if (module != null) 'module': module!, + if (copyrightHeader != null) 'copyrightHeader': copyrightHeader!, + }; + return result; + } + + /// Overrides any non-null parameters from [options] into this to make a new + /// [GObjectOptions]. + GObjectOptions merge(GObjectOptions options) { + return GObjectOptions.fromMap(mergeMaps(toMap(), options.toMap())); + } +} + +/// Class that manages all GObject code generation. +class GObjectGenerator extends Generator> { + /// Constructor. + const GObjectGenerator(); + + /// Generates GObject file of type specified in [generatorOptions] + @override + void generate( + OutputFileOptions generatorOptions, + Root root, + StringSink sink, { + required String dartPackageName, + }) { + assert(generatorOptions.fileType == FileType.header || + generatorOptions.fileType == FileType.source); + if (generatorOptions.fileType == FileType.header) { + const GObjectHeaderGenerator().generate( + generatorOptions.languageOptions, + root, + sink, + dartPackageName: dartPackageName, + ); + } else if (generatorOptions.fileType == FileType.source) { + const GObjectSourceGenerator().generate( + generatorOptions.languageOptions, + root, + sink, + dartPackageName: dartPackageName, + ); + } + } +} + +/// Writes GObject header (.h) file to sink. +class GObjectHeaderGenerator extends StructuredGenerator { + /// Constructor. + const GObjectHeaderGenerator(); + + @override + void writeFilePrologue( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + if (generatorOptions.copyrightHeader != null) { + addLines(indent, generatorOptions.copyrightHeader!, linePrefix: '// '); + } + indent.writeln('// ${getGeneratedCodeWarning()}'); + indent.writeln('// $seeAlsoWarning'); + } + + @override + void writeFileImports( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + indent.newln(); + final String guardName = _getGuardName(generatorOptions.headerIncludePath); + indent.writeln('#ifndef $guardName'); + indent.writeln('#define $guardName'); + + indent.newln(); + indent.writeln('#include '); + } + + @override + void writeOpenNamespace( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + indent.newln(); + indent.writeln('G_BEGIN_DECLS'); + } + + @override + void writeEnum( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Enum anEnum, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String enumName = _getClassName(module, anEnum.name); + + indent.newln(); + final List enumValueCommentLines = []; + for (int i = 0; i < anEnum.members.length; i++) { + final EnumMember member = anEnum.members[i]; + final String itemName = + _getEnumValue(dartPackageName, anEnum.name, member.name); + enumValueCommentLines.add('$itemName:'); + enumValueCommentLines.addAll(member.documentationComments); + } + addDocumentationComments( + indent, + [ + '$enumName:', + ...enumValueCommentLines, + '', + ...anEnum.documentationComments + ], + _docCommentSpec); + indent.writeScoped('typedef enum {', '} $enumName;', () { + for (int i = 0; i < anEnum.members.length; i++) { + final EnumMember member = anEnum.members[i]; + final String itemName = + _getEnumValue(dartPackageName, anEnum.name, member.name); + indent.writeln( + '$itemName = $i${i == anEnum.members.length - 1 ? '' : ','}'); + } + }); + } + + @override + void writeDataClass( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Class classDefinition, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String className = _getClassName(module, classDefinition.name); + final String methodPrefix = _getMethodPrefix(module, classDefinition.name); + + indent.newln(); + addDocumentationComments( + indent, + [ + '$className:', + '', + ...classDefinition.documentationComments, + ], + _docCommentSpec); + + indent.newln(); + _writeDeclareFinalType(indent, module, classDefinition.name); + + indent.newln(); + final List constructorArgs = []; + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String type = _getType(module, field.type); + constructorArgs.add('$type $fieldName'); + if (_isNumericListType(field.type)) { + constructorArgs.add('size_t ${fieldName}_length'); + } + } + final List constructorFieldCommentLines = []; + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + constructorFieldCommentLines.add('$fieldName: field in this object.'); + if (_isNumericListType(field.type)) { + constructorFieldCommentLines + .add('${fieldName}_length: length of @$fieldName.'); + } + } + addDocumentationComments( + indent, + [ + '${methodPrefix}_new:', + ...constructorFieldCommentLines, + '', + 'Creates a new #${classDefinition.name} object.', + '', + 'Returns: a new #$className', + ], + _docCommentSpec); + + indent.writeln( + "$className* ${methodPrefix}_new(${constructorArgs.join(', ')});"); + + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String returnType = _getType(module, field.type); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${methodPrefix}_get_$fieldName', + '@object: a #$className.', + if (_isNumericListType(field.type)) + '@length: location to write the length of this value.', + '', + if (field.documentationComments.isNotEmpty) + ...field.documentationComments + else + 'Gets the value of the ${field.name} field of @object.', + '', + 'Returns: the field value.', + ], + _docCommentSpec); + final List getterArgs = [ + '$className* object', + if (_isNumericListType(field.type)) 'size_t* length' + ]; + indent.writeln( + '$returnType ${methodPrefix}_get_$fieldName(${getterArgs.join(', ')});'); + } + } + + @override + void writeGeneralCodec( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) {} + + @override + void writeFlutterApi( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Api api, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String className = _getClassName(module, api.name); + + for (final Method method in api.methods) { + _writeFlutterApiRespondClass(indent, module, api, method); + } + + final String methodPrefix = _getMethodPrefix(module, api.name); + indent.newln(); + addDocumentationComments( + indent, + [ + '$className:', + '', + ...api.documentationComments, + ], + _docCommentSpec); + + indent.newln(); + _writeDeclareFinalType(indent, module, api.name); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${methodPrefix}_new:', + '@messenger: an #FlBinaryMessenger.', + '@suffix: (allow-none): a suffix to add to the API or %NULL for none.', + '', + 'Creates a new object to access the ${api.name} API.', + '', + 'Returns: a new #$className', + ], + _docCommentSpec); + indent.writeln( + '$className* ${methodPrefix}_new(FlBinaryMessenger* messenger, const gchar* suffix);'); + + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + + final List asyncArgs = ['$className* api']; + for (final Parameter param in method.parameters) { + final String paramName = _snakeCaseFromCamelCase(param.name); + asyncArgs.add('${_getType(module, param.type)} $paramName'); + if (_isNumericListType(param.type)) { + asyncArgs.add('size_t ${paramName}_length'); + } + } + asyncArgs.addAll([ + 'GCancellable* cancellable', + 'GAsyncReadyCallback callback', + 'gpointer user_data' + ]); + indent.newln(); + final List methodParameterCommentLines = []; + for (final Parameter param in method.parameters) { + final String paramName = _snakeCaseFromCamelCase(param.name); + methodParameterCommentLines.add( + '@$paramName: ${param.type.isNullable ? '(allow-none): ' : ''}parameter for this method.'); + if (_isNumericListType(param.type)) { + methodParameterCommentLines + .add('@${paramName}_length: length of $paramName.'); + } + } + addDocumentationComments( + indent, + [ + '${methodPrefix}_$methodName:', + '@api: a #$className.', + ...methodParameterCommentLines, + '@cancellable: (allow-none): a #GCancellable or %NULL.', + '@callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when the call is complete or %NULL to ignore the response.', + '@user_data: (closure): user data to pass to @callback.', + '', + ...method.documentationComments + ], + _docCommentSpec); + indent.writeln( + "void ${methodPrefix}_$methodName(${asyncArgs.join(', ')});"); + + final List finishArgs = [ + '$className* api', + 'GAsyncResult* result', + 'GError** error' + ]; + indent.newln(); + addDocumentationComments( + indent, + [ + '${methodPrefix}_${methodName}_finish:', + '@api: a #$className.', + '@result: a #GAsyncResult.', + '@error: (allow-none): #GError location to store the error occurring, or %NULL to ignore.', + '', + 'Completes a ${methodPrefix}_$methodName() call.', + '', + 'Returns: a #$responseClassName or %NULL on error.', + ], + _docCommentSpec); + indent.writeln( + "$responseClassName* ${methodPrefix}_${methodName}_finish(${finishArgs.join(', ')});"); + } + } + + // Write the API response classes. + void _writeFlutterApiRespondClass( + Indent indent, String module, Api api, Method method) { + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + final String responseMethodPrefix = _getMethodPrefix(module, responseName); + final String primitiveType = + _getType(module, method.returnType, primitive: true); + + indent.newln(); + _writeDeclareFinalType(indent, module, responseName); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_is_error:', + '@response: a #$responseClassName.', + '', + 'Checks if a response to ${api.name}.${method.name} is an error.', + '', + 'Returns: a %TRUE if this response is an error.', + ], + _docCommentSpec); + indent.writeln( + 'gboolean ${responseMethodPrefix}_is_error($responseClassName* response);'); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_get_error_code:', + '@response: a #$responseClassName.', + '', + 'Get the error code for this response.', + '', + 'Returns: an error code or %NULL if not an error.', + ], + _docCommentSpec); + indent.writeln( + 'const gchar* ${responseMethodPrefix}_get_error_code($responseClassName* response);'); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_get_error_message:', + '@response: a #$responseClassName.', + '', + 'Get the error message for this response.', + '', + 'Returns: an error message.', + ], + _docCommentSpec); + indent.writeln( + 'const gchar* ${responseMethodPrefix}_get_error_message($responseClassName* response);'); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_get_error_details:', + '@response: a #$responseClassName.', + '', + 'Get the error details for this response.', + '', + 'Returns: (allow-none): an error details or %NULL.', + ], + _docCommentSpec); + indent.writeln( + 'FlValue* ${responseMethodPrefix}_get_error_details($responseClassName* response);'); + + if (!method.returnType.isVoid) { + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_get_return_value:', + '@response: a #$responseClassName.', + if (_isNumericListType(method.returnType)) + '@return_value_length: (allow-none): location to write length of the return value or %NULL to ignore.', + '', + 'Get the return value for this response.', + '', + if (method.returnType.isNullable) + 'Returns: (allow-none): a return value or %NULL.' + else + 'Returns: a return value.', + ], + _docCommentSpec); + final String returnType = _isNullablePrimitiveType(method.returnType) + ? '$primitiveType*' + : primitiveType; + indent.writeln( + '$returnType ${responseMethodPrefix}_get_return_value($responseClassName* response${_isNumericListType(method.returnType) ? ', size_t* return_value_length' : ''});'); + } + } + + @override + void writeHostApi( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Api api, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String methodPrefix = _getMethodPrefix(module, api.name); + final String vtableName = _getVTableName(module, api.name); + + final bool hasAsyncMethod = + api.methods.any((Method method) => method.isAsynchronous); + if (hasAsyncMethod) { + indent.newln(); + _writeDeclareFinalType(indent, module, '${api.name}ResponseHandle'); + } + + for (final Method method + in api.methods.where((Method method) => !method.isAsynchronous)) { + _writeHostApiRespondClass(indent, module, api, method); + } + + indent.newln(); + _writeApiVTable(indent, module, api); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${methodPrefix}_set_method_handlers:', + '', + '@messenger: an #FlBinaryMessenger.', + '@suffix: (allow-none): a suffix to add to the API or %NULL for none.', + '@vtable: implementations of the methods in this API.', + '@user_data: (closure): user data to pass to the functions in @vtable.', + '@user_data_free_func: (allow-none): a function which gets called to free @user_data, or %NULL.', + '', + 'Connects the method handlers in the ${api.name} API.', + ], + _docCommentSpec); + indent.writeln( + 'void ${methodPrefix}_set_method_handlers(FlBinaryMessenger* messenger, const gchar* suffix, const $vtableName* vtable, gpointer user_data, GDestroyNotify user_data_free_func);'); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${methodPrefix}_clear_method_handlers:', + '', + '@messenger: an #FlBinaryMessenger.', + '@suffix: (allow-none): a suffix to add to the API or %NULL for none.', + '', + 'Clears the method handlers in the ${api.name} API.', + ], + _docCommentSpec); + indent.writeln( + 'void ${methodPrefix}_clear_method_handlers(FlBinaryMessenger* messenger, const gchar* suffix);'); + + for (final Method method + in api.methods.where((Method method) => method.isAsynchronous)) { + _writeHostApiRespondFunctionPrototype(indent, module, api, method); + } + } + + // Write the API response classes. + void _writeHostApiRespondClass( + Indent indent, String module, Api api, Method method) { + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + final String responseMethodPrefix = _getMethodPrefix(module, responseName); + + indent.newln(); + _writeDeclareFinalType(indent, module, responseName); + + final String returnType = _getType(module, method.returnType); + indent.newln(); + final List constructorArgs = [ + if (returnType != 'void') '$returnType return_value', + if (_isNumericListType(method.returnType)) 'size_t return_value_length' + ]; + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_new:', + '', + 'Creates a new response to ${api.name}.${method.name}.', + '', + 'Returns: a new #$responseClassName', + ], + _docCommentSpec); + indent.writeln( + '$responseClassName* ${responseMethodPrefix}_new(${constructorArgs.join(', ')});'); + + indent.newln(); + addDocumentationComments( + indent, + [ + '${responseMethodPrefix}_new_error:', + '@code: error code.', + '@message: error message.', + '@details: (allow-none): error details or %NULL.', + '', + 'Creates a new error response to ${api.name}.${method.name}.', + '', + 'Returns: a new #$responseClassName', + ], + _docCommentSpec); + indent.writeln( + '$responseClassName* ${responseMethodPrefix}_new_error(const gchar* code, const gchar* message, FlValue* details);'); + } + + // Write the vtable for an API. + void _writeApiVTable(Indent indent, String module, Api api) { + final String className = _getClassName(module, api.name); + final String vtableName = _getVTableName(module, api.name); + + addDocumentationComments( + indent, + [ + '$vtableName:', + '', + 'Table of functions exposed by ${api.name} to be implemented by the API provider.', + ], + _docCommentSpec); + indent.writeScoped('typedef struct {', '} $vtableName;', () { + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + + final List methodArgs = []; + for (final Parameter param in method.parameters) { + final String name = _snakeCaseFromCamelCase(param.name); + methodArgs.add('${_getType(module, param.type)} $name'); + if (_isNumericListType(param.type)) { + methodArgs.add('size_t ${name}_length'); + } + } + methodArgs.addAll([ + if (method.isAsynchronous) + '${className}ResponseHandle* response_handle', + 'gpointer user_data', + ]); + final String returnType = + method.isAsynchronous ? 'void' : '$responseClassName*'; + indent.writeln("$returnType (*$methodName)(${methodArgs.join(', ')});"); + } + }); + } + + // Write the function prototype for an API method response. + void _writeHostApiRespondFunctionPrototype( + Indent indent, String module, Api api, Method method) { + final String className = _getClassName(module, api.name); + final String methodPrefix = _getMethodPrefix(module, api.name); + final String methodName = _getMethodName(method.name); + final String returnType = _getType(module, method.returnType); + + indent.newln(); + final List respondArgs = [ + '${className}ResponseHandle* response_handle', + if (returnType != 'void') '$returnType return_value', + if (_isNumericListType(method.returnType)) 'size_t return_value_length' + ]; + addDocumentationComments( + indent, + [ + '${methodPrefix}_respond_$methodName:', + '@response_handle: a #${className}ResponseHandle.', + if (returnType != 'void') + '@return_value: location to write the value returned by this method.', + if (_isNumericListType(method.returnType)) + '@return_value_length: (allow-none): location to write length of @return_value or %NULL to ignore.', + '', + 'Responds to ${api.name}.${method.name}. ', + ], + _docCommentSpec); + indent.writeln( + "void ${methodPrefix}_respond_$methodName(${respondArgs.join(', ')});"); + + indent.newln(); + final List respondErrorArgs = [ + '${className}ResponseHandle* response_handle', + 'const gchar* code', + 'const gchar* message', + 'FlValue* details' + ]; + addDocumentationComments( + indent, + [ + '${methodPrefix}_respond_error_$methodName:', + '@response_handle: a #${className}ResponseHandle.', + '@code: error code.', + '@message: error message.', + '@details: (allow-none): error details or %NULL.', + '', + 'Responds with an error to ${api.name}.${method.name}. ', + ], + _docCommentSpec); + indent.writeln( + "void ${methodPrefix}_respond_error_$methodName(${respondErrorArgs.join(', ')});"); + } + + @override + void writeCloseNamespace( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + indent.newln(); + indent.writeln('G_END_DECLS'); + + indent.newln(); + final String guardName = _getGuardName(generatorOptions.headerIncludePath); + indent.writeln('#endif // $guardName'); + } +} + +/// Writes GObject source (.cc) file to sink. +class GObjectSourceGenerator extends StructuredGenerator { + /// Constructor. + const GObjectSourceGenerator(); + + @override + void writeFilePrologue( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + if (generatorOptions.copyrightHeader != null) { + addLines(indent, generatorOptions.copyrightHeader!, linePrefix: '// '); + } + indent.writeln('// ${getGeneratedCodeWarning()}'); + indent.writeln('// $seeAlsoWarning'); + } + + @override + void writeFileImports( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + indent.newln(); + indent.writeln('#include "${generatorOptions.headerIncludePath}"'); + } + + @override + void writeDataClass( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Class classDefinition, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String snakeModule = _snakeCaseFromCamelCase(module); + final String className = _getClassName(module, classDefinition.name); + final String snakeClassName = _snakeCaseFromCamelCase(classDefinition.name); + + final String methodPrefix = _getMethodPrefix(module, classDefinition.name); + final String testMacro = '${snakeModule}_IS_$snakeClassName'.toUpperCase(); + + indent.newln(); + _writeObjectStruct(indent, module, classDefinition.name, () { + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String fieldType = _getType(module, field.type, isOutput: true); + indent.writeln('$fieldType $fieldName;'); + if (_isNumericListType(field.type)) { + indent.writeln('size_t ${fieldName}_length;'); + } + } + }); + + indent.newln(); + _writeDefineType(indent, module, classDefinition.name); + + indent.newln(); + _writeDispose(indent, module, classDefinition.name, () { + bool haveSelf = false; + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String? clear = _getClearFunction(field.type, 'self->$fieldName'); + if (clear != null) { + if (!haveSelf) { + _writeCastSelf(indent, module, classDefinition.name, 'object'); + haveSelf = true; + } + indent.writeln('$clear;'); + } + } + }); + + indent.newln(); + _writeInit(indent, module, classDefinition.name, () {}); + + indent.newln(); + _writeClassInit(indent, module, classDefinition.name, () {}); + + final List constructorArgs = []; + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + constructorArgs.add('${_getType(module, field.type)} $fieldName'); + if (_isNumericListType(field.type)) { + constructorArgs.add('size_t ${fieldName}_length'); + } + } + indent.newln(); + indent.writeScoped( + "$className* ${methodPrefix}_new(${constructorArgs.join(', ')}) {", '}', + () { + _writeObjectNew(indent, module, classDefinition.name); + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String value = _referenceValue(module, field.type, fieldName, + lengthVariableName: '${fieldName}_length'); + + if (_isNullablePrimitiveType(field.type)) { + final String primitiveType = + _getType(module, field.type, primitive: true); + indent.writeScoped('if ($value != nullptr) {', '}', () { + indent.writeln( + 'self->$fieldName = static_cast<$primitiveType*>(malloc(sizeof($primitiveType)));'); + indent.writeln('*self->$fieldName = *$value;'); + }); + indent.writeScoped('else {', '}', () { + indent.writeln('self->$fieldName = nullptr;'); + }); + } else if (field.type.isNullable) { + indent.writeScoped('if ($fieldName != nullptr) {', '}', () { + indent.writeln('self->$fieldName = $value;'); + if (_isNumericListType(field.type)) { + indent + .writeln('self->${fieldName}_length = ${fieldName}_length;'); + } + }); + indent.writeScoped('else {', '}', () { + indent.writeln('self->$fieldName = nullptr;'); + if (_isNumericListType(field.type)) { + indent.writeln('self->${fieldName}_length = 0;'); + } + }); + } else { + indent.writeln('self->$fieldName = $value;'); + if (_isNumericListType(field.type)) { + indent.writeln('self->${fieldName}_length = ${fieldName}_length;'); + } + } + } + indent.writeln('return self;'); + }); + + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + final String returnType = _getType(module, field.type); + + indent.newln(); + final List getterArgs = [ + '$className* self', + if (_isNumericListType(field.type)) 'size_t* length' + ]; + indent.writeScoped( + '$returnType ${methodPrefix}_get_$fieldName(${getterArgs.join(', ')}) {', + '}', () { + indent.writeln( + 'g_return_val_if_fail($testMacro(self), ${_getDefaultValue(module, field.type)});'); + if (_isNumericListType(field.type)) { + indent.writeln('*length = self->${fieldName}_length;'); + } + indent.writeln('return self->$fieldName;'); + }); + } + + indent.newln(); + indent.writeScoped( + 'static FlValue* ${methodPrefix}_to_list($className* self) {', '}', () { + indent.writeln('FlValue* values = fl_value_new_list();'); + for (final NamedType field in classDefinition.fields) { + final String fieldName = _getFieldName(field.name); + indent.writeln( + 'fl_value_append_take(values, ${_makeFlValue(root, module, field.type, 'self->$fieldName', lengthVariableName: 'self->${fieldName}_length')});'); + } + indent.writeln('return values;'); + }); + + indent.newln(); + indent.writeScoped( + 'static $className* ${methodPrefix}_new_from_list(FlValue* values) {', + '}', () { + final List args = []; + for (int i = 0; i < classDefinition.fields.length; i++) { + final NamedType field = classDefinition.fields[i]; + final String fieldName = _getFieldName(field.name); + final String fieldType = _getType(module, field.type); + final String fieldValue = _fromFlValue(module, field.type, 'value$i'); + indent + .writeln('FlValue* value$i = fl_value_get_list_value(values, $i);'); + args.add(fieldName); + if (_isNullablePrimitiveType(field.type)) { + indent.writeln('$fieldType $fieldName = nullptr;'); + indent.writeln( + '${_getType(module, field.type, isOutput: true, primitive: true)} ${fieldName}_value;'); + indent.writeScoped( + 'if (fl_value_get_type(value$i) != FL_VALUE_TYPE_NULL) {', '}', + () { + indent.writeln('${fieldName}_value = $fieldValue;'); + indent.writeln('$fieldName = &${fieldName}_value;'); + }); + } else if (field.type.isNullable) { + indent.writeln('$fieldType $fieldName = nullptr;'); + if (_isNumericListType(field.type)) { + indent.writeln('size_t ${fieldName}_length = 0;'); + args.add('${fieldName}_length'); + } + indent.writeScoped( + 'if (fl_value_get_type(value$i) != FL_VALUE_TYPE_NULL) {', '}', + () { + indent.writeln('$fieldName = $fieldValue;'); + if (_isNumericListType(field.type)) { + indent.writeln( + '${fieldName}_length = fl_value_get_length(value$i);'); + } + }); + } else { + indent.writeln('$fieldType $fieldName = $fieldValue;'); + if (_isNumericListType(field.type)) { + indent.writeln( + 'size_t ${fieldName}_length = fl_value_get_length(value$i);'); + args.add('${fieldName}_length'); + } + } + } + indent.writeln('return ${methodPrefix}_new(${args.join(', ')});'); + }); + } + + @override + void writeGeneralCodec( + GObjectOptions generatorOptions, + Root root, + Indent indent, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String codecClassName = _getClassName(module, _codecBaseName); + final String codecMethodPrefix = _getMethodPrefix(module, _codecBaseName); + + final Iterable customTypes = getEnumeratedTypes(root); + + indent.newln(); + _writeDeclareFinalType(indent, module, _codecBaseName, + parentClassName: 'FlStandardMessageCodec'); + + indent.newln(); + _writeObjectStruct(indent, module, _codecBaseName, () {}, + parentClassName: 'FlStandardMessageCodec'); + + indent.newln(); + _writeDefineType(indent, module, _codecBaseName, + parentType: 'fl_standard_message_codec_get_type()'); + + for (final EnumeratedType customType in customTypes) { + final String customTypeName = _getClassName(module, customType.name); + final String snakeCustomTypeName = + _snakeCaseFromCamelCase(customTypeName); + indent.newln(); + final String valueType = customType.type == CustomTypes.customClass + ? '$customTypeName*' + : 'FlValue*'; + indent.writeScoped( + 'static gboolean ${codecMethodPrefix}_write_$snakeCustomTypeName(FlStandardMessageCodec* codec, GByteArray* buffer, $valueType value, GError** error) {', + '}', () { + indent.writeln('uint8_t type = ${customType.enumeration};'); + indent.writeln('g_byte_array_append(buffer, &type, sizeof(uint8_t));'); + if (customType.type == CustomTypes.customClass) { + indent.writeln( + 'g_autoptr(FlValue) values = ${snakeCustomTypeName}_to_list(value);'); + indent.writeln( + 'return fl_standard_message_codec_write_value(codec, buffer, values, error);'); + } else if (customType.type == CustomTypes.customEnum) { + indent.writeln( + 'return fl_standard_message_codec_write_value(codec, buffer, value, error);'); + } + }); + } + + indent.newln(); + indent.writeScoped( + 'static gboolean ${codecMethodPrefix}_write_value(FlStandardMessageCodec* codec, GByteArray* buffer, FlValue* value, GError** error) {', + '}', () { + indent.writeScoped( + 'if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM) {', '}', () { + indent.writeScoped('switch (fl_value_get_custom_type(value)) {', '}', + () { + for (final EnumeratedType customType in customTypes) { + indent.writeln('case ${customType.enumeration}:'); + indent.nest(1, () { + final String customTypeName = + _getClassName(module, customType.name); + final String snakeCustomTypeName = + _snakeCaseFromCamelCase(customTypeName); + final String castMacro = + _getClassCastMacro(module, customType.name); + if (customType.type == CustomTypes.customClass) { + indent.writeln( + 'return ${codecMethodPrefix}_write_$snakeCustomTypeName(codec, buffer, $castMacro(fl_value_get_custom_value_object(value)), error);'); + } else if (customType.type == CustomTypes.customEnum) { + indent.writeln( + 'return ${codecMethodPrefix}_write_$snakeCustomTypeName(codec, buffer, reinterpret_cast(const_cast(fl_value_get_custom_value(value))), error);'); + } + }); + } + }); + }); + + indent.newln(); + indent.writeln( + 'return FL_STANDARD_MESSAGE_CODEC_CLASS(${codecMethodPrefix}_parent_class)->write_value(codec, buffer, value, error);'); + }); + + for (final EnumeratedType customType in customTypes) { + final String customTypeName = _getClassName(module, customType.name); + final String snakeCustomTypeName = + _snakeCaseFromCamelCase(customTypeName); + indent.newln(); + indent.writeScoped( + 'static FlValue* ${codecMethodPrefix}_read_$snakeCustomTypeName(FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, GError** error) {', + '}', () { + if (customType.type == CustomTypes.customClass) { + indent.writeln( + 'g_autoptr(FlValue) values = fl_standard_message_codec_read_value(codec, buffer, offset, error);'); + indent.writeScoped('if (values == nullptr) {', '}', () { + indent.writeln('return nullptr;'); + }); + indent.newln(); + indent.writeln( + 'g_autoptr($customTypeName) value = ${snakeCustomTypeName}_new_from_list(values);'); + indent.writeScoped('if (value == nullptr) {', '}', () { + indent.writeln( + 'g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, "Invalid data received for MessageData");'); + indent.writeln('return nullptr;'); + }); + indent.newln(); + indent.writeln( + 'return fl_value_new_custom_object(${customType.enumeration}, G_OBJECT(value));'); + } else if (customType.type == CustomTypes.customEnum) { + indent.writeln( + 'return fl_value_new_custom(${customType.enumeration}, fl_standard_message_codec_read_value(codec, buffer, offset, error), (GDestroyNotify)fl_value_unref);'); + } + }); + } + + indent.newln(); + indent.writeScoped( + 'static FlValue* ${codecMethodPrefix}_read_value_of_type(FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, int type, GError** error) {', + '}', () { + indent.writeScoped('switch (type) {', '}', () { + for (final EnumeratedType customType in customTypes) { + final String customTypeName = _getClassName(module, customType.name); + final String snakeCustomTypeName = + _snakeCaseFromCamelCase(customTypeName); + indent.writeln('case ${customType.enumeration}:'); + indent.nest(1, () { + indent.writeln( + 'return ${codecMethodPrefix}_read_$snakeCustomTypeName(codec, buffer, offset, error);'); + }); + } + + indent.writeln('default:'); + indent.nest(1, () { + indent.writeln( + 'return FL_STANDARD_MESSAGE_CODEC_CLASS(${codecMethodPrefix}_parent_class)->read_value_of_type(codec, buffer, offset, type, error);'); + }); + }); + }); + + indent.newln(); + _writeInit(indent, module, _codecBaseName, () {}); + + indent.newln(); + _writeClassInit(indent, module, _codecBaseName, () { + indent.writeln( + 'FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value = ${codecMethodPrefix}_write_value;'); + indent.writeln( + 'FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type = ${codecMethodPrefix}_read_value_of_type;'); + }, hasDispose: false); + + indent.newln(); + indent.writeScoped( + 'static $codecClassName* ${codecMethodPrefix}_new() {', '}', () { + _writeObjectNew(indent, module, _codecBaseName); + indent.writeln('return self;'); + }); + } + + @override + void writeFlutterApi( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Api api, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String className = _getClassName(module, api.name); + final String methodPrefix = _getMethodPrefix(module, api.name); + final String codecClassName = _getClassName(module, _codecBaseName); + final String codecMethodPrefix = _getMethodPrefix(module, _codecBaseName); + + indent.newln(); + _writeObjectStruct(indent, module, api.name, () { + indent.writeln('FlBinaryMessenger* messenger;'); + indent.writeln('gchar *suffix;'); + }); + + indent.newln(); + _writeDefineType(indent, module, api.name); + + indent.newln(); + _writeDispose(indent, module, api.name, () { + _writeCastSelf(indent, module, api.name, 'object'); + indent.writeln('g_clear_object(&self->messenger);'); + indent.writeln('g_clear_pointer(&self->suffix, g_free);'); + }); + + indent.newln(); + _writeInit(indent, module, api.name, () {}); + + indent.newln(); + _writeClassInit(indent, module, api.name, () {}); + + indent.newln(); + indent.writeScoped( + '$className* ${methodPrefix}_new(FlBinaryMessenger* messenger, const gchar* suffix) {', + '}', () { + _writeObjectNew(indent, module, api.name); + indent.writeln( + 'self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger));'); + indent.writeln( + 'self->suffix = suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup("");'); + indent.writeln('return self;'); + }); + + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + final String responseMethodPrefix = + _getMethodPrefix(module, responseName); + final String testResponseMacro = + '${_snakeCaseFromCamelCase(module)}_IS_${_snakeCaseFromCamelCase(responseName)}' + .toUpperCase(); + + indent.newln(); + _writeObjectStruct(indent, module, responseName, () { + indent.writeln('FlValue* error;'); + if (!method.returnType.isVoid) { + indent.writeln('FlValue* return_value;'); + if (_isNullablePrimitiveType(method.returnType)) { + final String primitiveType = + _getType(module, method.returnType, primitive: true); + indent.writeln('$primitiveType return_value_;'); + } + } + }); + + indent.newln(); + _writeDefineType(indent, module, responseName); + + indent.newln(); + _writeDispose(indent, module, responseName, () { + _writeCastSelf(indent, module, responseName, 'object'); + indent.writeln('g_clear_pointer(&self->error, fl_value_unref);'); + if (!method.returnType.isVoid) { + indent + .writeln('g_clear_pointer(&self->return_value, fl_value_unref);'); + } + }); + + indent.newln(); + _writeInit(indent, module, responseName, () {}); + + indent.newln(); + _writeClassInit(indent, module, responseName, () {}); + + indent.newln(); + indent.writeScoped( + 'static $responseClassName* ${responseMethodPrefix}_new(FlValue* response) {', + '}', () { + _writeObjectNew(indent, module, responseName); + indent.writeScoped('if (fl_value_get_length(response) > 1) {', '}', () { + indent.writeln('self->error = fl_value_ref(response);'); + }); + if (!method.returnType.isVoid) { + indent.writeScoped('else {', '}', () { + indent.writeln( + 'FlValue* value = fl_value_get_list_value(response, 0);'); + indent.writeln('self->return_value = fl_value_ref(value);'); + }); + } + indent.writeln('return self;'); + }); + + indent.newln(); + indent.writeScoped( + 'gboolean ${responseMethodPrefix}_is_error($responseClassName* self) {', + '}', () { + indent + .writeln('g_return_val_if_fail($testResponseMacro(self), FALSE);'); + indent.writeln('return self->error != nullptr;'); + }); + + indent.newln(); + indent.writeScoped( + 'const gchar* ${responseMethodPrefix}_get_error_code($responseClassName* self) {', + '}', () { + indent.writeln( + 'g_return_val_if_fail($testResponseMacro(self), nullptr);'); + indent.writeln('g_assert(${responseMethodPrefix}_is_error(self));'); + indent.writeln( + 'return fl_value_get_string(fl_value_get_list_value(self->error, 0));'); + }); + + indent.newln(); + indent.writeScoped( + 'const gchar* ${responseMethodPrefix}_get_error_message($responseClassName* self) {', + '}', () { + indent.writeln( + 'g_return_val_if_fail($testResponseMacro(self), nullptr);'); + indent.writeln('g_assert(${responseMethodPrefix}_is_error(self));'); + indent.writeln( + 'return fl_value_get_string(fl_value_get_list_value(self->error, 1));'); + }); + + indent.newln(); + indent.writeScoped( + 'FlValue* ${responseMethodPrefix}_get_error_details($responseClassName* self) {', + '}', () { + indent.writeln( + 'g_return_val_if_fail($testResponseMacro(self), nullptr);'); + indent.writeln('g_assert(${responseMethodPrefix}_is_error(self));'); + indent.writeln('return fl_value_get_list_value(self->error, 2);'); + }); + + if (!method.returnType.isVoid) { + final String primitiveType = + _getType(module, method.returnType, primitive: true); + + indent.newln(); + final String returnType = _isNullablePrimitiveType(method.returnType) + ? '$primitiveType*' + : primitiveType; + indent.writeScoped( + '$returnType ${responseMethodPrefix}_get_return_value($responseClassName* self${_isNumericListType(method.returnType) ? ', size_t* return_value_length' : ''}) {', + '}', () { + indent.writeln( + 'g_return_val_if_fail($testResponseMacro(self), ${_getDefaultValue(module, method.returnType)});'); + indent.writeln('g_assert(!${responseMethodPrefix}_is_error(self));'); + if (method.returnType.isNullable) { + indent.writeScoped( + 'if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) {', + '}', () { + indent.writeln('return nullptr;'); + }); + } + if (_isNumericListType(method.returnType)) { + indent.writeScoped('if (return_value_length != nullptr) {', '}', + () { + indent.writeln( + '*return_value_length = fl_value_get_length(self->return_value);'); + }); + } + if (_isNullablePrimitiveType(method.returnType)) { + indent.writeln( + 'self->return_value_ = ${_fromFlValue(module, method.returnType, 'self->return_value')};'); + indent.writeln('return &self->return_value_;'); + } else { + indent.writeln( + 'return ${_fromFlValue(module, method.returnType, 'self->return_value')};'); + } + }); + } + + indent.newln(); + indent.writeScoped( + 'static void ${methodPrefix}_${methodName}_cb(GObject* object, GAsyncResult* result, gpointer user_data) {', + '}', () { + indent.writeln('GTask* task = G_TASK(user_data);'); + indent.writeln('g_task_return_pointer(task, result, g_object_unref);'); + }); + + final List asyncArgs = ['$className* self']; + for (final Parameter param in method.parameters) { + final String name = _snakeCaseFromCamelCase(param.name); + asyncArgs.add('${_getType(module, param.type)} $name'); + if (_isNumericListType(param.type)) { + asyncArgs.add('size_t ${name}_length'); + } + } + asyncArgs.addAll([ + 'GCancellable* cancellable', + 'GAsyncReadyCallback callback', + 'gpointer user_data', + ]); + indent.newln(); + indent.writeScoped( + "void ${methodPrefix}_$methodName(${asyncArgs.join(', ')}) {", '}', + () { + indent.writeln('g_autoptr(FlValue) args = fl_value_new_list();'); + for (final Parameter param in method.parameters) { + final String name = _snakeCaseFromCamelCase(param.name); + final String value = _makeFlValue(root, module, param.type, name, + lengthVariableName: '${name}_length'); + indent.writeln('fl_value_append_take(args, $value);'); + } + final String channelName = + makeChannelName(api, method, dartPackageName); + indent.writeln( + 'g_autofree gchar* channel_name = g_strdup_printf("$channelName%s", self->suffix);'); + indent.writeln( + 'g_autoptr($codecClassName) codec = ${codecMethodPrefix}_new();'); + indent.writeln( + 'FlBasicMessageChannel* channel = fl_basic_message_channel_new(self->messenger, channel_name, FL_MESSAGE_CODEC(codec));'); + indent.writeln( + 'GTask* task = g_task_new(self, cancellable, callback, user_data);'); + indent.writeln('g_task_set_task_data(task, channel, g_object_unref);'); + indent.writeln( + 'fl_basic_message_channel_send(channel, args, cancellable, ${methodPrefix}_${methodName}_cb, task);'); + }); + + final List finishArgs = [ + '$className* self', + 'GAsyncResult* result', + 'GError** error', + ]; + indent.newln(); + indent.writeScoped( + "$responseClassName* ${methodPrefix}_${methodName}_finish(${finishArgs.join(', ')}) {", + '}', () { + indent.writeln('g_autoptr(GTask) task = G_TASK(result);'); + indent.writeln( + 'GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr));'); + indent.writeln( + 'FlBasicMessageChannel* channel = FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task));'); + indent.writeln( + 'g_autoptr(FlValue) response = fl_basic_message_channel_send_finish(channel, r, error);'); + indent.writeScoped('if (response == nullptr) { ', '}', () { + indent.writeln('return nullptr;'); + }); + indent.writeln('return ${responseMethodPrefix}_new(response);'); + }); + } + } + + @override + void writeHostApi( + GObjectOptions generatorOptions, + Root root, + Indent indent, + Api api, { + required String dartPackageName, + }) { + final String module = _getModule(generatorOptions, dartPackageName); + final String className = _getClassName(module, api.name); + + final String methodPrefix = _getMethodPrefix(module, api.name); + final String vtableName = _getVTableName(module, api.name); + + final String codecClassName = _getClassName(module, _codecBaseName); + final String codecMethodPrefix = _getMethodPrefix(module, _codecBaseName); + + final bool hasAsyncMethod = + api.methods.any((Method method) => method.isAsynchronous); + if (hasAsyncMethod) { + indent.newln(); + _writeObjectStruct(indent, module, '${api.name}ResponseHandle', () { + indent.writeln('FlBasicMessageChannel* channel;'); + indent.writeln('FlBasicMessageChannelResponseHandle* response_handle;'); + }); + + indent.newln(); + _writeDefineType(indent, module, '${api.name}ResponseHandle'); + + indent.newln(); + _writeDispose(indent, module, '${api.name}ResponseHandle', () { + _writeCastSelf(indent, module, '${api.name}ResponseHandle', 'object'); + indent.writeln('g_clear_object(&self->channel);'); + indent.writeln('g_clear_object(&self->response_handle);'); + }); + + indent.newln(); + _writeInit(indent, module, '${api.name}ResponseHandle', () {}); + + indent.newln(); + _writeClassInit(indent, module, '${api.name}ResponseHandle', () {}); + + indent.newln(); + indent.writeScoped( + 'static ${className}ResponseHandle* ${methodPrefix}_response_handle_new(FlBasicMessageChannel* channel, FlBasicMessageChannelResponseHandle* response_handle) {', + '}', () { + _writeObjectNew(indent, module, '${api.name}ResponseHandle'); + indent.writeln( + 'self->channel = FL_BASIC_MESSAGE_CHANNEL(g_object_ref(channel));'); + indent.writeln( + 'self->response_handle = FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_ref(response_handle));'); + indent.writeln('return self;'); + }); + } + + for (final Method method in api.methods) { + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + final String responseMethodPrefix = + _getMethodPrefix(module, responseName); + + if (method.isAsynchronous) { + indent.newln(); + _writeDeclareFinalType(indent, module, responseName); + } + + indent.newln(); + _writeObjectStruct(indent, module, responseName, () { + indent.writeln('FlValue* value;'); + }); + + indent.newln(); + _writeDefineType(indent, module, responseName); + + indent.newln(); + _writeDispose(indent, module, responseName, () { + _writeCastSelf(indent, module, responseName, 'object'); + indent.writeln('g_clear_pointer(&self->value, fl_value_unref);'); + }); + + indent.newln(); + _writeInit(indent, module, responseName, () {}); + + indent.newln(); + _writeClassInit(indent, module, responseName, () {}); + + final String returnType = _getType(module, method.returnType); + indent.newln(); + final List constructorArgs = [ + if (returnType != 'void') '$returnType return_value', + if (_isNumericListType(method.returnType)) 'size_t return_value_length' + ]; + indent.writeScoped( + "${method.isAsynchronous ? 'static ' : ''}$responseClassName* ${responseMethodPrefix}_new(${constructorArgs.join(', ')}) {", + '}', () { + _writeObjectNew(indent, module, responseName); + indent.writeln('self->value = fl_value_new_list();'); + indent.writeln( + "fl_value_append_take(self->value, ${_makeFlValue(root, module, method.returnType, 'return_value', lengthVariableName: 'return_value_length')});"); + indent.writeln('return self;'); + }); + + indent.newln(); + indent.writeScoped( + '${method.isAsynchronous ? 'static ' : ''}$responseClassName* ${responseMethodPrefix}_new_error(const gchar* code, const gchar* message, FlValue* details) {', + '}', () { + _writeObjectNew(indent, module, responseName); + indent.writeln('self->value = fl_value_new_list();'); + indent.writeln( + 'fl_value_append_take(self->value, fl_value_new_string(code));'); + indent.writeln( + 'fl_value_append_take(self->value, fl_value_new_string(message != nullptr ? message : ""));'); + indent.writeln( + 'fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) : fl_value_new_null());'); + indent.writeln('return self;'); + }); + } + + indent.newln(); + _writeDeclareFinalType(indent, module, api.name); + + indent.newln(); + _writeObjectStruct(indent, module, api.name, () { + indent.writeln('const ${className}VTable* vtable;'); + indent.writeln('gpointer user_data;'); + indent.writeln('GDestroyNotify user_data_free_func;'); + }); + + indent.newln(); + _writeDefineType(indent, module, api.name); + + indent.newln(); + _writeDispose(indent, module, api.name, () { + _writeCastSelf(indent, module, api.name, 'object'); + indent.writeScoped('if (self->user_data != nullptr) {', '}', () { + indent.writeln('self->user_data_free_func(self->user_data);'); + }); + indent.writeln('self->user_data = nullptr;'); + }); + + indent.newln(); + _writeInit(indent, module, api.name, () {}); + + indent.newln(); + _writeClassInit(indent, module, api.name, () {}); + + indent.newln(); + indent.writeScoped( + 'static $className* ${methodPrefix}_new(const $vtableName* vtable, gpointer user_data, GDestroyNotify user_data_free_func) {', + '}', () { + _writeObjectNew(indent, module, api.name); + indent.writeln('self->vtable = vtable;'); + indent.writeln('self->user_data = user_data;'); + indent.writeln('self->user_data_free_func = user_data_free_func;'); + indent.writeln('return self;'); + }); + + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + + indent.newln(); + indent.writeScoped( + 'static void ${methodPrefix}_${methodName}_cb(FlBasicMessageChannel* channel, FlValue* message_, FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) {', + '}', () { + _writeCastSelf(indent, module, api.name, 'user_data'); + + indent.newln(); + indent.writeScoped( + 'if (self->vtable == nullptr || self->vtable->$methodName == nullptr) {', + '}', () { + indent.writeln('return;'); + }); + + indent.newln(); + final List methodArgs = []; + for (int i = 0; i < method.parameters.length; i++) { + final Parameter param = method.parameters[i]; + final String paramName = _snakeCaseFromCamelCase(param.name); + final String paramType = _getType(module, param.type); + indent.writeln( + 'FlValue* value$i = fl_value_get_list_value(message_, $i);'); + if (_isNullablePrimitiveType(param.type)) { + final String primitiveType = + _getType(module, param.type, primitive: true); + indent.writeln('$paramType $paramName = nullptr;'); + indent.writeln('$primitiveType ${paramName}_value;'); + indent.writeScoped( + 'if (fl_value_get_type(value$i) != FL_VALUE_TYPE_NULL) {', '}', + () { + final String paramValue = + _fromFlValue(module, method.parameters[i].type, 'value$i'); + indent.writeln('${paramName}_value = $paramValue;'); + indent.writeln('$paramName = &${paramName}_value;'); + }); + } else { + final String paramValue = + _fromFlValue(module, method.parameters[i].type, 'value$i'); + indent.writeln('$paramType $paramName = $paramValue;'); + } + methodArgs.add(paramName); + if (_isNumericListType(method.parameters[i].type)) { + indent.writeln( + 'size_t ${paramName}_length = fl_value_get_length(value$i);'); + methodArgs.add('${paramName}_length'); + } + } + if (method.isAsynchronous) { + final List vfuncArgs = []; + vfuncArgs.addAll(methodArgs); + vfuncArgs.addAll(['handle', 'self->user_data']); + indent.writeln( + 'g_autoptr(${className}ResponseHandle) handle = ${methodPrefix}_response_handle_new(channel, response_handle);'); + indent.writeln("self->vtable->$methodName(${vfuncArgs.join(', ')});"); + } else { + final List vfuncArgs = []; + vfuncArgs.addAll(methodArgs); + vfuncArgs.add('self->user_data'); + indent.writeln( + "g_autoptr($responseClassName) response = self->vtable->$methodName(${vfuncArgs.join(', ')});"); + indent.writeScoped('if (response == nullptr) {', '}', () { + indent.writeln( + 'g_warning("No response returned to %s.%s", "${api.name}", "${method.name}");'); + indent.writeln('return;'); + }); + + indent.newln(); + indent.writeln('g_autoptr(GError) error = NULL;'); + indent.writeScoped( + 'if (!fl_basic_message_channel_respond(channel, response_handle, response->value, &error)) {', + '}', () { + indent.writeln( + 'g_warning("Failed to send response to %s.%s: %s", "${api.name}", "${method.name}", error->message);'); + }); + } + }); + } + + indent.newln(); + indent.writeScoped( + 'void ${methodPrefix}_set_method_handlers(FlBinaryMessenger* messenger, const gchar* suffix, const $vtableName* vtable, gpointer user_data, GDestroyNotify user_data_free_func) {', + '}', () { + indent.writeln( + 'g_autofree gchar* dot_suffix = suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup("");'); + indent.writeln( + 'g_autoptr($className) api_data = ${methodPrefix}_new(vtable, user_data, user_data_free_func);'); + + indent.newln(); + indent.writeln( + 'g_autoptr($codecClassName) codec = ${codecMethodPrefix}_new();'); + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String channelName = + makeChannelName(api, method, dartPackageName); + indent.writeln( + 'g_autofree gchar* ${methodName}_channel_name = g_strdup_printf("$channelName%s", dot_suffix);'); + indent.writeln( + 'g_autoptr(FlBasicMessageChannel) ${methodName}_channel = fl_basic_message_channel_new(messenger, ${methodName}_channel_name, FL_MESSAGE_CODEC(codec));'); + indent.writeln( + 'fl_basic_message_channel_set_message_handler(${methodName}_channel, ${methodPrefix}_${methodName}_cb, g_object_ref(api_data), g_object_unref);'); + } + }); + + indent.newln(); + indent.writeScoped( + 'void ${methodPrefix}_clear_method_handlers(FlBinaryMessenger* messenger, const gchar* suffix) {', + '}', () { + indent.writeln( + 'g_autofree gchar* dot_suffix = suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup("");'); + + indent.newln(); + indent.writeln( + 'g_autoptr($codecClassName) codec = ${codecMethodPrefix}_new();'); + for (final Method method in api.methods) { + final String methodName = _getMethodName(method.name); + final String channelName = + makeChannelName(api, method, dartPackageName); + indent.writeln( + 'g_autofree gchar* ${methodName}_channel_name = g_strdup_printf("$channelName%s", dot_suffix);'); + indent.writeln( + 'g_autoptr(FlBasicMessageChannel) ${methodName}_channel = fl_basic_message_channel_new(messenger, ${methodName}_channel_name, FL_MESSAGE_CODEC(codec));'); + indent.writeln( + 'fl_basic_message_channel_set_message_handler(${methodName}_channel, nullptr, nullptr, nullptr);'); + } + }); + + for (final Method method + in api.methods.where((Method method) => method.isAsynchronous)) { + final String returnType = _getType(module, method.returnType); + final String methodName = _getMethodName(method.name); + final String responseName = _getResponseName(api.name, method.name); + final String responseClassName = _getClassName(module, responseName); + final String responseMethodPrefix = + _getMethodPrefix(module, responseName); + + indent.newln(); + final List respondArgs = [ + '${className}ResponseHandle* response_handle', + if (returnType != 'void') '$returnType return_value', + if (_isNumericListType(method.returnType)) 'size_t return_value_length' + ]; + indent.writeScoped( + "void ${methodPrefix}_respond_$methodName(${respondArgs.join(', ')}) {", + '}', () { + final List returnArgs = [ + if (returnType != 'void') 'return_value', + if (_isNumericListType(method.returnType)) 'return_value_length' + ]; + indent.writeln( + 'g_autoptr($responseClassName) response = ${responseMethodPrefix}_new(${returnArgs.join(', ')});'); + indent.writeln('g_autoptr(GError) error = nullptr;'); + indent.writeScoped( + 'if (!fl_basic_message_channel_respond(response_handle->channel, response_handle->response_handle, response->value, &error)) {', + '}', () { + indent.writeln( + 'g_warning("Failed to send response to %s.%s: %s", "${api.name}", "${method.name}", error->message);'); + }); + }); + + indent.newln(); + final List respondErrorArgs = [ + '${className}ResponseHandle* response_handle', + 'const gchar* code', + 'const gchar* message', + 'FlValue* details' + ]; + indent.writeScoped( + "void ${methodPrefix}_respond_error_$methodName(${respondErrorArgs.join(', ')}) {", + '}', () { + indent.writeln( + 'g_autoptr($responseClassName) response = ${responseMethodPrefix}_new_error(code, message, details);'); + indent.writeln('g_autoptr(GError) error = nullptr;'); + indent.writeScoped( + 'if (!fl_basic_message_channel_respond(response_handle->channel, response_handle->response_handle, response->value, &error)) {', + '}', () { + indent.writeln( + 'g_warning("Failed to send response to %s.%s: %s", "${api.name}", "${method.name}", error->message);'); + }); + }); + } + } +} + +// Returns the module name to use. +String _getModule(GObjectOptions generatorOptions, String dartPackageName) { + return generatorOptions.module ?? _camelCaseFromSnakeCase(dartPackageName); +} + +// Returns the header guard defintion for [headerFileName]. +String _getGuardName(String? headerFileName) { + const String prefix = 'PIGEON_'; + if (headerFileName != null) { + return '$prefix${headerFileName.replaceAll('.', '_').toUpperCase()}_'; + } else { + return '${prefix}H_'; + } +} + +// Writes the GObject macro to generate a new type. +void _writeDeclareFinalType(Indent indent, String module, String name, + {String parentClassName = 'GObject'}) { + final String upperModule = _snakeCaseFromCamelCase(module).toUpperCase(); + final String className = _getClassName(module, name); + final String snakeClassName = _snakeCaseFromCamelCase(name); + final String upperSnakeClassName = snakeClassName.toUpperCase(); + final String methodPrefix = _getMethodPrefix(module, name); + + indent.writeln( + 'G_DECLARE_FINAL_TYPE($className, $methodPrefix, $upperModule, $upperSnakeClassName, $parentClassName)'); +} + +// Writes the GObject macro to define a new type. +void _writeDefineType(Indent indent, String module, String name, + {String parentType = 'G_TYPE_OBJECT'}) { + final String className = _getClassName(module, name); + final String methodPrefix = _getMethodPrefix(module, name); + + indent.writeln('G_DEFINE_TYPE($className, $methodPrefix, $parentType)'); +} + +// Writes the struct for a GObject. +void _writeObjectStruct( + Indent indent, String module, String name, void Function() func, + {String parentClassName = 'GObject'}) { + final String className = _getClassName(module, name); + + indent.writeScoped('struct _$className {', '};', () { + indent.writeln('$parentClassName parent_instance;'); + indent.newln(); + + func(); + }); +} + +// Writes the dispose method for a GObject. +void _writeDispose( + Indent indent, String module, String name, void Function() func) { + final String methodPrefix = _getMethodPrefix(module, name); + + indent.writeScoped( + 'static void ${methodPrefix}_dispose(GObject* object) {', '}', () { + func(); + indent.writeln( + 'G_OBJECT_CLASS(${methodPrefix}_parent_class)->dispose(object);'); + }); +} + +// Writes the init function for a GObject. +void _writeInit( + Indent indent, String module, String name, void Function() func) { + final String className = _getClassName(module, name); + final String methodPrefix = _getMethodPrefix(module, name); + + indent.writeScoped( + 'static void ${methodPrefix}_init($className* self) {', '}', () { + func(); + }); +} + +// Writes the class init function for a GObject. +void _writeClassInit( + Indent indent, String module, String name, void Function() func, + {bool hasDispose = true}) { + final String className = _getClassName(module, name); + final String methodPrefix = _getMethodPrefix(module, name); + + indent.writeScoped( + 'static void ${methodPrefix}_class_init(${className}Class* klass) {', '}', + () { + if (hasDispose) { + indent + .writeln('G_OBJECT_CLASS(klass)->dispose = ${methodPrefix}_dispose;'); + } + func(); + }); +} + +// Writes the constructor for a GObject. +void _writeObjectNew(Indent indent, String module, String name) { + final String className = _getClassName(module, name); + final String methodPrefix = _getMethodPrefix(module, name); + final String castMacro = _getClassCastMacro(module, name); + + indent.writeln( + '$className* self = $castMacro(g_object_new(${methodPrefix}_get_type(), nullptr));'); +} + +// Writes the cast used at the top of GObject methods. +void _writeCastSelf( + Indent indent, String module, String name, String variableName) { + final String className = _getClassName(module, name); + final String castMacro = _getClassCastMacro(module, name); + indent.writeln('$className* self = $castMacro($variableName);'); +} + +// Converts a string from CamelCase to snake_case. +String _snakeCaseFromCamelCase(String camelCase) { + return camelCase.replaceAllMapped(RegExp(r'[A-Z]'), + (Match m) => '${m.start == 0 ? '' : '_'}${m[0]!.toLowerCase()}'); +} + +// Converts a string from snake_case to CamelCase +String _camelCaseFromSnakeCase(String snakeCase) { + return snakeCase + .split('_') + .map((String v) => v[0].toUpperCase() + v.substring(1)) + .join(); +} + +// Returns the GObject class name for [name]. +String _getClassName(String module, String name) { + return '$module$name'; +} + +// Returns the name to use for a class field with [name]. +String _getFieldName(String name) { + final List reservedNames = ['type']; + if (reservedNames.contains(name)) { + name += '_'; + } + return _snakeCaseFromCamelCase(name); +} + +// Returns the name to user for a class method with [name] +String _getMethodName(String name) { + final List reservedNames = ['new', 'get_type']; + if (reservedNames.contains(name)) { + name += '_'; + } + return _snakeCaseFromCamelCase(name); +} + +/// Return the name of the VTable structure to use for API requests. +String _getVTableName(String module, String name) { + final String className = _getClassName(module, name); + return '${className}VTable'; +} + +// Returns the GObject macro to cast a GObject to a class of [name]. +String _getClassCastMacro(String module, String name) { + final String className = _getClassName(module, name); + final String snakeClassName = _snakeCaseFromCamelCase(className); + return snakeClassName.toUpperCase(); +} + +// Returns the prefix used for methods in class [name]. +String _getMethodPrefix(String module, String name) { + final String className = _getClassName(module, name); + return _snakeCaseFromCamelCase(className); +} + +// Returns an enumeration value in C++ form. +String _getEnumValue(String module, String enumName, String memberName) { + final String snakeEnumName = _snakeCaseFromCamelCase(enumName); + final String snakeMemberName = _snakeCaseFromCamelCase(memberName); + return '${module}_${snakeEnumName}_$snakeMemberName'.toUpperCase(); +} + +// Returns code for storing a value of [type]. +String _getType(String module, TypeDeclaration type, + {bool isOutput = false, bool primitive = false}) { + if (type.isClass) { + return '${_getClassName(module, type.baseName)}*'; + } else if (type.isEnum) { + final String name = _getClassName(module, type.baseName); + return type.isNullable && !primitive ? '$name*' : name; + } else if (_isFlValueWrappedType(type)) { + return 'FlValue*'; + } else if (type.baseName == 'void') { + return 'void'; + } else if (type.baseName == 'bool') { + return type.isNullable && !primitive ? 'gboolean*' : 'gboolean'; + } else if (type.baseName == 'int') { + return type.isNullable && !primitive ? 'int64_t*' : 'int64_t'; + } else if (type.baseName == 'double') { + return type.isNullable && !primitive ? 'double*' : 'double'; + } else if (type.baseName == 'String') { + return isOutput ? 'gchar*' : 'const gchar*'; + } else if (type.baseName == 'Uint8List') { + return isOutput ? 'uint8_t*' : 'const uint8_t*'; + } else if (type.baseName == 'Int32List') { + return isOutput ? 'int32_t*' : 'const int32_t*'; + } else if (type.baseName == 'Int64List') { + return isOutput ? 'int64_t*' : 'const int64_t*'; + } else if (type.baseName == 'Float32List') { + return isOutput ? 'float*' : 'const float*'; + } else if (type.baseName == 'Float64List') { + return isOutput ? 'double*' : 'const double*'; + } else { + throw Exception('Unknown type ${type.baseName}'); + } +} + +// Returns true if [type] is a *List typed numeric list type. +bool _isNumericListType(TypeDeclaration type) { + return type.baseName == 'Uint8List' || + type.baseName == 'Int32List' || + type.baseName == 'Int64List' || + type.baseName == 'Float32List' || + type.baseName == 'Float64List'; +} + +// Returns true if [type] is a nullable type with a primitive native data type. +bool _isNullablePrimitiveType(TypeDeclaration type) { + if (!type.isNullable) { + return false; + } + + return type.isEnum || + type.baseName == 'bool' || + type.baseName == 'int' || + type.baseName == 'double'; +} + +// Whether [type] is a type that needs to stay an FlValue* since it can't be +// expressed as a more concrete type. +bool _isFlValueWrappedType(TypeDeclaration type) { + return type.baseName == 'List' || + type.baseName == 'Map' || + type.baseName == 'Object'; +} + +// Returns code to clear a value stored in [variableName], or null if no function required. +String? _getClearFunction(TypeDeclaration type, String variableName) { + if (type.isClass) { + return 'g_clear_object(&$variableName)'; + } else if (_isFlValueWrappedType(type)) { + return 'g_clear_pointer(&$variableName, fl_value_unref)'; + } else if (type.baseName == 'String') { + return 'g_clear_pointer(&$variableName, g_free)'; + } else if (_isNullablePrimitiveType(type)) { + return 'g_clear_pointer(&$variableName, g_free)'; + } else { + return null; + } +} + +// Returns code for the default value for [type]. +String _getDefaultValue(String module, TypeDeclaration type, + {bool primitive = false}) { + if (type.isClass || (type.isNullable && !primitive)) { + return 'nullptr'; + } else if (type.isEnum) { + final String enumName = _getClassName(module, type.baseName); + return 'static_cast<$enumName>(0)'; + } else if (_isFlValueWrappedType(type)) { + return 'nullptr'; + } else if (type.baseName == 'void') { + return ''; + } else if (type.baseName == 'bool') { + return 'FALSE'; + } else if (type.baseName == 'int') { + return '0'; + } else if (type.baseName == 'double') { + return '0.0'; + } else if (type.baseName == 'String') { + return 'nullptr'; + } else if (_isNumericListType(type)) { + return 'nullptr'; + } else { + throw Exception('Unknown type ${type.baseName}'); + } +} + +// Returns code to copy the native data type stored in [variableName]. +// +// [lengthVariableName] must be provided for the typed numeric *List types. +String _referenceValue(String module, TypeDeclaration type, String variableName, + {String? lengthVariableName}) { + if (type.isClass) { + final String castMacro = _getClassCastMacro(module, type.baseName); + return '$castMacro(g_object_ref($variableName))'; + } else if (_isFlValueWrappedType(type)) { + return 'fl_value_ref($variableName)'; + } else if (type.baseName == 'String') { + return 'g_strdup($variableName)'; + } else if (type.baseName == 'Uint8List') { + return 'static_cast(memcpy(malloc($lengthVariableName), $variableName, $lengthVariableName))'; + } else if (type.baseName == 'Int32List') { + return 'static_cast(memcpy(malloc(sizeof(int32_t) * $lengthVariableName), $variableName, sizeof(int32_t) * $lengthVariableName))'; + } else if (type.baseName == 'Int64List') { + return 'static_cast(memcpy(malloc(sizeof(int64_t) * $lengthVariableName), $variableName, sizeof(int64_t) * $lengthVariableName))'; + } else if (type.baseName == 'Float32List') { + return 'static_cast(memcpy(malloc(sizeof(float) * $lengthVariableName), $variableName, sizeof(float) * $lengthVariableName))'; + } else if (type.baseName == 'Float64List') { + return 'static_cast(memcpy(malloc(sizeof(double) * $lengthVariableName), $variableName, sizeof(double) * $lengthVariableName))'; + } else { + return variableName; + } +} + +int _getTypeEnumeration(Root root, TypeDeclaration type) { + return getEnumeratedTypes(root) + .firstWhere((EnumeratedType t) => + (type.isClass && t.associatedClass == type.associatedClass) || + (type.isEnum && t.associatedEnum == type.associatedEnum)) + .enumeration; +} + +// Returns code to convert the native data type stored in [variableName] to a FlValue. +// +// [lengthVariableName] must be provided for the typed numeric *List types. +String _makeFlValue( + Root root, String module, TypeDeclaration type, String variableName, + {String? lengthVariableName}) { + final String value; + if (type.isClass) { + final int enumeration = _getTypeEnumeration(root, type); + value = 'fl_value_new_custom_object($enumeration, G_OBJECT($variableName))'; + } else if (type.isEnum) { + final int enumeration = _getTypeEnumeration(root, type); + value = + 'fl_value_new_custom($enumeration, fl_value_new_int(${type.isNullable ? '*$variableName' : variableName}), (GDestroyNotify)fl_value_unref)'; + } else if (_isFlValueWrappedType(type)) { + value = 'fl_value_ref($variableName)'; + } else if (type.baseName == 'void') { + value = 'fl_value_new_null()'; + } else if (type.baseName == 'bool') { + value = type.isNullable + ? 'fl_value_new_bool(*$variableName)' + : 'fl_value_new_bool($variableName)'; + } else if (type.baseName == 'int') { + value = type.isNullable + ? 'fl_value_new_int(*$variableName)' + : 'fl_value_new_int($variableName)'; + } else if (type.baseName == 'double') { + value = type.isNullable + ? 'fl_value_new_float(*$variableName)' + : 'fl_value_new_float($variableName)'; + } else if (type.baseName == 'String') { + value = 'fl_value_new_string($variableName)'; + } else if (type.baseName == 'Uint8List') { + value = 'fl_value_new_uint8_list($variableName, $lengthVariableName)'; + } else if (type.baseName == 'Int32List') { + value = 'fl_value_new_int32_list($variableName, $lengthVariableName)'; + } else if (type.baseName == 'Int64List') { + value = 'fl_value_new_int64_list($variableName, $lengthVariableName)'; + } else if (type.baseName == 'Float32List') { + value = 'fl_value_new_float32_list($variableName, $lengthVariableName)'; + } else if (type.baseName == 'Float64List') { + value = 'fl_value_new_float_list($variableName, $lengthVariableName)'; + } else { + throw Exception('Unknown type ${type.baseName}'); + } + + if (type.isNullable) { + return '$variableName != nullptr ? $value : fl_value_new_null()'; + } else { + return value; + } +} + +// Returns code to convert the FlValue stored in [variableName] to a native data type. +String _fromFlValue(String module, TypeDeclaration type, String variableName) { + if (type.isClass) { + final String castMacro = _getClassCastMacro(module, type.baseName); + return '$castMacro(fl_value_get_custom_value_object($variableName))'; + } else if (type.isEnum) { + final String enumName = _getClassName(module, type.baseName); + return 'static_cast<$enumName>(fl_value_get_int(reinterpret_cast(const_cast(fl_value_get_custom_value($variableName)))))'; + } else if (_isFlValueWrappedType(type)) { + return variableName; + } else if (type.baseName == 'bool') { + return 'fl_value_get_bool($variableName)'; + } else if (type.baseName == 'int') { + return 'fl_value_get_int($variableName)'; + } else if (type.baseName == 'double') { + return 'fl_value_get_float($variableName)'; + } else if (type.baseName == 'String') { + return 'fl_value_get_string($variableName)'; + } else if (type.baseName == 'Uint8List') { + return 'fl_value_get_uint8_list($variableName)'; + } else if (type.baseName == 'Int32List') { + return 'fl_value_get_int32_list($variableName)'; + } else if (type.baseName == 'Int64List') { + return 'fl_value_get_int64_list($variableName)'; + } else if (type.baseName == 'Float32List') { + return 'fl_value_get_float32_list($variableName)'; + } else if (type.baseName == 'Float64List') { + return 'fl_value_get_float_list($variableName)'; + } else { + throw Exception('Unknown type ${type.baseName}'); + } +} + +// Returns the name of a GObject class used to send responses to [methodName]. +String _getResponseName(String name, String methodName) { + final String upperMethodName = + methodName[0].toUpperCase() + methodName.substring(1); + return '$name${upperMethodName}Response'; +} diff --git a/packages/pigeon/lib/pigeon.dart b/packages/pigeon/lib/pigeon.dart index 7f2fb7505fa8..53087ae7877a 100644 --- a/packages/pigeon/lib/pigeon.dart +++ b/packages/pigeon/lib/pigeon.dart @@ -6,6 +6,7 @@ export 'dart:typed_data' show Float64List, Int32List, Int64List, Uint8List; export 'cpp_generator.dart' show CppOptions; export 'dart_generator.dart' show DartOptions; +export 'gobject_generator.dart' show GObjectOptions; export 'java_generator.dart' show JavaOptions; export 'kotlin_generator.dart' show KotlinOptions; export 'objc_generator.dart' show ObjcOptions; diff --git a/packages/pigeon/lib/pigeon_lib.dart b/packages/pigeon/lib/pigeon_lib.dart index 2592dd24c55c..af2618e47e6a 100644 --- a/packages/pigeon/lib/pigeon_lib.dart +++ b/packages/pigeon/lib/pigeon_lib.dart @@ -30,6 +30,7 @@ import 'cpp_generator.dart'; import 'dart_generator.dart'; import 'generator_tools.dart'; import 'generator_tools.dart' as generator_tools; +import 'gobject_generator.dart'; import 'java_generator.dart'; import 'kotlin_generator.dart'; import 'objc_generator.dart'; @@ -253,6 +254,9 @@ class PigeonOptions { this.cppHeaderOut, this.cppSourceOut, this.cppOptions, + this.gobjectHeaderOut, + this.gobjectSourceOut, + this.gobjectOptions, this.dartOptions, this.copyrightHeader, this.oneLanguage, @@ -307,6 +311,15 @@ class PigeonOptions { /// Options that control how C++ will be generated. final CppOptions? cppOptions; + /// Path to the ".h" GObject file that will be generated. + final String? gobjectHeaderOut; + + /// Path to the ".cc" GObject file that will be generated. + final String? gobjectSourceOut; + + /// Options that control how GObject source will be generated. + final GObjectOptions? gobjectOptions; + /// Options that control how Dart will be generated. final DartOptions? dartOptions; @@ -357,6 +370,12 @@ class PigeonOptions { cppOptions: map.containsKey('cppOptions') ? CppOptions.fromMap(map['cppOptions']! as Map) : null, + gobjectHeaderOut: map['gobjectHeaderOut'] as String?, + gobjectSourceOut: map['gobjectSourceOut'] as String?, + gobjectOptions: map.containsKey('gobjectOptions') + ? GObjectOptions.fromMap( + map['gobjectOptions']! as Map) + : null, dartOptions: map.containsKey('dartOptions') ? DartOptions.fromMap(map['dartOptions']! as Map) : null, @@ -388,6 +407,9 @@ class PigeonOptions { if (cppHeaderOut != null) 'cppHeaderOut': cppHeaderOut!, if (cppSourceOut != null) 'cppSourceOut': cppSourceOut!, if (cppOptions != null) 'cppOptions': cppOptions!.toMap(), + if (gobjectHeaderOut != null) 'gobjectHeaderOut': gobjectHeaderOut!, + if (gobjectSourceOut != null) 'gobjectSourceOut': gobjectSourceOut!, + if (gobjectOptions != null) 'gobjectOptions': gobjectOptions!.toMap(), if (dartOptions != null) 'dartOptions': dartOptions!.toMap(), if (copyrightHeader != null) 'copyrightHeader': copyrightHeader!, if (astOut != null) 'astOut': astOut!, @@ -776,6 +798,54 @@ class CppGeneratorAdapter implements GeneratorAdapter { List validate(PigeonOptions options, Root root) => []; } +/// A [GeneratorAdapter] that generates GObject source code. +class GObjectGeneratorAdapter implements GeneratorAdapter { + /// Constructor for [GObjectGeneratorAdapter]. + GObjectGeneratorAdapter( + {this.fileTypeList = const [FileType.header, FileType.source]}); + + @override + List fileTypeList; + + @override + void generate( + StringSink sink, PigeonOptions options, Root root, FileType fileType) { + final GObjectOptions gobjectOptions = + options.gobjectOptions ?? const GObjectOptions(); + final GObjectOptions gobjectOptionsWithHeader = + gobjectOptions.merge(GObjectOptions( + copyrightHeader: options.copyrightHeader != null + ? _lineReader( + path.posix.join(options.basePath ?? '', options.copyrightHeader)) + : null, + )); + final OutputFileOptions outputFileOptions = + OutputFileOptions( + fileType: fileType, languageOptions: gobjectOptionsWithHeader); + const GObjectGenerator generator = GObjectGenerator(); + generator.generate( + outputFileOptions, + root, + sink, + dartPackageName: options.getPackageName(), + ); + } + + @override + IOSink? shouldGenerate(PigeonOptions options, FileType fileType) { + if (fileType == FileType.source) { + return _openSink(options.gobjectSourceOut, + basePath: options.basePath ?? ''); + } else { + return _openSink(options.gobjectHeaderOut, + basePath: options.basePath ?? ''); + } + } + + @override + List validate(PigeonOptions options, Root root) => []; +} + /// A [GeneratorAdapter] that generates Kotlin source code. class KotlinGeneratorAdapter implements GeneratorAdapter { /// Constructor for [KotlinGeneratorAdapter]. @@ -2100,6 +2170,18 @@ ${_argParser.usage}'''; ) ..addOption('cpp_namespace', help: 'The namespace that generated C++ code will be in.') + ..addOption( + 'gobject_header_out', + help: 'Path to generated GObject header file (.h).', + aliases: const ['experimental_gobject_header_out'], + ) + ..addOption( + 'gobject_source_out', + help: 'Path to generated GObject classes file (.cc).', + aliases: const ['experimental_gobject_source_out'], + ) + ..addOption('gobject_module', + help: 'The module that generated GObject code will be in.') ..addOption('objc_header_out', help: 'Path to generated Objective-C header file (.h).') ..addOption('objc_prefix', @@ -2154,6 +2236,11 @@ ${_argParser.usage}'''; cppOptions: CppOptions( namespace: results['cpp_namespace'] as String?, ), + gobjectHeaderOut: results['gobject_header_out'] as String?, + gobjectSourceOut: results['gobject_source_out'] as String?, + gobjectOptions: GObjectOptions( + module: results['gobject_module'] as String?, + ), copyrightHeader: results['copyright_header'] as String?, oneLanguage: results['one_language'] as bool?, astOut: results['ast_out'] as String?, @@ -2210,6 +2297,7 @@ ${_argParser.usage}'''; SwiftGeneratorAdapter(), KotlinGeneratorAdapter(), CppGeneratorAdapter(), + GObjectGeneratorAdapter(), DartTestGeneratorAdapter(), ObjcGeneratorAdapter(), AstGeneratorAdapter(), @@ -2280,6 +2368,14 @@ ${_argParser.usage}'''; path.basename(options.cppHeaderOut!))))); } + if (options.gobjectHeaderOut != null) { + options = options.merge(PigeonOptions( + gobjectOptions: (options.gobjectOptions ?? const GObjectOptions()) + .merge(GObjectOptions( + headerIncludePath: + path.basename(options.gobjectHeaderOut!))))); + } + for (final GeneratorAdapter adapter in safeGeneratorAdapters) { for (final FileType fileType in adapter.fileTypeList) { final IOSink? sink = adapter.shouldGenerate(options, fileType); diff --git a/packages/pigeon/platform_tests/shared_test_plugin_code/lib/integration_tests.dart b/packages/pigeon/platform_tests/shared_test_plugin_code/lib/integration_tests.dart index ba3ac04c1c95..de771318eb6c 100644 --- a/packages/pigeon/platform_tests/shared_test_plugin_code/lib/integration_tests.dart +++ b/packages/pigeon/platform_tests/shared_test_plugin_code/lib/integration_tests.dart @@ -19,6 +19,9 @@ enum TargetGenerator { /// The Windows C++ generator. cpp, + /// The Linux GObject generator. + gobject, + /// The Android Java generator. java, diff --git a/packages/pigeon/platform_tests/test_plugin/example/integration_test/test.dart b/packages/pigeon/platform_tests/test_plugin/example/integration_test/test.dart index bfbe0b7085a6..535e39206dd8 100644 --- a/packages/pigeon/platform_tests/test_plugin/example/integration_test/test.dart +++ b/packages/pigeon/platform_tests/test_plugin/example/integration_test/test.dart @@ -15,6 +15,9 @@ TargetGenerator _getTarget() { if (Platform.isIOS || Platform.isMacOS) { return TargetGenerator.swift; } + if (Platform.isLinux) { + return TargetGenerator.gobject; + } if (Platform.isWindows) { return TargetGenerator.cpp; } diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/.gitignore b/packages/pigeon/platform_tests/test_plugin/example/linux/.gitignore new file mode 100644 index 000000000000..d3896c98444f --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/CMakeLists.txt b/packages/pigeon/platform_tests/test_plugin/example/linux/CMakeLists.txt new file mode 100644 index 000000000000..972ceb58f205 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/CMakeLists.txt @@ -0,0 +1,151 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "test_plugin_example") + +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "com.example.test_plugin") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Enable the test target. +set(include_test_plugin_tests TRUE) + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + +# Enable the test target. +set(include_test_plugin_tests TRUE) + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") + +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/CMakeLists.txt b/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/CMakeLists.txt new file mode 100644 index 000000000000..d5bd01648a96 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/generated_plugins.cmake b/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/generated_plugins.cmake new file mode 100644 index 000000000000..98e2c9fa93fd --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + test_plugin +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/main.cc b/packages/pigeon/platform_tests/test_plugin/example/linux/main.cc new file mode 100644 index 000000000000..1507d02825e7 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/main.cc @@ -0,0 +1,10 @@ +// 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. + +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.cc b/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.cc new file mode 100644 index 000000000000..2c91863a8049 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.cc @@ -0,0 +1,131 @@ +// 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. + +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "test_plugin_example"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "test_plugin_example"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments( + project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, + gchar*** arguments, + int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + // MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + // MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = + my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, "flags", + G_APPLICATION_NON_UNIQUE, nullptr)); +} diff --git a/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.h b/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.h new file mode 100644 index 000000000000..6e9f0c3ff665 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/example/linux/my_application.h @@ -0,0 +1,22 @@ +// 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 FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/packages/pigeon/platform_tests/test_plugin/linux/CMakeLists.txt b/packages/pigeon/platform_tests/test_plugin/linux/CMakeLists.txt new file mode 100644 index 000000000000..3d2845f8d3e4 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/CMakeLists.txt @@ -0,0 +1,119 @@ +# The Flutter tooling requires that developers have CMake 3.10 or later +# installed. You should not increase this version, as doing so will cause +# the plugin to fail to compile for some customers of the plugin. +cmake_minimum_required(VERSION 3.10) + +# Project-level configuration. +set(PROJECT_NAME "test_plugin") +project(${PROJECT_NAME} LANGUAGES CXX) + +# This value is used when generating builds using this plugin, so it must +# not be changed. +set(PLUGIN_NAME "test_plugin_plugin") + +# Any new source files that you add to the plugin should be added here. +list(APPEND PLUGIN_SOURCES + "test_plugin.cc" + # Generated sources. + "pigeon/core_tests.gen.cc" + "pigeon/core_tests.gen.h" + "pigeon/enum.gen.cc" + "pigeon/enum.gen.h" + "pigeon/message.gen.cc" + "pigeon/message.gen.h" + "pigeon/multiple_arity.gen.cc" + "pigeon/multiple_arity.gen.h" + "pigeon/non_null_fields.gen.cc" + "pigeon/non_null_fields.gen.h" + "pigeon/null_fields.gen.cc" + "pigeon/null_fields.gen.h" + "pigeon/nullable_returns.gen.cc" + "pigeon/nullable_returns.gen.h" + "pigeon/primitive.gen.cc" + "pigeon/primitive.gen.h" +) + +# Define the plugin library target. Its name must not be changed (see comment +# on PLUGIN_NAME above). +add_library(${PLUGIN_NAME} SHARED + ${PLUGIN_SOURCES} +) + +# Apply a standard set of build settings that are configured in the +# application-level CMakeLists.txt. This can be removed for plugins that want +# full control over build settings. +apply_standard_settings(${PLUGIN_NAME}) + +# Symbols are hidden by default to reduce the chance of accidental conflicts +# between plugins. This should not be removed; any symbols that should be +# exported should be explicitly exported with the FLUTTER_PLUGIN_EXPORT macro. +set_target_properties(${PLUGIN_NAME} PROPERTIES + CXX_VISIBILITY_PRESET hidden) +target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL) + +# Source include directories and library dependencies. Add any plugin-specific +# dependencies here. +target_include_directories(${PLUGIN_NAME} INTERFACE + "${CMAKE_CURRENT_SOURCE_DIR}/include") +target_link_libraries(${PLUGIN_NAME} PRIVATE flutter) +target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK) + +# List of absolute paths to libraries that should be bundled with the plugin. +# This list could contain prebuilt libraries, or libraries created by an +# external build triggered from this build file. +set(test_plugin_bundled_libraries + "" + PARENT_SCOPE +) + +# === Tests === +# These unit tests can be run from a terminal after building the example. + +# Only enable test builds when building the example (which sets this variable) +# so that plugin clients aren't building the tests. +if (${include_${PROJECT_NAME}_tests}) +if(${CMAKE_VERSION} VERSION_LESS "3.11.0") +message("Unit tests require CMake 3.11.0 or later") +else() +set(TEST_RUNNER "${PROJECT_NAME}_test") +enable_testing() + +# Add the Google Test dependency. +include(FetchContent) +FetchContent_Declare( + googletest + URL https://github.com/google/googletest/archive/release-1.11.0.zip +) +# Prevent overriding the parent project's compiler/linker settings +set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) +# Disable install commands for gtest so it doesn't end up in the bundle. +set(INSTALL_GTEST OFF CACHE BOOL "Disable installation of googletest" FORCE) + +FetchContent_MakeAvailable(googletest) + +# The plugin's exported API is not very useful for unit testing, so build the +# sources directly into the test binary rather than using the shared library. +add_executable(${TEST_RUNNER} + # Tests. + test/multiple_arity_test.cc + test/non_null_fields_test.cc + test/nullable_returns_test.cc + test/null_fields_test.cc + test/primitive_test.cc + # Test utilities. + test/utils/fake_host_messenger.cc + test/utils/fake_host_messenger.h + ${PLUGIN_SOURCES} +) +apply_standard_settings(${TEST_RUNNER}) +target_include_directories(${TEST_RUNNER} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}") +target_link_libraries(${TEST_RUNNER} PRIVATE flutter) +target_link_libraries(${TEST_RUNNER} PRIVATE PkgConfig::GTK) +target_link_libraries(${TEST_RUNNER} PRIVATE gtest_main gmock) + +# Enable automatic test discovery. +include(GoogleTest) +gtest_discover_tests(${TEST_RUNNER}) + +endif() # CMake version check +endif() # include_${PROJECT_NAME}_tests \ No newline at end of file diff --git a/packages/pigeon/platform_tests/test_plugin/linux/include/test_plugin/test_plugin.h b/packages/pigeon/platform_tests/test_plugin/linux/include/test_plugin/test_plugin.h new file mode 100644 index 000000000000..9cb33f32e54e --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/include/test_plugin/test_plugin.h @@ -0,0 +1,25 @@ +// 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 FLUTTER_PLUGIN_TEST_PLUGIN_H_ +#define FLUTTER_PLUGIN_TEST_PLUGIN_H_ + +#include + +G_BEGIN_DECLS + +#ifdef FLUTTER_PLUGIN_IMPL +#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default"))) +#else +#define FLUTTER_PLUGIN_EXPORT +#endif + +G_DECLARE_FINAL_TYPE(TestPlugin, test_plugin, TEST, PLUGIN, GObject) + +FLUTTER_PLUGIN_EXPORT void test_plugin_register_with_registrar( + FlPluginRegistrar* registrar); + +G_END_DECLS + +#endif // FLUTTER_PLUGIN_TEST_PLUGIN_H_ diff --git a/packages/pigeon/platform_tests/test_plugin/linux/pigeon/.gitignore b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/.gitignore new file mode 100644 index 000000000000..3c556db82870 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/.gitignore @@ -0,0 +1,6 @@ +# TODO(stuartmorgan): Remove this, so that review will show the effects of +# changes on generated files, once https://github.com/flutter/flutter/issues/115168 +# is done. +*.gen.h +*.gen.cc +!core_tests.gen* diff --git a/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.cc b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.cc new file mode 100644 index 000000000000..fddf46a03a80 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.cc @@ -0,0 +1,19101 @@ +// 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. +// +// Autogenerated from Pigeon, do not edit directly. +// See also: https://pub.dev/packages/pigeon + +#include "core_tests.gen.h" + +struct _CoreTestsPigeonTestAllTypes { + GObject parent_instance; + + gboolean a_bool; + int64_t an_int; + int64_t an_int64; + double a_double; + uint8_t* a_byte_array; + size_t a_byte_array_length; + int32_t* a4_byte_array; + size_t a4_byte_array_length; + int64_t* a8_byte_array; + size_t a8_byte_array_length; + double* a_float_array; + size_t a_float_array_length; + CoreTestsPigeonTestAnEnum an_enum; + gchar* a_string; + FlValue* an_object; + FlValue* list; + FlValue* string_list; + FlValue* int_list; + FlValue* double_list; + FlValue* bool_list; + FlValue* map; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestAllTypes, core_tests_pigeon_test_all_types, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_all_types_dispose(GObject* object) { + CoreTestsPigeonTestAllTypes* self = CORE_TESTS_PIGEON_TEST_ALL_TYPES(object); + g_clear_pointer(&self->a_string, g_free); + g_clear_pointer(&self->an_object, fl_value_unref); + g_clear_pointer(&self->list, fl_value_unref); + g_clear_pointer(&self->string_list, fl_value_unref); + g_clear_pointer(&self->int_list, fl_value_unref); + g_clear_pointer(&self->double_list, fl_value_unref); + g_clear_pointer(&self->bool_list, fl_value_unref); + g_clear_pointer(&self->map, fl_value_unref); + G_OBJECT_CLASS(core_tests_pigeon_test_all_types_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_all_types_init( + CoreTestsPigeonTestAllTypes* self) {} + +static void core_tests_pigeon_test_all_types_class_init( + CoreTestsPigeonTestAllTypesClass* klass) { + G_OBJECT_CLASS(klass)->dispose = core_tests_pigeon_test_all_types_dispose; +} + +CoreTestsPigeonTestAllTypes* core_tests_pigeon_test_all_types_new( + gboolean a_bool, int64_t an_int, int64_t an_int64, double a_double, + const uint8_t* a_byte_array, size_t a_byte_array_length, + const int32_t* a4_byte_array, size_t a4_byte_array_length, + const int64_t* a8_byte_array, size_t a8_byte_array_length, + const double* a_float_array, size_t a_float_array_length, + CoreTestsPigeonTestAnEnum an_enum, const gchar* a_string, + FlValue* an_object, FlValue* list, FlValue* string_list, FlValue* int_list, + FlValue* double_list, FlValue* bool_list, FlValue* map) { + CoreTestsPigeonTestAllTypes* self = CORE_TESTS_PIGEON_TEST_ALL_TYPES( + g_object_new(core_tests_pigeon_test_all_types_get_type(), nullptr)); + self->a_bool = a_bool; + self->an_int = an_int; + self->an_int64 = an_int64; + self->a_double = a_double; + self->a_byte_array = static_cast( + memcpy(malloc(a_byte_array_length), a_byte_array, a_byte_array_length)); + self->a_byte_array_length = a_byte_array_length; + self->a4_byte_array = static_cast( + memcpy(malloc(sizeof(int32_t) * a4_byte_array_length), a4_byte_array, + sizeof(int32_t) * a4_byte_array_length)); + self->a4_byte_array_length = a4_byte_array_length; + self->a8_byte_array = static_cast( + memcpy(malloc(sizeof(int64_t) * a8_byte_array_length), a8_byte_array, + sizeof(int64_t) * a8_byte_array_length)); + self->a8_byte_array_length = a8_byte_array_length; + self->a_float_array = static_cast( + memcpy(malloc(sizeof(double) * a_float_array_length), a_float_array, + sizeof(double) * a_float_array_length)); + self->a_float_array_length = a_float_array_length; + self->an_enum = an_enum; + self->a_string = g_strdup(a_string); + self->an_object = fl_value_ref(an_object); + self->list = fl_value_ref(list); + self->string_list = fl_value_ref(string_list); + self->int_list = fl_value_ref(int_list); + self->double_list = fl_value_ref(double_list); + self->bool_list = fl_value_ref(bool_list); + self->map = fl_value_ref(map); + return self; +} + +gboolean core_tests_pigeon_test_all_types_get_a_bool( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), FALSE); + return self->a_bool; +} + +int64_t core_tests_pigeon_test_all_types_get_an_int( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), 0); + return self->an_int; +} + +int64_t core_tests_pigeon_test_all_types_get_an_int64( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), 0); + return self->an_int64; +} + +double core_tests_pigeon_test_all_types_get_a_double( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), 0.0); + return self->a_double; +} + +const uint8_t* core_tests_pigeon_test_all_types_get_a_byte_array( + CoreTestsPigeonTestAllTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + *length = self->a_byte_array_length; + return self->a_byte_array; +} + +const int32_t* core_tests_pigeon_test_all_types_get_a4_byte_array( + CoreTestsPigeonTestAllTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + *length = self->a4_byte_array_length; + return self->a4_byte_array; +} + +const int64_t* core_tests_pigeon_test_all_types_get_a8_byte_array( + CoreTestsPigeonTestAllTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + *length = self->a8_byte_array_length; + return self->a8_byte_array; +} + +const double* core_tests_pigeon_test_all_types_get_a_float_array( + CoreTestsPigeonTestAllTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + *length = self->a_float_array_length; + return self->a_float_array; +} + +CoreTestsPigeonTestAnEnum core_tests_pigeon_test_all_types_get_an_enum( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), + static_cast(0)); + return self->an_enum; +} + +const gchar* core_tests_pigeon_test_all_types_get_a_string( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->a_string; +} + +FlValue* core_tests_pigeon_test_all_types_get_an_object( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->an_object; +} + +FlValue* core_tests_pigeon_test_all_types_get_list( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->list; +} + +FlValue* core_tests_pigeon_test_all_types_get_string_list( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->string_list; +} + +FlValue* core_tests_pigeon_test_all_types_get_int_list( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->int_list; +} + +FlValue* core_tests_pigeon_test_all_types_get_double_list( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->double_list; +} + +FlValue* core_tests_pigeon_test_all_types_get_bool_list( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->bool_list; +} + +FlValue* core_tests_pigeon_test_all_types_get_map( + CoreTestsPigeonTestAllTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_TYPES(self), nullptr); + return self->map; +} + +static FlValue* core_tests_pigeon_test_all_types_to_list( + CoreTestsPigeonTestAllTypes* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, fl_value_new_bool(self->a_bool)); + fl_value_append_take(values, fl_value_new_int(self->an_int)); + fl_value_append_take(values, fl_value_new_int(self->an_int64)); + fl_value_append_take(values, fl_value_new_float(self->a_double)); + fl_value_append_take( + values, + fl_value_new_uint8_list(self->a_byte_array, self->a_byte_array_length)); + fl_value_append_take( + values, + fl_value_new_int32_list(self->a4_byte_array, self->a4_byte_array_length)); + fl_value_append_take( + values, + fl_value_new_int64_list(self->a8_byte_array, self->a8_byte_array_length)); + fl_value_append_take( + values, + fl_value_new_float_list(self->a_float_array, self->a_float_array_length)); + fl_value_append_take(values, + fl_value_new_custom(134, fl_value_new_int(self->an_enum), + (GDestroyNotify)fl_value_unref)); + fl_value_append_take(values, fl_value_new_string(self->a_string)); + fl_value_append_take(values, fl_value_ref(self->an_object)); + fl_value_append_take(values, fl_value_ref(self->list)); + fl_value_append_take(values, fl_value_ref(self->string_list)); + fl_value_append_take(values, fl_value_ref(self->int_list)); + fl_value_append_take(values, fl_value_ref(self->double_list)); + fl_value_append_take(values, fl_value_ref(self->bool_list)); + fl_value_append_take(values, fl_value_ref(self->map)); + return values; +} + +static CoreTestsPigeonTestAllTypes* +core_tests_pigeon_test_all_types_new_from_list(FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + gboolean a_bool = fl_value_get_bool(value0); + FlValue* value1 = fl_value_get_list_value(values, 1); + int64_t an_int = fl_value_get_int(value1); + FlValue* value2 = fl_value_get_list_value(values, 2); + int64_t an_int64 = fl_value_get_int(value2); + FlValue* value3 = fl_value_get_list_value(values, 3); + double a_double = fl_value_get_float(value3); + FlValue* value4 = fl_value_get_list_value(values, 4); + const uint8_t* a_byte_array = fl_value_get_uint8_list(value4); + size_t a_byte_array_length = fl_value_get_length(value4); + FlValue* value5 = fl_value_get_list_value(values, 5); + const int32_t* a4_byte_array = fl_value_get_int32_list(value5); + size_t a4_byte_array_length = fl_value_get_length(value5); + FlValue* value6 = fl_value_get_list_value(values, 6); + const int64_t* a8_byte_array = fl_value_get_int64_list(value6); + size_t a8_byte_array_length = fl_value_get_length(value6); + FlValue* value7 = fl_value_get_list_value(values, 7); + const double* a_float_array = fl_value_get_float_list(value7); + size_t a_float_array_length = fl_value_get_length(value7); + FlValue* value8 = fl_value_get_list_value(values, 8); + CoreTestsPigeonTestAnEnum an_enum = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value8))))); + FlValue* value9 = fl_value_get_list_value(values, 9); + const gchar* a_string = fl_value_get_string(value9); + FlValue* value10 = fl_value_get_list_value(values, 10); + FlValue* an_object = value10; + FlValue* value11 = fl_value_get_list_value(values, 11); + FlValue* list = value11; + FlValue* value12 = fl_value_get_list_value(values, 12); + FlValue* string_list = value12; + FlValue* value13 = fl_value_get_list_value(values, 13); + FlValue* int_list = value13; + FlValue* value14 = fl_value_get_list_value(values, 14); + FlValue* double_list = value14; + FlValue* value15 = fl_value_get_list_value(values, 15); + FlValue* bool_list = value15; + FlValue* value16 = fl_value_get_list_value(values, 16); + FlValue* map = value16; + return core_tests_pigeon_test_all_types_new( + a_bool, an_int, an_int64, a_double, a_byte_array, a_byte_array_length, + a4_byte_array, a4_byte_array_length, a8_byte_array, a8_byte_array_length, + a_float_array, a_float_array_length, an_enum, a_string, an_object, list, + string_list, int_list, double_list, bool_list, map); +} + +struct _CoreTestsPigeonTestAllNullableTypes { + GObject parent_instance; + + gboolean* a_nullable_bool; + int64_t* a_nullable_int; + int64_t* a_nullable_int64; + double* a_nullable_double; + uint8_t* a_nullable_byte_array; + size_t a_nullable_byte_array_length; + int32_t* a_nullable4_byte_array; + size_t a_nullable4_byte_array_length; + int64_t* a_nullable8_byte_array; + size_t a_nullable8_byte_array_length; + double* a_nullable_float_array; + size_t a_nullable_float_array_length; + FlValue* nullable_nested_list; + FlValue* nullable_map_with_annotations; + FlValue* nullable_map_with_object; + CoreTestsPigeonTestAnEnum* a_nullable_enum; + gchar* a_nullable_string; + FlValue* a_nullable_object; + CoreTestsPigeonTestAllNullableTypes* all_nullable_types; + FlValue* list; + FlValue* string_list; + FlValue* int_list; + FlValue* double_list; + FlValue* bool_list; + FlValue* nested_class_list; + FlValue* map; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestAllNullableTypes, + core_tests_pigeon_test_all_nullable_types, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_all_nullable_types_dispose(GObject* object) { + CoreTestsPigeonTestAllNullableTypes* self = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES(object); + g_clear_pointer(&self->a_nullable_bool, g_free); + g_clear_pointer(&self->a_nullable_int, g_free); + g_clear_pointer(&self->a_nullable_int64, g_free); + g_clear_pointer(&self->a_nullable_double, g_free); + g_clear_pointer(&self->nullable_nested_list, fl_value_unref); + g_clear_pointer(&self->nullable_map_with_annotations, fl_value_unref); + g_clear_pointer(&self->nullable_map_with_object, fl_value_unref); + g_clear_pointer(&self->a_nullable_enum, g_free); + g_clear_pointer(&self->a_nullable_string, g_free); + g_clear_pointer(&self->a_nullable_object, fl_value_unref); + g_clear_object(&self->all_nullable_types); + g_clear_pointer(&self->list, fl_value_unref); + g_clear_pointer(&self->string_list, fl_value_unref); + g_clear_pointer(&self->int_list, fl_value_unref); + g_clear_pointer(&self->double_list, fl_value_unref); + g_clear_pointer(&self->bool_list, fl_value_unref); + g_clear_pointer(&self->nested_class_list, fl_value_unref); + g_clear_pointer(&self->map, fl_value_unref); + G_OBJECT_CLASS(core_tests_pigeon_test_all_nullable_types_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_all_nullable_types_init( + CoreTestsPigeonTestAllNullableTypes* self) {} + +static void core_tests_pigeon_test_all_nullable_types_class_init( + CoreTestsPigeonTestAllNullableTypesClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_all_nullable_types_dispose; +} + +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_nullable_types_new( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + int64_t* a_nullable_int64, double* a_nullable_double, + const uint8_t* a_nullable_byte_array, size_t a_nullable_byte_array_length, + const int32_t* a_nullable4_byte_array, size_t a_nullable4_byte_array_length, + const int64_t* a_nullable8_byte_array, size_t a_nullable8_byte_array_length, + const double* a_nullable_float_array, size_t a_nullable_float_array_length, + FlValue* nullable_nested_list, FlValue* nullable_map_with_annotations, + FlValue* nullable_map_with_object, + CoreTestsPigeonTestAnEnum* a_nullable_enum, const gchar* a_nullable_string, + FlValue* a_nullable_object, + CoreTestsPigeonTestAllNullableTypes* all_nullable_types, FlValue* list, + FlValue* string_list, FlValue* int_list, FlValue* double_list, + FlValue* bool_list, FlValue* nested_class_list, FlValue* map) { + CoreTestsPigeonTestAllNullableTypes* self = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES(g_object_new( + core_tests_pigeon_test_all_nullable_types_get_type(), nullptr)); + if (a_nullable_bool != nullptr) { + self->a_nullable_bool = static_cast(malloc(sizeof(gboolean))); + *self->a_nullable_bool = *a_nullable_bool; + } else { + self->a_nullable_bool = nullptr; + } + if (a_nullable_int != nullptr) { + self->a_nullable_int = static_cast(malloc(sizeof(int64_t))); + *self->a_nullable_int = *a_nullable_int; + } else { + self->a_nullable_int = nullptr; + } + if (a_nullable_int64 != nullptr) { + self->a_nullable_int64 = static_cast(malloc(sizeof(int64_t))); + *self->a_nullable_int64 = *a_nullable_int64; + } else { + self->a_nullable_int64 = nullptr; + } + if (a_nullable_double != nullptr) { + self->a_nullable_double = static_cast(malloc(sizeof(double))); + *self->a_nullable_double = *a_nullable_double; + } else { + self->a_nullable_double = nullptr; + } + if (a_nullable_byte_array != nullptr) { + self->a_nullable_byte_array = static_cast( + memcpy(malloc(a_nullable_byte_array_length), a_nullable_byte_array, + a_nullable_byte_array_length)); + self->a_nullable_byte_array_length = a_nullable_byte_array_length; + } else { + self->a_nullable_byte_array = nullptr; + self->a_nullable_byte_array_length = 0; + } + if (a_nullable4_byte_array != nullptr) { + self->a_nullable4_byte_array = static_cast( + memcpy(malloc(sizeof(int32_t) * a_nullable4_byte_array_length), + a_nullable4_byte_array, + sizeof(int32_t) * a_nullable4_byte_array_length)); + self->a_nullable4_byte_array_length = a_nullable4_byte_array_length; + } else { + self->a_nullable4_byte_array = nullptr; + self->a_nullable4_byte_array_length = 0; + } + if (a_nullable8_byte_array != nullptr) { + self->a_nullable8_byte_array = static_cast( + memcpy(malloc(sizeof(int64_t) * a_nullable8_byte_array_length), + a_nullable8_byte_array, + sizeof(int64_t) * a_nullable8_byte_array_length)); + self->a_nullable8_byte_array_length = a_nullable8_byte_array_length; + } else { + self->a_nullable8_byte_array = nullptr; + self->a_nullable8_byte_array_length = 0; + } + if (a_nullable_float_array != nullptr) { + self->a_nullable_float_array = static_cast( + memcpy(malloc(sizeof(double) * a_nullable_float_array_length), + a_nullable_float_array, + sizeof(double) * a_nullable_float_array_length)); + self->a_nullable_float_array_length = a_nullable_float_array_length; + } else { + self->a_nullable_float_array = nullptr; + self->a_nullable_float_array_length = 0; + } + if (nullable_nested_list != nullptr) { + self->nullable_nested_list = fl_value_ref(nullable_nested_list); + } else { + self->nullable_nested_list = nullptr; + } + if (nullable_map_with_annotations != nullptr) { + self->nullable_map_with_annotations = + fl_value_ref(nullable_map_with_annotations); + } else { + self->nullable_map_with_annotations = nullptr; + } + if (nullable_map_with_object != nullptr) { + self->nullable_map_with_object = fl_value_ref(nullable_map_with_object); + } else { + self->nullable_map_with_object = nullptr; + } + if (a_nullable_enum != nullptr) { + self->a_nullable_enum = static_cast( + malloc(sizeof(CoreTestsPigeonTestAnEnum))); + *self->a_nullable_enum = *a_nullable_enum; + } else { + self->a_nullable_enum = nullptr; + } + if (a_nullable_string != nullptr) { + self->a_nullable_string = g_strdup(a_nullable_string); + } else { + self->a_nullable_string = nullptr; + } + if (a_nullable_object != nullptr) { + self->a_nullable_object = fl_value_ref(a_nullable_object); + } else { + self->a_nullable_object = nullptr; + } + if (all_nullable_types != nullptr) { + self->all_nullable_types = CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + g_object_ref(all_nullable_types)); + } else { + self->all_nullable_types = nullptr; + } + if (list != nullptr) { + self->list = fl_value_ref(list); + } else { + self->list = nullptr; + } + if (string_list != nullptr) { + self->string_list = fl_value_ref(string_list); + } else { + self->string_list = nullptr; + } + if (int_list != nullptr) { + self->int_list = fl_value_ref(int_list); + } else { + self->int_list = nullptr; + } + if (double_list != nullptr) { + self->double_list = fl_value_ref(double_list); + } else { + self->double_list = nullptr; + } + if (bool_list != nullptr) { + self->bool_list = fl_value_ref(bool_list); + } else { + self->bool_list = nullptr; + } + if (nested_class_list != nullptr) { + self->nested_class_list = fl_value_ref(nested_class_list); + } else { + self->nested_class_list = nullptr; + } + if (map != nullptr) { + self->map = fl_value_ref(map); + } else { + self->map = nullptr; + } + return self; +} + +gboolean* core_tests_pigeon_test_all_nullable_types_get_a_nullable_bool( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_bool; +} + +int64_t* core_tests_pigeon_test_all_nullable_types_get_a_nullable_int( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_int; +} + +int64_t* core_tests_pigeon_test_all_nullable_types_get_a_nullable_int64( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_int64; +} + +double* core_tests_pigeon_test_all_nullable_types_get_a_nullable_double( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_double; +} + +const uint8_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_byte_array( + CoreTestsPigeonTestAllNullableTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + *length = self->a_nullable_byte_array_length; + return self->a_nullable_byte_array; +} + +const int32_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable4_byte_array( + CoreTestsPigeonTestAllNullableTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + *length = self->a_nullable4_byte_array_length; + return self->a_nullable4_byte_array; +} + +const int64_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable8_byte_array( + CoreTestsPigeonTestAllNullableTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + *length = self->a_nullable8_byte_array_length; + return self->a_nullable8_byte_array; +} + +const double* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_float_array( + CoreTestsPigeonTestAllNullableTypes* self, size_t* length) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + *length = self->a_nullable_float_array_length; + return self->a_nullable_float_array; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_nullable_nested_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->nullable_nested_list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_annotations( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->nullable_map_with_annotations; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_object( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->nullable_map_with_object; +} + +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_enum( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_enum; +} + +const gchar* core_tests_pigeon_test_all_nullable_types_get_a_nullable_string( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_string; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_a_nullable_object( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->a_nullable_object; +} + +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_nullable_types_get_all_nullable_types( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->all_nullable_types; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_string_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->string_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_int_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->int_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_double_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->double_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_bool_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->bool_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_nested_class_list( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->nested_class_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_get_map( + CoreTestsPigeonTestAllNullableTypes* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES(self), + nullptr); + return self->map; +} + +static FlValue* core_tests_pigeon_test_all_nullable_types_to_list( + CoreTestsPigeonTestAllNullableTypes* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, self->a_nullable_bool != nullptr + ? fl_value_new_bool(*self->a_nullable_bool) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_int != nullptr + ? fl_value_new_int(*self->a_nullable_int) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_int64 != nullptr + ? fl_value_new_int(*self->a_nullable_int64) + : fl_value_new_null()); + fl_value_append_take(values, + self->a_nullable_double != nullptr + ? fl_value_new_float(*self->a_nullable_double) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable_byte_array != nullptr + ? fl_value_new_uint8_list(self->a_nullable_byte_array, + self->a_nullable_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable4_byte_array != nullptr + ? fl_value_new_int32_list(self->a_nullable4_byte_array, + self->a_nullable4_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable8_byte_array != nullptr + ? fl_value_new_int64_list(self->a_nullable8_byte_array, + self->a_nullable8_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable_float_array != nullptr + ? fl_value_new_float_list(self->a_nullable_float_array, + self->a_nullable_float_array_length) + : fl_value_new_null()); + fl_value_append_take(values, self->nullable_nested_list != nullptr + ? fl_value_ref(self->nullable_nested_list) + : fl_value_new_null()); + fl_value_append_take(values, + self->nullable_map_with_annotations != nullptr + ? fl_value_ref(self->nullable_map_with_annotations) + : fl_value_new_null()); + fl_value_append_take(values, + self->nullable_map_with_object != nullptr + ? fl_value_ref(self->nullable_map_with_object) + : fl_value_new_null()); + fl_value_append_take( + values, + self->a_nullable_enum != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*self->a_nullable_enum), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + fl_value_append_take(values, + self->a_nullable_string != nullptr + ? fl_value_new_string(self->a_nullable_string) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_object != nullptr + ? fl_value_ref(self->a_nullable_object) + : fl_value_new_null()); + fl_value_append_take( + values, + self->all_nullable_types != nullptr + ? fl_value_new_custom_object(130, G_OBJECT(self->all_nullable_types)) + : fl_value_new_null()); + fl_value_append_take(values, self->list != nullptr ? fl_value_ref(self->list) + : fl_value_new_null()); + fl_value_append_take(values, self->string_list != nullptr + ? fl_value_ref(self->string_list) + : fl_value_new_null()); + fl_value_append_take(values, self->int_list != nullptr + ? fl_value_ref(self->int_list) + : fl_value_new_null()); + fl_value_append_take(values, self->double_list != nullptr + ? fl_value_ref(self->double_list) + : fl_value_new_null()); + fl_value_append_take(values, self->bool_list != nullptr + ? fl_value_ref(self->bool_list) + : fl_value_new_null()); + fl_value_append_take(values, self->nested_class_list != nullptr + ? fl_value_ref(self->nested_class_list) + : fl_value_new_null()); + fl_value_append_take(values, self->map != nullptr ? fl_value_ref(self->map) + : fl_value_new_null()); + return values; +} + +static CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_nullable_types_new_from_list(FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(values, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(values, 2); + int64_t* a_nullable_int64 = nullptr; + int64_t a_nullable_int64_value; + if (fl_value_get_type(value2) != FL_VALUE_TYPE_NULL) { + a_nullable_int64_value = fl_value_get_int(value2); + a_nullable_int64 = &a_nullable_int64_value; + } + FlValue* value3 = fl_value_get_list_value(values, 3); + double* a_nullable_double = nullptr; + double a_nullable_double_value; + if (fl_value_get_type(value3) != FL_VALUE_TYPE_NULL) { + a_nullable_double_value = fl_value_get_float(value3); + a_nullable_double = &a_nullable_double_value; + } + FlValue* value4 = fl_value_get_list_value(values, 4); + const uint8_t* a_nullable_byte_array = nullptr; + size_t a_nullable_byte_array_length = 0; + if (fl_value_get_type(value4) != FL_VALUE_TYPE_NULL) { + a_nullable_byte_array = fl_value_get_uint8_list(value4); + a_nullable_byte_array_length = fl_value_get_length(value4); + } + FlValue* value5 = fl_value_get_list_value(values, 5); + const int32_t* a_nullable4_byte_array = nullptr; + size_t a_nullable4_byte_array_length = 0; + if (fl_value_get_type(value5) != FL_VALUE_TYPE_NULL) { + a_nullable4_byte_array = fl_value_get_int32_list(value5); + a_nullable4_byte_array_length = fl_value_get_length(value5); + } + FlValue* value6 = fl_value_get_list_value(values, 6); + const int64_t* a_nullable8_byte_array = nullptr; + size_t a_nullable8_byte_array_length = 0; + if (fl_value_get_type(value6) != FL_VALUE_TYPE_NULL) { + a_nullable8_byte_array = fl_value_get_int64_list(value6); + a_nullable8_byte_array_length = fl_value_get_length(value6); + } + FlValue* value7 = fl_value_get_list_value(values, 7); + const double* a_nullable_float_array = nullptr; + size_t a_nullable_float_array_length = 0; + if (fl_value_get_type(value7) != FL_VALUE_TYPE_NULL) { + a_nullable_float_array = fl_value_get_float_list(value7); + a_nullable_float_array_length = fl_value_get_length(value7); + } + FlValue* value8 = fl_value_get_list_value(values, 8); + FlValue* nullable_nested_list = nullptr; + if (fl_value_get_type(value8) != FL_VALUE_TYPE_NULL) { + nullable_nested_list = value8; + } + FlValue* value9 = fl_value_get_list_value(values, 9); + FlValue* nullable_map_with_annotations = nullptr; + if (fl_value_get_type(value9) != FL_VALUE_TYPE_NULL) { + nullable_map_with_annotations = value9; + } + FlValue* value10 = fl_value_get_list_value(values, 10); + FlValue* nullable_map_with_object = nullptr; + if (fl_value_get_type(value10) != FL_VALUE_TYPE_NULL) { + nullable_map_with_object = value10; + } + FlValue* value11 = fl_value_get_list_value(values, 11); + CoreTestsPigeonTestAnEnum* a_nullable_enum = nullptr; + CoreTestsPigeonTestAnEnum a_nullable_enum_value; + if (fl_value_get_type(value11) != FL_VALUE_TYPE_NULL) { + a_nullable_enum_value = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value11))))); + a_nullable_enum = &a_nullable_enum_value; + } + FlValue* value12 = fl_value_get_list_value(values, 12); + const gchar* a_nullable_string = nullptr; + if (fl_value_get_type(value12) != FL_VALUE_TYPE_NULL) { + a_nullable_string = fl_value_get_string(value12); + } + FlValue* value13 = fl_value_get_list_value(values, 13); + FlValue* a_nullable_object = nullptr; + if (fl_value_get_type(value13) != FL_VALUE_TYPE_NULL) { + a_nullable_object = value13; + } + FlValue* value14 = fl_value_get_list_value(values, 14); + CoreTestsPigeonTestAllNullableTypes* all_nullable_types = nullptr; + if (fl_value_get_type(value14) != FL_VALUE_TYPE_NULL) { + all_nullable_types = CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value14)); + } + FlValue* value15 = fl_value_get_list_value(values, 15); + FlValue* list = nullptr; + if (fl_value_get_type(value15) != FL_VALUE_TYPE_NULL) { + list = value15; + } + FlValue* value16 = fl_value_get_list_value(values, 16); + FlValue* string_list = nullptr; + if (fl_value_get_type(value16) != FL_VALUE_TYPE_NULL) { + string_list = value16; + } + FlValue* value17 = fl_value_get_list_value(values, 17); + FlValue* int_list = nullptr; + if (fl_value_get_type(value17) != FL_VALUE_TYPE_NULL) { + int_list = value17; + } + FlValue* value18 = fl_value_get_list_value(values, 18); + FlValue* double_list = nullptr; + if (fl_value_get_type(value18) != FL_VALUE_TYPE_NULL) { + double_list = value18; + } + FlValue* value19 = fl_value_get_list_value(values, 19); + FlValue* bool_list = nullptr; + if (fl_value_get_type(value19) != FL_VALUE_TYPE_NULL) { + bool_list = value19; + } + FlValue* value20 = fl_value_get_list_value(values, 20); + FlValue* nested_class_list = nullptr; + if (fl_value_get_type(value20) != FL_VALUE_TYPE_NULL) { + nested_class_list = value20; + } + FlValue* value21 = fl_value_get_list_value(values, 21); + FlValue* map = nullptr; + if (fl_value_get_type(value21) != FL_VALUE_TYPE_NULL) { + map = value21; + } + return core_tests_pigeon_test_all_nullable_types_new( + a_nullable_bool, a_nullable_int, a_nullable_int64, a_nullable_double, + a_nullable_byte_array, a_nullable_byte_array_length, + a_nullable4_byte_array, a_nullable4_byte_array_length, + a_nullable8_byte_array, a_nullable8_byte_array_length, + a_nullable_float_array, a_nullable_float_array_length, + nullable_nested_list, nullable_map_with_annotations, + nullable_map_with_object, a_nullable_enum, a_nullable_string, + a_nullable_object, all_nullable_types, list, string_list, int_list, + double_list, bool_list, nested_class_list, map); +} + +struct _CoreTestsPigeonTestAllNullableTypesWithoutRecursion { + GObject parent_instance; + + gboolean* a_nullable_bool; + int64_t* a_nullable_int; + int64_t* a_nullable_int64; + double* a_nullable_double; + uint8_t* a_nullable_byte_array; + size_t a_nullable_byte_array_length; + int32_t* a_nullable4_byte_array; + size_t a_nullable4_byte_array_length; + int64_t* a_nullable8_byte_array; + size_t a_nullable8_byte_array_length; + double* a_nullable_float_array; + size_t a_nullable_float_array_length; + FlValue* nullable_nested_list; + FlValue* nullable_map_with_annotations; + FlValue* nullable_map_with_object; + CoreTestsPigeonTestAnEnum* a_nullable_enum; + gchar* a_nullable_string; + FlValue* a_nullable_object; + FlValue* list; + FlValue* string_list; + FlValue* int_list; + FlValue* double_list; + FlValue* bool_list; + FlValue* map; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestAllNullableTypesWithoutRecursion, + core_tests_pigeon_test_all_nullable_types_without_recursion, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_all_nullable_types_without_recursion_dispose( + GObject* object) { + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(object); + g_clear_pointer(&self->a_nullable_bool, g_free); + g_clear_pointer(&self->a_nullable_int, g_free); + g_clear_pointer(&self->a_nullable_int64, g_free); + g_clear_pointer(&self->a_nullable_double, g_free); + g_clear_pointer(&self->nullable_nested_list, fl_value_unref); + g_clear_pointer(&self->nullable_map_with_annotations, fl_value_unref); + g_clear_pointer(&self->nullable_map_with_object, fl_value_unref); + g_clear_pointer(&self->a_nullable_enum, g_free); + g_clear_pointer(&self->a_nullable_string, g_free); + g_clear_pointer(&self->a_nullable_object, fl_value_unref); + g_clear_pointer(&self->list, fl_value_unref); + g_clear_pointer(&self->string_list, fl_value_unref); + g_clear_pointer(&self->int_list, fl_value_unref); + g_clear_pointer(&self->double_list, fl_value_unref); + g_clear_pointer(&self->bool_list, fl_value_unref); + g_clear_pointer(&self->map, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_all_nullable_types_without_recursion_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_all_nullable_types_without_recursion_init( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) {} + +static void +core_tests_pigeon_test_all_nullable_types_without_recursion_class_init( + CoreTestsPigeonTestAllNullableTypesWithoutRecursionClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_all_nullable_types_without_recursion_dispose; +} + +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_all_nullable_types_without_recursion_new( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + int64_t* a_nullable_int64, double* a_nullable_double, + const uint8_t* a_nullable_byte_array, size_t a_nullable_byte_array_length, + const int32_t* a_nullable4_byte_array, size_t a_nullable4_byte_array_length, + const int64_t* a_nullable8_byte_array, size_t a_nullable8_byte_array_length, + const double* a_nullable_float_array, size_t a_nullable_float_array_length, + FlValue* nullable_nested_list, FlValue* nullable_map_with_annotations, + FlValue* nullable_map_with_object, + CoreTestsPigeonTestAnEnum* a_nullable_enum, const gchar* a_nullable_string, + FlValue* a_nullable_object, FlValue* list, FlValue* string_list, + FlValue* int_list, FlValue* double_list, FlValue* bool_list, FlValue* map) { + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(g_object_new( + core_tests_pigeon_test_all_nullable_types_without_recursion_get_type(), + nullptr)); + if (a_nullable_bool != nullptr) { + self->a_nullable_bool = static_cast(malloc(sizeof(gboolean))); + *self->a_nullable_bool = *a_nullable_bool; + } else { + self->a_nullable_bool = nullptr; + } + if (a_nullable_int != nullptr) { + self->a_nullable_int = static_cast(malloc(sizeof(int64_t))); + *self->a_nullable_int = *a_nullable_int; + } else { + self->a_nullable_int = nullptr; + } + if (a_nullable_int64 != nullptr) { + self->a_nullable_int64 = static_cast(malloc(sizeof(int64_t))); + *self->a_nullable_int64 = *a_nullable_int64; + } else { + self->a_nullable_int64 = nullptr; + } + if (a_nullable_double != nullptr) { + self->a_nullable_double = static_cast(malloc(sizeof(double))); + *self->a_nullable_double = *a_nullable_double; + } else { + self->a_nullable_double = nullptr; + } + if (a_nullable_byte_array != nullptr) { + self->a_nullable_byte_array = static_cast( + memcpy(malloc(a_nullable_byte_array_length), a_nullable_byte_array, + a_nullable_byte_array_length)); + self->a_nullable_byte_array_length = a_nullable_byte_array_length; + } else { + self->a_nullable_byte_array = nullptr; + self->a_nullable_byte_array_length = 0; + } + if (a_nullable4_byte_array != nullptr) { + self->a_nullable4_byte_array = static_cast( + memcpy(malloc(sizeof(int32_t) * a_nullable4_byte_array_length), + a_nullable4_byte_array, + sizeof(int32_t) * a_nullable4_byte_array_length)); + self->a_nullable4_byte_array_length = a_nullable4_byte_array_length; + } else { + self->a_nullable4_byte_array = nullptr; + self->a_nullable4_byte_array_length = 0; + } + if (a_nullable8_byte_array != nullptr) { + self->a_nullable8_byte_array = static_cast( + memcpy(malloc(sizeof(int64_t) * a_nullable8_byte_array_length), + a_nullable8_byte_array, + sizeof(int64_t) * a_nullable8_byte_array_length)); + self->a_nullable8_byte_array_length = a_nullable8_byte_array_length; + } else { + self->a_nullable8_byte_array = nullptr; + self->a_nullable8_byte_array_length = 0; + } + if (a_nullable_float_array != nullptr) { + self->a_nullable_float_array = static_cast( + memcpy(malloc(sizeof(double) * a_nullable_float_array_length), + a_nullable_float_array, + sizeof(double) * a_nullable_float_array_length)); + self->a_nullable_float_array_length = a_nullable_float_array_length; + } else { + self->a_nullable_float_array = nullptr; + self->a_nullable_float_array_length = 0; + } + if (nullable_nested_list != nullptr) { + self->nullable_nested_list = fl_value_ref(nullable_nested_list); + } else { + self->nullable_nested_list = nullptr; + } + if (nullable_map_with_annotations != nullptr) { + self->nullable_map_with_annotations = + fl_value_ref(nullable_map_with_annotations); + } else { + self->nullable_map_with_annotations = nullptr; + } + if (nullable_map_with_object != nullptr) { + self->nullable_map_with_object = fl_value_ref(nullable_map_with_object); + } else { + self->nullable_map_with_object = nullptr; + } + if (a_nullable_enum != nullptr) { + self->a_nullable_enum = static_cast( + malloc(sizeof(CoreTestsPigeonTestAnEnum))); + *self->a_nullable_enum = *a_nullable_enum; + } else { + self->a_nullable_enum = nullptr; + } + if (a_nullable_string != nullptr) { + self->a_nullable_string = g_strdup(a_nullable_string); + } else { + self->a_nullable_string = nullptr; + } + if (a_nullable_object != nullptr) { + self->a_nullable_object = fl_value_ref(a_nullable_object); + } else { + self->a_nullable_object = nullptr; + } + if (list != nullptr) { + self->list = fl_value_ref(list); + } else { + self->list = nullptr; + } + if (string_list != nullptr) { + self->string_list = fl_value_ref(string_list); + } else { + self->string_list = nullptr; + } + if (int_list != nullptr) { + self->int_list = fl_value_ref(int_list); + } else { + self->int_list = nullptr; + } + if (double_list != nullptr) { + self->double_list = fl_value_ref(double_list); + } else { + self->double_list = nullptr; + } + if (bool_list != nullptr) { + self->bool_list = fl_value_ref(bool_list); + } else { + self->bool_list = nullptr; + } + if (map != nullptr) { + self->map = fl_value_ref(map); + } else { + self->map = nullptr; + } + return self; +} + +gboolean* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_bool( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_bool; +} + +int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_int; +} + +int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int64( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_int64; +} + +double* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_double( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_double; +} + +const uint8_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self, size_t* length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + *length = self->a_nullable_byte_array_length; + return self->a_nullable_byte_array; +} + +const int32_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable4_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self, size_t* length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + *length = self->a_nullable4_byte_array_length; + return self->a_nullable4_byte_array; +} + +const int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable8_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self, size_t* length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + *length = self->a_nullable8_byte_array_length; + return self->a_nullable8_byte_array; +} + +const double* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_float_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self, size_t* length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + *length = self->a_nullable_float_array_length; + return self->a_nullable_float_array; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_nested_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->nullable_nested_list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_annotations( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->nullable_map_with_annotations; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_object( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->nullable_map_with_object; +} + +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_enum( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_enum; +} + +const gchar* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_string( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_string; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_object( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->a_nullable_object; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_without_recursion_get_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_string_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->string_list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_int_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->int_list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_double_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->double_list; +} + +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_bool_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->bool_list; +} + +FlValue* core_tests_pigeon_test_all_nullable_types_without_recursion_get_map( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_ALL_NULLABLE_TYPES_WITHOUT_RECURSION(self), + nullptr); + return self->map; +} + +static FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_to_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, self->a_nullable_bool != nullptr + ? fl_value_new_bool(*self->a_nullable_bool) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_int != nullptr + ? fl_value_new_int(*self->a_nullable_int) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_int64 != nullptr + ? fl_value_new_int(*self->a_nullable_int64) + : fl_value_new_null()); + fl_value_append_take(values, + self->a_nullable_double != nullptr + ? fl_value_new_float(*self->a_nullable_double) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable_byte_array != nullptr + ? fl_value_new_uint8_list(self->a_nullable_byte_array, + self->a_nullable_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable4_byte_array != nullptr + ? fl_value_new_int32_list(self->a_nullable4_byte_array, + self->a_nullable4_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable8_byte_array != nullptr + ? fl_value_new_int64_list(self->a_nullable8_byte_array, + self->a_nullable8_byte_array_length) + : fl_value_new_null()); + fl_value_append_take( + values, self->a_nullable_float_array != nullptr + ? fl_value_new_float_list(self->a_nullable_float_array, + self->a_nullable_float_array_length) + : fl_value_new_null()); + fl_value_append_take(values, self->nullable_nested_list != nullptr + ? fl_value_ref(self->nullable_nested_list) + : fl_value_new_null()); + fl_value_append_take(values, + self->nullable_map_with_annotations != nullptr + ? fl_value_ref(self->nullable_map_with_annotations) + : fl_value_new_null()); + fl_value_append_take(values, + self->nullable_map_with_object != nullptr + ? fl_value_ref(self->nullable_map_with_object) + : fl_value_new_null()); + fl_value_append_take( + values, + self->a_nullable_enum != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*self->a_nullable_enum), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + fl_value_append_take(values, + self->a_nullable_string != nullptr + ? fl_value_new_string(self->a_nullable_string) + : fl_value_new_null()); + fl_value_append_take(values, self->a_nullable_object != nullptr + ? fl_value_ref(self->a_nullable_object) + : fl_value_new_null()); + fl_value_append_take(values, self->list != nullptr ? fl_value_ref(self->list) + : fl_value_new_null()); + fl_value_append_take(values, self->string_list != nullptr + ? fl_value_ref(self->string_list) + : fl_value_new_null()); + fl_value_append_take(values, self->int_list != nullptr + ? fl_value_ref(self->int_list) + : fl_value_new_null()); + fl_value_append_take(values, self->double_list != nullptr + ? fl_value_ref(self->double_list) + : fl_value_new_null()); + fl_value_append_take(values, self->bool_list != nullptr + ? fl_value_ref(self->bool_list) + : fl_value_new_null()); + fl_value_append_take(values, self->map != nullptr ? fl_value_ref(self->map) + : fl_value_new_null()); + return values; +} + +static CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_all_nullable_types_without_recursion_new_from_list( + FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(values, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(values, 2); + int64_t* a_nullable_int64 = nullptr; + int64_t a_nullable_int64_value; + if (fl_value_get_type(value2) != FL_VALUE_TYPE_NULL) { + a_nullable_int64_value = fl_value_get_int(value2); + a_nullable_int64 = &a_nullable_int64_value; + } + FlValue* value3 = fl_value_get_list_value(values, 3); + double* a_nullable_double = nullptr; + double a_nullable_double_value; + if (fl_value_get_type(value3) != FL_VALUE_TYPE_NULL) { + a_nullable_double_value = fl_value_get_float(value3); + a_nullable_double = &a_nullable_double_value; + } + FlValue* value4 = fl_value_get_list_value(values, 4); + const uint8_t* a_nullable_byte_array = nullptr; + size_t a_nullable_byte_array_length = 0; + if (fl_value_get_type(value4) != FL_VALUE_TYPE_NULL) { + a_nullable_byte_array = fl_value_get_uint8_list(value4); + a_nullable_byte_array_length = fl_value_get_length(value4); + } + FlValue* value5 = fl_value_get_list_value(values, 5); + const int32_t* a_nullable4_byte_array = nullptr; + size_t a_nullable4_byte_array_length = 0; + if (fl_value_get_type(value5) != FL_VALUE_TYPE_NULL) { + a_nullable4_byte_array = fl_value_get_int32_list(value5); + a_nullable4_byte_array_length = fl_value_get_length(value5); + } + FlValue* value6 = fl_value_get_list_value(values, 6); + const int64_t* a_nullable8_byte_array = nullptr; + size_t a_nullable8_byte_array_length = 0; + if (fl_value_get_type(value6) != FL_VALUE_TYPE_NULL) { + a_nullable8_byte_array = fl_value_get_int64_list(value6); + a_nullable8_byte_array_length = fl_value_get_length(value6); + } + FlValue* value7 = fl_value_get_list_value(values, 7); + const double* a_nullable_float_array = nullptr; + size_t a_nullable_float_array_length = 0; + if (fl_value_get_type(value7) != FL_VALUE_TYPE_NULL) { + a_nullable_float_array = fl_value_get_float_list(value7); + a_nullable_float_array_length = fl_value_get_length(value7); + } + FlValue* value8 = fl_value_get_list_value(values, 8); + FlValue* nullable_nested_list = nullptr; + if (fl_value_get_type(value8) != FL_VALUE_TYPE_NULL) { + nullable_nested_list = value8; + } + FlValue* value9 = fl_value_get_list_value(values, 9); + FlValue* nullable_map_with_annotations = nullptr; + if (fl_value_get_type(value9) != FL_VALUE_TYPE_NULL) { + nullable_map_with_annotations = value9; + } + FlValue* value10 = fl_value_get_list_value(values, 10); + FlValue* nullable_map_with_object = nullptr; + if (fl_value_get_type(value10) != FL_VALUE_TYPE_NULL) { + nullable_map_with_object = value10; + } + FlValue* value11 = fl_value_get_list_value(values, 11); + CoreTestsPigeonTestAnEnum* a_nullable_enum = nullptr; + CoreTestsPigeonTestAnEnum a_nullable_enum_value; + if (fl_value_get_type(value11) != FL_VALUE_TYPE_NULL) { + a_nullable_enum_value = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value11))))); + a_nullable_enum = &a_nullable_enum_value; + } + FlValue* value12 = fl_value_get_list_value(values, 12); + const gchar* a_nullable_string = nullptr; + if (fl_value_get_type(value12) != FL_VALUE_TYPE_NULL) { + a_nullable_string = fl_value_get_string(value12); + } + FlValue* value13 = fl_value_get_list_value(values, 13); + FlValue* a_nullable_object = nullptr; + if (fl_value_get_type(value13) != FL_VALUE_TYPE_NULL) { + a_nullable_object = value13; + } + FlValue* value14 = fl_value_get_list_value(values, 14); + FlValue* list = nullptr; + if (fl_value_get_type(value14) != FL_VALUE_TYPE_NULL) { + list = value14; + } + FlValue* value15 = fl_value_get_list_value(values, 15); + FlValue* string_list = nullptr; + if (fl_value_get_type(value15) != FL_VALUE_TYPE_NULL) { + string_list = value15; + } + FlValue* value16 = fl_value_get_list_value(values, 16); + FlValue* int_list = nullptr; + if (fl_value_get_type(value16) != FL_VALUE_TYPE_NULL) { + int_list = value16; + } + FlValue* value17 = fl_value_get_list_value(values, 17); + FlValue* double_list = nullptr; + if (fl_value_get_type(value17) != FL_VALUE_TYPE_NULL) { + double_list = value17; + } + FlValue* value18 = fl_value_get_list_value(values, 18); + FlValue* bool_list = nullptr; + if (fl_value_get_type(value18) != FL_VALUE_TYPE_NULL) { + bool_list = value18; + } + FlValue* value19 = fl_value_get_list_value(values, 19); + FlValue* map = nullptr; + if (fl_value_get_type(value19) != FL_VALUE_TYPE_NULL) { + map = value19; + } + return core_tests_pigeon_test_all_nullable_types_without_recursion_new( + a_nullable_bool, a_nullable_int, a_nullable_int64, a_nullable_double, + a_nullable_byte_array, a_nullable_byte_array_length, + a_nullable4_byte_array, a_nullable4_byte_array_length, + a_nullable8_byte_array, a_nullable8_byte_array_length, + a_nullable_float_array, a_nullable_float_array_length, + nullable_nested_list, nullable_map_with_annotations, + nullable_map_with_object, a_nullable_enum, a_nullable_string, + a_nullable_object, list, string_list, int_list, double_list, bool_list, + map); +} + +struct _CoreTestsPigeonTestAllClassesWrapper { + GObject parent_instance; + + CoreTestsPigeonTestAllNullableTypes* all_nullable_types; + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* + all_nullable_types_without_recursion; + CoreTestsPigeonTestAllTypes* all_types; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestAllClassesWrapper, + core_tests_pigeon_test_all_classes_wrapper, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_all_classes_wrapper_dispose( + GObject* object) { + CoreTestsPigeonTestAllClassesWrapper* self = + CORE_TESTS_PIGEON_TEST_ALL_CLASSES_WRAPPER(object); + g_clear_object(&self->all_nullable_types); + g_clear_object(&self->all_nullable_types_without_recursion); + g_clear_object(&self->all_types); + G_OBJECT_CLASS(core_tests_pigeon_test_all_classes_wrapper_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_all_classes_wrapper_init( + CoreTestsPigeonTestAllClassesWrapper* self) {} + +static void core_tests_pigeon_test_all_classes_wrapper_class_init( + CoreTestsPigeonTestAllClassesWrapperClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_all_classes_wrapper_dispose; +} + +CoreTestsPigeonTestAllClassesWrapper* +core_tests_pigeon_test_all_classes_wrapper_new( + CoreTestsPigeonTestAllNullableTypes* all_nullable_types, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* + all_nullable_types_without_recursion, + CoreTestsPigeonTestAllTypes* all_types) { + CoreTestsPigeonTestAllClassesWrapper* self = + CORE_TESTS_PIGEON_TEST_ALL_CLASSES_WRAPPER(g_object_new( + core_tests_pigeon_test_all_classes_wrapper_get_type(), nullptr)); + self->all_nullable_types = CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + g_object_ref(all_nullable_types)); + if (all_nullable_types_without_recursion != nullptr) { + self->all_nullable_types_without_recursion = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + g_object_ref(all_nullable_types_without_recursion)); + } else { + self->all_nullable_types_without_recursion = nullptr; + } + if (all_types != nullptr) { + self->all_types = CORE_TESTS_PIGEON_TEST_ALL_TYPES(g_object_ref(all_types)); + } else { + self->all_types = nullptr; + } + return self; +} + +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types( + CoreTestsPigeonTestAllClassesWrapper* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_CLASSES_WRAPPER(self), + nullptr); + return self->all_nullable_types; +} + +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types_without_recursion( + CoreTestsPigeonTestAllClassesWrapper* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_CLASSES_WRAPPER(self), + nullptr); + return self->all_nullable_types_without_recursion; +} + +CoreTestsPigeonTestAllTypes* +core_tests_pigeon_test_all_classes_wrapper_get_all_types( + CoreTestsPigeonTestAllClassesWrapper* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_ALL_CLASSES_WRAPPER(self), + nullptr); + return self->all_types; +} + +static FlValue* core_tests_pigeon_test_all_classes_wrapper_to_list( + CoreTestsPigeonTestAllClassesWrapper* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, fl_value_new_custom_object( + 130, G_OBJECT(self->all_nullable_types))); + fl_value_append_take( + values, + self->all_nullable_types_without_recursion != nullptr + ? fl_value_new_custom_object( + 131, G_OBJECT(self->all_nullable_types_without_recursion)) + : fl_value_new_null()); + fl_value_append_take( + values, self->all_types != nullptr + ? fl_value_new_custom_object(129, G_OBJECT(self->all_types)) + : fl_value_new_null()); + return values; +} + +static CoreTestsPigeonTestAllClassesWrapper* +core_tests_pigeon_test_all_classes_wrapper_new_from_list(FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + CoreTestsPigeonTestAllNullableTypes* all_nullable_types = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value0)); + FlValue* value1 = fl_value_get_list_value(values, 1); + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* + all_nullable_types_without_recursion = nullptr; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + all_nullable_types_without_recursion = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(value1)); + } + FlValue* value2 = fl_value_get_list_value(values, 2); + CoreTestsPigeonTestAllTypes* all_types = nullptr; + if (fl_value_get_type(value2) != FL_VALUE_TYPE_NULL) { + all_types = CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(value2)); + } + return core_tests_pigeon_test_all_classes_wrapper_new( + all_nullable_types, all_nullable_types_without_recursion, all_types); +} + +struct _CoreTestsPigeonTestTestMessage { + GObject parent_instance; + + FlValue* test_list; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestTestMessage, + core_tests_pigeon_test_test_message, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_test_message_dispose(GObject* object) { + CoreTestsPigeonTestTestMessage* self = + CORE_TESTS_PIGEON_TEST_TEST_MESSAGE(object); + g_clear_pointer(&self->test_list, fl_value_unref); + G_OBJECT_CLASS(core_tests_pigeon_test_test_message_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_test_message_init( + CoreTestsPigeonTestTestMessage* self) {} + +static void core_tests_pigeon_test_test_message_class_init( + CoreTestsPigeonTestTestMessageClass* klass) { + G_OBJECT_CLASS(klass)->dispose = core_tests_pigeon_test_test_message_dispose; +} + +CoreTestsPigeonTestTestMessage* core_tests_pigeon_test_test_message_new( + FlValue* test_list) { + CoreTestsPigeonTestTestMessage* self = CORE_TESTS_PIGEON_TEST_TEST_MESSAGE( + g_object_new(core_tests_pigeon_test_test_message_get_type(), nullptr)); + if (test_list != nullptr) { + self->test_list = fl_value_ref(test_list); + } else { + self->test_list = nullptr; + } + return self; +} + +FlValue* core_tests_pigeon_test_test_message_get_test_list( + CoreTestsPigeonTestTestMessage* self) { + g_return_val_if_fail(CORE_TESTS_PIGEON_TEST_IS_TEST_MESSAGE(self), nullptr); + return self->test_list; +} + +static FlValue* core_tests_pigeon_test_test_message_to_list( + CoreTestsPigeonTestTestMessage* self) { + FlValue* values = fl_value_new_list(); + fl_value_append_take(values, self->test_list != nullptr + ? fl_value_ref(self->test_list) + : fl_value_new_null()); + return values; +} + +static CoreTestsPigeonTestTestMessage* +core_tests_pigeon_test_test_message_new_from_list(FlValue* values) { + FlValue* value0 = fl_value_get_list_value(values, 0); + FlValue* test_list = nullptr; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + test_list = value0; + } + return core_tests_pigeon_test_test_message_new(test_list); +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestMessageCodec, + core_tests_pigeon_test_message_codec, + CORE_TESTS_PIGEON_TEST, MESSAGE_CODEC, + FlStandardMessageCodec) + +struct _CoreTestsPigeonTestMessageCodec { + FlStandardMessageCodec parent_instance; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestMessageCodec, + core_tests_pigeon_test_message_codec, + fl_standard_message_codec_get_type()) + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_types( + FlStandardMessageCodec* codec, GByteArray* buffer, + CoreTestsPigeonTestAllTypes* value, GError** error) { + uint8_t type = 129; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = core_tests_pigeon_test_all_types_to_list(value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_nullable_types( + FlStandardMessageCodec* codec, GByteArray* buffer, + CoreTestsPigeonTestAllNullableTypes* value, GError** error) { + uint8_t type = 130; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = + core_tests_pigeon_test_all_nullable_types_to_list(value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_nullable_types_without_recursion( + FlStandardMessageCodec* codec, GByteArray* buffer, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* value, + GError** error) { + uint8_t type = 131; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = + core_tests_pigeon_test_all_nullable_types_without_recursion_to_list( + value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_classes_wrapper( + FlStandardMessageCodec* codec, GByteArray* buffer, + CoreTestsPigeonTestAllClassesWrapper* value, GError** error) { + uint8_t type = 132; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = + core_tests_pigeon_test_all_classes_wrapper_to_list(value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_test_message( + FlStandardMessageCodec* codec, GByteArray* buffer, + CoreTestsPigeonTestTestMessage* value, GError** error) { + uint8_t type = 133; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + g_autoptr(FlValue) values = + core_tests_pigeon_test_test_message_to_list(value); + return fl_standard_message_codec_write_value(codec, buffer, values, error); +} + +static gboolean +core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_an_enum( + FlStandardMessageCodec* codec, GByteArray* buffer, FlValue* value, + GError** error) { + uint8_t type = 134; + g_byte_array_append(buffer, &type, sizeof(uint8_t)); + return fl_standard_message_codec_write_value(codec, buffer, value, error); +} + +static gboolean core_tests_pigeon_test_message_codec_write_value( + FlStandardMessageCodec* codec, GByteArray* buffer, FlValue* value, + GError** error) { + if (fl_value_get_type(value) == FL_VALUE_TYPE_CUSTOM) { + switch (fl_value_get_custom_type(value)) { + case 129: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_types( + codec, buffer, + CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(value)), + error); + case 130: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_nullable_types( + codec, buffer, + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value)), + error); + case 131: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_nullable_types_without_recursion( + codec, buffer, + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(value)), + error); + case 132: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_all_classes_wrapper( + codec, buffer, + CORE_TESTS_PIGEON_TEST_ALL_CLASSES_WRAPPER( + fl_value_get_custom_value_object(value)), + error); + case 133: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_test_message( + codec, buffer, + CORE_TESTS_PIGEON_TEST_TEST_MESSAGE( + fl_value_get_custom_value_object(value)), + error); + case 134: + return core_tests_pigeon_test_message_codec_write_core_tests_pigeon_test_an_enum( + codec, buffer, + reinterpret_cast( + const_cast(fl_value_get_custom_value(value))), + error); + } + } + + return FL_STANDARD_MESSAGE_CODEC_CLASS( + core_tests_pigeon_test_message_codec_parent_class) + ->write_value(codec, buffer, value, error); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_types( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(CoreTestsPigeonTestAllTypes) value = + core_tests_pigeon_test_all_types_new_from_list(values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(129, G_OBJECT(value)); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_nullable_types( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(CoreTestsPigeonTestAllNullableTypes) value = + core_tests_pigeon_test_all_nullable_types_new_from_list(values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(130, G_OBJECT(value)); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_nullable_types_without_recursion( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(CoreTestsPigeonTestAllNullableTypesWithoutRecursion) value = + core_tests_pigeon_test_all_nullable_types_without_recursion_new_from_list( + values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(131, G_OBJECT(value)); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_classes_wrapper( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(CoreTestsPigeonTestAllClassesWrapper) value = + core_tests_pigeon_test_all_classes_wrapper_new_from_list(values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(132, G_OBJECT(value)); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_test_message( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + g_autoptr(FlValue) values = + fl_standard_message_codec_read_value(codec, buffer, offset, error); + if (values == nullptr) { + return nullptr; + } + + g_autoptr(CoreTestsPigeonTestTestMessage) value = + core_tests_pigeon_test_test_message_new_from_list(values); + if (value == nullptr) { + g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED, + "Invalid data received for MessageData"); + return nullptr; + } + + return fl_value_new_custom_object(133, G_OBJECT(value)); +} + +static FlValue* +core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_an_enum( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, + GError** error) { + return fl_value_new_custom( + 134, fl_standard_message_codec_read_value(codec, buffer, offset, error), + (GDestroyNotify)fl_value_unref); +} + +static FlValue* core_tests_pigeon_test_message_codec_read_value_of_type( + FlStandardMessageCodec* codec, GBytes* buffer, size_t* offset, int type, + GError** error) { + switch (type) { + case 129: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_types( + codec, buffer, offset, error); + case 130: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_nullable_types( + codec, buffer, offset, error); + case 131: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_nullable_types_without_recursion( + codec, buffer, offset, error); + case 132: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_all_classes_wrapper( + codec, buffer, offset, error); + case 133: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_test_message( + codec, buffer, offset, error); + case 134: + return core_tests_pigeon_test_message_codec_read_core_tests_pigeon_test_an_enum( + codec, buffer, offset, error); + default: + return FL_STANDARD_MESSAGE_CODEC_CLASS( + core_tests_pigeon_test_message_codec_parent_class) + ->read_value_of_type(codec, buffer, offset, type, error); + } +} + +static void core_tests_pigeon_test_message_codec_init( + CoreTestsPigeonTestMessageCodec* self) {} + +static void core_tests_pigeon_test_message_codec_class_init( + CoreTestsPigeonTestMessageCodecClass* klass) { + FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->write_value = + core_tests_pigeon_test_message_codec_write_value; + FL_STANDARD_MESSAGE_CODEC_CLASS(klass)->read_value_of_type = + core_tests_pigeon_test_message_codec_read_value_of_type; +} + +static CoreTestsPigeonTestMessageCodec* +core_tests_pigeon_test_message_codec_new() { + CoreTestsPigeonTestMessageCodec* self = CORE_TESTS_PIGEON_TEST_MESSAGE_CODEC( + g_object_new(core_tests_pigeon_test_message_codec_get_type(), nullptr)); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle { + GObject parent_instance; + + FlBasicMessageChannel* channel; + FlBasicMessageChannelResponseHandle* response_handle; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle, + core_tests_pigeon_test_host_integration_core_api_response_handle, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_response_handle_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_RESPONSE_HANDLE(object); + g_clear_object(&self->channel); + g_clear_object(&self->response_handle); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_response_handle_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_response_handle_init( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_response_handle_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandleClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_response_handle_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* +core_tests_pigeon_test_host_integration_core_api_response_handle_new( + FlBasicMessageChannel* channel, + FlBasicMessageChannelResponseHandle* response_handle) { + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_RESPONSE_HANDLE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_response_handle_get_type(), + nullptr)); + self->channel = FL_BASIC_MESSAGE_CHANNEL(g_object_ref(channel)); + self->response_handle = + FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_ref(response_handle)); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse, + core_tests_pigeon_test_host_integration_core_api_noop_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_noop_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_noop_response_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_integration_core_api_noop_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_noop_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_noop_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_host_integration_core_api_noop_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_host_integration_core_api_noop_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new( + CoreTestsPigeonTestAllTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(129, G_OBJECT(return_value))); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_error_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_FLUTTER_ERROR_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_FLUTTER_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_FLUTTER_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_int_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_int_response_new( + int64_t return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_INT_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_int(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_INT_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_double_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_double_response_new( + double return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_float(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_bool_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new( + gboolean return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_bool(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, fl_value_new_uint8_list(return_value, return_value_length)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_object_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_object_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OBJECT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_object_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_object_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_object_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_object_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_object_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_list_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_map_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse, + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_CLASS_WRAPPER_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new( + CoreTestsPigeonTestAllClassesWrapper* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_CLASS_WRAPPER_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(132, G_OBJECT(return_value))); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_CLASS_WRAPPER_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_enum_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new( + CoreTestsPigeonTestAnEnum return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom(134, fl_value_new_int(return_value), + (GDestroyNotify)fl_value_unref)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_DEFAULT_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_DEFAULT_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_DEFAULT_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_DEFAULT_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new( + double return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_DEFAULT_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_float(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_DEFAULT_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_REQUIRED_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new( + int64_t return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_REQUIRED_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_int(return_value)); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_REQUIRED_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(130, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(131, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_EXTRACT_NESTED_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_EXTRACT_NESTED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_string(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_EXTRACT_NESTED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CREATE_NESTED_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new( + CoreTestsPigeonTestAllClassesWrapper* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CREATE_NESTED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(132, G_OBJECT(return_value))); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CREATE_NESTED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(130, G_OBJECT(return_value))); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(131, G_OBJECT(return_value))); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new( + int64_t* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_int(*return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new( + double* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_float(*return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new( + gboolean* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_bool(*return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_string(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_uint8_list( + return_value, return_value_length) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_OBJECT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new( + CoreTestsPigeonTestAnEnum* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, + return_value != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*return_value), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_NULLABLE_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new( + int64_t* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_int(*return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_dispose; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_string(return_value) + : fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_NAMED_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse, + core_tests_pigeon_test_host_integration_core_api_noop_async_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse, + core_tests_pigeon_test_host_integration_core_api_noop_async_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_noop_async_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_noop_async_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_noop_async_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_noop_async_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_noop_async_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* +core_tests_pigeon_test_host_integration_core_api_noop_async_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_noop_async_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* +core_tests_pigeon_test_host_integration_core_api_noop_async_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE(g_object_new( + core_tests_pigeon_test_host_integration_core_api_noop_async_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ASYNC_INT_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_new( + int64_t return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_int(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_DOUBLE_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_new( + double return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_float(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ASYNC_BOOL_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_new( + gboolean return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_bool(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_UINT8_LIST_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, fl_value_new_uint8_list(return_value, return_value_length)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_OBJECT_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_OBJECT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ASYNC_LIST_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ASYNC_MAP_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ENUM_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_new( + CoreTestsPigeonTestAnEnum return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom(134, fl_value_new_int(return_value), + (GDestroyNotify)fl_value_unref)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_FROM_VOID_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_FROM_VOID_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_THROW_ASYNC_FLUTTER_ERROR_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_FLUTTER_ERROR_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_FLUTTER_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_THROW_ASYNC_FLUTTER_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ALL_TYPES_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ALL_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_new( + CoreTestsPigeonTestAllTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(129, G_OBJECT(return_value))); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(130, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(131, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_INT_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_new( + int64_t* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_int(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_DOUBLE_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_new( + double* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_float(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_BOOL_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_new( + gboolean* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_bool(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_STRING_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_string(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_UINT8_LIST_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_uint8_list( + return_value, return_value_length) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_OBJECT_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_OBJECT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_OBJECT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_LIST_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_MAP_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ENUM_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_new( + CoreTestsPigeonTestAnEnum* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, + return_value != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*return_value), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_ECHO_ASYNC_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_NOOP_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_NOOP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_NOOP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_NOOP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_FROM_VOID_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_FROM_VOID_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_new() { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_THROW_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_TYPES_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_new( + CoreTestsPigeonTestAllTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(129, G_OBJECT(return_value))); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(130, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(130, G_OBJECT(return_value))); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, return_value != nullptr + ? fl_value_new_custom_object(131, G_OBJECT(return_value)) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom_object(131, G_OBJECT(return_value))); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_BOOL_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_new( + gboolean return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_bool(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_INT_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_new( + int64_t return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_int(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_DOUBLE_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_new( + double return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_float(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_STRING_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_UINT8_LIST_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, fl_value_new_uint8_list(return_value, return_value_length)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_LIST_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_MAP_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* self) { +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_ref(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ENUM_RESPONSE, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_new( + CoreTestsPigeonTestAnEnum return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, + fl_value_new_custom(134, fl_value_new_int(return_value), + (GDestroyNotify)fl_value_unref)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_BOOL_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_BOOL_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_new( + gboolean* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_bool(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_INT_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_INT_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_new( + int64_t* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_int(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_DOUBLE_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_new( + double* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_float(*return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_STRING_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_string(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_UINT8_LIST_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_new_uint8_list( + return_value, return_value_length) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse* + self = CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_LIST_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_LIST_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_MAP_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_MAP_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_new( + FlValue* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, return_value != nullptr + ? fl_value_ref(return_value) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_ENUM_RESPONSE, GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_ENUM_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_new( + CoreTestsPigeonTestAnEnum* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take( + self->value, + return_value != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*return_value), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_ECHO_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE, + GObject) + +struct + _CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* + self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE( + object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* + self) {} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_CALL_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostIntegrationCoreApi, + core_tests_pigeon_test_host_integration_core_api, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API, GObject) + +struct _CoreTestsPigeonTestHostIntegrationCoreApi { + GObject parent_instance; + + const CoreTestsPigeonTestHostIntegrationCoreApiVTable* vtable; + gpointer user_data; + GDestroyNotify user_data_free_func; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostIntegrationCoreApi, + core_tests_pigeon_test_host_integration_core_api, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_integration_core_api_dispose( + GObject* object) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(object); + if (self->user_data != nullptr) { + self->user_data_free_func(self->user_data); + } + self->user_data = nullptr; + G_OBJECT_CLASS(core_tests_pigeon_test_host_integration_core_api_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_integration_core_api_init( + CoreTestsPigeonTestHostIntegrationCoreApi* self) {} + +static void core_tests_pigeon_test_host_integration_core_api_class_init( + CoreTestsPigeonTestHostIntegrationCoreApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_integration_core_api_dispose; +} + +static CoreTestsPigeonTestHostIntegrationCoreApi* +core_tests_pigeon_test_host_integration_core_api_new( + const CoreTestsPigeonTestHostIntegrationCoreApiVTable* vtable, + gpointer user_data, GDestroyNotify user_data_free_func) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(g_object_new( + core_tests_pigeon_test_host_integration_core_api_get_type(), + nullptr)); + self->vtable = vtable; + self->user_data = user_data; + self->user_data_free_func = user_data_free_func; + return self; +} + +static void core_tests_pigeon_test_host_integration_core_api_noop_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->noop == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse) response = + self->vtable->noop(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "noop"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "noop", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_all_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_all_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllTypes* everything = CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse) + response = self->vtable->echo_all_types(everything, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoAllTypes"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAllTypes", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_throw_error_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->throw_error == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse) + response = self->vtable->throw_error(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "throwError"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwError", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->throw_error_from_void == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse) + response = self->vtable->throw_error_from_void(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "throwErrorFromVoid"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwErrorFromVoid", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->throw_flutter_error == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse) + response = self->vtable->throw_flutter_error(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "throwFlutterError"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwFlutterError", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t an_int = fl_value_get_int(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse) response = + self->vtable->echo_int(an_int, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoInt"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoInt", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double a_double = fl_value_get_float(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse) + response = self->vtable->echo_double(a_double, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoDouble"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoDouble", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean a_bool = fl_value_get_bool(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse) + response = self->vtable->echo_bool(a_bool, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoBool"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoBool", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse) + response = self->vtable->echo_string(a_string, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoString", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* a_uint8_list = fl_value_get_uint8_list(value0); + size_t a_uint8_list_length = fl_value_get_length(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse) + response = self->vtable->echo_uint8_list( + a_uint8_list, a_uint8_list_length, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoUint8List"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoUint8List", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_object_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_object == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* an_object = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse) + response = self->vtable->echo_object(an_object, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoObject"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoObject", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse) + response = self->vtable->echo_list(list, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoList"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoList", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse) response = + self->vtable->echo_map(a_map, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoMap"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoMap", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_class_wrapper == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllClassesWrapper* wrapper = + CORE_TESTS_PIGEON_TEST_ALL_CLASSES_WRAPPER( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse) + response = self->vtable->echo_class_wrapper(wrapper, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoClassWrapper"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoClassWrapper", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum an_enum = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse) + response = self->vtable->echo_enum(an_enum, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoEnum"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoEnum", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_named_default_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse) + response = + self->vtable->echo_named_default_string(a_string, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNamedDefaultString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNamedDefaultString", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_optional_default_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double a_double = fl_value_get_float(value0); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse) + response = + self->vtable->echo_optional_default_double(a_double, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoOptionalDefaultDouble"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoOptionalDefaultDouble", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_required_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_required_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t an_int = fl_value_get_int(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse) + response = self->vtable->echo_required_int(an_int, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoRequiredInt"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoRequiredInt", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_all_nullable_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypes* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse) + response = + self->vtable->echo_all_nullable_types(everything, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoAllNullableTypes"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAllNullableTypes", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_all_nullable_types_without_recursion == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(value0)); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse) + response = self->vtable->echo_all_nullable_types_without_recursion( + everything, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoAllNullableTypesWithoutRecursion"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAllNullableTypesWithoutRecursion", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->extract_nested_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllClassesWrapper* wrapper = + CORE_TESTS_PIGEON_TEST_ALL_CLASSES_WRAPPER( + fl_value_get_custom_value_object(value0)); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse) + response = self->vtable->extract_nested_nullable_string(wrapper, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "extractNestedNullableString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "extractNestedNullableString", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->create_nested_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* nullable_string = fl_value_get_string(value0); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse) + response = self->vtable->create_nested_nullable_string(nullable_string, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "createNestedNullableString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "createNestedNullableString", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->send_multiple_nullable_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(message_, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(message_, 2); + const gchar* a_nullable_string = fl_value_get_string(value2); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse) + response = self->vtable->send_multiple_nullable_types( + a_nullable_bool, a_nullable_int, a_nullable_string, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "sendMultipleNullableTypes"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "sendMultipleNullableTypes", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->send_multiple_nullable_types_without_recursion == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(message_, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(message_, 2); + const gchar* a_nullable_string = fl_value_get_string(value2); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse) + response = self->vtable->send_multiple_nullable_types_without_recursion( + a_nullable_bool, a_nullable_int, a_nullable_string, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "sendMultipleNullableTypesWithoutRecursion"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "sendMultipleNullableTypesWithoutRecursion", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_nullable_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value0); + a_nullable_int = &a_nullable_int_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse) + response = + self->vtable->echo_nullable_int(a_nullable_int, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableInt"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableInt", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_nullable_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double* a_nullable_double = nullptr; + double a_nullable_double_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_double_value = fl_value_get_float(value0); + a_nullable_double = &a_nullable_double_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse) + response = self->vtable->echo_nullable_double(a_nullable_double, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableDouble"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableDouble", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_nullable_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse) + response = + self->vtable->echo_nullable_bool(a_nullable_bool, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableBool"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableBool", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_nullable_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse) + response = self->vtable->echo_nullable_string(a_nullable_string, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableString", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_nullable_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* a_nullable_uint8_list = fl_value_get_uint8_list(value0); + size_t a_nullable_uint8_list_length = fl_value_get_length(value0); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse) + response = self->vtable->echo_nullable_uint8_list( + a_nullable_uint8_list, a_nullable_uint8_list_length, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableUint8List"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableUint8List", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_nullable_object == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_nullable_object = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse) + response = self->vtable->echo_nullable_object(a_nullable_object, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableObject"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableObject", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_nullable_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_nullable_list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse) + response = + self->vtable->echo_nullable_list(a_nullable_list, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableList"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableList", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_nullable_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_nullable_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse) + response = + self->vtable->echo_nullable_map(a_nullable_map, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableMap"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableMap", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_nullable_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum* an_enum = nullptr; + CoreTestsPigeonTestAnEnum an_enum_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + an_enum_value = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + an_enum = &an_enum_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse) + response = self->vtable->echo_nullable_enum(an_enum, self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNullableEnum"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNullableEnum", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_optional_nullable_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value0); + a_nullable_int = &a_nullable_int_value; + } + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse) + response = self->vtable->echo_optional_nullable_int(a_nullable_int, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoOptionalNullableInt"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoOptionalNullableInt", error->message); + } +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_named_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_nullable_string = fl_value_get_string(value0); + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse) + response = self->vtable->echo_named_nullable_string(a_nullable_string, + self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostIntegrationCoreApi", + "echoNamedNullableString"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoNamedNullableString", error->message); + } +} + +static void core_tests_pigeon_test_host_integration_core_api_noop_async_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->noop_async == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->noop_async(handle, self->user_data); +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_async_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t an_int = fl_value_get_int(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_int(an_int, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double a_double = fl_value_get_float(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_double(a_double, handle, self->user_data); +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_async_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean a_bool = fl_value_get_bool(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_bool(a_bool, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_string(a_string, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* a_uint8_list = fl_value_get_uint8_list(value0); + size_t a_uint8_list_length = fl_value_get_length(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_uint8_list(a_uint8_list, a_uint8_list_length, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_object_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_object == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* an_object = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_object(an_object, handle, self->user_data); +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_async_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_list(list, handle, self->user_data); +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_async_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_map(a_map, handle, self->user_data); +} + +static void core_tests_pigeon_test_host_integration_core_api_echo_async_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo_async_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum an_enum = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_enum(an_enum, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->throw_async_error == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->throw_async_error(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->throw_async_error_from_void == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->throw_async_error_from_void(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->throw_async_flutter_error == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->throw_async_flutter_error(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_all_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllTypes* everything = CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_all_types(everything, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_all_nullable_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypes* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_all_nullable_types(everything, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_all_nullable_types_without_recursion == + nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_all_nullable_types_without_recursion( + everything, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t* an_int = nullptr; + int64_t an_int_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + an_int_value = fl_value_get_int(value0); + an_int = &an_int_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_int(an_int, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double* a_double = nullptr; + double a_double_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_double_value = fl_value_get_float(value0); + a_double = &a_double_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_double(a_double, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_bool = nullptr; + gboolean a_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_bool_value = fl_value_get_bool(value0); + a_bool = &a_bool_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_bool(a_bool, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_string(a_string, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* a_uint8_list = fl_value_get_uint8_list(value0); + size_t a_uint8_list_length = fl_value_get_length(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_uint8_list( + a_uint8_list, a_uint8_list_length, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_object == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* an_object = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_object(an_object, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_list(list, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_map(a_map, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->echo_async_nullable_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum* an_enum = nullptr; + CoreTestsPigeonTestAnEnum an_enum_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + an_enum_value = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + an_enum = &an_enum_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->echo_async_nullable_enum(an_enum, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || self->vtable->call_flutter_noop == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_noop(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_throw_error == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_throw_error(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_throw_error_from_void == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_throw_error_from_void(handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_all_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllTypes* everything = CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_all_types(everything, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_all_nullable_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypes* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_all_nullable_types(everything, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_send_multiple_nullable_types == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(message_, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(message_, 2); + const gchar* a_nullable_string = fl_value_get_string(value2); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_send_multiple_nullable_types( + a_nullable_bool, a_nullable_int, a_nullable_string, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_all_nullable_types_without_recursion == + nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything = + CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(value0)); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_all_nullable_types_without_recursion( + everything, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable + ->call_flutter_send_multiple_nullable_types_without_recursion == + nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_nullable_bool = nullptr; + gboolean a_nullable_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_nullable_bool_value = fl_value_get_bool(value0); + a_nullable_bool = &a_nullable_bool_value; + } + FlValue* value1 = fl_value_get_list_value(message_, 1); + int64_t* a_nullable_int = nullptr; + int64_t a_nullable_int_value; + if (fl_value_get_type(value1) != FL_VALUE_TYPE_NULL) { + a_nullable_int_value = fl_value_get_int(value1); + a_nullable_int = &a_nullable_int_value; + } + FlValue* value2 = fl_value_get_list_value(message_, 2); + const gchar* a_nullable_string = fl_value_get_string(value2); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_send_multiple_nullable_types_without_recursion( + a_nullable_bool, a_nullable_int, a_nullable_string, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean a_bool = fl_value_get_bool(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_bool(a_bool, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t an_int = fl_value_get_int(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_int(an_int, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double a_double = fl_value_get_float(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_double(a_double, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_string(a_string, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* list = fl_value_get_uint8_list(value0); + size_t list_length = fl_value_get_length(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_uint8_list(list, list_length, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_list(list, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_map(a_map, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum an_enum = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_enum(an_enum, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_bool == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + gboolean* a_bool = nullptr; + gboolean a_bool_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_bool_value = fl_value_get_bool(value0); + a_bool = &a_bool_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_bool(a_bool, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_int == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + int64_t* an_int = nullptr; + int64_t an_int_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + an_int_value = fl_value_get_int(value0); + an_int = &an_int_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_int(an_int, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_double == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + double* a_double = nullptr; + double a_double_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + a_double_value = fl_value_get_float(value0); + a_double = &a_double_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_double(a_double, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_string(a_string, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_uint8_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const uint8_t* list = fl_value_get_uint8_list(value0); + size_t list_length = fl_value_get_length(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_uint8_list(list, list_length, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_list == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* list = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_list(list, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_map == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + FlValue* a_map = value0; + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_map(a_map, handle, self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_echo_nullable_enum == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + CoreTestsPigeonTestAnEnum* an_enum = nullptr; + CoreTestsPigeonTestAnEnum an_enum_value; + if (fl_value_get_type(value0) != FL_VALUE_TYPE_NULL) { + an_enum_value = static_cast( + fl_value_get_int(reinterpret_cast( + const_cast(fl_value_get_custom_value(value0))))); + an_enum = &an_enum_value; + } + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_echo_nullable_enum(an_enum, handle, + self->user_data); +} + +static void +core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API(user_data); + + if (self->vtable == nullptr || + self->vtable->call_flutter_small_api_echo_string == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle) handle = + core_tests_pigeon_test_host_integration_core_api_response_handle_new( + channel, response_handle); + self->vtable->call_flutter_small_api_echo_string(a_string, handle, + self->user_data); +} + +void core_tests_pigeon_test_host_integration_core_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostIntegrationCoreApiVTable* vtable, + gpointer user_data, GDestroyNotify user_data_free_func) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApi) api_data = + core_tests_pigeon_test_host_integration_core_api_new(vtable, user_data, + user_data_free_func); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi.noop%" + "s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_channel = fl_basic_message_channel_new( + messenger, noop_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + noop_channel, core_tests_pigeon_test_host_integration_core_api_noop_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_all_types_channel = + fl_basic_message_channel_new(messenger, echo_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_all_types_channel, + core_tests_pigeon_test_host_integration_core_api_echo_all_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_error_channel = + fl_basic_message_channel_new(messenger, throw_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_error_channel, + core_tests_pigeon_test_host_integration_core_api_throw_error_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_error_from_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_error_from_void_channel = + fl_basic_message_channel_new(messenger, + throw_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_error_from_void_channel, + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_flutter_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwFlutterError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_flutter_error_channel = + fl_basic_message_channel_new(messenger, throw_flutter_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_flutter_error_channel, + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_int_channel = + fl_basic_message_channel_new(messenger, echo_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_double_channel = + fl_basic_message_channel_new(messenger, echo_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_double_channel, + core_tests_pigeon_test_host_integration_core_api_echo_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_bool_channel = + fl_basic_message_channel_new(messenger, echo_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_bool_channel, + core_tests_pigeon_test_host_integration_core_api_echo_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_string_channel = + fl_basic_message_channel_new(messenger, echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_uint8_list_channel = + fl_basic_message_channel_new(messenger, echo_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_object_channel = + fl_basic_message_channel_new(messenger, echo_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_object_channel, + core_tests_pigeon_test_host_integration_core_api_echo_object_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_list_channel = + fl_basic_message_channel_new(messenger, echo_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_map_channel = + fl_basic_message_channel_new(messenger, echo_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_map_channel, + core_tests_pigeon_test_host_integration_core_api_echo_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_class_wrapper_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoClassWrapper%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_class_wrapper_channel = + fl_basic_message_channel_new(messenger, echo_class_wrapper_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_class_wrapper_channel, + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_enum_channel = + fl_basic_message_channel_new(messenger, echo_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_enum_channel, + core_tests_pigeon_test_host_integration_core_api_echo_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_named_default_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNamedDefaultString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_named_default_string_channel = + fl_basic_message_channel_new(messenger, + echo_named_default_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_named_default_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_optional_default_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoOptionalDefaultDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_optional_default_double_channel = + fl_basic_message_channel_new(messenger, + echo_optional_default_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_optional_default_double_channel, + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_required_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoRequiredInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_required_int_channel = + fl_basic_message_channel_new(messenger, echo_required_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_required_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_required_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_all_nullable_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_all_nullable_types_channel = + fl_basic_message_channel_new(messenger, + echo_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_all_nullable_types_channel, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, echo_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_all_nullable_types_without_recursion_channel, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* extract_nested_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "extractNestedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) extract_nested_nullable_string_channel = + fl_basic_message_channel_new(messenger, + extract_nested_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + extract_nested_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* create_nested_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "createNestedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) create_nested_nullable_string_channel = + fl_basic_message_channel_new(messenger, + create_nested_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + create_nested_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* send_multiple_nullable_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "sendMultipleNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) send_multiple_nullable_types_channel = + fl_basic_message_channel_new(messenger, + send_multiple_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + send_multiple_nullable_types_channel, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* + send_multiple_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "sendMultipleNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + send_multiple_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + send_multiple_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + send_multiple_nullable_types_without_recursion_channel, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_int_channel = + fl_basic_message_channel_new(messenger, echo_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_double_channel = + fl_basic_message_channel_new(messenger, echo_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_double_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_bool_channel = + fl_basic_message_channel_new(messenger, echo_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_bool_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_string_channel = + fl_basic_message_channel_new(messenger, echo_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_object_channel = + fl_basic_message_channel_new(messenger, echo_nullable_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_object_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_list_channel = + fl_basic_message_channel_new(messenger, echo_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_map_channel = + fl_basic_message_channel_new(messenger, echo_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_map_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_nullable_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_enum_channel = + fl_basic_message_channel_new(messenger, echo_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_nullable_enum_channel, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_optional_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoOptionalNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_optional_nullable_int_channel = + fl_basic_message_channel_new(messenger, + echo_optional_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_optional_nullable_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_named_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNamedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_named_nullable_string_channel = + fl_basic_message_channel_new(messenger, + echo_named_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_named_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* noop_async_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "noopAsync%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_async_channel = + fl_basic_message_channel_new(messenger, noop_async_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + noop_async_channel, + core_tests_pigeon_test_host_integration_core_api_noop_async_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_int_channel = + fl_basic_message_channel_new(messenger, echo_async_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_double_channel = + fl_basic_message_channel_new(messenger, echo_async_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_double_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_bool_channel = + fl_basic_message_channel_new(messenger, echo_async_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_bool_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_string_channel = + fl_basic_message_channel_new(messenger, echo_async_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_object_channel = + fl_basic_message_channel_new(messenger, echo_async_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_object_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_object_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_list_channel = + fl_basic_message_channel_new(messenger, echo_async_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_map_channel = + fl_basic_message_channel_new(messenger, echo_async_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_map_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_enum_channel = + fl_basic_message_channel_new(messenger, echo_async_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_enum_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_async_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_error_channel = + fl_basic_message_channel_new(messenger, throw_async_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_async_error_channel, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_async_error_from_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_error_from_void_channel = + fl_basic_message_channel_new(messenger, + throw_async_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_async_error_from_void_channel, + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* throw_async_flutter_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncFlutterError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_flutter_error_channel = + fl_basic_message_channel_new(messenger, + throw_async_flutter_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_async_flutter_error_channel, + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_all_types_channel = + fl_basic_message_channel_new(messenger, echo_async_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_all_types_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_all_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_async_nullable_all_nullable_types_channel = + fl_basic_message_channel_new( + messenger, echo_async_nullable_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_all_nullable_types_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* + echo_async_nullable_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "echoAsyncNullableAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_async_nullable_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + echo_async_nullable_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_all_nullable_types_without_recursion_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_int_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_int_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_double_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_double_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_bool_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_bool_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_string_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_uint8_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_object_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_object_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_list_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_map_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_map_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* echo_async_nullable_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_enum_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_enum_channel, + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterNoop%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_noop_channel = + fl_basic_message_channel_new(messenger, call_flutter_noop_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_noop_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_throw_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterThrowError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_throw_error_channel = + fl_basic_message_channel_new(messenger, + call_flutter_throw_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_throw_error_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_throw_error_from_void_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterThrowErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_throw_error_from_void_channel = + fl_basic_message_channel_new( + messenger, call_flutter_throw_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_throw_error_from_void_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_all_types_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_types_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_all_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_all_nullable_types_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_nullable_types_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_send_multiple_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterSendMultipleNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_send_multiple_nullable_types_channel = + fl_basic_message_channel_new( + messenger, call_flutter_send_multiple_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_send_multiple_nullable_types_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* + call_flutter_echo_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "callFlutterEchoAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + call_flutter_echo_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_nullable_types_without_recursion_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* + call_flutter_send_multiple_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "callFlutterSendMultipleNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_send_multiple_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + call_flutter_send_multiple_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_send_multiple_nullable_types_without_recursion_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_bool_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_bool_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_int_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_int_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_double_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_double_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_string_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_string_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_uint8_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_list_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_map_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_map_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_enum_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_enum_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_bool_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_bool_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_bool_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_int_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_int_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_int_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_double_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_double_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_double_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_string_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_string_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_uint8_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_nullable_uint8_list_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_uint8_list_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_list_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_map_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_map_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_map_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_echo_nullable_enum_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_enum_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_enum_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* call_flutter_small_api_echo_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterSmallApiEchoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_small_api_echo_string_channel = + fl_basic_message_channel_new( + messenger, call_flutter_small_api_echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_small_api_echo_string_channel, + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_cb, + g_object_ref(api_data), g_object_unref); +} + +void core_tests_pigeon_test_host_integration_core_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi.noop%" + "s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_channel = fl_basic_message_channel_new( + messenger, noop_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(noop_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* echo_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_all_types_channel = + fl_basic_message_channel_new(messenger, echo_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_all_types_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* throw_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_error_channel = + fl_basic_message_channel_new(messenger, throw_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(throw_error_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* throw_error_from_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_error_from_void_channel = + fl_basic_message_channel_new(messenger, + throw_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(throw_error_from_void_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* throw_flutter_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwFlutterError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_flutter_error_channel = + fl_basic_message_channel_new(messenger, throw_flutter_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(throw_flutter_error_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_int_channel = + fl_basic_message_channel_new(messenger, echo_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_int_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_double_channel = + fl_basic_message_channel_new(messenger, echo_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_double_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_bool_channel = + fl_basic_message_channel_new(messenger, echo_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_bool_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_string_channel = + fl_basic_message_channel_new(messenger, echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_string_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_uint8_list_channel = + fl_basic_message_channel_new(messenger, echo_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_uint8_list_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_object_channel = + fl_basic_message_channel_new(messenger, echo_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_object_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_list_channel = + fl_basic_message_channel_new(messenger, echo_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_list_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_map_channel = + fl_basic_message_channel_new(messenger, echo_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_map_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_class_wrapper_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoClassWrapper%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_class_wrapper_channel = + fl_basic_message_channel_new(messenger, echo_class_wrapper_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_class_wrapper_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_enum_channel = + fl_basic_message_channel_new(messenger, echo_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_enum_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_named_default_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNamedDefaultString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_named_default_string_channel = + fl_basic_message_channel_new(messenger, + echo_named_default_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_named_default_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_optional_default_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoOptionalDefaultDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_optional_default_double_channel = + fl_basic_message_channel_new(messenger, + echo_optional_default_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_optional_default_double_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_required_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoRequiredInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_required_int_channel = + fl_basic_message_channel_new(messenger, echo_required_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_required_int_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_all_nullable_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_all_nullable_types_channel = + fl_basic_message_channel_new(messenger, + echo_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_all_nullable_types_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, echo_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_all_nullable_types_without_recursion_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* extract_nested_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "extractNestedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) extract_nested_nullable_string_channel = + fl_basic_message_channel_new(messenger, + extract_nested_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + extract_nested_nullable_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* create_nested_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "createNestedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) create_nested_nullable_string_channel = + fl_basic_message_channel_new(messenger, + create_nested_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + create_nested_nullable_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* send_multiple_nullable_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "sendMultipleNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) send_multiple_nullable_types_channel = + fl_basic_message_channel_new(messenger, + send_multiple_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + send_multiple_nullable_types_channel, nullptr, nullptr, nullptr); + g_autofree gchar* + send_multiple_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "sendMultipleNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + send_multiple_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + send_multiple_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + send_multiple_nullable_types_without_recursion_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* echo_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_int_channel = + fl_basic_message_channel_new(messenger, echo_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_int_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_double_channel = + fl_basic_message_channel_new(messenger, echo_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_double_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_bool_channel = + fl_basic_message_channel_new(messenger, echo_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_bool_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_string_channel = + fl_basic_message_channel_new(messenger, echo_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_string_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_uint8_list_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_object_channel = + fl_basic_message_channel_new(messenger, echo_nullable_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_object_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_list_channel = + fl_basic_message_channel_new(messenger, echo_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_list_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_map_channel = + fl_basic_message_channel_new(messenger, echo_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_map_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_nullable_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_nullable_enum_channel = + fl_basic_message_channel_new(messenger, echo_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_nullable_enum_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_optional_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoOptionalNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_optional_nullable_int_channel = + fl_basic_message_channel_new(messenger, + echo_optional_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_optional_nullable_int_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_named_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoNamedNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_named_nullable_string_channel = + fl_basic_message_channel_new(messenger, + echo_named_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_named_nullable_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* noop_async_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "noopAsync%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_async_channel = + fl_basic_message_channel_new(messenger, noop_async_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(noop_async_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_int_channel = + fl_basic_message_channel_new(messenger, echo_async_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_int_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_double_channel = + fl_basic_message_channel_new(messenger, echo_async_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_double_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_bool_channel = + fl_basic_message_channel_new(messenger, echo_async_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_bool_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_string_channel = + fl_basic_message_channel_new(messenger, echo_async_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_string_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_uint8_list_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_object_channel = + fl_basic_message_channel_new(messenger, echo_async_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_object_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_list_channel = + fl_basic_message_channel_new(messenger, echo_async_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_list_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_map_channel = + fl_basic_message_channel_new(messenger, echo_async_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_map_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_enum_channel = + fl_basic_message_channel_new(messenger, echo_async_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_enum_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* throw_async_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_error_channel = + fl_basic_message_channel_new(messenger, throw_async_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(throw_async_error_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* throw_async_error_from_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_error_from_void_channel = + fl_basic_message_channel_new(messenger, + throw_async_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_async_error_from_void_channel, nullptr, nullptr, nullptr); + g_autofree gchar* throw_async_flutter_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "throwAsyncFlutterError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) throw_async_flutter_error_channel = + fl_basic_message_channel_new(messenger, + throw_async_flutter_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + throw_async_flutter_error_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_all_types_channel = + fl_basic_message_channel_new(messenger, echo_async_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_all_types_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_all_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_async_nullable_all_nullable_types_channel = + fl_basic_message_channel_new( + messenger, echo_async_nullable_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_all_nullable_types_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* + echo_async_nullable_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "echoAsyncNullableAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + echo_async_nullable_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + echo_async_nullable_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_all_nullable_types_without_recursion_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* echo_async_nullable_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_int_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_nullable_int_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_double_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_double_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_bool_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_nullable_bool_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_string_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_uint8_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_uint8_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_uint8_list_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_object_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableObject%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_object_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_object_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_async_nullable_object_channel, nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_list_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_nullable_list_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_map_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_nullable_map_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* echo_async_nullable_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "echoAsyncNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_async_nullable_enum_channel = + fl_basic_message_channel_new(messenger, + echo_async_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_async_nullable_enum_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterNoop%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_noop_channel = + fl_basic_message_channel_new(messenger, call_flutter_noop_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_noop_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_throw_error_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterThrowError%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_throw_error_channel = + fl_basic_message_channel_new(messenger, + call_flutter_throw_error_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_throw_error_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_throw_error_from_void_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterThrowErrorFromVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_throw_error_from_void_channel = + fl_basic_message_channel_new( + messenger, call_flutter_throw_error_from_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_throw_error_from_void_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_all_types_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoAllTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_all_types_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_all_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_types_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_all_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoAllNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_all_nullable_types_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_all_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_nullable_types_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_send_multiple_nullable_types_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterSendMultipleNullableTypes%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_send_multiple_nullable_types_channel = + fl_basic_message_channel_new( + messenger, call_flutter_send_multiple_nullable_types_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_send_multiple_nullable_types_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* + call_flutter_echo_all_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "callFlutterEchoAllNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_all_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + call_flutter_echo_all_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_all_nullable_types_without_recursion_channel, nullptr, + nullptr, nullptr); + g_autofree gchar* + call_flutter_send_multiple_nullable_types_without_recursion_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests." + "HostIntegrationCoreApi." + "callFlutterSendMultipleNullableTypesWithoutRecursion%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_send_multiple_nullable_types_without_recursion_channel = + fl_basic_message_channel_new( + messenger, + call_flutter_send_multiple_nullable_types_without_recursion_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_send_multiple_nullable_types_without_recursion_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_bool_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_bool_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_bool_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_int_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_int_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_int_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_double_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_double_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_double_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_string_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_string_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_string_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_uint8_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_uint8_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_uint8_list_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_list_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_list_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_map_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_map_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_map_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_enum_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_enum_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(call_flutter_echo_enum_channel, + nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_bool_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableBool%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_bool_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_bool_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_bool_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_int_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableInt%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_int_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_int_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_int_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_double_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableDouble%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_double_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_double_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_double_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_string_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_string_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_uint8_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableUint8List%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) + call_flutter_echo_nullable_uint8_list_channel = + fl_basic_message_channel_new( + messenger, call_flutter_echo_nullable_uint8_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_uint8_list_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_list_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableList%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_list_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_list_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_list_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_map_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableMap%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_map_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_map_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_map_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_echo_nullable_enum_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterEchoNullableEnum%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_echo_nullable_enum_channel = + fl_basic_message_channel_new(messenger, + call_flutter_echo_nullable_enum_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_echo_nullable_enum_channel, nullptr, nullptr, nullptr); + g_autofree gchar* call_flutter_small_api_echo_string_channel_name = + g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostIntegrationCoreApi." + "callFlutterSmallApiEchoString%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) call_flutter_small_api_echo_string_channel = + fl_basic_message_channel_new( + messenger, call_flutter_small_api_echo_string_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + call_flutter_small_api_echo_string_channel, nullptr, nullptr, nullptr); +} + +void core_tests_pigeon_test_host_integration_core_api_respond_noop_async( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse) response = + core_tests_pigeon_test_host_integration_core_api_noop_async_response_new(); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "noopAsync", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_noop_async( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiNoopAsyncResponse) response = + core_tests_pigeon_test_host_integration_core_api_noop_async_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "noopAsync", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncIntResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_int_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncDoubleResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_double_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncBoolResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_bool_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncStringResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_string_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_new( + return_value, return_value_length); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_uint8_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncObject", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncObjectResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_object_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncObject", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncListResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncMapResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_map_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncEnumResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_enum_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse) response = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorResponse) response = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse) + response = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_new(); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncErrorFromVoid", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncErrorFromVoidResponse) + response = + core_tests_pigeon_test_host_integration_core_api_throw_async_error_from_void_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncErrorFromVoid", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_flutter_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse) + response = + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncFlutterError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_flutter_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiThrowAsyncFlutterErrorResponse) + response = + core_tests_pigeon_test_host_integration_core_api_throw_async_flutter_error_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "throwAsyncFlutterError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllTypes* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncAllTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncAllTypesResponse) response = + core_tests_pigeon_test_host_integration_core_api_echo_async_all_types_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncAllTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableAllNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableAllNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableAllNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableAllNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_all_nullable_types_without_recursion_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableAllNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_int_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_double_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_bool_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_string_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_new( + return_value, return_value_length); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_uint8_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableObject", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableObjectResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_object_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableObject", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_map_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAsyncNullableEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_echo_async_nullable_enum_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "echoAsyncNullableEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_noop( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse) response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_new(); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterNoop", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_noop( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterNoopResponse) response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_noop_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterNoop", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterThrowError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterThrowError", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_new(); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterThrowErrorFromVoid", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterThrowErrorFromVoidResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_throw_error_from_void_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterThrowErrorFromVoid", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllTypes* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_types_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSendMultipleNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSendMultipleNullableTypes", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoAllNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_all_nullable_types_without_recursion_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoAllNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSendMultipleNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSendMultipleNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_send_multiple_nullable_types_without_recursion_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSendMultipleNullableTypesWithoutRecursion", + error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_bool_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t return_value) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_int_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_double_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_string_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_new( + return_value, return_value_length); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_uint8_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_map_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_enum_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableBoolResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_bool_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableBool", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableIntResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_int_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableInt", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableDoubleResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_double_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableDouble", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_string_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_new( + return_value, return_value_length); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableUint8ListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_uint8_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableUint8List", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableListResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_list_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableList", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableMapResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_map_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableMap", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterEchoNullableEnumResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_echo_nullable_enum_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterEchoNullableEnum", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_small_api_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_new( + return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSmallApiEchoString", error->message); + } +} + +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_small_api_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr( + CoreTestsPigeonTestHostIntegrationCoreApiCallFlutterSmallApiEchoStringResponse) + response = + core_tests_pigeon_test_host_integration_core_api_call_flutter_small_api_echo_string_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostIntegrationCoreApi", + "callFlutterSmallApiEchoString", error->message); + } +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApi { + GObject parent_instance; + + FlBinaryMessenger* messenger; + gchar* suffix; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestFlutterIntegrationCoreApi, + core_tests_pigeon_test_flutter_integration_core_api, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_flutter_integration_core_api_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object); + g_clear_object(&self->messenger); + g_clear_pointer(&self->suffix, g_free); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_init( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self) {} + +static void core_tests_pigeon_test_flutter_integration_core_api_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_dispose; +} + +CoreTestsPigeonTestFlutterIntegrationCoreApi* +core_tests_pigeon_test_flutter_integration_core_api_new( + FlBinaryMessenger* messenger, const gchar* suffix) { + CoreTestsPigeonTestFlutterIntegrationCoreApi* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_get_type(), + nullptr)); + self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger)); + self->suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + return self; +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse { + GObject parent_instance; + + FlValue* error; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse, + core_tests_pigeon_test_flutter_integration_core_api_noop_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE(object); + g_clear_pointer(&self->error, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_noop_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_noop_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE(g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_noop_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_noop( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "noop%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_noop_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_noop_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return self->return_value; +} + +static void core_tests_pigeon_test_flutter_integration_core_api_throw_error_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_throw_error( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "throwError%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse { + GObject parent_instance; + + FlValue* error; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "throwErrorFromVoid%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAllTypes* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + self)); + return CORE_TESTS_PIGEON_TEST_ALL_TYPES( + fl_value_get_custom_value_object(self->return_value)); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + CoreTestsPigeonTestAllTypes* everything, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, + fl_value_new_custom_object(129, G_OBJECT(everything))); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoAllTypes%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_new( + response); +} + +struct + _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(self->return_value)); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + CoreTestsPigeonTestAllNullableTypes* everything, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take( + args, everything != nullptr + ? fl_value_new_custom_object(130, G_OBJECT(everything)) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoAllNullableTypes%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_new( + response); +} + +struct + _CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + self)); + return CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES( + fl_value_get_custom_value_object(self->return_value)); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_nullable_bool != nullptr + ? fl_value_new_bool(*a_nullable_bool) + : fl_value_new_null()); + fl_value_append_take(args, a_nullable_int != nullptr + ? fl_value_new_int(*a_nullable_int) + : fl_value_new_null()); + fl_value_append_take(args, a_nullable_string != nullptr + ? fl_value_new_string(a_nullable_string) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "sendMultipleNullableTypes%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_new( + response); +} + +struct + _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(self->return_value)); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take( + args, everything != nullptr + ? fl_value_new_custom_object(131, G_OBJECT(everything)) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoAllNullableTypesWithoutRecursion%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_new( + response); +} + +struct + _CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self = CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + self)); + return CORE_TESTS_PIGEON_TEST_ALL_NULLABLE_TYPES_WITHOUT_RECURSION( + fl_value_get_custom_value_object(self->return_value)); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_nullable_bool != nullptr + ? fl_value_new_bool(*a_nullable_bool) + : fl_value_new_null()); + fl_value_append_take(args, a_nullable_int != nullptr + ? fl_value_new_int(*a_nullable_int) + : fl_value_new_null()); + fl_value_append_take(args, a_nullable_string != nullptr + ? fl_value_new_string(a_nullable_string) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "sendMultipleNullableTypesWithoutRecursion%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE( + self), + FALSE); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + self)); + return fl_value_get_bool(self->return_value); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_bool_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_bool( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, gboolean a_bool, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_bool(a_bool)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoBool%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +int64_t +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE( + self), + 0); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + self)); + return fl_value_get_int(self->return_value); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_int_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_int( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, int64_t an_int, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_int(an_int)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoInt%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_int_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +double +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE( + self), + 0.0); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + self)); + return fl_value_get_float(self->return_value); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_double_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_double( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, double a_double, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_float(a_double)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoDouble%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_double_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + self)); + return fl_value_get_string(self->return_value); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_string_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_string(a_string)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoString%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_string_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const uint8_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* self, + size_t* return_value_length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + self)); + if (return_value_length != nullptr) { + *return_value_length = fl_value_get_length(self->return_value); + } + return fl_value_get_uint8_list(self->return_value); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, const uint8_t* list, + size_t list_length, GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_uint8_list(list, list_length)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoUint8List%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + self)); + return self->return_value; +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_list_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, FlValue* list, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_ref(list)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoList%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_list_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + self)); + return self->return_value; +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_map_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_map( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, FlValue* a_map, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_ref(a_map)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoMap%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_map_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAnEnum +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE( + self), + static_cast(0)); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + self)); + return static_cast( + fl_value_get_int(reinterpret_cast(const_cast( + fl_value_get_custom_value(self->return_value))))); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_echo_enum_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_enum( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + CoreTestsPigeonTestAnEnum an_enum, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, + fl_value_new_custom(134, fl_value_new_int(an_enum), + (GDestroyNotify)fl_value_unref)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoEnum%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; + gboolean return_value_; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +gboolean* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + self->return_value_ = fl_value_get_bool(self->return_value); + return &self->return_value_; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, gboolean* a_bool, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_bool != nullptr ? fl_value_new_bool(*a_bool) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableBool%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; + int64_t return_value_; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +int64_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + self->return_value_ = fl_value_get_int(self->return_value); + return &self->return_value_; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, int64_t* an_int, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, an_int != nullptr ? fl_value_new_int(*an_int) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableInt%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; + double return_value_; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +double* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + self->return_value_ = fl_value_get_float(self->return_value); + return &self->return_value_; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, double* a_double, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_double != nullptr ? fl_value_new_float(*a_double) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableDouble%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return fl_value_get_string(self->return_value); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, a_string != nullptr ? fl_value_new_string(a_string) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableString%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_new( + response); +} + +struct + _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const uint8_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + self, + size_t* return_value_length) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + if (return_value_length != nullptr) { + *return_value_length = fl_value_get_length(self->return_value); + } + return fl_value_get_uint8_list(self->return_value); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, const uint8_t* list, + size_t list_length, GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, list != nullptr + ? fl_value_new_uint8_list(list, list_length) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableUint8List%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return self->return_value; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, FlValue* list, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take( + args, list != nullptr ? fl_value_ref(list) : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableList%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + return self->return_value; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, FlValue* a_map, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take( + args, a_map != nullptr ? fl_value_ref(a_map) : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableMap%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; + CoreTestsPigeonTestAnEnum return_value_; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + self)); + if (fl_value_get_type(self->return_value) == FL_VALUE_TYPE_NULL) { + return nullptr; + } + self->return_value_ = static_cast( + fl_value_get_int(reinterpret_cast(const_cast( + fl_value_get_custom_value(self->return_value))))); + return &self->return_value_; +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + CoreTestsPigeonTestAnEnum* an_enum, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take( + args, an_enum != nullptr + ? fl_value_new_custom(134, fl_value_new_int(*an_enum), + (GDestroyNotify)fl_value_unref) + : fl_value_new_null()); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoNullableEnum%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse { + GObject parent_instance; + + FlValue* error; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse, + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self) {} + +static void +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +static void core_tests_pigeon_test_flutter_integration_core_api_noop_async_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_noop_async( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "noopAsync%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_noop_async_cb, task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_class_init( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponseClass* + klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_dispose; +} + +static CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + g_object_new( + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + self)); + return fl_value_get_string(self->return_value); +} + +static void +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_integration_core_api_echo_async_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_string(a_string)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterIntegrationCoreApi." + "echoAsyncString%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_cb, + task); +} + +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_new( + response); +} + +struct _CoreTestsPigeonTestHostTrivialApiNoopResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostTrivialApiNoopResponse, + core_tests_pigeon_test_host_trivial_api_noop_response, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_trivial_api_noop_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostTrivialApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API_NOOP_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_trivial_api_noop_response_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_trivial_api_noop_response_init( + CoreTestsPigeonTestHostTrivialApiNoopResponse* self) {} + +static void core_tests_pigeon_test_host_trivial_api_noop_response_class_init( + CoreTestsPigeonTestHostTrivialApiNoopResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_trivial_api_noop_response_dispose; +} + +CoreTestsPigeonTestHostTrivialApiNoopResponse* +core_tests_pigeon_test_host_trivial_api_noop_response_new() { + CoreTestsPigeonTestHostTrivialApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API_NOOP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_trivial_api_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +CoreTestsPigeonTestHostTrivialApiNoopResponse* +core_tests_pigeon_test_host_trivial_api_noop_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostTrivialApiNoopResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API_NOOP_RESPONSE(g_object_new( + core_tests_pigeon_test_host_trivial_api_noop_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostTrivialApi, + core_tests_pigeon_test_host_trivial_api, + CORE_TESTS_PIGEON_TEST, HOST_TRIVIAL_API, GObject) + +struct _CoreTestsPigeonTestHostTrivialApi { + GObject parent_instance; + + const CoreTestsPigeonTestHostTrivialApiVTable* vtable; + gpointer user_data; + GDestroyNotify user_data_free_func; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostTrivialApi, + core_tests_pigeon_test_host_trivial_api, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_trivial_api_dispose(GObject* object) { + CoreTestsPigeonTestHostTrivialApi* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API(object); + if (self->user_data != nullptr) { + self->user_data_free_func(self->user_data); + } + self->user_data = nullptr; + G_OBJECT_CLASS(core_tests_pigeon_test_host_trivial_api_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_trivial_api_init( + CoreTestsPigeonTestHostTrivialApi* self) {} + +static void core_tests_pigeon_test_host_trivial_api_class_init( + CoreTestsPigeonTestHostTrivialApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_trivial_api_dispose; +} + +static CoreTestsPigeonTestHostTrivialApi* +core_tests_pigeon_test_host_trivial_api_new( + const CoreTestsPigeonTestHostTrivialApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + CoreTestsPigeonTestHostTrivialApi* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API(g_object_new( + core_tests_pigeon_test_host_trivial_api_get_type(), nullptr)); + self->vtable = vtable; + self->user_data = user_data; + self->user_data_free_func = user_data_free_func; + return self; +} + +static void core_tests_pigeon_test_host_trivial_api_noop_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostTrivialApi* self = + CORE_TESTS_PIGEON_TEST_HOST_TRIVIAL_API(user_data); + + if (self->vtable == nullptr || self->vtable->noop == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostTrivialApiNoopResponse) response = + self->vtable->noop(self->user_data); + if (response == nullptr) { + g_warning("No response returned to %s.%s", "HostTrivialApi", "noop"); + return; + } + + g_autoptr(GError) error = NULL; + if (!fl_basic_message_channel_respond(channel, response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostTrivialApi", "noop", + error->message); + } +} + +void core_tests_pigeon_test_host_trivial_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostTrivialApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + g_autoptr(CoreTestsPigeonTestHostTrivialApi) api_data = + core_tests_pigeon_test_host_trivial_api_new(vtable, user_data, + user_data_free_func); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostTrivialApi.noop%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_channel = fl_basic_message_channel_new( + messenger, noop_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + noop_channel, core_tests_pigeon_test_host_trivial_api_noop_cb, + g_object_ref(api_data), g_object_unref); +} + +void core_tests_pigeon_test_host_trivial_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* noop_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostTrivialApi.noop%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) noop_channel = fl_basic_message_channel_new( + messenger, noop_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(noop_channel, nullptr, nullptr, + nullptr); +} + +struct _CoreTestsPigeonTestHostSmallApiResponseHandle { + GObject parent_instance; + + FlBasicMessageChannel* channel; + FlBasicMessageChannelResponseHandle* response_handle; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostSmallApiResponseHandle, + core_tests_pigeon_test_host_small_api_response_handle, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_small_api_response_handle_dispose( + GObject* object) { + CoreTestsPigeonTestHostSmallApiResponseHandle* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_RESPONSE_HANDLE(object); + g_clear_object(&self->channel); + g_clear_object(&self->response_handle); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_small_api_response_handle_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_small_api_response_handle_init( + CoreTestsPigeonTestHostSmallApiResponseHandle* self) {} + +static void core_tests_pigeon_test_host_small_api_response_handle_class_init( + CoreTestsPigeonTestHostSmallApiResponseHandleClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_small_api_response_handle_dispose; +} + +static CoreTestsPigeonTestHostSmallApiResponseHandle* +core_tests_pigeon_test_host_small_api_response_handle_new( + FlBasicMessageChannel* channel, + FlBasicMessageChannelResponseHandle* response_handle) { + CoreTestsPigeonTestHostSmallApiResponseHandle* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_RESPONSE_HANDLE(g_object_new( + core_tests_pigeon_test_host_small_api_response_handle_get_type(), + nullptr)); + self->channel = FL_BASIC_MESSAGE_CHANNEL(g_object_ref(channel)); + self->response_handle = + FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_ref(response_handle)); + return self; +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostSmallApiEchoResponse, + core_tests_pigeon_test_host_small_api_echo_response, + CORE_TESTS_PIGEON_TEST, HOST_SMALL_API_ECHO_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostSmallApiEchoResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostSmallApiEchoResponse, + core_tests_pigeon_test_host_small_api_echo_response, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_small_api_echo_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostSmallApiEchoResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_ECHO_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_small_api_echo_response_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_small_api_echo_response_init( + CoreTestsPigeonTestHostSmallApiEchoResponse* self) {} + +static void core_tests_pigeon_test_host_small_api_echo_response_class_init( + CoreTestsPigeonTestHostSmallApiEchoResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_small_api_echo_response_dispose; +} + +static CoreTestsPigeonTestHostSmallApiEchoResponse* +core_tests_pigeon_test_host_small_api_echo_response_new( + const gchar* return_value) { + CoreTestsPigeonTestHostSmallApiEchoResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_ECHO_RESPONSE(g_object_new( + core_tests_pigeon_test_host_small_api_echo_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(return_value)); + return self; +} + +static CoreTestsPigeonTestHostSmallApiEchoResponse* +core_tests_pigeon_test_host_small_api_echo_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostSmallApiEchoResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_ECHO_RESPONSE(g_object_new( + core_tests_pigeon_test_host_small_api_echo_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostSmallApiVoidVoidResponse, + core_tests_pigeon_test_host_small_api_void_void_response, + CORE_TESTS_PIGEON_TEST, HOST_SMALL_API_VOID_VOID_RESPONSE, + GObject) + +struct _CoreTestsPigeonTestHostSmallApiVoidVoidResponse { + GObject parent_instance; + + FlValue* value; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostSmallApiVoidVoidResponse, + core_tests_pigeon_test_host_small_api_void_void_response, + G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_small_api_void_void_response_dispose( + GObject* object) { + CoreTestsPigeonTestHostSmallApiVoidVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_VOID_VOID_RESPONSE(object); + g_clear_pointer(&self->value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_host_small_api_void_void_response_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_small_api_void_void_response_init( + CoreTestsPigeonTestHostSmallApiVoidVoidResponse* self) {} + +static void core_tests_pigeon_test_host_small_api_void_void_response_class_init( + CoreTestsPigeonTestHostSmallApiVoidVoidResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_small_api_void_void_response_dispose; +} + +static CoreTestsPigeonTestHostSmallApiVoidVoidResponse* +core_tests_pigeon_test_host_small_api_void_void_response_new() { + CoreTestsPigeonTestHostSmallApiVoidVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_VOID_VOID_RESPONSE(g_object_new( + core_tests_pigeon_test_host_small_api_void_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_null()); + return self; +} + +static CoreTestsPigeonTestHostSmallApiVoidVoidResponse* +core_tests_pigeon_test_host_small_api_void_void_response_new_error( + const gchar* code, const gchar* message, FlValue* details) { + CoreTestsPigeonTestHostSmallApiVoidVoidResponse* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API_VOID_VOID_RESPONSE(g_object_new( + core_tests_pigeon_test_host_small_api_void_void_response_get_type(), + nullptr)); + self->value = fl_value_new_list(); + fl_value_append_take(self->value, fl_value_new_string(code)); + fl_value_append_take(self->value, + fl_value_new_string(message != nullptr ? message : "")); + fl_value_append_take(self->value, details != nullptr ? fl_value_ref(details) + : fl_value_new_null()); + return self; +} + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostSmallApi, + core_tests_pigeon_test_host_small_api, + CORE_TESTS_PIGEON_TEST, HOST_SMALL_API, GObject) + +struct _CoreTestsPigeonTestHostSmallApi { + GObject parent_instance; + + const CoreTestsPigeonTestHostSmallApiVTable* vtable; + gpointer user_data; + GDestroyNotify user_data_free_func; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestHostSmallApi, + core_tests_pigeon_test_host_small_api, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_host_small_api_dispose(GObject* object) { + CoreTestsPigeonTestHostSmallApi* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API(object); + if (self->user_data != nullptr) { + self->user_data_free_func(self->user_data); + } + self->user_data = nullptr; + G_OBJECT_CLASS(core_tests_pigeon_test_host_small_api_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_host_small_api_init( + CoreTestsPigeonTestHostSmallApi* self) {} + +static void core_tests_pigeon_test_host_small_api_class_init( + CoreTestsPigeonTestHostSmallApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_host_small_api_dispose; +} + +static CoreTestsPigeonTestHostSmallApi* +core_tests_pigeon_test_host_small_api_new( + const CoreTestsPigeonTestHostSmallApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + CoreTestsPigeonTestHostSmallApi* self = CORE_TESTS_PIGEON_TEST_HOST_SMALL_API( + g_object_new(core_tests_pigeon_test_host_small_api_get_type(), nullptr)); + self->vtable = vtable; + self->user_data = user_data; + self->user_data_free_func = user_data_free_func; + return self; +} + +static void core_tests_pigeon_test_host_small_api_echo_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostSmallApi* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API(user_data); + + if (self->vtable == nullptr || self->vtable->echo == nullptr) { + return; + } + + FlValue* value0 = fl_value_get_list_value(message_, 0); + const gchar* a_string = fl_value_get_string(value0); + g_autoptr(CoreTestsPigeonTestHostSmallApiResponseHandle) handle = + core_tests_pigeon_test_host_small_api_response_handle_new( + channel, response_handle); + self->vtable->echo(a_string, handle, self->user_data); +} + +static void core_tests_pigeon_test_host_small_api_void_void_cb( + FlBasicMessageChannel* channel, FlValue* message_, + FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { + CoreTestsPigeonTestHostSmallApi* self = + CORE_TESTS_PIGEON_TEST_HOST_SMALL_API(user_data); + + if (self->vtable == nullptr || self->vtable->void_void == nullptr) { + return; + } + + g_autoptr(CoreTestsPigeonTestHostSmallApiResponseHandle) handle = + core_tests_pigeon_test_host_small_api_response_handle_new( + channel, response_handle); + self->vtable->void_void(handle, self->user_data); +} + +void core_tests_pigeon_test_host_small_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostSmallApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + g_autoptr(CoreTestsPigeonTestHostSmallApi) api_data = + core_tests_pigeon_test_host_small_api_new(vtable, user_data, + user_data_free_func); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* echo_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostSmallApi.echo%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_channel = fl_basic_message_channel_new( + messenger, echo_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + echo_channel, core_tests_pigeon_test_host_small_api_echo_cb, + g_object_ref(api_data), g_object_unref); + g_autofree gchar* void_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostSmallApi.voidVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) void_void_channel = + fl_basic_message_channel_new(messenger, void_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler( + void_void_channel, core_tests_pigeon_test_host_small_api_void_void_cb, + g_object_ref(api_data), g_object_unref); +} + +void core_tests_pigeon_test_host_small_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix) { + g_autofree gchar* dot_suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + g_autofree gchar* echo_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostSmallApi.echo%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) echo_channel = fl_basic_message_channel_new( + messenger, echo_channel_name, FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(echo_channel, nullptr, nullptr, + nullptr); + g_autofree gchar* void_void_channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.HostSmallApi.voidVoid%s", + dot_suffix); + g_autoptr(FlBasicMessageChannel) void_void_channel = + fl_basic_message_channel_new(messenger, void_void_channel_name, + FL_MESSAGE_CODEC(codec)); + fl_basic_message_channel_set_message_handler(void_void_channel, nullptr, + nullptr, nullptr); +} + +void core_tests_pigeon_test_host_small_api_respond_echo( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* return_value) { + g_autoptr(CoreTestsPigeonTestHostSmallApiEchoResponse) response = + core_tests_pigeon_test_host_small_api_echo_response_new(return_value); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostSmallApi", "echo", + error->message); + } +} + +void core_tests_pigeon_test_host_small_api_respond_error_echo( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(CoreTestsPigeonTestHostSmallApiEchoResponse) response = + core_tests_pigeon_test_host_small_api_echo_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostSmallApi", "echo", + error->message); + } +} + +void core_tests_pigeon_test_host_small_api_respond_void_void( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle) { + g_autoptr(CoreTestsPigeonTestHostSmallApiVoidVoidResponse) response = + core_tests_pigeon_test_host_small_api_void_void_response_new(); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostSmallApi", + "voidVoid", error->message); + } +} + +void core_tests_pigeon_test_host_small_api_respond_error_void_void( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details) { + g_autoptr(CoreTestsPigeonTestHostSmallApiVoidVoidResponse) response = + core_tests_pigeon_test_host_small_api_void_void_response_new_error( + code, message, details); + g_autoptr(GError) error = nullptr; + if (!fl_basic_message_channel_respond(response_handle->channel, + response_handle->response_handle, + response->value, &error)) { + g_warning("Failed to send response to %s.%s: %s", "HostSmallApi", + "voidVoid", error->message); + } +} + +struct _CoreTestsPigeonTestFlutterSmallApi { + GObject parent_instance; + + FlBinaryMessenger* messenger; + gchar* suffix; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestFlutterSmallApi, + core_tests_pigeon_test_flutter_small_api, G_TYPE_OBJECT) + +static void core_tests_pigeon_test_flutter_small_api_dispose(GObject* object) { + CoreTestsPigeonTestFlutterSmallApi* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API(object); + g_clear_object(&self->messenger); + g_clear_pointer(&self->suffix, g_free); + G_OBJECT_CLASS(core_tests_pigeon_test_flutter_small_api_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_flutter_small_api_init( + CoreTestsPigeonTestFlutterSmallApi* self) {} + +static void core_tests_pigeon_test_flutter_small_api_class_init( + CoreTestsPigeonTestFlutterSmallApiClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_small_api_dispose; +} + +CoreTestsPigeonTestFlutterSmallApi* +core_tests_pigeon_test_flutter_small_api_new(FlBinaryMessenger* messenger, + const gchar* suffix) { + CoreTestsPigeonTestFlutterSmallApi* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API(g_object_new( + core_tests_pigeon_test_flutter_small_api_get_type(), nullptr)); + self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger)); + self->suffix = + suffix != nullptr ? g_strdup_printf(".%s", suffix) : g_strdup(""); + return self; +} + +struct _CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse, + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_parent_class) + ->dispose(object); +} + +static void +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_init( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) {} + +static void +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_class_init( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_dispose; +} + +static CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE(g_object_new( + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_code( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_message( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_details( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +CoreTestsPigeonTestTestMessage* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_return_value( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE( + self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + self)); + return CORE_TESTS_PIGEON_TEST_TEST_MESSAGE( + fl_value_get_custom_value_object(self->return_value)); +} + +static void core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_small_api_echo_wrapped_list( + CoreTestsPigeonTestFlutterSmallApi* self, + CoreTestsPigeonTestTestMessage* msg, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_custom_object(133, G_OBJECT(msg))); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterSmallApi." + "echoWrappedList%s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_cb, task); +} + +CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_finish( + CoreTestsPigeonTestFlutterSmallApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_new( + response); +} + +struct _CoreTestsPigeonTestFlutterSmallApiEchoStringResponse { + GObject parent_instance; + + FlValue* error; + FlValue* return_value; +}; + +G_DEFINE_TYPE(CoreTestsPigeonTestFlutterSmallApiEchoStringResponse, + core_tests_pigeon_test_flutter_small_api_echo_string_response, + G_TYPE_OBJECT) + +static void +core_tests_pigeon_test_flutter_small_api_echo_string_response_dispose( + GObject* object) { + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(object); + g_clear_pointer(&self->error, fl_value_unref); + g_clear_pointer(&self->return_value, fl_value_unref); + G_OBJECT_CLASS( + core_tests_pigeon_test_flutter_small_api_echo_string_response_parent_class) + ->dispose(object); +} + +static void core_tests_pigeon_test_flutter_small_api_echo_string_response_init( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) {} + +static void +core_tests_pigeon_test_flutter_small_api_echo_string_response_class_init( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponseClass* klass) { + G_OBJECT_CLASS(klass)->dispose = + core_tests_pigeon_test_flutter_small_api_echo_string_response_dispose; +} + +static CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* +core_tests_pigeon_test_flutter_small_api_echo_string_response_new( + FlValue* response) { + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self = + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(g_object_new( + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_type(), + nullptr)); + if (fl_value_get_length(response) > 1) { + self->error = fl_value_ref(response); + } else { + FlValue* value = fl_value_get_list_value(response, 0); + self->return_value = fl_value_ref(value); + } + return self; +} + +gboolean core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(self), + FALSE); + return self->error != nullptr; +} + +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_code( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 0)); +} + +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_message( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + self)); + return fl_value_get_string(fl_value_get_list_value(self->error, 1)); +} + +FlValue* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_details( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(self), + nullptr); + g_assert( + core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + self)); + return fl_value_get_list_value(self->error, 2); +} + +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_return_value( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* self) { + g_return_val_if_fail( + CORE_TESTS_PIGEON_TEST_IS_FLUTTER_SMALL_API_ECHO_STRING_RESPONSE(self), + nullptr); + g_assert( + !core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + self)); + return fl_value_get_string(self->return_value); +} + +static void core_tests_pigeon_test_flutter_small_api_echo_string_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + GTask* task = G_TASK(user_data); + g_task_return_pointer(task, result, g_object_unref); +} + +void core_tests_pigeon_test_flutter_small_api_echo_string( + CoreTestsPigeonTestFlutterSmallApi* self, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data) { + g_autoptr(FlValue) args = fl_value_new_list(); + fl_value_append_take(args, fl_value_new_string(a_string)); + g_autofree gchar* channel_name = g_strdup_printf( + "dev.flutter.pigeon.pigeon_integration_tests.FlutterSmallApi.echoString%" + "s", + self->suffix); + g_autoptr(CoreTestsPigeonTestMessageCodec) codec = + core_tests_pigeon_test_message_codec_new(); + FlBasicMessageChannel* channel = fl_basic_message_channel_new( + self->messenger, channel_name, FL_MESSAGE_CODEC(codec)); + GTask* task = g_task_new(self, cancellable, callback, user_data); + g_task_set_task_data(task, channel, g_object_unref); + fl_basic_message_channel_send( + channel, args, cancellable, + core_tests_pigeon_test_flutter_small_api_echo_string_cb, task); +} + +CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* +core_tests_pigeon_test_flutter_small_api_echo_string_finish( + CoreTestsPigeonTestFlutterSmallApi* self, GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr)); + FlBasicMessageChannel* channel = + FL_BASIC_MESSAGE_CHANNEL(g_task_get_task_data(task)); + g_autoptr(FlValue) response = + fl_basic_message_channel_send_finish(channel, r, error); + if (response == nullptr) { + return nullptr; + } + return core_tests_pigeon_test_flutter_small_api_echo_string_response_new( + response); +} diff --git a/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.h b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.h new file mode 100644 index 000000000000..086101d4b628 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/pigeon/core_tests.gen.h @@ -0,0 +1,6847 @@ +// 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. +// +// Autogenerated from Pigeon, do not edit directly. +// See also: https://pub.dev/packages/pigeon + +#ifndef PIGEON_CORE_TESTS_GEN_H_ +#define PIGEON_CORE_TESTS_GEN_H_ + +#include + +G_BEGIN_DECLS + +/** + * CoreTestsPigeonTestAnEnum: + * PIGEON_INTEGRATION_TESTS_AN_ENUM_ONE: + * PIGEON_INTEGRATION_TESTS_AN_ENUM_TWO: + * PIGEON_INTEGRATION_TESTS_AN_ENUM_THREE: + * PIGEON_INTEGRATION_TESTS_AN_ENUM_FORTY_TWO: + * PIGEON_INTEGRATION_TESTS_AN_ENUM_FOUR_HUNDRED_TWENTY_TWO: + * + */ +typedef enum { + PIGEON_INTEGRATION_TESTS_AN_ENUM_ONE = 0, + PIGEON_INTEGRATION_TESTS_AN_ENUM_TWO = 1, + PIGEON_INTEGRATION_TESTS_AN_ENUM_THREE = 2, + PIGEON_INTEGRATION_TESTS_AN_ENUM_FORTY_TWO = 3, + PIGEON_INTEGRATION_TESTS_AN_ENUM_FOUR_HUNDRED_TWENTY_TWO = 4 +} CoreTestsPigeonTestAnEnum; + +/** + * CoreTestsPigeonTestAllTypes: + * + * A class containing all supported types. + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestAllTypes, + core_tests_pigeon_test_all_types, CORE_TESTS_PIGEON_TEST, + ALL_TYPES, GObject) + +/** + * core_tests_pigeon_test_all_types_new: + * a_bool: field in this object. + * an_int: field in this object. + * an_int64: field in this object. + * a_double: field in this object. + * a_byte_array: field in this object. + * a_byte_array_length: length of @a_byte_array. + * a4_byte_array: field in this object. + * a4_byte_array_length: length of @a4_byte_array. + * a8_byte_array: field in this object. + * a8_byte_array_length: length of @a8_byte_array. + * a_float_array: field in this object. + * a_float_array_length: length of @a_float_array. + * an_enum: field in this object. + * a_string: field in this object. + * an_object: field in this object. + * list: field in this object. + * string_list: field in this object. + * int_list: field in this object. + * double_list: field in this object. + * bool_list: field in this object. + * map: field in this object. + * + * Creates a new #AllTypes object. + * + * Returns: a new #CoreTestsPigeonTestAllTypes + */ +CoreTestsPigeonTestAllTypes* core_tests_pigeon_test_all_types_new( + gboolean a_bool, int64_t an_int, int64_t an_int64, double a_double, + const uint8_t* a_byte_array, size_t a_byte_array_length, + const int32_t* a4_byte_array, size_t a4_byte_array_length, + const int64_t* a8_byte_array, size_t a8_byte_array_length, + const double* a_float_array, size_t a_float_array_length, + CoreTestsPigeonTestAnEnum an_enum, const gchar* a_string, + FlValue* an_object, FlValue* list, FlValue* string_list, FlValue* int_list, + FlValue* double_list, FlValue* bool_list, FlValue* map); + +/** + * core_tests_pigeon_test_all_types_get_a_bool + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the aBool field of @object. + * + * Returns: the field value. + */ +gboolean core_tests_pigeon_test_all_types_get_a_bool( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_an_int + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the anInt field of @object. + * + * Returns: the field value. + */ +int64_t core_tests_pigeon_test_all_types_get_an_int( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_an_int64 + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the anInt64 field of @object. + * + * Returns: the field value. + */ +int64_t core_tests_pigeon_test_all_types_get_an_int64( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_a_double + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the aDouble field of @object. + * + * Returns: the field value. + */ +double core_tests_pigeon_test_all_types_get_a_double( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_a_byte_array + * @object: a #CoreTestsPigeonTestAllTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aByteArray field of @object. + * + * Returns: the field value. + */ +const uint8_t* core_tests_pigeon_test_all_types_get_a_byte_array( + CoreTestsPigeonTestAllTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_types_get_a4_byte_array + * @object: a #CoreTestsPigeonTestAllTypes. + * @length: location to write the length of this value. + * + * Gets the value of the a4ByteArray field of @object. + * + * Returns: the field value. + */ +const int32_t* core_tests_pigeon_test_all_types_get_a4_byte_array( + CoreTestsPigeonTestAllTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_types_get_a8_byte_array + * @object: a #CoreTestsPigeonTestAllTypes. + * @length: location to write the length of this value. + * + * Gets the value of the a8ByteArray field of @object. + * + * Returns: the field value. + */ +const int64_t* core_tests_pigeon_test_all_types_get_a8_byte_array( + CoreTestsPigeonTestAllTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_types_get_a_float_array + * @object: a #CoreTestsPigeonTestAllTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aFloatArray field of @object. + * + * Returns: the field value. + */ +const double* core_tests_pigeon_test_all_types_get_a_float_array( + CoreTestsPigeonTestAllTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_types_get_an_enum + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the anEnum field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAnEnum core_tests_pigeon_test_all_types_get_an_enum( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_a_string + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the aString field of @object. + * + * Returns: the field value. + */ +const gchar* core_tests_pigeon_test_all_types_get_a_string( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_an_object + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the anObject field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_an_object( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_list + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the list field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_list( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_string_list + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the stringList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_string_list( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_int_list + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the intList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_int_list( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_double_list + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the doubleList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_double_list( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_bool_list + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the boolList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_bool_list( + CoreTestsPigeonTestAllTypes* object); + +/** + * core_tests_pigeon_test_all_types_get_map + * @object: a #CoreTestsPigeonTestAllTypes. + * + * Gets the value of the map field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_types_get_map( + CoreTestsPigeonTestAllTypes* object); + +/** + * CoreTestsPigeonTestAllNullableTypes: + * + * A class containing all supported nullable types. + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestAllNullableTypes, + core_tests_pigeon_test_all_nullable_types, + CORE_TESTS_PIGEON_TEST, ALL_NULLABLE_TYPES, GObject) + +/** + * core_tests_pigeon_test_all_nullable_types_new: + * a_nullable_bool: field in this object. + * a_nullable_int: field in this object. + * a_nullable_int64: field in this object. + * a_nullable_double: field in this object. + * a_nullable_byte_array: field in this object. + * a_nullable_byte_array_length: length of @a_nullable_byte_array. + * a_nullable4_byte_array: field in this object. + * a_nullable4_byte_array_length: length of @a_nullable4_byte_array. + * a_nullable8_byte_array: field in this object. + * a_nullable8_byte_array_length: length of @a_nullable8_byte_array. + * a_nullable_float_array: field in this object. + * a_nullable_float_array_length: length of @a_nullable_float_array. + * nullable_nested_list: field in this object. + * nullable_map_with_annotations: field in this object. + * nullable_map_with_object: field in this object. + * a_nullable_enum: field in this object. + * a_nullable_string: field in this object. + * a_nullable_object: field in this object. + * all_nullable_types: field in this object. + * list: field in this object. + * string_list: field in this object. + * int_list: field in this object. + * double_list: field in this object. + * bool_list: field in this object. + * nested_class_list: field in this object. + * map: field in this object. + * + * Creates a new #AllNullableTypes object. + * + * Returns: a new #CoreTestsPigeonTestAllNullableTypes + */ +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_nullable_types_new( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + int64_t* a_nullable_int64, double* a_nullable_double, + const uint8_t* a_nullable_byte_array, size_t a_nullable_byte_array_length, + const int32_t* a_nullable4_byte_array, size_t a_nullable4_byte_array_length, + const int64_t* a_nullable8_byte_array, size_t a_nullable8_byte_array_length, + const double* a_nullable_float_array, size_t a_nullable_float_array_length, + FlValue* nullable_nested_list, FlValue* nullable_map_with_annotations, + FlValue* nullable_map_with_object, + CoreTestsPigeonTestAnEnum* a_nullable_enum, const gchar* a_nullable_string, + FlValue* a_nullable_object, + CoreTestsPigeonTestAllNullableTypes* all_nullable_types, FlValue* list, + FlValue* string_list, FlValue* int_list, FlValue* double_list, + FlValue* bool_list, FlValue* nested_class_list, FlValue* map); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_bool + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableBool field of @object. + * + * Returns: the field value. + */ +gboolean* core_tests_pigeon_test_all_nullable_types_get_a_nullable_bool( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_int + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableInt field of @object. + * + * Returns: the field value. + */ +int64_t* core_tests_pigeon_test_all_nullable_types_get_a_nullable_int( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_int64 + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableInt64 field of @object. + * + * Returns: the field value. + */ +int64_t* core_tests_pigeon_test_all_nullable_types_get_a_nullable_int64( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_double + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableDouble field of @object. + * + * Returns: the field value. + */ +double* core_tests_pigeon_test_all_nullable_types_get_a_nullable_double( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aNullableByteArray field of @object. + * + * Returns: the field value. + */ +const uint8_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_byte_array( + CoreTestsPigeonTestAllNullableTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable4_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aNullable4ByteArray field of @object. + * + * Returns: the field value. + */ +const int32_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable4_byte_array( + CoreTestsPigeonTestAllNullableTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable8_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aNullable8ByteArray field of @object. + * + * Returns: the field value. + */ +const int64_t* +core_tests_pigeon_test_all_nullable_types_get_a_nullable8_byte_array( + CoreTestsPigeonTestAllNullableTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_float_array + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * @length: location to write the length of this value. + * + * Gets the value of the aNullableFloatArray field of @object. + * + * Returns: the field value. + */ +const double* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_float_array( + CoreTestsPigeonTestAllNullableTypes* object, size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_get_nullable_nested_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the nullableNestedList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_nullable_nested_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_annotations + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the nullableMapWithAnnotations field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_annotations( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_object + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the nullableMapWithObject field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_nullable_map_with_object( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_enum + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableEnum field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_all_nullable_types_get_a_nullable_enum( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_string + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableString field of @object. + * + * Returns: the field value. + */ +const gchar* core_tests_pigeon_test_all_nullable_types_get_a_nullable_string( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_a_nullable_object + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the aNullableObject field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_a_nullable_object( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_all_nullable_types + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the allNullableTypes field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_nullable_types_get_all_nullable_types( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the list field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_string_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the stringList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_string_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_int_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the intList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_int_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_double_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the doubleList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_double_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_bool_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the boolList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_bool_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_nested_class_list + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the nestedClassList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_nested_class_list( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * core_tests_pigeon_test_all_nullable_types_get_map + * @object: a #CoreTestsPigeonTestAllNullableTypes. + * + * Gets the value of the map field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_get_map( + CoreTestsPigeonTestAllNullableTypes* object); + +/** + * CoreTestsPigeonTestAllNullableTypesWithoutRecursion: + * + * The primary purpose for this class is to ensure coverage of Swift structs + * with nullable items, as the primary [AllNullableTypes] class is being used to + * test Swift classes. + */ + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion, + core_tests_pigeon_test_all_nullable_types_without_recursion, + CORE_TESTS_PIGEON_TEST, ALL_NULLABLE_TYPES_WITHOUT_RECURSION, GObject) + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_new: + * a_nullable_bool: field in this object. + * a_nullable_int: field in this object. + * a_nullable_int64: field in this object. + * a_nullable_double: field in this object. + * a_nullable_byte_array: field in this object. + * a_nullable_byte_array_length: length of @a_nullable_byte_array. + * a_nullable4_byte_array: field in this object. + * a_nullable4_byte_array_length: length of @a_nullable4_byte_array. + * a_nullable8_byte_array: field in this object. + * a_nullable8_byte_array_length: length of @a_nullable8_byte_array. + * a_nullable_float_array: field in this object. + * a_nullable_float_array_length: length of @a_nullable_float_array. + * nullable_nested_list: field in this object. + * nullable_map_with_annotations: field in this object. + * nullable_map_with_object: field in this object. + * a_nullable_enum: field in this object. + * a_nullable_string: field in this object. + * a_nullable_object: field in this object. + * list: field in this object. + * string_list: field in this object. + * int_list: field in this object. + * double_list: field in this object. + * bool_list: field in this object. + * map: field in this object. + * + * Creates a new #AllNullableTypesWithoutRecursion object. + * + * Returns: a new #CoreTestsPigeonTestAllNullableTypesWithoutRecursion + */ +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_all_nullable_types_without_recursion_new( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + int64_t* a_nullable_int64, double* a_nullable_double, + const uint8_t* a_nullable_byte_array, size_t a_nullable_byte_array_length, + const int32_t* a_nullable4_byte_array, size_t a_nullable4_byte_array_length, + const int64_t* a_nullable8_byte_array, size_t a_nullable8_byte_array_length, + const double* a_nullable_float_array, size_t a_nullable_float_array_length, + FlValue* nullable_nested_list, FlValue* nullable_map_with_annotations, + FlValue* nullable_map_with_object, + CoreTestsPigeonTestAnEnum* a_nullable_enum, const gchar* a_nullable_string, + FlValue* a_nullable_object, FlValue* list, FlValue* string_list, + FlValue* int_list, FlValue* double_list, FlValue* bool_list, FlValue* map); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_bool + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableBool field of @object. + * + * Returns: the field value. + */ +gboolean* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_bool( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableInt field of @object. + * + * Returns: the field value. + */ +int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int64 + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableInt64 field of @object. + * + * Returns: the field value. + */ +int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_int64( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_double + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableDouble field of @object. + * + * Returns: the field value. + */ +double* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_double( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * @length: location to write the length of this value. + * + * Gets the value of the aNullableByteArray field of @object. + * + * Returns: the field value. + */ +const uint8_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object, + size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable4_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * @length: location to write the length of this value. + * + * Gets the value of the aNullable4ByteArray field of @object. + * + * Returns: the field value. + */ +const int32_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable4_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object, + size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable8_byte_array + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * @length: location to write the length of this value. + * + * Gets the value of the aNullable8ByteArray field of @object. + * + * Returns: the field value. + */ +const int64_t* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable8_byte_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object, + size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_float_array + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * @length: location to write the length of this value. + * + * Gets the value of the aNullableFloatArray field of @object. + * + * Returns: the field value. + */ +const double* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_float_array( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object, + size_t* length); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_nested_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the nullableNestedList field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_nested_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_annotations + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the nullableMapWithAnnotations field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_annotations( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_object + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the nullableMapWithObject field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_nullable_map_with_object( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_enum + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableEnum field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_enum( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_string + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableString field of @object. + * + * Returns: the field value. + */ +const gchar* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_string( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_object + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the aNullableObject field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_a_nullable_object( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the list field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_without_recursion_get_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_string_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the stringList field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_string_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_int_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the intList field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_int_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_double_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the doubleList field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_double_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_bool_list + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the boolList field of @object. + * + * Returns: the field value. + */ +FlValue* +core_tests_pigeon_test_all_nullable_types_without_recursion_get_bool_list( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * core_tests_pigeon_test_all_nullable_types_without_recursion_get_map + * @object: a #CoreTestsPigeonTestAllNullableTypesWithoutRecursion. + * + * Gets the value of the map field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_all_nullable_types_without_recursion_get_map( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* object); + +/** + * CoreTestsPigeonTestAllClassesWrapper: + * + * A class for testing nested class handling. + * + * This is needed to test nested nullable and non-nullable classes, + * `AllNullableTypes` is non-nullable here as it is easier to instantiate + * than `AllTypes` when testing doesn't require both (ie. testing null classes). + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestAllClassesWrapper, + core_tests_pigeon_test_all_classes_wrapper, + CORE_TESTS_PIGEON_TEST, ALL_CLASSES_WRAPPER, GObject) + +/** + * core_tests_pigeon_test_all_classes_wrapper_new: + * all_nullable_types: field in this object. + * all_nullable_types_without_recursion: field in this object. + * all_types: field in this object. + * + * Creates a new #AllClassesWrapper object. + * + * Returns: a new #CoreTestsPigeonTestAllClassesWrapper + */ +CoreTestsPigeonTestAllClassesWrapper* +core_tests_pigeon_test_all_classes_wrapper_new( + CoreTestsPigeonTestAllNullableTypes* all_nullable_types, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* + all_nullable_types_without_recursion, + CoreTestsPigeonTestAllTypes* all_types); + +/** + * core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types + * @object: a #CoreTestsPigeonTestAllClassesWrapper. + * + * Gets the value of the allNullableTypes field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types( + CoreTestsPigeonTestAllClassesWrapper* object); + +/** + * core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types_without_recursion + * @object: a #CoreTestsPigeonTestAllClassesWrapper. + * + * Gets the value of the allNullableTypesWithoutRecursion field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types_without_recursion( + CoreTestsPigeonTestAllClassesWrapper* object); + +/** + * core_tests_pigeon_test_all_classes_wrapper_get_all_types + * @object: a #CoreTestsPigeonTestAllClassesWrapper. + * + * Gets the value of the allTypes field of @object. + * + * Returns: the field value. + */ +CoreTestsPigeonTestAllTypes* +core_tests_pigeon_test_all_classes_wrapper_get_all_types( + CoreTestsPigeonTestAllClassesWrapper* object); + +/** + * CoreTestsPigeonTestTestMessage: + * + * A data class containing a List, used in unit tests. + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestTestMessage, + core_tests_pigeon_test_test_message, + CORE_TESTS_PIGEON_TEST, TEST_MESSAGE, GObject) + +/** + * core_tests_pigeon_test_test_message_new: + * test_list: field in this object. + * + * Creates a new #TestMessage object. + * + * Returns: a new #CoreTestsPigeonTestTestMessage + */ +CoreTestsPigeonTestTestMessage* core_tests_pigeon_test_test_message_new( + FlValue* test_list); + +/** + * core_tests_pigeon_test_test_message_get_test_list + * @object: a #CoreTestsPigeonTestTestMessage. + * + * Gets the value of the testList field of @object. + * + * Returns: the field value. + */ +FlValue* core_tests_pigeon_test_test_message_get_test_list( + CoreTestsPigeonTestTestMessage* object); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle, + core_tests_pigeon_test_host_integration_core_api_response_handle, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_RESPONSE_HANDLE, GObject) + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse, + core_tests_pigeon_test_host_integration_core_api_noop_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_NOOP_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_noop_response_new: + * + * Creates a new response to HostIntegrationCoreApi.noop. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_host_integration_core_api_noop_response_new(); + +/** + * core_tests_pigeon_test_host_integration_core_api_noop_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.noop. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_host_integration_core_api_noop_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_types_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoAllTypes. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new( + CoreTestsPigeonTestAllTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoAllTypes. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_error_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_error_response_new: + * + * Creates a new response to HostIntegrationCoreApi.throwError. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_error_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.throwError. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse, + core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new: + * + * Creates a new response to HostIntegrationCoreApi.throwErrorFromVoid. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new(); + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.throwErrorFromVoid. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse, + core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_THROW_FLUTTER_ERROR_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new: + * + * Creates a new response to HostIntegrationCoreApi.throwFlutterError. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.throwFlutterError. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* +core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_int_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_INT_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_int_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoInt. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_int_response_new( + int64_t return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_int_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoInt. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_double_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_double_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoDouble. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_double_response_new( + double return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_double_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoDouble. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_bool_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoBool. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new( + gboolean return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoBool. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_string_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoString. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_string_response_new( + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoString. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoUint8List. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoUint8List. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_object_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_OBJECT_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_object_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoObject. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_object_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_object_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoObject. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_list_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_list_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoList. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_list_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_list_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoList. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_map_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_map_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoMap. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_map_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_map_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoMap. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse, + core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_CLASS_WRAPPER_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoClassWrapper. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new( + CoreTestsPigeonTestAllClassesWrapper* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoClassWrapper. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* +core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_enum_response, + CORE_TESTS_PIGEON_TEST, HOST_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoEnum. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new( + CoreTestsPigeonTestAnEnum return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoEnum. + * + * Returns: a new #CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NAMED_DEFAULT_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNamedDefaultString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new( + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.echoNamedDefaultString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_DEFAULT_DOUBLE_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoOptionalDefaultDouble. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new( + double return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.echoOptionalDefaultDouble. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_required_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_REQUIRED_INT_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoRequiredInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new( + int64_t return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoRequiredInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoAllNullableTypes. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoAllNullableTypes. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new: + * + * Creates a new response to + * HostIntegrationCoreApi.echoAllNullableTypesWithoutRecursion. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.echoAllNullableTypesWithoutRecursion. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_EXTRACT_NESTED_NULLABLE_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.extractNestedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new( + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.extractNestedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_CREATE_NESTED_NULLABLE_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.createNestedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new( + CoreTestsPigeonTestAllClassesWrapper* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.createNestedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new: + * + * Creates a new response to HostIntegrationCoreApi.sendMultipleNullableTypes. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new( + CoreTestsPigeonTestAllNullableTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.sendMultipleNullableTypes. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new: + * + * Creates a new response to + * HostIntegrationCoreApi.sendMultipleNullableTypesWithoutRecursion. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.sendMultipleNullableTypesWithoutRecursion. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new( + int64_t* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableDouble. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new( + double* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableDouble. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableBool. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new( + gboolean* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableBool. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new( + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableUint8List. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new( + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableUint8List. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_OBJECT_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableObject. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableObject. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableList. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableList. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableMap. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new( + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableMap. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse, + core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNullableEnum. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new( + CoreTestsPigeonTestAnEnum* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostIntegrationCoreApi.echoNullableEnum. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse, + core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_OPTIONAL_NULLABLE_INT_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoOptionalNullableInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new( + int64_t* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.echoOptionalNullableInt. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* +core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse, + core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + HOST_INTEGRATION_CORE_API_ECHO_NAMED_NULLABLE_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new: + * + * Creates a new response to HostIntegrationCoreApi.echoNamedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new( + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to + * HostIntegrationCoreApi.echoNamedNullableString. + * + * Returns: a new + * #CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse + */ +CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* +core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +/** + * CoreTestsPigeonTestHostIntegrationCoreApiVTable: + * + * Table of functions exposed by HostIntegrationCoreApi to be implemented by the + * API provider. + */ +typedef struct { + CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* (*noop)( + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* ( + *echo_all_types)(CoreTestsPigeonTestAllTypes* everything, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* (*throw_error)( + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* ( + *throw_error_from_void)(gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* ( + *throw_flutter_error)(gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* (*echo_int)( + int64_t an_int, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* (*echo_double)( + double a_double, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* (*echo_bool)( + gboolean a_bool, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* (*echo_string)( + const gchar* a_string, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* ( + *echo_uint8_list)(const uint8_t* a_uint8_list, size_t a_uint8_list_length, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* (*echo_object)( + FlValue* an_object, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* (*echo_list)( + FlValue* list, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* (*echo_map)( + FlValue* a_map, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* ( + *echo_class_wrapper)(CoreTestsPigeonTestAllClassesWrapper* wrapper, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* (*echo_enum)( + CoreTestsPigeonTestAnEnum an_enum, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* ( + *echo_named_default_string)(const gchar* a_string, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* ( + *echo_optional_default_double)(double a_double, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* ( + *echo_required_int)(int64_t an_int, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* ( + *echo_all_nullable_types)(CoreTestsPigeonTestAllNullableTypes* everything, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* ( + *echo_all_nullable_types_without_recursion)( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* ( + *extract_nested_nullable_string)( + CoreTestsPigeonTestAllClassesWrapper* wrapper, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* ( + *create_nested_nullable_string)(const gchar* nullable_string, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* ( + *send_multiple_nullable_types)(gboolean* a_nullable_bool, + int64_t* a_nullable_int, + const gchar* a_nullable_string, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* ( + *send_multiple_nullable_types_without_recursion)( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* ( + *echo_nullable_int)(int64_t* a_nullable_int, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* ( + *echo_nullable_double)(double* a_nullable_double, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* ( + *echo_nullable_bool)(gboolean* a_nullable_bool, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* ( + *echo_nullable_string)(const gchar* a_nullable_string, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* ( + *echo_nullable_uint8_list)(const uint8_t* a_nullable_uint8_list, + size_t a_nullable_uint8_list_length, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* ( + *echo_nullable_object)(FlValue* a_nullable_object, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* ( + *echo_nullable_list)(FlValue* a_nullable_list, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* ( + *echo_nullable_map)(FlValue* a_nullable_map, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* ( + *echo_nullable_enum)(CoreTestsPigeonTestAnEnum* an_enum, + gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* ( + *echo_optional_nullable_int)(int64_t* a_nullable_int, gpointer user_data); + CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* ( + *echo_named_nullable_string)(const gchar* a_nullable_string, + gpointer user_data); + void (*noop_async)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_int)( + int64_t an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_double)( + double a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_bool)( + gboolean a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_string)( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_uint8_list)( + const uint8_t* a_uint8_list, size_t a_uint8_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_object)( + FlValue* an_object, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_list)( + FlValue* list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_map)( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_enum)( + CoreTestsPigeonTestAnEnum an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*throw_async_error)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*throw_async_error_from_void)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*throw_async_flutter_error)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_all_types)( + CoreTestsPigeonTestAllTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_all_nullable_types)( + CoreTestsPigeonTestAllNullableTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_all_nullable_types_without_recursion)( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_int)( + int64_t* an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_double)( + double* a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_bool)( + gboolean* a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_string)( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_uint8_list)( + const uint8_t* a_uint8_list, size_t a_uint8_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_object)( + FlValue* an_object, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_list)( + FlValue* list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_map)( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*echo_async_nullable_enum)( + CoreTestsPigeonTestAnEnum* an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_noop)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_throw_error)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_throw_error_from_void)( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_all_types)( + CoreTestsPigeonTestAllTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_all_nullable_types)( + CoreTestsPigeonTestAllNullableTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_send_multiple_nullable_types)( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_all_nullable_types_without_recursion)( + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_send_multiple_nullable_types_without_recursion)( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_bool)( + gboolean a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_int)( + int64_t an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_double)( + double a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_string)( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_uint8_list)( + const uint8_t* list, size_t list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_list)( + FlValue* list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_map)( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_enum)( + CoreTestsPigeonTestAnEnum an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_bool)( + gboolean* a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_int)( + int64_t* an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_double)( + double* a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_string)( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_uint8_list)( + const uint8_t* list, size_t list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_list)( + FlValue* list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_map)( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_echo_nullable_enum)( + CoreTestsPigeonTestAnEnum* an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); + void (*call_flutter_small_api_echo_string)( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data); +} CoreTestsPigeonTestHostIntegrationCoreApiVTable; + +/** + * core_tests_pigeon_test_host_integration_core_api_set_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * @vtable: implementations of the methods in this API. + * @user_data: (closure): user data to pass to the functions in @vtable. + * @user_data_free_func: (allow-none): a function which gets called to free + * @user_data, or %NULL. + * + * Connects the method handlers in the HostIntegrationCoreApi API. + */ +void core_tests_pigeon_test_host_integration_core_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostIntegrationCoreApiVTable* vtable, + gpointer user_data, GDestroyNotify user_data_free_func); + +/** + * core_tests_pigeon_test_host_integration_core_api_clear_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Clears the method handlers in the HostIntegrationCoreApi API. + */ +void core_tests_pigeon_test_host_integration_core_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_noop_async: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * + * Responds to HostIntegrationCoreApi.noopAsync. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_noop_async( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_noop_async: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.noopAsync. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_noop_async( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * @return_value_length: (allow-none): location to write length of @return_value + * or %NULL to ignore. + * + * Responds to HostIntegrationCoreApi.echoAsyncUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_object: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncObject. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_object: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncObject. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.throwAsyncError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.throwAsyncError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error_from_void: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * + * Responds to HostIntegrationCoreApi.throwAsyncErrorFromVoid. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error_from_void: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.throwAsyncErrorFromVoid. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_throw_async_flutter_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.throwAsyncFlutterError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_throw_async_flutter_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_flutter_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.throwAsyncFlutterError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_flutter_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_all_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncAllTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_all_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncAllTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableAllNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.echoAsyncNullableAllNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to + * HostIntegrationCoreApi.echoAsyncNullableAllNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.echoAsyncNullableAllNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * @return_value_length: (allow-none): location to write length of @return_value + * or %NULL to ignore. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_object: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableObject. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_object: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableObject. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_object( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.echoAsyncNullableEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.echoAsyncNullableEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_echo_async_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_noop: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * + * Responds to HostIntegrationCoreApi.callFlutterNoop. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_noop( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_noop: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterNoop. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_noop( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterThrowError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterThrowError. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error_from_void: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * + * Responds to HostIntegrationCoreApi.callFlutterThrowErrorFromVoid. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error_from_void: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterThrowErrorFromVoid. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error_from_void( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoAllTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoAllTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoAllNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterEchoAllNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterSendMultipleNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypes* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterSendMultipleNullableTypes. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to + * HostIntegrationCoreApi.callFlutterEchoAllNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterEchoAllNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to + * HostIntegrationCoreApi.callFlutterSendMultipleNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types_without_recursion: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterSendMultipleNullableTypesWithoutRecursion. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * @return_value_length: (allow-none): location to write length of @return_value + * or %NULL to ignore. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gboolean* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_bool: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoNullableBool. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_bool( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + int64_t* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_int: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoNullableInt. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_int( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + double* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_double: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterEchoNullableDouble. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_double( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterEchoNullableString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * @return_value_length: (allow-none): location to write length of @return_value + * or %NULL to ignore. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const uint8_t* return_value, size_t return_value_length); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_uint8_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterEchoNullableUint8List. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_uint8_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_list: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoNullableList. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_list( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + FlValue* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_map: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoNullableMap. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_map( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterEchoNullableEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + CoreTestsPigeonTestAnEnum* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_enum: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostIntegrationCoreApi.callFlutterEchoNullableEnum. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_enum( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_small_api_echo_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostIntegrationCoreApi.callFlutterSmallApiEchoString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_small_api_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_small_api_echo_string: + * @response_handle: a #CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to + * HostIntegrationCoreApi.callFlutterSmallApiEchoString. + */ +void core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_small_api_echo_string( + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse, + core_tests_pigeon_test_flutter_integration_core_api_noop_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_NOOP_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.noop is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.throwError is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_THROW_ERROR_FROM_VOID_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.throwErrorFromVoid is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_TYPES_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoAllTypes is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +CoreTestsPigeonTestAllTypes* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoAllNullableTypes is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.sendMultipleNullableTypes + * is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +CoreTestsPigeonTestAllNullableTypes* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_ALL_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse. + * + * Checks if a response to + * FlutterIntegrationCoreApi.echoAllNullableTypesWithoutRecursion is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_SEND_MULTIPLE_NULLABLE_TYPES_WITHOUT_RECURSION_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse. + * + * Checks if a response to + * FlutterIntegrationCoreApi.sendMultipleNullableTypesWithoutRecursion is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +CoreTestsPigeonTestAllNullableTypesWithoutRecursion* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_BOOL_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoBool is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_INT_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoInt is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +int64_t +core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_DOUBLE_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoDouble is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +double +core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_STRING_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoString is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_UINT8_LIST_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoUint8List is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse. + * @return_value_length: (allow-none): location to write length of the return + * value or %NULL to ignore. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +const uint8_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* response, + size_t* return_value_length); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_LIST_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoList is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_MAP_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoMap is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_ECHO_ENUM_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoEnum is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +CoreTestsPigeonTestAnEnum +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_BOOL_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableBool is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +gboolean* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_INT_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableInt is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +int64_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_DOUBLE_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableDouble is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +double* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableString is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_UINT8_LIST_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableUint8List is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse. + * @return_value_length: (allow-none): location to write length of the return + * value or %NULL to ignore. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +const uint8_t* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* + response, + size_t* return_value_length); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_LIST_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableList is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_MAP_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableMap is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_NULLABLE_ENUM_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoNullableEnum is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse. + * + * Get the return value for this response. + * + * Returns: (allow-none): a return value or %NULL. + */ +CoreTestsPigeonTestAnEnum* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* + response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse, + core_tests_pigeon_test_flutter_integration_core_api_noop_async_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API_NOOP_ASYNC_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.noopAsync is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse, + core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response, + CORE_TESTS_PIGEON_TEST, + FLUTTER_INTEGRATION_CORE_API_ECHO_ASYNC_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse. + * + * Checks if a response to FlutterIntegrationCoreApi.echoAsyncString is an + * error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_is_error( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_code: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_code( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_message: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_message( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_details: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_error_details( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* + response); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_return_value: + * @response: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +const gchar* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_response_get_return_value( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* + response); + +/** + * CoreTestsPigeonTestFlutterIntegrationCoreApi: + * + * The core interface that the Dart platform_test code implements for host + * integration tests to call into. + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestFlutterIntegrationCoreApi, + core_tests_pigeon_test_flutter_integration_core_api, + CORE_TESTS_PIGEON_TEST, FLUTTER_INTEGRATION_CORE_API, + GObject) + +/** + * core_tests_pigeon_test_flutter_integration_core_api_new: + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Creates a new object to access the FlutterIntegrationCoreApi API. + * + * Returns: a new #CoreTestsPigeonTestFlutterIntegrationCoreApi + */ +CoreTestsPigeonTestFlutterIntegrationCoreApi* +core_tests_pigeon_test_flutter_integration_core_api_new( + FlBinaryMessenger* messenger, const gchar* suffix); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * A no-op function taking no arguments and returning no value, to sanity + * test basic calling. + */ +void core_tests_pigeon_test_flutter_integration_core_api_noop( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_noop() call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse or %NULL + * on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Responds with an error from an async function returning a value. + */ +void core_tests_pigeon_test_flutter_integration_core_api_throw_error( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_throw_error() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Responds with an error from an async void function. + */ +void core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse* +core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @everything: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed object, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + CoreTestsPigeonTestAllTypes* everything, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_types() call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse + * or %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @everything: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed object, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + CoreTestsPigeonTestAllNullableTypes* everything, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_nullable_bool: (allow-none): parameter for this method. + * @a_nullable_int: (allow-none): parameter for this method. + * @a_nullable_string: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns passed in arguments of multiple types. + * + * Tests multiple-arity FlutterApi handling. + */ +void core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse + * or %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @everything: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed object, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse + * or %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_nullable_bool: (allow-none): parameter for this method. + * @a_nullable_int: (allow-none): parameter for this method. + * @a_nullable_string: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns passed in arguments of multiple types. + * + * Tests multiple-arity FlutterApi handling. + */ +void core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse + * or %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_bool: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed boolean, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_bool( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, gboolean a_bool, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_bool_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_bool() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_bool_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @an_int: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed int, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_int( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, int64_t an_int, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_int_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_int() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_int_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_double: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed double, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_double( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, double a_double, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_double_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_double() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_double_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_string: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed string, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_string_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_string() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @list: parameter for this method. + * @list_length: length of list. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed byte list, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, const uint8_t* list, + size_t list_length, GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list() call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse + * or %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @list: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed list, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, FlValue* list, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_list_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_list() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_map: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed map, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_map( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, FlValue* a_map, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_map_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_map() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_map_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @an_enum: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed enum to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_enum( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + CoreTestsPigeonTestAnEnum an_enum, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_enum_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_echo_enum() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_enum_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_bool: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed boolean, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, gboolean* a_bool, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @an_int: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed int, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, int64_t* an_int, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int() call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse or %NULL + * on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_double: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed double, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, double* a_double, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_string: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed string, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @list: (allow-none): parameter for this method. + * @list_length: length of list. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed byte list, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, const uint8_t* list, + size_t list_length, GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @list: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed list, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, FlValue* list, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_map: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed map, to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, FlValue* a_map, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map() call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse or %NULL + * on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @an_enum: (allow-none): parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed enum to test serialization and deserialization. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + CoreTestsPigeonTestAnEnum* an_enum, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum() + * call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * A no-op function taking no arguments and returning no value, to sanity + * test basic asynchronous calling. + */ +void core_tests_pigeon_test_flutter_integration_core_api_noop_async( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_noop_async_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_integration_core_api_noop_async() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiNoopAsyncResponse* +core_tests_pigeon_test_flutter_integration_core_api_noop_async_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @a_string: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + * Returns the passed in generic Object asynchronously. + */ +void core_tests_pigeon_test_flutter_integration_core_api_echo_async_string( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_finish: + * @api: a #CoreTestsPigeonTestFlutterIntegrationCoreApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a + * core_tests_pigeon_test_flutter_integration_core_api_echo_async_string() call. + * + * Returns: a + * #CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse or %NULL + * on error. + */ +CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAsyncStringResponse* +core_tests_pigeon_test_flutter_integration_core_api_echo_async_string_finish( + CoreTestsPigeonTestFlutterIntegrationCoreApi* api, GAsyncResult* result, + GError** error); + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostTrivialApiNoopResponse, + core_tests_pigeon_test_host_trivial_api_noop_response, + CORE_TESTS_PIGEON_TEST, HOST_TRIVIAL_API_NOOP_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_host_trivial_api_noop_response_new: + * + * Creates a new response to HostTrivialApi.noop. + * + * Returns: a new #CoreTestsPigeonTestHostTrivialApiNoopResponse + */ +CoreTestsPigeonTestHostTrivialApiNoopResponse* +core_tests_pigeon_test_host_trivial_api_noop_response_new(); + +/** + * core_tests_pigeon_test_host_trivial_api_noop_response_new_error: + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Creates a new error response to HostTrivialApi.noop. + * + * Returns: a new #CoreTestsPigeonTestHostTrivialApiNoopResponse + */ +CoreTestsPigeonTestHostTrivialApiNoopResponse* +core_tests_pigeon_test_host_trivial_api_noop_response_new_error( + const gchar* code, const gchar* message, FlValue* details); + +/** + * CoreTestsPigeonTestHostTrivialApiVTable: + * + * Table of functions exposed by HostTrivialApi to be implemented by the API + * provider. + */ +typedef struct { + CoreTestsPigeonTestHostTrivialApiNoopResponse* (*noop)(gpointer user_data); +} CoreTestsPigeonTestHostTrivialApiVTable; + +/** + * core_tests_pigeon_test_host_trivial_api_set_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * @vtable: implementations of the methods in this API. + * @user_data: (closure): user data to pass to the functions in @vtable. + * @user_data_free_func: (allow-none): a function which gets called to free + * @user_data, or %NULL. + * + * Connects the method handlers in the HostTrivialApi API. + */ +void core_tests_pigeon_test_host_trivial_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostTrivialApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func); + +/** + * core_tests_pigeon_test_host_trivial_api_clear_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Clears the method handlers in the HostTrivialApi API. + */ +void core_tests_pigeon_test_host_trivial_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix); + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestHostSmallApiResponseHandle, + core_tests_pigeon_test_host_small_api_response_handle, + CORE_TESTS_PIGEON_TEST, HOST_SMALL_API_RESPONSE_HANDLE, + GObject) + +/** + * CoreTestsPigeonTestHostSmallApiVTable: + * + * Table of functions exposed by HostSmallApi to be implemented by the API + * provider. + */ +typedef struct { + void (*echo)(const gchar* a_string, + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + gpointer user_data); + void (*void_void)( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + gpointer user_data); +} CoreTestsPigeonTestHostSmallApiVTable; + +/** + * core_tests_pigeon_test_host_small_api_set_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * @vtable: implementations of the methods in this API. + * @user_data: (closure): user data to pass to the functions in @vtable. + * @user_data_free_func: (allow-none): a function which gets called to free + * @user_data, or %NULL. + * + * Connects the method handlers in the HostSmallApi API. + */ +void core_tests_pigeon_test_host_small_api_set_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix, + const CoreTestsPigeonTestHostSmallApiVTable* vtable, gpointer user_data, + GDestroyNotify user_data_free_func); + +/** + * core_tests_pigeon_test_host_small_api_clear_method_handlers: + * + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Clears the method handlers in the HostSmallApi API. + */ +void core_tests_pigeon_test_host_small_api_clear_method_handlers( + FlBinaryMessenger* messenger, const gchar* suffix); + +/** + * core_tests_pigeon_test_host_small_api_respond_echo: + * @response_handle: a #CoreTestsPigeonTestHostSmallApiResponseHandle. + * @return_value: location to write the value returned by this method. + * + * Responds to HostSmallApi.echo. + */ +void core_tests_pigeon_test_host_small_api_respond_echo( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* return_value); + +/** + * core_tests_pigeon_test_host_small_api_respond_error_echo: + * @response_handle: a #CoreTestsPigeonTestHostSmallApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostSmallApi.echo. + */ +void core_tests_pigeon_test_host_small_api_respond_error_echo( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +/** + * core_tests_pigeon_test_host_small_api_respond_void_void: + * @response_handle: a #CoreTestsPigeonTestHostSmallApiResponseHandle. + * + * Responds to HostSmallApi.voidVoid. + */ +void core_tests_pigeon_test_host_small_api_respond_void_void( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle); + +/** + * core_tests_pigeon_test_host_small_api_respond_error_void_void: + * @response_handle: a #CoreTestsPigeonTestHostSmallApiResponseHandle. + * @code: error code. + * @message: error message. + * @details: (allow-none): error details or %NULL. + * + * Responds with an error to HostSmallApi.voidVoid. + */ +void core_tests_pigeon_test_host_small_api_respond_error_void_void( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + const gchar* code, const gchar* message, FlValue* details); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse, + core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_SMALL_API_ECHO_WRAPPED_LIST_RESPONSE, + GObject) + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse. + * + * Checks if a response to FlutterSmallApi.echoWrappedList is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_is_error( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_code( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_message( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_error_details( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +CoreTestsPigeonTestTestMessage* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_response_get_return_value( + CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* response); + +G_DECLARE_FINAL_TYPE( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse, + core_tests_pigeon_test_flutter_small_api_echo_string_response, + CORE_TESTS_PIGEON_TEST, FLUTTER_SMALL_API_ECHO_STRING_RESPONSE, GObject) + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse. + * + * Checks if a response to FlutterSmallApi.echoString is an error. + * + * Returns: a %TRUE if this response is an error. + */ +gboolean core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_code: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse. + * + * Get the error code for this response. + * + * Returns: an error code or %NULL if not an error. + */ +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_code( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_message: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse. + * + * Get the error message for this response. + * + * Returns: an error message. + */ +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_message( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_details: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse. + * + * Get the error details for this response. + * + * Returns: (allow-none): an error details or %NULL. + */ +FlValue* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_details( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* response); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_response_get_return_value: + * @response: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse. + * + * Get the return value for this response. + * + * Returns: a return value. + */ +const gchar* +core_tests_pigeon_test_flutter_small_api_echo_string_response_get_return_value( + CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* response); + +/** + * CoreTestsPigeonTestFlutterSmallApi: + * + * A simple API called in some unit tests. + */ + +G_DECLARE_FINAL_TYPE(CoreTestsPigeonTestFlutterSmallApi, + core_tests_pigeon_test_flutter_small_api, + CORE_TESTS_PIGEON_TEST, FLUTTER_SMALL_API, GObject) + +/** + * core_tests_pigeon_test_flutter_small_api_new: + * @messenger: an #FlBinaryMessenger. + * @suffix: (allow-none): a suffix to add to the API or %NULL for none. + * + * Creates a new object to access the FlutterSmallApi API. + * + * Returns: a new #CoreTestsPigeonTestFlutterSmallApi + */ +CoreTestsPigeonTestFlutterSmallApi* +core_tests_pigeon_test_flutter_small_api_new(FlBinaryMessenger* messenger, + const gchar* suffix); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list: + * @api: a #CoreTestsPigeonTestFlutterSmallApi. + * @msg: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + */ +void core_tests_pigeon_test_flutter_small_api_echo_wrapped_list( + CoreTestsPigeonTestFlutterSmallApi* api, + CoreTestsPigeonTestTestMessage* msg, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_finish: + * @api: a #CoreTestsPigeonTestFlutterSmallApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_small_api_echo_wrapped_list() + * call. + * + * Returns: a #CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse or + * %NULL on error. + */ +CoreTestsPigeonTestFlutterSmallApiEchoWrappedListResponse* +core_tests_pigeon_test_flutter_small_api_echo_wrapped_list_finish( + CoreTestsPigeonTestFlutterSmallApi* api, GAsyncResult* result, + GError** error); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string: + * @api: a #CoreTestsPigeonTestFlutterSmallApi. + * @a_string: parameter for this method. + * @cancellable: (allow-none): a #GCancellable or %NULL. + * @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when + * the call is complete or %NULL to ignore the response. + * @user_data: (closure): user data to pass to @callback. + * + */ +void core_tests_pigeon_test_flutter_small_api_echo_string( + CoreTestsPigeonTestFlutterSmallApi* api, const gchar* a_string, + GCancellable* cancellable, GAsyncReadyCallback callback, + gpointer user_data); + +/** + * core_tests_pigeon_test_flutter_small_api_echo_string_finish: + * @api: a #CoreTestsPigeonTestFlutterSmallApi. + * @result: a #GAsyncResult. + * @error: (allow-none): #GError location to store the error occurring, or %NULL + * to ignore. + * + * Completes a core_tests_pigeon_test_flutter_small_api_echo_string() call. + * + * Returns: a #CoreTestsPigeonTestFlutterSmallApiEchoStringResponse or %NULL on + * error. + */ +CoreTestsPigeonTestFlutterSmallApiEchoStringResponse* +core_tests_pigeon_test_flutter_small_api_echo_string_finish( + CoreTestsPigeonTestFlutterSmallApi* api, GAsyncResult* result, + GError** error); + +G_END_DECLS + +#endif // PIGEON_CORE_TESTS_GEN_H_ diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/multiple_arity_test.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/multiple_arity_test.cc new file mode 100644 index 000000000000..4e9ab9a9a279 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/multiple_arity_test.cc @@ -0,0 +1,44 @@ +// 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. + +#include + +#include "pigeon/multiple_arity.gen.h" +#include "test/utils/fake_host_messenger.h" + +static MultipleArityPigeonTestMultipleArityHostApiSubtractResponse* subtract( + int64_t x, int64_t y, gpointer user_data) { + return multiple_arity_pigeon_test_multiple_arity_host_api_subtract_response_new( + x - y); +} + +static MultipleArityPigeonTestMultipleArityHostApiVTable vtable = { + .subtract = subtract}; + +static void subtract_reply_cb(FlValue* reply, gpointer user_data) { + int64_t* result = reinterpret_cast(user_data); + *result = fl_value_get_int(fl_value_get_list_value(reply, 0)); +} + +TEST(MultipleArity, HostSimple) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + multiple_arity_pigeon_test_multiple_arity_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + int64_t result = 0; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_int(30)); + fl_value_append_take(message, fl_value_new_int(10)); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.MultipleArityHostApi." + "subtract", + message, subtract_reply_cb, &result); + + EXPECT_EQ(result, 20); +} + +// TODO(stuartmorgan): Add a FlutterApi version of the test. diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/non_null_fields_test.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/non_null_fields_test.cc new file mode 100644 index 000000000000..93c3938149aa --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/non_null_fields_test.cc @@ -0,0 +1,17 @@ +// 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. + +#include + +#include "pigeon/non_null_fields.gen.h" + +TEST(NonNullFields, Build) { + g_autoptr(NonNullFieldsPigeonTestNonNullFieldSearchRequest) request = + non_null_fields_pigeon_test_non_null_field_search_request_new("hello"); + + EXPECT_STREQ( + non_null_fields_pigeon_test_non_null_field_search_request_get_query( + request), + "hello"); +} diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/null_fields_test.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/null_fields_test.cc new file mode 100644 index 000000000000..fc0410f312ea --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/null_fields_test.cc @@ -0,0 +1,63 @@ +// 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. + +#include + +#include "pigeon/null_fields.gen.h" + +TEST(NullFields, BuildWithValues) { + g_autoptr(NullFieldsPigeonTestNullFieldsSearchRequest) request = + null_fields_pigeon_test_null_fields_search_request_new("hello", 0); + + int64_t indicies_values[] = {1, 2, 3}; + g_autoptr(FlValue) indicies = fl_value_new_int64_list(indicies_values, 3); + NullFieldsPigeonTestNullFieldsSearchReplyType type = + PIGEON_INTEGRATION_TESTS_NULL_FIELDS_SEARCH_REPLY_TYPE_SUCCESS; + g_autoptr(NullFieldsPigeonTestNullFieldsSearchReply) reply = + null_fields_pigeon_test_null_fields_search_reply_new( + "result", "error", indicies, request, &type); + + EXPECT_STREQ( + null_fields_pigeon_test_null_fields_search_reply_get_result(reply), + "result"); + EXPECT_STREQ( + null_fields_pigeon_test_null_fields_search_reply_get_error(reply), + "error"); + EXPECT_EQ( + fl_value_get_length( + null_fields_pigeon_test_null_fields_search_reply_get_indices(reply)), + 3); + EXPECT_STREQ( + null_fields_pigeon_test_null_fields_search_request_get_query( + null_fields_pigeon_test_null_fields_search_reply_get_request(reply)), + "hello"); + EXPECT_EQ(*null_fields_pigeon_test_null_fields_search_reply_get_type_(reply), + PIGEON_INTEGRATION_TESTS_NULL_FIELDS_SEARCH_REPLY_TYPE_SUCCESS); +} + +TEST(NullFields, BuildRequestWithNulls) { + g_autoptr(NullFieldsPigeonTestNullFieldsSearchRequest) request = + null_fields_pigeon_test_null_fields_search_request_new(nullptr, 0); + + EXPECT_EQ( + null_fields_pigeon_test_null_fields_search_request_get_query(request), + nullptr); +} + +TEST(NullFields, BuildReplyWithNulls) { + g_autoptr(NullFieldsPigeonTestNullFieldsSearchReply) reply = + null_fields_pigeon_test_null_fields_search_reply_new( + nullptr, nullptr, nullptr, nullptr, nullptr); + + EXPECT_EQ(null_fields_pigeon_test_null_fields_search_reply_get_result(reply), + nullptr); + EXPECT_EQ(null_fields_pigeon_test_null_fields_search_reply_get_error(reply), + nullptr); + EXPECT_EQ(null_fields_pigeon_test_null_fields_search_reply_get_indices(reply), + nullptr); + EXPECT_EQ(null_fields_pigeon_test_null_fields_search_reply_get_request(reply), + nullptr); + EXPECT_EQ(null_fields_pigeon_test_null_fields_search_reply_get_type_(reply), + nullptr); +} diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/nullable_returns_test.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/nullable_returns_test.cc new file mode 100644 index 000000000000..0dc2a346fad3 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/nullable_returns_test.cc @@ -0,0 +1,132 @@ +// 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. + +#include + +#include "pigeon/nullable_returns.gen.h" +#include "test/utils/fake_host_messenger.h" + +static NullableReturnsPigeonTestNullableArgHostApiDoitResponse* arg_doit( + int64_t* x, gpointer user_data) { + return nullable_returns_pigeon_test_nullable_arg_host_api_doit_response_new( + x == nullptr ? 42 : *x); +} + +static NullableReturnsPigeonTestNullableArgHostApiVTable arg_vtable = { + .doit = arg_doit}; + +static void arg_doit_reply_cb(FlValue* reply, gpointer user_data) { + int64_t* result = reinterpret_cast(user_data); + *result = fl_value_get_int(fl_value_get_list_value(reply, 0)); +} + +TEST(NullableReturns, HostNullableArgNull) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + nullable_returns_pigeon_test_nullable_arg_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &arg_vtable, nullptr, nullptr); + + int64_t result = 0; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_null()); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.NullableArgHostApi.doit", + message, arg_doit_reply_cb, &result); + + EXPECT_EQ(result, 42); +} + +TEST(NullableReturns, HostNullableArgNonNull) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + nullable_returns_pigeon_test_nullable_arg_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &arg_vtable, nullptr, nullptr); + + int64_t result = 0; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_int(7)); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.NullableArgHostApi.doit", + message, arg_doit_reply_cb, &result); + + EXPECT_EQ(result, 7); +} + +static NullableReturnsPigeonTestNullableReturnHostApiDoitResponse* +return_null_doit(gpointer user_data) { + return nullable_returns_pigeon_test_nullable_return_host_api_doit_response_new( + nullptr); +} + +static NullableReturnsPigeonTestNullableReturnHostApiVTable return_null_vtable = + {.doit = return_null_doit}; + +static NullableReturnsPigeonTestNullableReturnHostApiDoitResponse* +return_nonnull_doit(gpointer user_data) { + int64_t return_value = 42; + return nullable_returns_pigeon_test_nullable_return_host_api_doit_response_new( + &return_value); +} + +static NullableReturnsPigeonTestNullableReturnHostApiVTable + return_nonnull_vtable = {.doit = return_nonnull_doit}; + +static void return_doit_reply_cb(FlValue* reply, gpointer user_data) { + int64_t** result = reinterpret_cast(user_data); + FlValue* value = fl_value_get_list_value(reply, 0); + if (fl_value_get_type(value) == FL_VALUE_TYPE_NULL) { + *result = nullptr; + } else { + *result = reinterpret_cast(malloc(sizeof(int64_t))); + **result = fl_value_get_int(value); + } +} + +TEST(NullableReturns, HostNullableReturnNull) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + nullable_returns_pigeon_test_nullable_return_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &return_null_vtable, nullptr, + nullptr); + + // Initialize to a non-null value to ensure that it's actually set to null, + // rather than just never set. + int64_t result_ = 99; + int64_t* result = &result_; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_null()); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.NullableReturnHostApi.doit", + message, return_doit_reply_cb, &result); + + EXPECT_EQ(result, nullptr); +} + +TEST(NullableReturns, HostNullableReturnNonNull) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + nullable_returns_pigeon_test_nullable_return_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &return_nonnull_vtable, nullptr, + nullptr); + + g_autofree int64_t* result = nullptr; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_null()); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.NullableReturnHostApi.doit", + message, return_doit_reply_cb, &result); + + EXPECT_NE(result, nullptr); + EXPECT_EQ(*result, 42); +} + +// TODO(stuartmorgan): Add FlutterApi versions of the tests. diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/primitive_test.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/primitive_test.cc new file mode 100644 index 000000000000..cfb67feb069d --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/primitive_test.cc @@ -0,0 +1,216 @@ +// 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. + +#include + +#include "pigeon/primitive.gen.h" +#include "test/utils/fake_host_messenger.h" + +static PrimitivePigeonTestPrimitiveHostApiAnIntResponse* an_int( + int64_t value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_an_int_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiABoolResponse* a_bool( + gboolean value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_bool_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiAStringResponse* a_string( + const gchar* value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_string_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiADoubleResponse* a_double( + double value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_double_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiAMapResponse* a_map( + FlValue* value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_map_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiAListResponse* a_list( + FlValue* value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_list_response_new(value); +} + +static PrimitivePigeonTestPrimitiveHostApiAnInt32ListResponse* an_int32_list( + const int32_t* value, size_t value_length, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_an_int32_list_response_new( + value, value_length); +} + +static PrimitivePigeonTestPrimitiveHostApiABoolListResponse* a_bool_list( + FlValue* value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_bool_list_response_new( + value); +} + +static PrimitivePigeonTestPrimitiveHostApiAStringIntMapResponse* +a_string_int_map(FlValue* value, gpointer user_data) { + return primitive_pigeon_test_primitive_host_api_a_string_int_map_response_new( + value); +} + +static PrimitivePigeonTestPrimitiveHostApiVTable vtable = { + .an_int = an_int, + .a_bool = a_bool, + .a_string = a_string, + .a_double = a_double, + .a_map = a_map, + .a_list = a_list, + .an_int32_list = an_int32_list, + .a_bool_list = a_bool_list, + .a_string_int_map = a_string_int_map}; + +static void an_int_reply_cb(FlValue* reply, gpointer user_data) { + int64_t* result = reinterpret_cast(user_data); + *result = fl_value_get_int(fl_value_get_list_value(reply, 0)); +} + +TEST(Primitive, HostInt) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + int64_t result = 0; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_int(7)); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.anInt", + message, an_int_reply_cb, &result); + + EXPECT_EQ(result, 7); +} + +static void a_bool_reply_cb(FlValue* reply, gpointer user_data) { + gboolean* result = reinterpret_cast(user_data); + *result = fl_value_get_bool(fl_value_get_list_value(reply, 0)); +} + +TEST(Primitive, HostBool) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + gboolean result = false; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_bool(TRUE)); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.aBool", + message, a_bool_reply_cb, &result); + + EXPECT_EQ(result, true); +} + +static void a_double_reply_cb(FlValue* reply, gpointer user_data) { + double* result = reinterpret_cast(user_data); + *result = fl_value_get_float(fl_value_get_list_value(reply, 0)); +} + +TEST(Primitive, HostDouble) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + double result = 0.0; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_float(3.0)); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.aDouble", + message, a_double_reply_cb, &result); + + EXPECT_EQ(result, 3.0); +} + +static void a_string_reply_cb(FlValue* reply, gpointer user_data) { + gchar** result = reinterpret_cast(user_data); + *result = g_strdup(fl_value_get_string(fl_value_get_list_value(reply, 0))); +} + +TEST(Primitive, HostString) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + g_autofree gchar* result = nullptr; + g_autoptr(FlValue) message = fl_value_new_list(); + fl_value_append_take(message, fl_value_new_string("hello")); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.aString", + message, a_string_reply_cb, &result); + + EXPECT_STREQ(result, "hello"); +} + +static void a_list_reply_cb(FlValue* reply, gpointer user_data) { + FlValue** result = reinterpret_cast(user_data); + *result = fl_value_ref(fl_value_get_list_value(reply, 0)); +} + +TEST(Primitive, HostList) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + g_autoptr(FlValue) result = nullptr; + g_autoptr(FlValue) message = fl_value_new_list(); + g_autoptr(FlValue) list = fl_value_new_list(); + fl_value_append_take(list, fl_value_new_int(1)); + fl_value_append_take(list, fl_value_new_int(2)); + fl_value_append_take(list, fl_value_new_int(3)); + fl_value_append(message, list); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.aList", + message, a_list_reply_cb, &result); + + EXPECT_EQ(fl_value_get_length(result), 3); + EXPECT_EQ(fl_value_get_int(fl_value_get_list_value(result, 2)), 3); +} + +static void a_map_reply_cb(FlValue* reply, gpointer user_data) { + FlValue** result = reinterpret_cast(user_data); + *result = fl_value_ref(fl_value_get_list_value(reply, 0)); +} + +TEST(Primitive, HostMap) { + g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new(); + g_autoptr(FakeHostMessenger) messenger = + fake_host_messenger_new(FL_MESSAGE_CODEC(codec)); + primitive_pigeon_test_primitive_host_api_set_method_handlers( + FL_BINARY_MESSENGER(messenger), nullptr, &vtable, nullptr, nullptr); + + g_autoptr(FlValue) result = nullptr; + g_autoptr(FlValue) message = fl_value_new_list(); + g_autoptr(FlValue) map = fl_value_new_map(); + fl_value_set_string_take(map, "foo", fl_value_new_string("bar")); + fl_value_append(message, map); + fake_host_messenger_send_host_message( + messenger, + "dev.flutter.pigeon.pigeon_integration_tests.PrimitiveHostApi.aMap", + message, a_map_reply_cb, &result); + + EXPECT_EQ(fl_value_get_length(result), 1); + EXPECT_STREQ(fl_value_get_string(fl_value_lookup_string(result, "foo")), + "bar"); +} + +// TODO(stuartmorgan): Add FlutterApi versions of the tests. diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.cc b/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.cc new file mode 100644 index 000000000000..b78301cec7f0 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.cc @@ -0,0 +1,183 @@ +// 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. + +#include "fake_host_messenger.h" + +struct _FakeHostMessenger { + GObject parent_instance; + + FlMessageCodec* codec; + GHashTable* message_handlers; +}; + +G_DECLARE_FINAL_TYPE(FakeHostMessengerResponseHandle, + fake_host_messenger_response_handle, FAKE, + HOST_MESSENGER_RESPONSE_HANDLE, + FlBinaryMessengerResponseHandle) + +struct _FakeHostMessengerResponseHandle { + FlBinaryMessengerResponseHandle parent_instance; + + FakeHostMessengerReplyHandler reply_callback; + gpointer user_data; +}; + +static void fake_host_messenger_response_handle_class_init( + FakeHostMessengerResponseHandleClass* klass) {} + +static void fake_host_messenger_response_handle_init( + FakeHostMessengerResponseHandle* self) {} + +G_DEFINE_TYPE(FakeHostMessengerResponseHandle, + fake_host_messenger_response_handle, + fl_binary_messenger_response_handle_get_type()) + +FakeHostMessengerResponseHandle* fake_host_messenger_response_handle_new( + FakeHostMessengerReplyHandler reply_callback, gpointer user_data) { + FakeHostMessengerResponseHandle* self = FAKE_HOST_MESSENGER_RESPONSE_HANDLE( + g_object_new(fake_host_messenger_response_handle_get_type(), nullptr)); + + self->reply_callback = reply_callback; + self->user_data = user_data; + + return self; +} + +typedef struct { + FlBinaryMessengerMessageHandler message_handler; + gpointer message_handler_data; + GDestroyNotify message_handler_destroy_notify; +} MessageHandler; + +static MessageHandler* message_handler_new( + FlBinaryMessengerMessageHandler handler, gpointer user_data, + GDestroyNotify destroy_notify) { + MessageHandler* self = + static_cast(g_malloc0(sizeof(MessageHandler))); + self->message_handler = handler; + self->message_handler_data = user_data; + self->message_handler_destroy_notify = destroy_notify; + return self; +} + +static void message_handler_free(gpointer data) { + MessageHandler* self = static_cast(data); + if (self->message_handler_destroy_notify) { + self->message_handler_destroy_notify(self->message_handler_data); + } + + g_free(self); +} + +static void fake_host_messenger_binary_messenger_iface_init( + FlBinaryMessengerInterface* iface); + +G_DEFINE_TYPE_WITH_CODE( + FakeHostMessenger, fake_host_messenger, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(fl_binary_messenger_get_type(), + fake_host_messenger_binary_messenger_iface_init)) + +static void set_message_handler_on_channel( + FlBinaryMessenger* messenger, const gchar* channel, + FlBinaryMessengerMessageHandler handler, gpointer user_data, + GDestroyNotify destroy_notify) { + FakeHostMessenger* self = FAKE_HOST_MESSENGER(messenger); + g_hash_table_replace(self->message_handlers, g_strdup(channel), + message_handler_new(handler, user_data, destroy_notify)); +} + +static gboolean send_response(FlBinaryMessenger* messenger, + FlBinaryMessengerResponseHandle* response_handle, + GBytes* response, GError** error) { + FakeHostMessenger* self = FAKE_HOST_MESSENGER(messenger); + g_autoptr(FakeHostMessengerResponseHandle) r = + FAKE_HOST_MESSENGER_RESPONSE_HANDLE(response_handle); + g_autoptr(FlValue) reply = + fl_message_codec_decode_message(self->codec, response, error); + if (reply == nullptr) { + return FALSE; + } + + if (r->reply_callback != nullptr) { + r->reply_callback(reply, r->user_data); + } + + return TRUE; +} + +static void send_on_channel(FlBinaryMessenger* messenger, const gchar* channel, + GBytes* message, GCancellable* cancellable, + GAsyncReadyCallback callback, gpointer user_data) {} + +static GBytes* send_on_channel_finish(FlBinaryMessenger* messenger, + GAsyncResult* result, GError** error) { + return g_bytes_new(nullptr, 0); +} + +static void resize_channel(FlBinaryMessenger* messenger, const gchar* channel, + int64_t new_size) {} + +static void set_warns_on_channel_overflow(FlBinaryMessenger* messenger, + const gchar* channel, bool warns) {} + +static void fake_host_messenger_dispose(GObject* object) { + FakeHostMessenger* self = FAKE_HOST_MESSENGER(object); + + g_clear_pointer(&self->message_handlers, g_hash_table_unref); + g_clear_object(&self->codec); + + G_OBJECT_CLASS(fake_host_messenger_parent_class)->dispose(object); +} + +static void fake_host_messenger_class_init(FakeHostMessengerClass* klass) { + G_OBJECT_CLASS(klass)->dispose = fake_host_messenger_dispose; +} + +static void fake_host_messenger_binary_messenger_iface_init( + FlBinaryMessengerInterface* iface) { + iface->set_message_handler_on_channel = set_message_handler_on_channel; + iface->send_response = send_response; + iface->send_on_channel = send_on_channel; + iface->send_on_channel_finish = send_on_channel_finish; + iface->resize_channel = resize_channel; + iface->set_warns_on_channel_overflow = set_warns_on_channel_overflow; +} + +static void fake_host_messenger_init(FakeHostMessenger* self) { + self->message_handlers = g_hash_table_new_full(g_str_hash, g_str_equal, + g_free, message_handler_free); +} + +FakeHostMessenger* fake_host_messenger_new(FlMessageCodec* codec) { + FakeHostMessenger* self = FAKE_HOST_MESSENGER( + g_object_new(fake_host_messenger_get_type(), nullptr)); + + self->codec = FL_MESSAGE_CODEC(g_object_ref(codec)); + + return self; +} + +void fake_host_messenger_send_host_message( + FakeHostMessenger* self, const gchar* channel, FlValue* message, + FakeHostMessengerReplyHandler reply_callback, gpointer user_data) { + MessageHandler* handler = static_cast( + g_hash_table_lookup(self->message_handlers, channel)); + if (handler == nullptr) { + return; + } + + g_autoptr(GError) error = nullptr; + g_autoptr(GBytes) encoded_message = + fl_message_codec_encode_message(self->codec, message, &error); + if (encoded_message == nullptr) { + g_warning("Failed to encode message: %s", error->message); + return; + } + + FakeHostMessengerResponseHandle* response_handle = + fake_host_messenger_response_handle_new(reply_callback, user_data); + handler->message_handler(FL_BINARY_MESSENGER(self), channel, encoded_message, + FL_BINARY_MESSENGER_RESPONSE_HANDLE(response_handle), + handler->message_handler_data); +} diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.h b/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.h new file mode 100644 index 000000000000..d8f1952781ac --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test/utils/fake_host_messenger.h @@ -0,0 +1,28 @@ +// 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 PLATFORM_TESTS_TEST_PLUGIN_LINUX_TEST_UTILS_FAKE_HOST_MESSENGER_H_ +#define PLATFORM_TESTS_TEST_PLUGIN_LINUX_TEST_UTILS_FAKE_HOST_MESSENGER_H_ + +#include + +typedef void (*FakeHostMessengerReplyHandler)(FlValue* reply, + gpointer user_data); + +// A BinaryMessenger that allows tests to act as the engine to call host APIs. +G_DECLARE_FINAL_TYPE(FakeHostMessenger, fake_host_messenger, FAKE, + HOST_MESSENGER, GObject) + +FakeHostMessenger* fake_host_messenger_new(FlMessageCodec* codec); + +// Calls the registered handler for the given channel, and calls reply_handler +// with the response. +// +// This allows a test to simulate a message from the Dart side, exercising the +// encoding and decoding logic generated for a host API. +void fake_host_messenger_send_host_message( + FakeHostMessenger* messenger, const gchar* channel, FlValue* message, + FakeHostMessengerReplyHandler reply_callback, gpointer user_data); + +#endif // PLATFORM_TESTS_TEST_PLUGIN_LINUX_TEST_UTILS_FAKE_HOST_MESSENGER_H_ diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test_plugin.cc b/packages/pigeon/platform_tests/test_plugin/linux/test_plugin.cc new file mode 100644 index 000000000000..98d0dce95935 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test_plugin.cc @@ -0,0 +1,1864 @@ +// 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. + +#include "include/test_plugin/test_plugin.h" + +#include +#include +#include + +#include + +#include "pigeon/core_tests.gen.h" +#include "test_plugin_private.h" + +struct _TestPlugin { + GObject parent_instance; + + FlBinaryMessenger* messenger; + + CoreTestsPigeonTestFlutterIntegrationCoreApi* flutter_core_api; + + CoreTestsPigeonTestFlutterSmallApi* flutter_small_api_one; + CoreTestsPigeonTestFlutterSmallApi* flutter_small_api_two; + + GCancellable* cancellable; +}; + +G_DEFINE_TYPE(TestPlugin, test_plugin, G_TYPE_OBJECT) + +typedef struct { + TestPlugin* self; + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle; +} CallbackData; + +static CallbackData* callback_data_new( + TestPlugin* self, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle) { + CallbackData* data = g_new0(CallbackData, 1); + data->self = TEST_PLUGIN(g_object_ref(self)); + data->response_handle = + CORE_TESTS_PIGEON_TEST_HOST_INTEGRATION_CORE_API_RESPONSE_HANDLE( + g_object_ref(response_handle)); + return data; +} + +static void callback_data_free(CallbackData* data) { + g_object_unref(data->self); + g_object_unref(data->response_handle); + free(data); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC(CallbackData, callback_data_free) + +static CoreTestsPigeonTestHostIntegrationCoreApiNoopResponse* noop( + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_noop_response_new(); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAllTypesResponse* +echo_all_types(CoreTestsPigeonTestAllTypes* everything, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_all_types_response_new( + everything); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorResponse* throw_error( + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_throw_error_response_new_error( + "An error", "", nullptr); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowErrorFromVoidResponse* +throw_error_from_void(gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_throw_error_from_void_response_new_error( + "An error", "", nullptr); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiThrowFlutterErrorResponse* +throw_flutter_error(gpointer user_data) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + return core_tests_pigeon_test_host_integration_core_api_throw_flutter_error_response_new_error( + "code", "message", details); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoIntResponse* echo_int( + int64_t an_int, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_int_response_new( + an_int); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoDoubleResponse* echo_double( + double a_double, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_double_response_new( + a_double); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoBoolResponse* echo_bool( + gboolean a_bool, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_bool_response_new( + a_bool); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoStringResponse* echo_string( + const gchar* a_string, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_string_response_new( + a_string); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoUint8ListResponse* +echo_uint8_list(const uint8_t* a_uint8_list, size_t a_uint8_list_length, + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_uint8_list_response_new( + a_uint8_list, a_uint8_list_length); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoObjectResponse* echo_object( + FlValue* an_object, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_object_response_new( + an_object); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoListResponse* echo_list( + FlValue* a_list, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_list_response_new( + a_list); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoMapResponse* echo_map( + FlValue* a_map, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_map_response_new( + a_map); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoClassWrapperResponse* +echo_class_wrapper(CoreTestsPigeonTestAllClassesWrapper* wrapper, + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_class_wrapper_response_new( + wrapper); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoEnumResponse* echo_enum( + + CoreTestsPigeonTestAnEnum an_enum, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_enum_response_new( + an_enum); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedDefaultStringResponse* +echo_named_default_string(const gchar* a_string, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_named_default_string_response_new( + a_string); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalDefaultDoubleResponse* +echo_optional_default_double(double a_double, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_optional_default_double_response_new( + a_double); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoRequiredIntResponse* +echo_required_int(int64_t an_int, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_required_int_response_new( + an_int); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesResponse* +echo_all_nullable_types(CoreTestsPigeonTestAllNullableTypes* everything, + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_response_new( + everything); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse* +echo_all_nullable_types_without_recursion( + + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_all_nullable_types_without_recursion_response_new( + everything); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiExtractNestedNullableStringResponse* +extract_nested_nullable_string(CoreTestsPigeonTestAllClassesWrapper* wrapper, + gpointer user_data) { + CoreTestsPigeonTestAllNullableTypes* types = + core_tests_pigeon_test_all_classes_wrapper_get_all_nullable_types( + wrapper); + return core_tests_pigeon_test_host_integration_core_api_extract_nested_nullable_string_response_new( + core_tests_pigeon_test_all_nullable_types_get_a_nullable_string(types)); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiCreateNestedNullableStringResponse* +create_nested_nullable_string(const gchar* nullable_string, + gpointer user_data) { + g_autoptr(CoreTestsPigeonTestAllNullableTypes) types = + core_tests_pigeon_test_all_nullable_types_new( + nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, 0, nullptr, + 0, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullable_string, + nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, + nullptr, nullptr); + g_autoptr(CoreTestsPigeonTestAllClassesWrapper) wrapper = + core_tests_pigeon_test_all_classes_wrapper_new(types, nullptr, nullptr); + return core_tests_pigeon_test_host_integration_core_api_create_nested_nullable_string_response_new( + wrapper); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesResponse* +send_multiple_nullable_types(gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, + gpointer user_data) { + g_autoptr(CoreTestsPigeonTestAllNullableTypes) types = + core_tests_pigeon_test_all_nullable_types_new( + a_nullable_bool, a_nullable_int, nullptr, nullptr, nullptr, 0, + nullptr, 0, nullptr, 0, nullptr, 0, nullptr, nullptr, nullptr, + nullptr, a_nullable_string, nullptr, nullptr, nullptr, nullptr, + nullptr, nullptr, nullptr, nullptr, nullptr); + return core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_response_new( + types); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse* +send_multiple_nullable_types_without_recursion(gboolean* a_nullable_bool, + int64_t* a_nullable_int, + const gchar* a_nullable_string, + gpointer user_data) { + g_autoptr(CoreTestsPigeonTestAllNullableTypesWithoutRecursion) types = + core_tests_pigeon_test_all_nullable_types_without_recursion_new( + a_nullable_bool, a_nullable_int, nullptr, nullptr, nullptr, 0, + nullptr, 0, nullptr, 0, nullptr, 0, nullptr, nullptr, nullptr, + nullptr, a_nullable_string, nullptr, nullptr, nullptr, nullptr, + nullptr, nullptr, nullptr); + return core_tests_pigeon_test_host_integration_core_api_send_multiple_nullable_types_without_recursion_response_new( + types); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableIntResponse* +echo_nullable_int(int64_t* a_nullable_int, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_int_response_new( + a_nullable_int); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableDoubleResponse* +echo_nullable_double(double* a_nullable_double, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_double_response_new( + a_nullable_double); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableBoolResponse* +echo_nullable_bool(gboolean* a_nullable_bool, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_bool_response_new( + a_nullable_bool); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableStringResponse* +echo_nullable_string(const gchar* a_nullable_string, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_string_response_new( + a_nullable_string); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableUint8ListResponse* +echo_nullable_uint8_list(const uint8_t* a_nullable_uint8_list, + size_t a_nullable_uint8_list_length, + gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_uint8_list_response_new( + a_nullable_uint8_list, a_nullable_uint8_list_length); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableObjectResponse* +echo_nullable_object(FlValue* a_nullable_object, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_object_response_new( + a_nullable_object); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableListResponse* +echo_nullable_list(FlValue* a_nullable_list, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_list_response_new( + a_nullable_list); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableMapResponse* +echo_nullable_map(FlValue* a_nullable_map, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_map_response_new( + a_nullable_map); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNullableEnumResponse* +echo_nullable_enum(CoreTestsPigeonTestAnEnum* an_enum, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_nullable_enum_response_new( + an_enum); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoOptionalNullableIntResponse* +echo_optional_nullable_int(int64_t* a_nullable_int, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_optional_nullable_int_response_new( + a_nullable_int); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiEchoNamedNullableStringResponse* +echo_named_nullable_string(const gchar* a_nullable_string, gpointer user_data) { + return core_tests_pigeon_test_host_integration_core_api_echo_named_nullable_string_response_new( + a_nullable_string); +} + +static void noop_async( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_noop_async( + response_handle); +} + +static void echo_async_int( + int64_t an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_int( + response_handle, an_int); +} + +static void echo_async_double( + double a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_double( + response_handle, a_double); +} + +static void echo_async_bool( + gboolean a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_bool( + response_handle, a_bool); +} + +static void echo_async_string( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_string( + response_handle, a_string); +} + +static void echo_async_uint8_list( + const uint8_t* a_uint8_list, size_t a_uint8_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_uint8_list( + response_handle, a_uint8_list, a_uint8_list_length); +} + +static void echo_async_object( + FlValue* an_object, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_object( + response_handle, an_object); +} + +static void echo_async_list( + FlValue* a_list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_list( + response_handle, a_list); +} + +static void echo_async_map( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_map( + response_handle, a_map); +} + +static void echo_async_enum( + + CoreTestsPigeonTestAnEnum an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_enum( + response_handle, an_enum); +} + +static void throw_async_error( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error( + response_handle, "code", "message", details); +} + +static void throw_async_error_from_void( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_error_from_void( + response_handle, "code", "message", details); +} + +static void throw_async_flutter_error( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + g_autoptr(FlValue) details = fl_value_new_string("details"); + core_tests_pigeon_test_host_integration_core_api_respond_error_throw_async_flutter_error( + response_handle, "code", "message", details); +} + +static void echo_async_all_types( + + CoreTestsPigeonTestAllTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_all_types( + response_handle, everything); +} + +static void echo_async_nullable_all_nullable_types( + + CoreTestsPigeonTestAllNullableTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types( + response_handle, everything); +} + +static void echo_async_nullable_all_nullable_types_without_recursion( + + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_all_nullable_types_without_recursion( + response_handle, everything); +} + +static void echo_async_nullable_int( + int64_t* an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_int( + response_handle, an_int); +} + +static void echo_async_nullable_double( + double* a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_double( + response_handle, a_double); +} + +static void echo_async_nullable_bool( + gboolean* a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_bool( + response_handle, a_bool); +} + +static void echo_async_nullable_string( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_string( + response_handle, a_string); +} + +static void echo_async_nullable_uint8_list( + const uint8_t* a_uint8_list, size_t a_uint8_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_uint8_list( + response_handle, a_uint8_list, a_uint8_list_length); +} + +static void echo_async_nullable_object( + FlValue* an_object, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_object( + response_handle, an_object); +} + +static void echo_async_nullable_list( + FlValue* a_list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_list( + response_handle, a_list); +} + +static void echo_async_nullable_map( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_map( + response_handle, a_map); +} + +static void echo_async_nullable_enum( + + CoreTestsPigeonTestAnEnum* an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_integration_core_api_respond_echo_async_nullable_enum( + response_handle, an_enum); +} + +static void noop_cb(GObject* object, GAsyncResult* result, gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiNoopResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_noop_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_noop( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_noop_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_noop_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_noop( + data->response_handle); +} + +static void call_flutter_noop( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_noop( + self->flutter_core_api, nullptr, noop_cb, + callback_data_new(self, response_handle)); +} + +static void throw_error_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_throw_error_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_response_get_return_value( + response)); +} + +static void call_flutter_throw_error( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_throw_error( + self->flutter_core_api, nullptr, throw_error_cb, + callback_data_new(self, response_handle)); +} + +static void throw_error_from_void_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiThrowErrorFromVoidResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_throw_error_from_void( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_throw_error_from_void( + data->response_handle); +} + +static void call_flutter_throw_error_from_void( + + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_throw_error_from_void( + self->flutter_core_api, nullptr, throw_error_from_void_cb, + callback_data_new(self, response_handle)); +} + +static void echo_all_types_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllTypesResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_types( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_types( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types_response_get_return_value( + response)); +} + +static void call_flutter_echo_all_types( + + CoreTestsPigeonTestAllTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_all_types( + self->flutter_core_api, everything, self->cancellable, echo_all_types_cb, + callback_data_new(self, response_handle)); +} + +static void echo_all_nullable_types_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_response_get_return_value( + response)); +} + +static void call_flutter_echo_all_nullable_types( + + CoreTestsPigeonTestAllNullableTypes* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types( + self->flutter_core_api, everything, self->cancellable, + echo_all_nullable_types_cb, callback_data_new(self, response_handle)); +} + +static void send_multiple_nullable_types_cb(GObject* object, + GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_response_get_return_value( + response)); +} + +static void call_flutter_send_multiple_nullable_types( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types( + self->flutter_core_api, a_nullable_bool, a_nullable_int, + a_nullable_string, self->cancellable, send_multiple_nullable_types_cb, + callback_data_new(self, response_handle)); +} + +static void echo_all_nullable_types_without_recursion_cb(GObject* object, + GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoAllNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_all_nullable_types_without_recursion( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_all_nullable_types_without_recursion( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion_response_get_return_value( + response)); +} + +static void call_flutter_echo_all_nullable_types_without_recursion( + + CoreTestsPigeonTestAllNullableTypesWithoutRecursion* everything, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_all_nullable_types_without_recursion( + self->flutter_core_api, everything, self->cancellable, + echo_all_nullable_types_without_recursion_cb, + callback_data_new(self, response_handle)); +} + +static void send_multiple_nullable_types_without_recursion_cb( + GObject* object, GAsyncResult* result, gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiSendMultipleNullableTypesWithoutRecursionResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_send_multiple_nullable_types_without_recursion( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_send_multiple_nullable_types_without_recursion( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion_response_get_return_value( + response)); +} + +static void call_flutter_send_multiple_nullable_types_without_recursion( + gboolean* a_nullable_bool, int64_t* a_nullable_int, + const gchar* a_nullable_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_send_multiple_nullable_types_without_recursion( + self->flutter_core_api, a_nullable_bool, a_nullable_int, + a_nullable_string, self->cancellable, + send_multiple_nullable_types_without_recursion_cb, + callback_data_new(self, response_handle)); +} + +static void echo_bool_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoBoolResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_bool_response_get_return_value( + response)); +} + +static void call_flutter_echo_bool( + gboolean a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_bool( + self->flutter_core_api, a_bool, self->cancellable, echo_bool_cb, + callback_data_new(self, response_handle)); +} + +static void echo_int_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoIntResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_int_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_int( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_int( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_int_response_get_return_value( + response)); +} + +static void call_flutter_echo_int( + int64_t an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_int( + self->flutter_core_api, an_int, self->cancellable, echo_int_cb, + callback_data_new(self, response_handle)); +} + +static void echo_double_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoDoubleResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_echo_double_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_double( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_double( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_double_response_get_return_value( + response)); +} + +static void call_flutter_echo_double( + double a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_double( + self->flutter_core_api, a_double, self->cancellable, echo_double_cb, + callback_data_new(self, response_handle)); +} + +static void echo_string_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoStringResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_echo_string_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_string( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_string( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_string_response_get_return_value( + response)); +} + +static void call_flutter_echo_string( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_string( + self->flutter_core_api, a_string, self->cancellable, echo_string_cb, + callback_data_new(self, response_handle)); +} + +static void echo_uint8_list_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoUint8ListResponse) response = + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), result, + &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_uint8_list( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_error_details( + response)); + return; + } + + size_t return_value_length; + const uint8_t* return_value = + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list_response_get_return_value( + response, &return_value_length); + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_uint8_list( + data->response_handle, return_value, return_value_length); +} + +static void call_flutter_echo_uint8_list( + const uint8_t* a_list, size_t a_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_uint8_list( + self->flutter_core_api, a_list, a_list_length, self->cancellable, + echo_uint8_list_cb, callback_data_new(self, response_handle)); +} + +static void echo_list_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoListResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_list_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_list( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_list( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_list_response_get_return_value( + response)); +} + +static void call_flutter_echo_list( + FlValue* a_list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_list( + self->flutter_core_api, a_list, self->cancellable, echo_list_cb, + callback_data_new(self, response_handle)); +} + +static void echo_map_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoMapResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_map_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_map( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_map( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_map_response_get_return_value( + response)); +} + +static void call_flutter_echo_map( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_map( + self->flutter_core_api, a_map, self->cancellable, echo_map_cb, + callback_data_new(self, response_handle)); +} + +static void echo_enum_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoEnumResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_enum( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_enum( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_enum_response_get_return_value( + response)); +} + +static void call_flutter_echo_enum( + + CoreTestsPigeonTestAnEnum an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_enum( + self->flutter_core_api, an_enum, self->cancellable, echo_enum_cb, + callback_data_new(self, response_handle)); +} + +static void echo_nullable_bool_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableBoolResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_bool( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_bool( + gboolean* a_bool, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_bool( + self->flutter_core_api, a_bool, self->cancellable, echo_nullable_bool_cb, + callback_data_new(self, response_handle)); +} + +static void echo_nullable_int_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableIntResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_int( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_int( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_int( + int64_t* an_int, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_int( + self->flutter_core_api, an_int, self->cancellable, echo_nullable_int_cb, + callback_data_new(self, response_handle)); +} + +static void echo_nullable_double_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableDoubleResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_double( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_double( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_double( + double* a_double, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_double( + self->flutter_core_api, a_double, self->cancellable, + echo_nullable_double_cb, callback_data_new(self, response_handle)); +} + +static void echo_nullable_string_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableStringResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_string( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_string( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_string( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_string( + self->flutter_core_api, a_string, self->cancellable, + echo_nullable_string_cb, callback_data_new(self, response_handle)); +} + +static void echo_nullable_uint8_list_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableUint8ListResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_uint8_list( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_error_details( + response)); + return; + } + + size_t return_value_length; + const uint8_t* return_value = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list_response_get_return_value( + response, &return_value_length); + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_uint8_list( + data->response_handle, return_value, return_value_length); +} + +static void call_flutter_echo_nullable_uint8_list( + const uint8_t* a_list, size_t a_list_length, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_uint8_list( + self->flutter_core_api, a_list, a_list_length, self->cancellable, + echo_nullable_uint8_list_cb, callback_data_new(self, response_handle)); +} + +static void echo_nullable_list_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableListResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_list( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_list( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_list( + FlValue* a_list, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_list( + self->flutter_core_api, a_list, self->cancellable, echo_nullable_list_cb, + callback_data_new(self, response_handle)); +} + +static void echo_nullable_map_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableMapResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_map( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_map( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_map( + FlValue* a_map, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_map( + self->flutter_core_api, a_map, self->cancellable, echo_nullable_map_cb, + callback_data_new(self, response_handle)); +} + +static void echo_nullable_enum_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr( + CoreTestsPigeonTestFlutterIntegrationCoreApiEchoNullableEnumResponse) + response = + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_INTEGRATION_CORE_API(object), + result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_nullable_enum( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_code( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_message( + response), + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_echo_nullable_enum( + data->response_handle, + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum_response_get_return_value( + response)); +} + +static void call_flutter_echo_nullable_enum( + + CoreTestsPigeonTestAnEnum* an_enum, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_integration_core_api_echo_nullable_enum( + self->flutter_core_api, an_enum, self->cancellable, echo_nullable_enum_cb, + callback_data_new(self, response_handle)); +} + +static void small_api_two_echo_string_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterSmallApiEchoStringResponse) response = + core_tests_pigeon_test_flutter_small_api_echo_string_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API(object), result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_small_api_echo_string( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_code( + response), + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_message( + response), + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_host_integration_core_api_respond_call_flutter_small_api_echo_string( + data->response_handle, + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_return_value( + response)); +} + +static void small_api_one_echo_string_cb(GObject* object, GAsyncResult* result, + gpointer user_data) { + g_autoptr(CallbackData) data = static_cast(user_data); + TestPlugin* self = data->self; + + g_autoptr(GError) error = nullptr; + g_autoptr(CoreTestsPigeonTestFlutterSmallApiEchoStringResponse) response = + core_tests_pigeon_test_flutter_small_api_echo_string_finish( + CORE_TESTS_PIGEON_TEST_FLUTTER_SMALL_API(object), result, &error); + if (response == nullptr) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_small_api_echo_string( + data->response_handle, "Internal Error", error->message, nullptr); + return; + } + if (core_tests_pigeon_test_flutter_small_api_echo_string_response_is_error( + response)) { + core_tests_pigeon_test_host_integration_core_api_respond_error_call_flutter_echo_bool( + data->response_handle, + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_code( + response), + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_message( + response), + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_error_details( + response)); + return; + } + + core_tests_pigeon_test_flutter_small_api_echo_string( + self->flutter_small_api_two, + core_tests_pigeon_test_flutter_small_api_echo_string_response_get_return_value( + response), + self->cancellable, small_api_two_echo_string_cb, g_steal_pointer(&data)); +} + +static void call_flutter_small_api_echo_string( + const gchar* a_string, + CoreTestsPigeonTestHostIntegrationCoreApiResponseHandle* response_handle, + gpointer user_data) { + TestPlugin* self = TEST_PLUGIN(user_data); + + core_tests_pigeon_test_flutter_small_api_echo_string( + self->flutter_small_api_one, a_string, self->cancellable, + small_api_one_echo_string_cb, callback_data_new(self, response_handle)); +} + +static CoreTestsPigeonTestHostIntegrationCoreApiVTable host_core_api_vtable = { + .noop = noop, + .echo_all_types = echo_all_types, + .throw_error = throw_error, + .throw_error_from_void = throw_error_from_void, + .throw_flutter_error = throw_flutter_error, + .echo_int = echo_int, + .echo_double = echo_double, + .echo_bool = echo_bool, + .echo_string = echo_string, + .echo_uint8_list = echo_uint8_list, + .echo_object = echo_object, + .echo_list = echo_list, + .echo_map = echo_map, + .echo_class_wrapper = echo_class_wrapper, + .echo_enum = echo_enum, + .echo_named_default_string = echo_named_default_string, + .echo_optional_default_double = echo_optional_default_double, + .echo_required_int = echo_required_int, + .echo_all_nullable_types = echo_all_nullable_types, + .echo_all_nullable_types_without_recursion = + echo_all_nullable_types_without_recursion, + .extract_nested_nullable_string = extract_nested_nullable_string, + .create_nested_nullable_string = create_nested_nullable_string, + .send_multiple_nullable_types = send_multiple_nullable_types, + .send_multiple_nullable_types_without_recursion = + send_multiple_nullable_types_without_recursion, + .echo_nullable_int = echo_nullable_int, + .echo_nullable_double = echo_nullable_double, + .echo_nullable_bool = echo_nullable_bool, + .echo_nullable_string = echo_nullable_string, + .echo_nullable_uint8_list = echo_nullable_uint8_list, + .echo_nullable_object = echo_nullable_object, + .echo_nullable_list = echo_nullable_list, + .echo_nullable_map = echo_nullable_map, + .echo_nullable_enum = echo_nullable_enum, + .echo_optional_nullable_int = echo_optional_nullable_int, + .echo_named_nullable_string = echo_named_nullable_string, + .noop_async = noop_async, + .echo_async_int = echo_async_int, + .echo_async_double = echo_async_double, + .echo_async_bool = echo_async_bool, + .echo_async_string = echo_async_string, + .echo_async_uint8_list = echo_async_uint8_list, + .echo_async_object = echo_async_object, + .echo_async_list = echo_async_list, + .echo_async_map = echo_async_map, + .echo_async_enum = echo_async_enum, + .throw_async_error = throw_async_error, + .throw_async_error_from_void = throw_async_error_from_void, + .throw_async_flutter_error = throw_async_flutter_error, + .echo_async_all_types = echo_async_all_types, + .echo_async_nullable_all_nullable_types = + echo_async_nullable_all_nullable_types, + .echo_async_nullable_all_nullable_types_without_recursion = + echo_async_nullable_all_nullable_types_without_recursion, + .echo_async_nullable_int = echo_async_nullable_int, + .echo_async_nullable_double = echo_async_nullable_double, + .echo_async_nullable_bool = echo_async_nullable_bool, + .echo_async_nullable_string = echo_async_nullable_string, + .echo_async_nullable_uint8_list = echo_async_nullable_uint8_list, + .echo_async_nullable_object = echo_async_nullable_object, + .echo_async_nullable_list = echo_async_nullable_list, + .echo_async_nullable_map = echo_async_nullable_map, + .echo_async_nullable_enum = echo_async_nullable_enum, + .call_flutter_noop = call_flutter_noop, + .call_flutter_throw_error = call_flutter_throw_error, + .call_flutter_throw_error_from_void = call_flutter_throw_error_from_void, + .call_flutter_echo_all_types = call_flutter_echo_all_types, + .call_flutter_echo_all_nullable_types = + call_flutter_echo_all_nullable_types, + .call_flutter_send_multiple_nullable_types = + call_flutter_send_multiple_nullable_types, + .call_flutter_echo_all_nullable_types_without_recursion = + call_flutter_echo_all_nullable_types_without_recursion, + .call_flutter_send_multiple_nullable_types_without_recursion = + call_flutter_send_multiple_nullable_types_without_recursion, + .call_flutter_echo_bool = call_flutter_echo_bool, + .call_flutter_echo_int = call_flutter_echo_int, + .call_flutter_echo_double = call_flutter_echo_double, + .call_flutter_echo_string = call_flutter_echo_string, + .call_flutter_echo_uint8_list = call_flutter_echo_uint8_list, + .call_flutter_echo_list = call_flutter_echo_list, + .call_flutter_echo_map = call_flutter_echo_map, + .call_flutter_echo_enum = call_flutter_echo_enum, + .call_flutter_echo_nullable_bool = call_flutter_echo_nullable_bool, + .call_flutter_echo_nullable_int = call_flutter_echo_nullable_int, + .call_flutter_echo_nullable_double = call_flutter_echo_nullable_double, + .call_flutter_echo_nullable_string = call_flutter_echo_nullable_string, + .call_flutter_echo_nullable_uint8_list = + call_flutter_echo_nullable_uint8_list, + .call_flutter_echo_nullable_list = call_flutter_echo_nullable_list, + .call_flutter_echo_nullable_map = call_flutter_echo_nullable_map, + .call_flutter_echo_nullable_enum = call_flutter_echo_nullable_enum, + .call_flutter_small_api_echo_string = call_flutter_small_api_echo_string}; + +static void echo(const gchar* a_string, + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_small_api_respond_echo(response_handle, a_string); +} + +static void void_void( + CoreTestsPigeonTestHostSmallApiResponseHandle* response_handle, + gpointer user_data) { + core_tests_pigeon_test_host_small_api_respond_void_void(response_handle); +} + +static CoreTestsPigeonTestHostSmallApiVTable host_small_api_vtable = { + .echo = echo, .void_void = void_void}; + +static void test_plugin_dispose(GObject* object) { + TestPlugin* self = TEST_PLUGIN(object); + + g_cancellable_cancel(self->cancellable); + + core_tests_pigeon_test_host_integration_core_api_clear_method_handlers( + self->messenger, nullptr); + core_tests_pigeon_test_host_small_api_clear_method_handlers(self->messenger, + "suffixOne"); + core_tests_pigeon_test_host_small_api_clear_method_handlers(self->messenger, + "suffixTwo"); + + g_clear_object(&self->flutter_core_api); + g_clear_object(&self->flutter_small_api_one); + g_clear_object(&self->flutter_small_api_two); + g_clear_object(&self->cancellable); + + G_OBJECT_CLASS(test_plugin_parent_class)->dispose(object); +} + +static void test_plugin_class_init(TestPluginClass* klass) { + G_OBJECT_CLASS(klass)->dispose = test_plugin_dispose; +} + +static void test_plugin_init(TestPlugin* self) { + self->cancellable = g_cancellable_new(); +} + +static TestPlugin* test_plugin_new(FlBinaryMessenger* messenger) { + TestPlugin* self = TEST_PLUGIN(g_object_new(test_plugin_get_type(), nullptr)); + + self->messenger = messenger; + core_tests_pigeon_test_host_integration_core_api_set_method_handlers( + messenger, nullptr, &host_core_api_vtable, g_object_ref(self), + g_object_unref); + core_tests_pigeon_test_host_small_api_set_method_handlers( + messenger, "suffixOne", &host_small_api_vtable, g_object_ref(self), + g_object_unref); + core_tests_pigeon_test_host_small_api_set_method_handlers( + messenger, "suffixTwo", &host_small_api_vtable, g_object_ref(self), + g_object_unref); + self->flutter_core_api = + core_tests_pigeon_test_flutter_integration_core_api_new(messenger, + nullptr); + self->flutter_small_api_one = + core_tests_pigeon_test_flutter_small_api_new(messenger, "suffixOne"); + self->flutter_small_api_two = + core_tests_pigeon_test_flutter_small_api_new(messenger, "suffixTwo"); + + return self; +} + +void test_plugin_register_with_registrar(FlPluginRegistrar* registrar) { + g_autoptr(TestPlugin) plugin = + test_plugin_new(fl_plugin_registrar_get_messenger(registrar)); + (void)plugin; // unused variable + + g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new(); + g_autoptr(FlMethodChannel) channel = + fl_method_channel_new(fl_plugin_registrar_get_messenger(registrar), + "test_plugin", FL_METHOD_CODEC(codec)); + (void)channel; // unused variable +} diff --git a/packages/pigeon/platform_tests/test_plugin/linux/test_plugin_private.h b/packages/pigeon/platform_tests/test_plugin/linux/test_plugin_private.h new file mode 100644 index 000000000000..c4f53faa4bf6 --- /dev/null +++ b/packages/pigeon/platform_tests/test_plugin/linux/test_plugin_private.h @@ -0,0 +1,14 @@ +// 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. + +#include + +#include "include/test_plugin/test_plugin.h" + +// This file exposes some plugin internals for unit testing. See +// https://github.com/flutter/flutter/issues/88724 for current limitations +// in the unit-testable API. + +// Handles the getPlatformVersion method call. +FlMethodResponse* get_platform_version(); diff --git a/packages/pigeon/platform_tests/test_plugin/pubspec.yaml b/packages/pigeon/platform_tests/test_plugin/pubspec.yaml index a26b05c7eed3..0eb2b2f56894 100644 --- a/packages/pigeon/platform_tests/test_plugin/pubspec.yaml +++ b/packages/pigeon/platform_tests/test_plugin/pubspec.yaml @@ -15,6 +15,8 @@ flutter: pluginClass: TestPlugin ios: pluginClass: TestPlugin + linux: + pluginClass: TestPlugin macos: pluginClass: TestPlugin windows: diff --git a/packages/pigeon/pubspec.yaml b/packages/pigeon/pubspec.yaml index e833e74934bf..31832931d45a 100644 --- a/packages/pigeon/pubspec.yaml +++ b/packages/pigeon/pubspec.yaml @@ -2,7 +2,7 @@ name: pigeon description: Code generator tool to make communication between Flutter and the host platform type-safe and easier. repository: https://github.com/flutter/packages/tree/main/packages/pigeon issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+pigeon%22 -version: 21.0.0 # This must match the version in lib/generator_tools.dart +version: 21.1.0 # This must match the version in lib/generator_tools.dart environment: sdk: ^3.2.0 diff --git a/packages/pigeon/test/gobject_generator_test.dart b/packages/pigeon/test/gobject_generator_test.dart new file mode 100644 index 000000000000..935e9b98c804 --- /dev/null +++ b/packages/pigeon/test/gobject_generator_test.dart @@ -0,0 +1,774 @@ +// 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. + +import 'package:pigeon/ast.dart'; +import 'package:pigeon/generator_tools.dart'; +import 'package:pigeon/gobject_generator.dart'; +import 'package:test/test.dart'; + +const String DEFAULT_PACKAGE_NAME = 'test_package'; + +void main() { + test('gen one api', () { + final Class inputClass = Class(name: 'Input', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + name: 'input') + ]); + final Class outputClass = Class(name: 'Output', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + name: 'output') + ]); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + parameters: [ + Parameter( + type: TypeDeclaration( + baseName: 'Input', + isNullable: false, + associatedClass: inputClass, + ), + name: 'input') + ], + location: ApiLocation.host, + returnType: TypeDeclaration( + baseName: 'Output', + isNullable: false, + associatedClass: outputClass, + ), + ) + ]) + ], classes: [ + inputClass, + outputClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate(generatorOptions, root, sink, + dartPackageName: DEFAULT_PACKAGE_NAME); + final String code = sink.toString(); + expect( + code, + contains( + 'G_DECLARE_FINAL_TYPE(TestPackageInput, test_package_input, TEST_PACKAGE, INPUT, GObject)')); + expect( + code, + contains( + 'G_DECLARE_FINAL_TYPE(TestPackageOutput, test_package_output, TEST_PACKAGE, OUTPUT, GObject)')); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(), + ); + generator.generate(generatorOptions, root, sink, + dartPackageName: DEFAULT_PACKAGE_NAME); + final String code = sink.toString(); + expect( + code, + contains( + 'static void test_package_input_init(TestPackageInput* self) {')); + expect( + code, + contains( + 'static void test_package_output_init(TestPackageOutput* self) {')); + expect( + code, + contains( + 'static void test_package_api_init(TestPackageApi* self) {')); + } + }); + + test('naming follows style', () { + final Class inputClass = Class(name: 'Input', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'inputField') + ]); + final Class outputClass = Class(name: 'Output', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'outputField') + ]); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + parameters: [ + Parameter( + type: TypeDeclaration( + baseName: 'Input', + isNullable: false, + associatedClass: inputClass, + ), + name: 'someInput') + ], + location: ApiLocation.host, + returnType: TypeDeclaration( + baseName: 'Output', + isNullable: false, + associatedClass: outputClass, + ), + ) + ]) + ], classes: [ + inputClass, + outputClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate(generatorOptions, root, sink, + dartPackageName: DEFAULT_PACKAGE_NAME); + final String code = sink.toString(); + expect( + code, + contains( + ' TestPackageApiDoSomethingResponse* (*do_something)(TestPackageInput* some_input, gpointer user_data);')); + expect( + code, + contains( + 'gboolean test_package_input_get_input_field(TestPackageInput* object);')); + expect( + code, + contains( + 'gboolean test_package_output_get_output_field(TestPackageOutput* object);')); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(), + ); + generator.generate(generatorOptions, root, sink, + dartPackageName: DEFAULT_PACKAGE_NAME); + final String code = sink.toString(); + expect( + code, + contains( + 'gboolean test_package_input_get_input_field(TestPackageInput* self) {')); + expect( + code, + contains( + 'gboolean test_package_output_get_output_field(TestPackageOutput* self) {')); + } + }); + + test('Spaces before {', () { + final Class inputClass = Class(name: 'Input', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + name: 'input') + ]); + final Class outputClass = Class(name: 'Output', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + name: 'output') + ]); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + location: ApiLocation.host, + parameters: [ + Parameter( + type: TypeDeclaration( + baseName: 'Input', + isNullable: false, + associatedClass: inputClass, + ), + name: 'input') + ], + returnType: TypeDeclaration( + baseName: 'Output', + isNullable: false, + associatedClass: outputClass, + ), + ) + ]) + ], classes: [ + inputClass, + outputClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect(code, isNot(contains('){'))); + expect(code, isNot(contains('const{'))); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect(code, isNot(contains('){'))); + expect(code, isNot(contains('const{'))); + } + }); + + test('include blocks follow style', () { + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + location: ApiLocation.host, + parameters: [ + Parameter( + type: const TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + name: 'input') + ], + returnType: const TypeDeclaration(baseName: 'int', isNullable: false), + ) + ]) + ], classes: [], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect(code, contains(''' +#include +''')); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(headerIncludePath: 'a_header.h'), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect(code, contains(''' +#include "a_header.h" +''')); + } + }); + + test('data classes handle non-nullable fields', () { + final Class nestedClass = Class(name: 'Nested', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'nestedValue'), + ]); + final Class inputClass = Class(name: 'Input', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'nonNullableBool'), + NamedType( + type: const TypeDeclaration( + baseName: 'int', + isNullable: false, + ), + name: 'nonNullableInt'), + NamedType( + type: const TypeDeclaration( + baseName: 'String', + isNullable: false, + ), + name: 'nonNullableString'), + NamedType( + type: TypeDeclaration( + baseName: 'Nested', + isNullable: false, + associatedClass: nestedClass, + ), + name: 'nonNullableNested'), + ]); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + location: ApiLocation.host, + parameters: [ + Parameter( + type: TypeDeclaration( + baseName: 'Input', + isNullable: false, + associatedClass: inputClass, + ), + name: 'someInput') + ], + returnType: const TypeDeclaration.voidDeclaration(), + ) + ]) + ], classes: [ + nestedClass, + inputClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + + expect( + code, + contains( + 'TestPackageNested* test_package_nested_new(gboolean nested_value);')); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + + expect( + code, + contains( + 'TestPackageNested* test_package_nested_new(gboolean nested_value) {')); + } + }); + + test('host non-nullable return types map correctly', () { + final Class returnDataClass = Class(name: 'ReturnData', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'aValue'), + ]); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'returnBool', + location: ApiLocation.host, + parameters: [], + returnType: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + ), + Method( + name: 'returnInt', + location: ApiLocation.host, + parameters: [], + returnType: const TypeDeclaration( + baseName: 'int', + isNullable: false, + ), + ), + Method( + name: 'returnString', + location: ApiLocation.host, + parameters: [], + returnType: const TypeDeclaration( + baseName: 'String', + isNullable: false, + ), + ), + Method( + name: 'returnList', + location: ApiLocation.host, + parameters: [], + returnType: const TypeDeclaration( + baseName: 'List', + typeArguments: [ + TypeDeclaration( + baseName: 'String', + isNullable: true, + ) + ], + isNullable: false, + ), + ), + Method( + name: 'returnMap', + location: ApiLocation.host, + parameters: [], + returnType: const TypeDeclaration( + baseName: 'Map', + typeArguments: [ + TypeDeclaration( + baseName: 'String', + isNullable: true, + ), + TypeDeclaration( + baseName: 'String', + isNullable: true, + ) + ], + isNullable: false, + ), + ), + Method( + name: 'returnDataClass', + location: ApiLocation.host, + parameters: [], + returnType: TypeDeclaration( + baseName: 'ReturnData', + isNullable: false, + associatedClass: returnDataClass, + ), + ), + ]) + ], classes: [ + returnDataClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect( + code, + contains( + ' TestPackageApiReturnBoolResponse* (*return_bool)(gpointer user_data);')); + expect( + code, + contains( + ' TestPackageApiReturnIntResponse* (*return_int)(gpointer user_data);')); + expect( + code, + contains( + ' TestPackageApiReturnStringResponse* (*return_string)(gpointer user_data);')); + expect( + code, + contains( + ' TestPackageApiReturnListResponse* (*return_list)(gpointer user_data);')); + expect( + code, + contains( + ' TestPackageApiReturnMapResponse* (*return_map)(gpointer user_data);')); + expect( + code, + contains( + ' TestPackageApiReturnDataClassResponse* (*return_data_class)(gpointer user_data);')); + } + }); + + test('host non-nullable arguments map correctly', () { + final Class parameterObjectClass = + Class(name: 'ParameterObject', fields: [ + NamedType( + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + ), + name: 'aValue'), + ]); + final Class objectClass = Class(name: 'Object', fields: []); + final Root root = Root(apis: [ + AstHostApi(name: 'Api', methods: [ + Method( + name: 'doSomething', + location: ApiLocation.host, + parameters: [ + Parameter( + name: 'aBool', + type: const TypeDeclaration( + baseName: 'bool', + isNullable: false, + )), + Parameter( + name: 'anInt', + type: const TypeDeclaration( + baseName: 'int', + isNullable: false, + )), + Parameter( + name: 'aString', + type: const TypeDeclaration( + baseName: 'String', + isNullable: false, + )), + Parameter( + name: 'aList', + type: TypeDeclaration( + baseName: 'List', + typeArguments: [ + TypeDeclaration( + baseName: 'Object', + isNullable: true, + associatedClass: objectClass, + ) + ], + isNullable: false, + )), + Parameter( + name: 'aMap', + type: TypeDeclaration( + baseName: 'Map', + typeArguments: [ + const TypeDeclaration(baseName: 'String', isNullable: true), + TypeDeclaration( + baseName: 'Object', + isNullable: true, + associatedClass: objectClass, + ), + ], + isNullable: false, + )), + Parameter( + name: 'anObject', + type: TypeDeclaration( + baseName: 'ParameterObject', + isNullable: false, + associatedClass: parameterObjectClass, + )), + Parameter( + name: 'aGenericObject', + type: TypeDeclaration( + baseName: 'Object', + isNullable: false, + associatedClass: objectClass, + )), + ], + returnType: const TypeDeclaration.voidDeclaration(), + ), + ]) + ], classes: [ + parameterObjectClass, + objectClass + ], enums: []); + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect( + code, + contains( + ' TestPackageApiDoSomethingResponse* (*do_something)(gboolean a_bool, int64_t an_int, const gchar* a_string, FlValue* a_list, FlValue* a_map, TestPackageParameterObject* an_object, TestPackageObject* a_generic_object, gpointer user_data);')); + } + { + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.source, + languageOptions: const GObjectOptions(), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + expect( + code, + contains( + ' g_autoptr(TestPackageApiDoSomethingResponse) response = self->vtable->do_something(a_bool, an_int, a_string, a_list, a_map, an_object, a_generic_object, self->user_data);')); + } + }); + + test('transfers documentation comments', () { + final List comments = [ + ' api comment', + ' api method comment', + ' class comment', + ' class field comment', + ' enum comment', + ' enum member comment', + ]; + int count = 0; + + final List unspacedComments = ['////////']; + int unspacedCount = 0; + + final Root root = Root( + apis: [ + AstFlutterApi( + name: 'Api', + documentationComments: [comments[count++]], + methods: [ + Method( + name: 'method', + location: ApiLocation.flutter, + returnType: const TypeDeclaration.voidDeclaration(), + documentationComments: [comments[count++]], + parameters: [ + Parameter( + name: 'field', + type: const TypeDeclaration( + baseName: 'int', + isNullable: true, + ), + ), + ], + ) + ], + ) + ], + classes: [ + Class( + name: 'class', + documentationComments: [comments[count++]], + fields: [ + NamedType( + documentationComments: [comments[count++]], + type: const TypeDeclaration( + baseName: 'Map', + isNullable: true, + typeArguments: [ + TypeDeclaration(baseName: 'String', isNullable: true), + TypeDeclaration(baseName: 'int', isNullable: true), + ]), + name: 'field1'), + ], + ), + ], + enums: [ + Enum( + name: 'enum', + documentationComments: [ + comments[count++], + unspacedComments[unspacedCount++] + ], + members: [ + EnumMember( + name: 'one', + documentationComments: [comments[count++]], + ), + EnumMember(name: 'two'), + ], + ), + ], + ); + final StringBuffer sink = StringBuffer(); + const GObjectGenerator generator = GObjectGenerator(); + final OutputFileOptions generatorOptions = + OutputFileOptions( + fileType: FileType.header, + languageOptions: const GObjectOptions(headerIncludePath: 'foo'), + ); + generator.generate( + generatorOptions, + root, + sink, + dartPackageName: DEFAULT_PACKAGE_NAME, + ); + final String code = sink.toString(); + for (final String comment in comments) { + expect(code, contains(' *$comment')); + } + expect(code, contains(' * ///')); + }); +} diff --git a/packages/pigeon/tool/run_tests.dart b/packages/pigeon/tool/run_tests.dart index ffcbe78887b0..ec5487b49e3d 100644 --- a/packages/pigeon/tool/run_tests.dart +++ b/packages/pigeon/tool/run_tests.dart @@ -67,6 +67,7 @@ Future _validateGeneratedFiles( languagesToValidate = { GeneratorLanguage.cpp, GeneratorLanguage.dart, + GeneratorLanguage.gobject, GeneratorLanguage.java, GeneratorLanguage.kotlin, GeneratorLanguage.objc, @@ -140,6 +141,7 @@ Set _extensionsForLanguage(GeneratorLanguage language) { return switch (language) { GeneratorLanguage.cpp => {'cc', 'cpp', 'h'}, GeneratorLanguage.dart => {'dart'}, + GeneratorLanguage.gobject => {'cc', 'h'}, GeneratorLanguage.java => {'java'}, GeneratorLanguage.kotlin => {'kt'}, GeneratorLanguage.swift => {'swift'}, @@ -177,6 +179,8 @@ Future main(List args) async { androidKotlinUnitTests, androidJavaIntegrationTests, androidKotlinIntegrationTests, + linuxUnitTests, + linuxIntegrationTests, ]; const List macOSHostTests = [ iOSObjCUnitTests, @@ -234,5 +238,5 @@ Future main(List args) async { exit(2); } - await runTests(testsToRun); + await runTests(testsToRun, ciMode: true); } diff --git a/packages/pigeon/tool/shared/generation.dart b/packages/pigeon/tool/shared/generation.dart index 8166e49d73f0..fe3c85b7fc76 100644 --- a/packages/pigeon/tool/shared/generation.dart +++ b/packages/pigeon/tool/shared/generation.dart @@ -13,6 +13,7 @@ import 'process_utils.dart'; enum GeneratorLanguage { cpp, dart, + gobject, java, kotlin, objc, @@ -101,6 +102,8 @@ Future generateTestPigeons({required String baseDir}) async { dartTestOut: input == 'message' ? '$sharedDartOutputBase/test/test_message.gen.dart' : null, + dartPackageName: 'pigeon_integration_tests', + suppressVersion: true, // Android kotlinOut: skipLanguages.contains(GeneratorLanguage.kotlin) ? null @@ -113,6 +116,14 @@ Future generateTestPigeons({required String baseDir}) async { ? null : '$outputBase/ios/Classes/$pascalCaseName.gen.swift', swiftErrorClassName: swiftErrorClassName, + // Linux + gobjectHeaderOut: skipLanguages.contains(GeneratorLanguage.gobject) + ? null + : '$outputBase/linux/pigeon/$input.gen.h', + gobjectSourceOut: skipLanguages.contains(GeneratorLanguage.gobject) + ? null + : '$outputBase/linux/pigeon/$input.gen.cc', + gobjectModule: '${pascalCaseName}PigeonTest', // Windows cppHeaderOut: skipLanguages.contains(GeneratorLanguage.cpp) ? null @@ -121,8 +132,6 @@ Future generateTestPigeons({required String baseDir}) async { ? null : '$outputBase/windows/pigeon/$input.gen.cpp', cppNamespace: '${input}_pigeontest', - suppressVersion: true, - dartPackageName: 'pigeon_integration_tests', ); if (generateCode != 0) { return generateCode; @@ -204,6 +213,9 @@ Future runPigeon({ String? cppNamespace, String? dartOut, String? dartTestOut, + String? gobjectHeaderOut, + String? gobjectSourceOut, + String? gobjectModule, String? javaOut, String? javaPackage, String? objcHeaderOut, @@ -235,6 +247,9 @@ Future runPigeon({ cppHeaderOut: cppHeaderOut, cppSourceOut: cppSourceOut, cppOptions: CppOptions(namespace: cppNamespace), + gobjectHeaderOut: gobjectHeaderOut, + gobjectSourceOut: gobjectSourceOut, + gobjectOptions: GObjectOptions(module: gobjectModule), javaOut: javaOut, javaOptions: JavaOptions(package: javaPackage), kotlinOut: kotlinOut, @@ -267,6 +282,7 @@ Future formatAllFiles({ Set languages = const { GeneratorLanguage.cpp, GeneratorLanguage.dart, + GeneratorLanguage.gobject, GeneratorLanguage.java, GeneratorLanguage.kotlin, GeneratorLanguage.objc, @@ -282,6 +298,7 @@ Future formatAllFiles({ 'format', '--packages=pigeon', if (languages.contains(GeneratorLanguage.cpp) || + languages.contains(GeneratorLanguage.gobject) || languages.contains(GeneratorLanguage.objc)) '--clang-format' else diff --git a/packages/pigeon/tool/shared/native_project_runners.dart b/packages/pigeon/tool/shared/native_project_runners.dart index 06111e0257da..71ee6272232a 100644 --- a/packages/pigeon/tool/shared/native_project_runners.dart +++ b/packages/pigeon/tool/shared/native_project_runners.dart @@ -7,12 +7,15 @@ import 'process_utils.dart'; Future runFlutterCommand( String projectDirectory, - String command, [ - List commandArguments = const [], -]) { + String command, + List commandArguments, { + String? wrapperCommand, +}) { + final String flutterCommand = getFlutterCommand(); return runProcess( - getFlutterCommand(), + wrapperCommand ?? flutterCommand, [ + if (wrapperCommand != null) flutterCommand, command, ...commandArguments, ], diff --git a/packages/pigeon/tool/shared/test_runner.dart b/packages/pigeon/tool/shared/test_runner.dart index 01f12cb26fd8..f222bf74c5bb 100644 --- a/packages/pigeon/tool/shared/test_runner.dart +++ b/packages/pigeon/tool/shared/test_runner.dart @@ -17,6 +17,7 @@ Future runTests( List testsToRun, { bool runFormat = false, bool runGeneration = true, + bool ciMode = false, }) async { final String baseDir = p.dirname(p.dirname(Platform.script.toFilePath())); if (runGeneration) { @@ -47,7 +48,7 @@ Future runTests( if (info != null) { print('##############################'); print('# Running $test'); - final int testCode = await info.function(); + final int testCode = await info.function(ciMode: ciMode); if (testCode != 0) { print('# Failed, exit code: $testCode'); exit(testCode); diff --git a/packages/pigeon/tool/shared/test_suites.dart b/packages/pigeon/tool/shared/test_suites.dart index 8f9bb7a4cb40..c37c388d03f7 100644 --- a/packages/pigeon/tool/shared/test_suites.dart +++ b/packages/pigeon/tool/shared/test_suites.dart @@ -27,7 +27,7 @@ class TestInfo { const TestInfo({required this.function, this.description}); /// The function to run the test suite. - final Future Function() function; + final Future Function({bool ciMode}) function; /// A user-facing description of the test suite. final String? description; @@ -43,6 +43,8 @@ const String iOSObjCUnitTests = 'ios_objc_unittests'; const String iOSObjCIntegrationTests = 'ios_objc_integration_tests'; const String iOSSwiftUnitTests = 'ios_swift_unittests'; const String iOSSwiftIntegrationTests = 'ios_swift_integration_tests'; +const String linuxUnitTests = 'linux_unittests'; +const String linuxIntegrationTests = 'linux_integration_tests'; const String macOSObjCIntegrationTests = 'macos_objc_integration_tests'; const String macOSSwiftUnitTests = 'macos_swift_unittests'; const String macOSSwiftIntegrationTests = 'macos_swift_integration_tests'; @@ -91,6 +93,12 @@ const Map testSuites = { iOSSwiftIntegrationTests: TestInfo( function: _runIOSSwiftIntegrationTests, description: 'Integration tests on generated Swift code.'), + linuxUnitTests: TestInfo( + function: _runLinuxUnitTests, + description: 'Unit tests on generated Linux C code.'), + linuxIntegrationTests: TestInfo( + function: _runLinuxIntegrationTests, + description: 'Integration tests on generated Linux C code.'), macOSObjCIntegrationTests: TestInfo( function: _runMacOSObjCIntegrationTests, description: 'Integration tests on generated Objective-C code on macOS.'), @@ -105,16 +113,16 @@ const Map testSuites = { description: 'Tests running pigeon with various command-line options.'), }; -Future _runAndroidJavaUnitTests() async { +Future _runAndroidJavaUnitTests({bool ciMode = false}) async { return _runAndroidUnitTests(_alternateLanguageTestPluginRelativePath); } -Future _runAndroidJavaIntegrationTests() async { +Future _runAndroidJavaIntegrationTests({bool ciMode = false}) async { return _runMobileIntegrationTests( 'Android', _alternateLanguageTestPluginRelativePath); } -Future _runAndroidJavaLint() async { +Future _runAndroidJavaLint({bool ciMode = false}) async { const String examplePath = './$_alternateLanguageTestPluginRelativePath/example'; const String androidProjectPath = '$examplePath/android'; @@ -131,7 +139,7 @@ Future _runAndroidJavaLint() async { androidProjectPath, 'alternate_language_test_plugin:lintDebug'); } -Future _runAndroidKotlinUnitTests() async { +Future _runAndroidKotlinUnitTests({bool ciMode = false}) async { return _runAndroidUnitTests(_testPluginRelativePath); } @@ -149,7 +157,7 @@ Future _runAndroidUnitTests(String testPluginPath) async { return runGradleBuild(androidProjectPath, 'testDebugUnitTest'); } -Future _runAndroidKotlinIntegrationTests() async { +Future _runAndroidKotlinIntegrationTests({bool ciMode = false}) async { return _runMobileIntegrationTests('Android', _testPluginRelativePath); } @@ -170,7 +178,7 @@ Future _runMobileIntegrationTests( ); } -Future _runDartUnitTests() async { +Future _runDartUnitTests({bool ciMode = false}) async { int exitCode = await runProcess('dart', ['analyze', 'bin']); if (exitCode != 0) { return exitCode; @@ -196,7 +204,7 @@ Future _analyzeFlutterUnitTests(String flutterUnitTestsPath) async { } final int analyzeCode = - await runFlutterCommand(flutterUnitTestsPath, 'analyze'); + await runFlutterCommand(flutterUnitTestsPath, 'analyze', []); if (analyzeCode != 0) { return analyzeCode; } @@ -207,14 +215,15 @@ Future _analyzeFlutterUnitTests(String flutterUnitTestsPath) async { return 0; } -Future _runFlutterUnitTests() async { +Future _runFlutterUnitTests({bool ciMode = false}) async { const String flutterUnitTestsPath = 'platform_tests/shared_test_plugin_code'; final int analyzeCode = await _analyzeFlutterUnitTests(flutterUnitTestsPath); if (analyzeCode != 0) { return analyzeCode; } - final int testCode = await runFlutterCommand(flutterUnitTestsPath, 'test'); + final int testCode = + await runFlutterCommand(flutterUnitTestsPath, 'test', []); if (testCode != 0) { return testCode; } @@ -222,11 +231,11 @@ Future _runFlutterUnitTests() async { return 0; } -Future _runIOSObjCUnitTests() async { +Future _runIOSObjCUnitTests({bool ciMode = false}) async { return _runIOSPluginUnitTests(_alternateLanguageTestPluginRelativePath); } -Future _runIOSObjCIntegrationTests() async { +Future _runIOSObjCIntegrationTests({bool ciMode = false}) async { final String? device = await getDeviceForPlatform('ios'); if (device == null) { print('No iOS device available. Attach an iOS device or start ' @@ -243,7 +252,7 @@ Future _runIOSObjCIntegrationTests() async { ); } -Future _runMacOSObjCIntegrationTests() async { +Future _runMacOSObjCIntegrationTests({bool ciMode = false}) async { const String examplePath = './$_alternateLanguageTestPluginRelativePath/example'; return runFlutterCommand( @@ -253,7 +262,7 @@ Future _runMacOSObjCIntegrationTests() async { ); } -Future _runMacOSSwiftUnitTests() async { +Future _runMacOSSwiftUnitTests({bool ciMode = false}) async { const String examplePath = './$_testPluginRelativePath/example'; final int compileCode = await runFlutterBuild(examplePath, 'macos'); if (compileCode != 0) { @@ -270,7 +279,7 @@ Future _runMacOSSwiftUnitTests() async { ); } -Future _runMacOSSwiftIntegrationTests() async { +Future _runMacOSSwiftIntegrationTests({bool ciMode = false}) async { const String examplePath = './$_testPluginRelativePath/example'; return runFlutterCommand( examplePath, @@ -279,7 +288,7 @@ Future _runMacOSSwiftIntegrationTests() async { ); } -Future _runIOSSwiftUnitTests() async { +Future _runIOSSwiftUnitTests({bool ciMode = false}) async { return _runIOSPluginUnitTests(_testPluginRelativePath); } @@ -345,24 +354,60 @@ Future _deleteSimulator(String deviceName) async { ); } -Future _runIOSSwiftIntegrationTests() async { +Future _runIOSSwiftIntegrationTests({bool ciMode = false}) async { return _runMobileIntegrationTests('iOS', _testPluginRelativePath); } -Future _runWindowsUnitTests() async { +Future _runLinuxUnitTests({bool ciMode = false}) async { + const String examplePath = './$_testPluginRelativePath/example'; + final int compileCode = await runFlutterBuild(examplePath, 'linux'); + if (compileCode != 0) { + return compileCode; + } + + const String buildDirBase = '$examplePath/build/linux'; + const String buildRelativeBinaryPath = + 'debug/plugins/test_plugin/test_plugin_test'; + const String arm64Path = '$buildDirBase/arm64/$buildRelativeBinaryPath'; + const String x64Path = '$buildDirBase/x64/$buildRelativeBinaryPath'; + final String testBinary = File(arm64Path).existsSync() ? arm64Path : x64Path; + if (ciMode) { + // To avoid having all custom tests in the repo run under xvfb, xvfb-run is + // done here rather than at the CI config level. Ideally, Pigeon tests + // should be incorporated into the repo tooling's standard runs, at which + // point this won't be necessary. + return runProcess('xvfb-run', [testBinary]); + } else { + return runProcess(testBinary, []); + } +} + +Future _runLinuxIntegrationTests({bool ciMode = false}) async { + const String examplePath = './$_testPluginRelativePath/example'; + return runFlutterCommand( + examplePath, + 'test', + [_integrationTestFileRelativePath, '-d', 'linux'], + // To avoid having all custom tests in the repo run under xvfb, xvfb-run is + // done here rather than at the CI config level. Ideally, Pigeon tests + // should be incorporated into the repo tooling's standard runs, at which + // point this won't be necessary. + wrapperCommand: ciMode ? 'xvfb-run' : null, + ); +} + +Future _runWindowsUnitTests({bool ciMode = false}) async { const String examplePath = './$_testPluginRelativePath/example'; final int compileCode = await runFlutterBuild(examplePath, 'windows'); if (compileCode != 0) { return compileCode; } - // Depending on the Flutter version, the build output path is different. To - // handle both master and stable, and to future-proof against the changes + // Depending on the Flutter version, the build output path may be different. + // To handle both master and stable, and to future-proof against the changes // that will happen in https://github.com/flutter/flutter/issues/129807 // - Try arm64, to future-proof against arm64 support. - // - Try x64, to cover pre-arm64 support on arm64 hosts, as well as x64 hosts - // running newer versions of Flutter. - // - Fall back to the pre-arch path, to support running against stable. + // - Try x64, to cover pre-arm64 support on arm64 hosts, as well as x64 hosts. // TODO(stuartmorgan): Remove all this when these tests no longer need to // support a version of Flutter without // https://github.com/flutter/flutter/issues/129807, and just construct the @@ -372,17 +417,14 @@ Future _runWindowsUnitTests() async { 'plugins/test_plugin/Debug/test_plugin_test.exe'; const String arm64Path = '$buildDirBase/arm64/$buildRelativeBinaryPath'; const String x64Path = '$buildDirBase/x64/$buildRelativeBinaryPath'; - const String oldPath = '$buildDirBase/$buildRelativeBinaryPath'; if (File(arm64Path).existsSync()) { return runProcess(arm64Path, []); - } else if (File(x64Path).existsSync()) { - return runProcess(x64Path, []); } else { - return runProcess(oldPath, []); + return runProcess(x64Path, []); } } -Future _runWindowsIntegrationTests() async { +Future _runWindowsIntegrationTests({bool ciMode = false}) async { const String examplePath = './$_testPluginRelativePath/example'; return runFlutterCommand( examplePath, @@ -391,7 +433,7 @@ Future _runWindowsIntegrationTests() async { ); } -Future _runCommandLineTests() async { +Future _runCommandLineTests({bool ciMode = false}) async { final Directory tempDir = Directory.systemTemp.createTempSync('pigeon'); final String tempOutput = p.join(tempDir.path, 'pigeon_output'); const String pigeonScript = 'bin/pigeon.dart'; diff --git a/packages/pigeon/tool/test.dart b/packages/pigeon/tool/test.dart index 4c3eab669f1d..4dea945fef7a 100644 --- a/packages/pigeon/tool/test.dart +++ b/packages/pigeon/tool/test.dart @@ -80,6 +80,10 @@ ${parser.usage}'''); iOSSwiftUnitTests, iOSSwiftIntegrationTests, ]; + const List linuxTests = [ + linuxUnitTests, + linuxIntegrationTests, + ]; const List macOSTests = [ macOSObjCIntegrationTests, macOSSwiftUnitTests, @@ -106,6 +110,7 @@ ${parser.usage}'''); testsToRun = [ ...dartTests, ...androidTests, + ...linuxTests, ]; } else { print('Unsupported host platform.'); From 19daf6f36df7f154c2408f052890200c1d9c1a5c Mon Sep 17 00:00:00 2001 From: Rexios Date: Thu, 25 Jul 2024 06:19:23 -0400 Subject: [PATCH 3/4] Modernize the rest of the `index.html` files to support WASM compilation (#7192) Turns out there are a bunch of other `index.html` files that used a different method of Flutter initialization https://github.com/flutter/flutter/issues/151663 --- packages/camera/camera/example/web/index.html | 1 - .../example/web/index.html | 23 +------------------ .../example/web/index.html | 23 +------------------ packages/flutter_image/example/web/index.html | 23 +------------------ .../google_identity_services_web/CHANGELOG.md | 4 ++++ .../google_identity_services_web/README.md | 5 +--- .../example/web/index-with-script-tag.html | 20 +--------------- .../example/web/index.html | 20 +--------------- .../google_identity_services_web/pubspec.yaml | 2 +- .../example/web/index.html | 23 +------------------ .../google_sign_in/example/web/index.html | 11 +-------- .../example/web/index.html | 15 +----------- .../example/web/index.html | 23 +------------------ 13 files changed, 15 insertions(+), 178 deletions(-) diff --git a/packages/camera/camera/example/web/index.html b/packages/camera/camera/example/web/index.html index 015dee5950ac..91502587edaf 100644 --- a/packages/camera/camera/example/web/index.html +++ b/packages/camera/camera/example/web/index.html @@ -23,7 +23,6 @@ - diff --git a/packages/extension_google_sign_in_as_googleapis_auth/example/web/index.html b/packages/extension_google_sign_in_as_googleapis_auth/example/web/index.html index 1d72ec5daa75..e178d6751c21 100644 --- a/packages/extension_google_sign_in_as_googleapis_auth/example/web/index.html +++ b/packages/extension_google_sign_in_as_googleapis_auth/example/web/index.html @@ -38,29 +38,8 @@ Google Sign In + googleapis - - - - - + diff --git a/packages/flutter_adaptive_scaffold/example/web/index.html b/packages/flutter_adaptive_scaffold/example/web/index.html index 9be0ff0a763a..064d7a356f47 100644 --- a/packages/flutter_adaptive_scaffold/example/web/index.html +++ b/packages/flutter_adaptive_scaffold/example/web/index.html @@ -34,29 +34,8 @@ example - - - - - + diff --git a/packages/flutter_image/example/web/index.html b/packages/flutter_image/example/web/index.html index e080bd4889aa..29f72bf6f773 100644 --- a/packages/flutter_image/example/web/index.html +++ b/packages/flutter_image/example/web/index.html @@ -35,29 +35,8 @@ example - - - - - + diff --git a/packages/google_identity_services_web/CHANGELOG.md b/packages/google_identity_services_web/CHANGELOG.md index f5752cbad972..b2181d130746 100644 --- a/packages/google_identity_services_web/CHANGELOG.md +++ b/packages/google_identity_services_web/CHANGELOG.md @@ -1,3 +1,7 @@ +## 0.3.1+3 + +* Updates `README.md` to reflect modern `index.html` script tag placement. + ## 0.3.1+2 * Updates web code to package `web: >=0.5.1 <2.0.0`. diff --git a/packages/google_identity_services_web/README.md b/packages/google_identity_services_web/README.md index 65214000a74d..733644af5ba0 100644 --- a/packages/google_identity_services_web/README.md +++ b/packages/google_identity_services_web/README.md @@ -24,8 +24,7 @@ There are two ways to load the JS SDK in your app. The most performant way is to modify your `web/index.html` file to insert a script tag [as recommended](https://developers.google.com/identity/gsi/web/guides/client-library). -Place the `script` tag in the `` of your site, next to the script tag that -loads `flutter.js`, so the browser can downloaded both in parallel: +Place the `script` tag in the `` of your site: ```html @@ -33,8 +32,6 @@ loads `flutter.js`, so the browser can downloaded both in parallel: - - ``` diff --git a/packages/google_identity_services_web/example/web/index-with-script-tag.html b/packages/google_identity_services_web/example/web/index-with-script-tag.html index 07441f7a5d44..bae6382acfa6 100644 --- a/packages/google_identity_services_web/example/web/index-with-script-tag.html +++ b/packages/google_identity_services_web/example/web/index-with-script-tag.html @@ -24,30 +24,12 @@ Authentication Example - - - - + diff --git a/packages/google_identity_services_web/example/web/index.html b/packages/google_identity_services_web/example/web/index.html index 5727323c8dbd..4c6fa80e71be 100644 --- a/packages/google_identity_services_web/example/web/index.html +++ b/packages/google_identity_services_web/example/web/index.html @@ -22,30 +22,12 @@ Authentication Example - - - - + diff --git a/packages/google_identity_services_web/pubspec.yaml b/packages/google_identity_services_web/pubspec.yaml index 160c50f16ce3..13825a367877 100644 --- a/packages/google_identity_services_web/pubspec.yaml +++ b/packages/google_identity_services_web/pubspec.yaml @@ -2,7 +2,7 @@ name: google_identity_services_web description: A Dart JS-interop layer for Google Identity Services. Google's new sign-in SDK for Web that supports multiple types of credentials. repository: https://github.com/flutter/packages/tree/main/packages/google_identity_services_web issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_identiy_services_web%22 -version: 0.3.1+2 +version: 0.3.1+3 environment: sdk: ^3.4.0 diff --git a/packages/google_maps_flutter/google_maps_flutter/example/web/index.html b/packages/google_maps_flutter/google_maps_flutter/example/web/index.html index 58522ba720c3..26de2ffd7cb0 100644 --- a/packages/google_maps_flutter/google_maps_flutter/example/web/index.html +++ b/packages/google_maps_flutter/google_maps_flutter/example/web/index.html @@ -38,29 +38,8 @@ - - - - - + diff --git a/packages/google_sign_in/google_sign_in/example/web/index.html b/packages/google_sign_in/google_sign_in/example/web/index.html index eff8f4effadb..d68026f3d90e 100644 --- a/packages/google_sign_in/google_sign_in/example/web/index.html +++ b/packages/google_sign_in/google_sign_in/example/web/index.html @@ -7,17 +7,8 @@ Google Sign-in Example - - + diff --git a/packages/pointer_interceptor/pointer_interceptor_web/example/web/index.html b/packages/pointer_interceptor/pointer_interceptor_web/example/web/index.html index 2720a1eaad86..064d7a356f47 100644 --- a/packages/pointer_interceptor/pointer_interceptor_web/example/web/index.html +++ b/packages/pointer_interceptor/pointer_interceptor_web/example/web/index.html @@ -34,21 +34,8 @@ example - - - - + diff --git a/packages/two_dimensional_scrollables/example/web/index.html b/packages/two_dimensional_scrollables/example/web/index.html index 3574a82d337e..3ce79d627fea 100644 --- a/packages/two_dimensional_scrollables/example/web/index.html +++ b/packages/two_dimensional_scrollables/example/web/index.html @@ -34,29 +34,8 @@ example - - - - - + From 94f8b2fb279961f831c7500a89c53cba2c8999c4 Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Thu, 25 Jul 2024 11:02:59 -0700 Subject: [PATCH 4/4] [flutter_migrate] Remove one set of parens that wrap a single String literal (#7216) In order to address dart-lang/linter#4354, we are reporting a few more cases in `unnecessary_parenthesis`. `('text') * 2` is one such case. This change is being made in https://dart-review.googlesource.com/c/sdk/+/376540. (These are the only newly-reported unnecessary parentheses for this change.) This is the _same_ change as https://github.com/flutter/flutter/pull/152031 ## Pre-launch Checklist - [x] I read the [Contributor Guide] and followed the process outlined there for submitting PRs. - [x] I read the [Tree Hygiene] page, which explains my responsibilities. - [x] I read and followed the [relevant style guides] and ran the auto-formatter. (Unlike the flutter/flutter repo, the flutter/packages repo does use `dart format`.) - [x] I signed the [CLA]. - [x] The title of the PR starts with the name of the package surrounded by square brackets, e.g. `[shared_preferences]` - [ ] I [linked to at least one issue that this PR fixes] in the description above. - [ ] I updated `pubspec.yaml` with an appropriate new version according to the [pub versioning philosophy], or this PR is [exempt from version changes]. - [ ] I updated `CHANGELOG.md` to add a description of the change, [following repository CHANGELOG style], or this PR is [exempt from CHANGELOG changes]. - [ ] I updated/added relevant documentation (doc comments with `///`). - [ ] I added new tests to check the change I am making, or this PR is [test-exempt]. - [x] All existing and new tests are passing. If you need help, consider asking for advice on the #hackers-new channel on [Discord]. [Contributor Guide]: https://github.com/flutter/packages/blob/main/CONTRIBUTING.md [Tree Hygiene]: https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md [relevant style guides]: https://github.com/flutter/packages/blob/main/CONTRIBUTING.md#style [CLA]: https://cla.developers.google.com/ [Discord]: https://github.com/flutter/flutter/blob/master/docs/contributing/Chat.md [linked to at least one issue that this PR fixes]: https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md#overview [pub versioning philosophy]: https://dart.dev/tools/pub/versioning [exempt from version changes]: https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#version [following repository CHANGELOG style]: https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changelog-style [exempt from CHANGELOG changes]: https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changelog [test-exempt]: https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md#tests --- packages/flutter_migrate/test/base/terminal_test.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/flutter_migrate/test/base/terminal_test.dart b/packages/flutter_migrate/test/base/terminal_test.dart index 6686ec269bbe..6dec484d59bc 100644 --- a/packages/flutter_migrate/test/base/terminal_test.dart +++ b/packages/flutter_migrate/test/base/terminal_test.dart @@ -19,7 +19,7 @@ void main() { ); bufferLogger.printStatus('0123456789' * 8); - expect(bufferLogger.statusText, equals(('${'0123456789' * 4}\n') * 2)); + expect(bufferLogger.statusText, equals('${'0123456789' * 4}\n' * 2)); }); testWithoutContext('can turn off wrapping', () async {