| // 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/cpp_generator.dart'; |
| import 'package:pigeon/generator_tools.dart'; |
| import 'package:pigeon/pigeon.dart' show Error; |
| import 'package:test/test.dart'; |
| |
| const String DEFAULT_PACKAGE_NAME = 'test_package'; |
| |
| final Class emptyClass = Class(name: 'className', fields: <NamedType>[ |
| NamedType( |
| name: 'namedTypeName', |
| type: const TypeDeclaration(baseName: 'baseName', isNullable: false), |
| ) |
| ]); |
| |
| final Enum emptyEnum = Enum( |
| name: 'enumName', |
| members: <EnumMember>[EnumMember(name: 'enumMemberName')], |
| ); |
| |
| void main() { |
| test('gen one api', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: 'input') |
| ], |
| location: ApiLocation.host, |
| returnType: TypeDeclaration( |
| baseName: 'Output', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Input', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'input') |
| ]), |
| Class(name: 'Output', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'output') |
| ]) |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate(generatorOptions, root, sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME); |
| final String code = sink.toString(); |
| expect(code, contains('class Input')); |
| expect(code, contains('class Output')); |
| expect(code, contains('class Api')); |
| expect(code, contains('virtual ~Api() {}\n')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate(generatorOptions, root, sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME); |
| final String code = sink.toString(); |
| expect(code, contains('Input::Input()')); |
| expect(code, contains('Output::Output')); |
| expect( |
| code, |
| contains(RegExp(r'void Api::SetUp\(\s*' |
| r'flutter::BinaryMessenger\* binary_messenger,\s*' |
| r'Api\* api\s*\)'))); |
| } |
| }); |
| |
| test('naming follows style', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: 'someInput') |
| ], |
| location: ApiLocation.host, |
| returnType: TypeDeclaration( |
| baseName: 'Output', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Input', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'inputField') |
| ]), |
| Class(name: 'Output', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'outputField') |
| ]) |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate(generatorOptions, root, sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME); |
| final String code = sink.toString(); |
| // Method name and argument names should be adjusted. |
| expect(code, contains(' DoSomething(const Input& some_input)')); |
| // Getters and setters should use optional getter/setter style. |
| expect(code, contains('bool input_field()')); |
| expect(code, contains('void set_input_field(bool value_arg)')); |
| expect(code, contains('bool output_field()')); |
| expect(code, contains('void set_output_field(bool value_arg)')); |
| // Instance variables should be adjusted. |
| expect(code, contains('bool input_field_')); |
| expect(code, contains('bool output_field_')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate(generatorOptions, root, sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME); |
| final String code = sink.toString(); |
| expect(code, contains('encodable_some_input')); |
| expect(code, contains('Output::output_field()')); |
| expect(code, contains('Output::set_output_field(bool value_arg)')); |
| } |
| }); |
| |
| test('FlutterError fields are private with public accessors', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: false, |
| ), |
| name: 'someInput') |
| ], |
| returnType: const TypeDeclaration(baseName: 'int', isNullable: false), |
| ) |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| |
| expect( |
| code.split('\n'), |
| containsAllInOrder(<Matcher>[ |
| contains('class FlutterError {'), |
| contains(' public:'), |
| contains(' const std::string& code() const { return code_; }'), |
| contains( |
| ' const std::string& message() const { return message_; }'), |
| contains( |
| ' const flutter::EncodableValue& details() const { return details_; }'), |
| contains(' private:'), |
| contains(' std::string code_;'), |
| contains(' std::string message_;'), |
| contains(' flutter::EncodableValue details_;'), |
| ])); |
| } |
| }); |
| |
| test('Error field is private with public accessors', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: false, |
| ), |
| name: 'someInput') |
| ], |
| returnType: const TypeDeclaration(baseName: 'int', isNullable: false), |
| ) |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate(generatorOptions, root, sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME); |
| final String code = sink.toString(); |
| |
| expect( |
| code.split('\n'), |
| containsAllInOrder(<Matcher>[ |
| contains('class ErrorOr {'), |
| contains(' public:'), |
| contains(' bool has_error() const {'), |
| contains(' const T& value() const {'), |
| contains(' const FlutterError& error() const {'), |
| contains(' private:'), |
| contains(' std::variant<T, FlutterError> v_;'), |
| ])); |
| } |
| }); |
| |
| test('Spaces before {', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: 'input') |
| ], |
| returnType: TypeDeclaration( |
| baseName: 'Output', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Input', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'input') |
| ]), |
| Class(name: 'Output', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'output') |
| ]) |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| 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 CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| 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: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'input') |
| ], |
| returnType: const TypeDeclaration(baseName: 'int', isNullable: false), |
| ) |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, contains(''' |
| #include <flutter/basic_message_channel.h> |
| #include <flutter/binary_messenger.h> |
| #include <flutter/encodable_value.h> |
| #include <flutter/standard_message_codec.h> |
| |
| #include <map> |
| #include <optional> |
| #include <string> |
| ''')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(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" |
| |
| #include <flutter/basic_message_channel.h> |
| #include <flutter/binary_messenger.h> |
| #include <flutter/encodable_value.h> |
| #include <flutter/standard_message_codec.h> |
| |
| #include <map> |
| #include <optional> |
| #include <string> |
| ''')); |
| } |
| }); |
| |
| test('namespaces follows style', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'input') |
| ], |
| returnType: const TypeDeclaration(baseName: 'int', isNullable: false), |
| ) |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(namespace: 'foo'), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, contains('namespace foo {')); |
| expect(code, contains('} // namespace foo')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(namespace: 'foo'), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, contains('namespace foo {')); |
| expect(code, contains('} // namespace foo')); |
| } |
| }); |
| |
| test('data classes handle nullable fields', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: 'someInput') |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Nested', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| ), |
| name: 'nestedValue'), |
| ]), |
| Class(name: 'Input', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| ), |
| name: 'nullableBool'), |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| ), |
| name: 'nullableInt'), |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'nullableString'), |
| NamedType( |
| type: TypeDeclaration( |
| baseName: 'Nested', |
| isNullable: true, |
| associatedClass: emptyClass, |
| ), |
| name: 'nullableNested'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| |
| // There should be a default constructor. |
| expect(code, contains('Nested();')); |
| // There should be a convenience constructor. |
| expect( |
| code, |
| contains( |
| RegExp(r'explicit Nested\(\s*const bool\* nested_value\s*\)'))); |
| |
| // Getters should return const pointers. |
| expect(code, contains('const bool* nullable_bool()')); |
| expect(code, contains('const int64_t* nullable_int()')); |
| expect(code, contains('const std::string* nullable_string()')); |
| expect(code, contains('const Nested* nullable_nested()')); |
| // Setters should take const pointers. |
| expect(code, contains('void set_nullable_bool(const bool* value_arg)')); |
| expect(code, contains('void set_nullable_int(const int64_t* value_arg)')); |
| // Strings should be string_view rather than string as an argument. |
| expect( |
| code, |
| contains( |
| 'void set_nullable_string(const std::string_view* value_arg)')); |
| expect( |
| code, contains('void set_nullable_nested(const Nested* value_arg)')); |
| // Setters should have non-null-style variants. |
| expect(code, contains('void set_nullable_bool(bool value_arg)')); |
| expect(code, contains('void set_nullable_int(int64_t value_arg)')); |
| expect(code, |
| contains('void set_nullable_string(std::string_view value_arg)')); |
| expect( |
| code, contains('void set_nullable_nested(const Nested& value_arg)')); |
| // Most instance variables should be std::optionals. |
| expect(code, contains('std::optional<bool> nullable_bool_')); |
| expect(code, contains('std::optional<int64_t> nullable_int_')); |
| expect(code, contains('std::optional<std::string> nullable_string_')); |
| // Custom classes are the exception, to avoid inline storage. |
| expect(code, contains('std::unique_ptr<Nested> nullable_nested_')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| |
| // There should be a default constructor. |
| expect(code, contains('Nested::Nested() {}')); |
| // There should be a convenience constructor. |
| expect( |
| code, |
| contains(RegExp(r'Nested::Nested\(\s*const bool\* nested_value\s*\)' |
| r'\s*:\s*nested_value_\(nested_value \? ' |
| r'std::optional<bool>\(\*nested_value\) : std::nullopt\)\s*{}'))); |
| |
| // Getters extract optionals. |
| expect(code, |
| contains('return nullable_bool_ ? &(*nullable_bool_) : nullptr;')); |
| expect(code, |
| contains('return nullable_int_ ? &(*nullable_int_) : nullptr;')); |
| expect( |
| code, |
| contains( |
| 'return nullable_string_ ? &(*nullable_string_) : nullptr;')); |
| expect(code, contains('return nullable_nested_.get();')); |
| // Setters convert to optionals. |
| expect( |
| code, |
| contains('nullable_bool_ = value_arg ? ' |
| 'std::optional<bool>(*value_arg) : std::nullopt;')); |
| expect( |
| code, |
| contains('nullable_int_ = value_arg ? ' |
| 'std::optional<int64_t>(*value_arg) : std::nullopt;')); |
| expect( |
| code, |
| contains('nullable_string_ = value_arg ? ' |
| 'std::optional<std::string>(*value_arg) : std::nullopt;')); |
| expect( |
| code, |
| contains( |
| 'nullable_nested_ = value_arg ? std::make_unique<Nested>(*value_arg) : nullptr;')); |
| // Serialization handles optionals. |
| expect( |
| code, |
| contains('nullable_bool_ ? EncodableValue(*nullable_bool_) ' |
| ': EncodableValue()')); |
| expect( |
| code, |
| contains( |
| 'nullable_nested_ ? CustomEncodableValue(*nullable_nested_) : EncodableValue())')); |
| |
| // Serialization should use push_back, not initializer lists, to avoid |
| // copies. |
| expect(code, contains('list.reserve(4)')); |
| expect( |
| code, |
| contains('list.push_back(nullable_bool_ ? ' |
| 'EncodableValue(*nullable_bool_) : ' |
| 'EncodableValue())')); |
| } |
| }); |
| |
| test('data classes handle non-nullable fields', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: 'someInput') |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Nested', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'nestedValue'), |
| ]), |
| Class(name: 'Input', fields: <NamedType>[ |
| 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: emptyClass, |
| ), |
| name: 'nonNullableNested'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| |
| // There should not be a default constructor. |
| expect(code, isNot(contains('Nested();'))); |
| // There should be a convenience constructor. |
| expect(code, |
| contains(RegExp(r'explicit Nested\(\s*bool nested_value\s*\)'))); |
| |
| // POD getters should return copies references. |
| expect(code, contains('bool non_nullable_bool()')); |
| expect(code, contains('int64_t non_nullable_int()')); |
| // Non-POD getters should return const references. |
| expect(code, contains('const std::string& non_nullable_string()')); |
| expect(code, contains('const Nested& non_nullable_nested()')); |
| // POD setters should take values. |
| expect(code, contains('void set_non_nullable_bool(bool value_arg)')); |
| expect(code, contains('void set_non_nullable_int(int64_t value_arg)')); |
| // Strings should be string_view as an argument. |
| expect(code, |
| contains('void set_non_nullable_string(std::string_view value_arg)')); |
| // Other non-POD setters should take const references. |
| expect(code, |
| contains('void set_non_nullable_nested(const Nested& value_arg)')); |
| // Instance variables should be plain types. |
| expect(code, contains('bool non_nullable_bool_;')); |
| expect(code, contains('int64_t non_nullable_int_;')); |
| expect(code, contains('std::string non_nullable_string_;')); |
| // Except for custom classes. |
| expect(code, contains('std::unique_ptr<Nested> non_nullable_nested_;')); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| |
| // There should not be a default constructor. |
| expect(code, isNot(contains('Nested::Nested() {}'))); |
| // There should be a convenience constructor. |
| expect( |
| code, |
| contains(RegExp(r'Nested::Nested\(\s*bool nested_value\s*\)' |
| r'\s*:\s*nested_value_\(nested_value\)\s*{}'))); |
| |
| // Getters just return the value. |
| expect(code, contains('return non_nullable_bool_;')); |
| expect(code, contains('return non_nullable_int_;')); |
| expect(code, contains('return non_nullable_string_;')); |
| // Unless it's a custom class. |
| expect(code, contains('return *non_nullable_nested_;')); |
| // Setters just assign the value. |
| expect(code, contains('non_nullable_bool_ = value_arg;')); |
| expect(code, contains('non_nullable_int_ = value_arg;')); |
| expect(code, contains('non_nullable_string_ = value_arg;')); |
| // Unless it's a custom class. |
| expect( |
| code, |
| contains( |
| 'non_nullable_nested_ = std::make_unique<Nested>(value_arg);')); |
| // Serialization uses the value directly. |
| expect(code, contains('EncodableValue(non_nullable_bool_)')); |
| expect(code, contains('CustomEncodableValue(*non_nullable_nested_)')); |
| |
| // Serialization should use push_back, not initializer lists, to avoid |
| // copies. |
| expect(code, contains('list.reserve(4)')); |
| expect( |
| code, |
| contains( |
| 'list.push_back(CustomEncodableValue(*non_nullable_nested_))')); |
| } |
| }); |
| |
| test('host nullable return types map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'returnNullableBool', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| ), |
| ), |
| Method( |
| name: 'returnNullableInt', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| ), |
| ), |
| Method( |
| name: 'returnNullableString', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| ), |
| Method( |
| name: 'returnNullableList', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ) |
| ], |
| isNullable: true, |
| ), |
| ), |
| Method( |
| name: 'returnNullableMap', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ) |
| ], |
| isNullable: true, |
| ), |
| ), |
| Method( |
| name: 'returnNullableDataClass', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: TypeDeclaration( |
| baseName: 'ReturnData', |
| isNullable: true, |
| associatedClass: emptyClass, |
| ), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ReturnData', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, contains('ErrorOr<std::optional<bool>> ReturnNullableBool()')); |
| expect(code, |
| contains('ErrorOr<std::optional<int64_t>> ReturnNullableInt()')); |
| expect( |
| code, |
| contains( |
| 'ErrorOr<std::optional<std::string>> ReturnNullableString()')); |
| expect( |
| code, |
| contains( |
| 'ErrorOr<std::optional<flutter::EncodableList>> ReturnNullableList()')); |
| expect( |
| code, |
| contains( |
| 'ErrorOr<std::optional<flutter::EncodableMap>> ReturnNullableMap()')); |
| expect( |
| code, |
| contains( |
| 'ErrorOr<std::optional<ReturnData>> ReturnNullableDataClass()')); |
| } |
| }); |
| |
| test('host non-nullable return types map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'returnBool', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| ), |
| Method( |
| name: 'returnInt', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: false, |
| ), |
| ), |
| Method( |
| name: 'returnString', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: false, |
| ), |
| ), |
| Method( |
| name: 'returnList', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ) |
| ], |
| isNullable: false, |
| ), |
| ), |
| Method( |
| name: 'returnMap', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ) |
| ], |
| isNullable: false, |
| ), |
| ), |
| Method( |
| name: 'returnDataClass', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: TypeDeclaration( |
| baseName: 'ReturnData', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ReturnData', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, contains('ErrorOr<bool> ReturnBool()')); |
| expect(code, contains('ErrorOr<int64_t> ReturnInt()')); |
| expect(code, contains('ErrorOr<std::string> ReturnString()')); |
| expect(code, contains('ErrorOr<flutter::EncodableList> ReturnList()')); |
| expect(code, contains('ErrorOr<flutter::EncodableMap> ReturnMap()')); |
| expect(code, contains('ErrorOr<ReturnData> ReturnDataClass()')); |
| } |
| }); |
| |
| test('host nullable arguments map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'aBool', |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'anInt', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aString', |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aList', |
| type: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'Object', isNullable: true) |
| ], |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aMap', |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'Object', isNullable: true), |
| ], |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'anObject', |
| type: TypeDeclaration( |
| baseName: 'ParameterObject', |
| isNullable: true, |
| associatedClass: emptyClass, |
| )), |
| Parameter( |
| name: 'aGenericObject', |
| type: const TypeDeclaration( |
| baseName: 'Object', |
| isNullable: true, |
| )), |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ParameterObject', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, |
| contains(RegExp(r'DoSomething\(\s*' |
| r'const bool\* a_bool,\s*' |
| r'const int64_t\* an_int,\s*' |
| r'const std::string\* a_string,\s*' |
| r'const flutter::EncodableList\* a_list,\s*' |
| r'const flutter::EncodableMap\* a_map,\s*' |
| r'const ParameterObject\* an_object,\s*' |
| r'const flutter::EncodableValue\* a_generic_object\s*\)'))); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // Most types should just use get_if, since the parameter is a pointer, |
| // and get_if will automatically handle null values (since a null |
| // EncodableValue will not match the queried type, so get_if will return |
| // nullptr). |
| expect( |
| code, |
| contains( |
| 'const auto* a_bool_arg = std::get_if<bool>(&encodable_a_bool_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto* a_string_arg = std::get_if<std::string>(&encodable_a_string_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto* a_list_arg = std::get_if<EncodableList>(&encodable_a_list_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto* a_map_arg = std::get_if<EncodableMap>(&encodable_a_map_arg);')); |
| // Ints are complicated since there are two possible pointer types, but |
| // the parameter always needs an int64_t*. |
| expect( |
| code, |
| contains( |
| 'const int64_t an_int_arg_value = encodable_an_int_arg.IsNull() ? 0 : encodable_an_int_arg.LongValue();')); |
| expect( |
| code, |
| contains( |
| 'const auto* an_int_arg = encodable_an_int_arg.IsNull() ? nullptr : &an_int_arg_value;')); |
| // Custom class types require an extra layer of extraction. |
| expect( |
| code, |
| contains( |
| 'const auto* an_object_arg = encodable_an_object_arg.IsNull() ? nullptr : &(std::any_cast<const ParameterObject&>(std::get<CustomEncodableValue>(encodable_an_object_arg)));')); |
| // "Object" requires no extraction at all since it has to use |
| // EncodableValue directly. |
| expect( |
| code, |
| contains( |
| 'const auto* a_generic_object_arg = &encodable_a_generic_object_arg;')); |
| } |
| }); |
| |
| test('host non-nullable arguments map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| 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: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'Object', isNullable: true) |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'aMap', |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'Object', isNullable: true), |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'anObject', |
| type: TypeDeclaration( |
| baseName: 'ParameterObject', |
| isNullable: false, |
| associatedClass: emptyClass, |
| )), |
| Parameter( |
| name: 'aGenericObject', |
| type: const TypeDeclaration( |
| baseName: 'Object', |
| isNullable: false, |
| )), |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ParameterObject', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, |
| contains(RegExp(r'DoSomething\(\s*' |
| r'bool a_bool,\s*' |
| r'int64_t an_int,\s*' |
| r'const std::string& a_string,\s*' |
| r'const flutter::EncodableList& a_list,\s*' |
| r'const flutter::EncodableMap& a_map,\s*' |
| r'const ParameterObject& an_object,\s*' |
| r'const flutter::EncodableValue& a_generic_object\s*\)'))); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // Most types should extract references. Since the type is non-nullable, |
| // there's only one possible type. |
| expect( |
| code, |
| contains( |
| 'const auto& a_bool_arg = std::get<bool>(encodable_a_bool_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto& a_string_arg = std::get<std::string>(encodable_a_string_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto& a_list_arg = std::get<EncodableList>(encodable_a_list_arg);')); |
| expect( |
| code, |
| contains( |
| 'const auto& a_map_arg = std::get<EncodableMap>(encodable_a_map_arg);')); |
| // Ints use a copy since there are two possible reference types, but |
| // the parameter always needs an int64_t. |
| expect( |
| code, |
| contains( |
| 'const int64_t an_int_arg = encodable_an_int_arg.LongValue();', |
| )); |
| // Custom class types require an extra layer of extraction. |
| expect( |
| code, |
| contains( |
| 'const auto& an_object_arg = std::any_cast<const ParameterObject&>(std::get<CustomEncodableValue>(encodable_an_object_arg));')); |
| // "Object" requires no extraction at all since it has to use |
| // EncodableValue directly. |
| expect( |
| code, |
| contains( |
| 'const auto& a_generic_object_arg = encodable_a_generic_object_arg;')); |
| } |
| }); |
| |
| test('flutter nullable arguments map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstFlutterApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.flutter, |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'aBool', |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'anInt', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aString', |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aList', |
| type: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'Object', isNullable: true) |
| ], |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'aMap', |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'Object', isNullable: true), |
| ], |
| isNullable: true, |
| )), |
| Parameter( |
| name: 'anObject', |
| type: TypeDeclaration( |
| baseName: 'ParameterObject', |
| isNullable: true, |
| associatedClass: emptyClass, |
| )), |
| Parameter( |
| name: 'aGenericObject', |
| type: const TypeDeclaration( |
| baseName: 'Object', |
| isNullable: true, |
| )), |
| ], |
| returnType: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: true, |
| ), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ParameterObject', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // Nullable arguments should all be pointers. This will make them somewhat |
| // awkward for some uses (literals, values that could be inlined) but |
| // unlike setters there's no way to provide reference-based alternatives |
| // since it's not always just one argument. |
| // TODO(stuartmorgan): Consider generating a second variant using |
| // `std::optional`s; that may be more ergonomic, but the perf implications |
| // would need to be considered. |
| expect( |
| code, |
| contains(RegExp(r'DoSomething\(\s*' |
| r'const bool\* a_bool,\s*' |
| r'const int64_t\* an_int,\s*' |
| // Nullable strings use std::string* rather than std::string_view* |
| // since there's no implicit conversion for pointer types. |
| r'const std::string\* a_string,\s*' |
| r'const flutter::EncodableList\* a_list,\s*' |
| r'const flutter::EncodableMap\* a_map,\s*' |
| r'const ParameterObject\* an_object,\s*' |
| r'const flutter::EncodableValue\* a_generic_object,'))); |
| // The callback should pass a pointer as well. |
| expect( |
| code, |
| contains( |
| RegExp(r'std::function<void\(const bool\*\)>&& on_success,\s*' |
| r'std::function<void\(const FlutterError&\)>&& on_error\)'))); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // All types pass nulls values when the pointer is null. |
| // Standard types are wrapped an EncodableValues. |
| expect( |
| code, |
| contains( |
| 'a_bool_arg ? EncodableValue(*a_bool_arg) : EncodableValue()')); |
| expect( |
| code, |
| contains( |
| 'an_int_arg ? EncodableValue(*an_int_arg) : EncodableValue()')); |
| expect( |
| code, |
| contains( |
| 'a_string_arg ? EncodableValue(*a_string_arg) : EncodableValue()')); |
| expect( |
| code, |
| contains( |
| 'a_list_arg ? EncodableValue(*a_list_arg) : EncodableValue()')); |
| expect( |
| code, |
| contains( |
| 'a_map_arg ? EncodableValue(*a_map_arg) : EncodableValue()')); |
| // Class types use ToEncodableList. |
| expect( |
| code, |
| contains( |
| 'an_object_arg ? CustomEncodableValue(*an_object_arg) : EncodableValue()')); |
| } |
| }); |
| |
| test('flutter non-nullable arguments map correctly', () { |
| final Root root = Root(apis: <Api>[ |
| AstFlutterApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.flutter, |
| parameters: <Parameter>[ |
| 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: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'Object', isNullable: true) |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'aMap', |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'Object', isNullable: true), |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'anObject', |
| type: TypeDeclaration( |
| baseName: 'ParameterObject', |
| isNullable: false, |
| associatedClass: emptyClass, |
| )), |
| Parameter( |
| name: 'aGenericObject', |
| type: const TypeDeclaration( |
| baseName: 'Object', |
| isNullable: false, |
| )), |
| ], |
| returnType: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ParameterObject', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, |
| contains(RegExp(r'DoSomething\(\s*' |
| r'bool a_bool,\s*' |
| r'int64_t an_int,\s*' |
| // Non-nullable strings use std::string for consistency with |
| // nullable strings. |
| r'const std::string& a_string,\s*' |
| // Non-POD types use const references. |
| r'const flutter::EncodableList& a_list,\s*' |
| r'const flutter::EncodableMap& a_map,\s*' |
| r'const ParameterObject& an_object,\s*' |
| r'const flutter::EncodableValue& a_generic_object,\s*'))); |
| // The callback should pass a value. |
| expect( |
| code, |
| contains(RegExp(r'std::function<void\(bool\)>&& on_success,\s*' |
| r'std::function<void\(const FlutterError&\)>&& on_error\s*\)'))); |
| } |
| { |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // Standard types are wrapped in EncodableValues. |
| expect(code, contains('EncodableValue(a_bool_arg)')); |
| expect(code, contains('EncodableValue(an_int_arg)')); |
| expect(code, contains('EncodableValue(a_string_arg)')); |
| expect(code, contains('EncodableValue(a_list_arg)')); |
| expect(code, contains('EncodableValue(a_map_arg)')); |
| // Class types are wrapped in CustomEncodableValues. |
| expect(code, contains('CustomEncodableValue(an_object_arg)')); |
| } |
| }); |
| |
| test('host API argument extraction uses references', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'anArg', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: false, |
| )), |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ), |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // A bare 'auto' here would create a copy, not a reference, which is |
| // inefficient. |
| expect( |
| code, contains('const auto& args = std::get<EncodableList>(message);')); |
| expect(code, contains('const auto& encodable_an_arg_arg = args.at(0);')); |
| }); |
| |
| test('enum argument', () { |
| final Root root = Root( |
| apis: <Api>[ |
| AstHostApi(name: 'Bar', methods: <Method>[ |
| Method( |
| name: 'bar', |
| location: ApiLocation.host, |
| returnType: const TypeDeclaration.voidDeclaration(), |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'foo', |
| type: TypeDeclaration( |
| baseName: 'Foo', |
| isNullable: false, |
| associatedEnum: emptyEnum, |
| ), |
| ) |
| ]) |
| ]) |
| ], |
| classes: <Class>[], |
| enums: <Enum>[ |
| Enum(name: 'Foo', members: <EnumMember>[ |
| EnumMember(name: 'one'), |
| EnumMember(name: 'two'), |
| ]) |
| ], |
| ); |
| final List<Error> errors = validateCpp(const CppOptions(), root); |
| expect(errors.length, 1); |
| }); |
| |
| test('transfers documentation comments', () { |
| final List<String> comments = <String>[ |
| ' api comment', |
| ' api method comment', |
| ' class comment', |
| ' class field comment', |
| ' enum comment', |
| ' enum member comment', |
| ]; |
| int count = 0; |
| |
| final List<String> unspacedComments = <String>['////////']; |
| int unspacedCount = 0; |
| |
| final Root root = Root( |
| apis: <Api>[ |
| AstFlutterApi( |
| name: 'Api', |
| documentationComments: <String>[comments[count++]], |
| methods: <Method>[ |
| Method( |
| name: 'method', |
| location: ApiLocation.flutter, |
| returnType: const TypeDeclaration.voidDeclaration(), |
| documentationComments: <String>[comments[count++]], |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'field', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| ), |
| ), |
| ], |
| ) |
| ], |
| ) |
| ], |
| classes: <Class>[ |
| Class( |
| name: 'class', |
| documentationComments: <String>[comments[count++]], |
| fields: <NamedType>[ |
| NamedType( |
| documentationComments: <String>[comments[count++]], |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| isNullable: true, |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'int', isNullable: true), |
| ]), |
| name: 'field1'), |
| ], |
| ), |
| ], |
| enums: <Enum>[ |
| Enum( |
| name: 'enum', |
| documentationComments: <String>[ |
| comments[count++], |
| unspacedComments[unspacedCount++] |
| ], |
| members: <EnumMember>[ |
| EnumMember( |
| name: 'one', |
| documentationComments: <String>[comments[count++]], |
| ), |
| EnumMember(name: 'two'), |
| ], |
| ), |
| ], |
| ); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(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('// ///')); |
| }); |
| |
| test('creates custom codecs', () { |
| final Root root = Root(apis: <Api>[ |
| AstFlutterApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.flutter, |
| parameters: <Parameter>[ |
| Parameter( |
| type: TypeDeclaration( |
| baseName: 'Input', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| name: '') |
| ], |
| returnType: TypeDeclaration( |
| baseName: 'Output', |
| isNullable: false, |
| associatedClass: emptyClass, |
| ), |
| isAsynchronous: true, |
| ) |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'Input', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'input') |
| ]), |
| Class(name: 'Output', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: true, |
| ), |
| name: 'output') |
| ]) |
| ], enums: <Enum>[]); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.header, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, contains(' : public flutter::StandardCodecSerializer')); |
| }); |
| |
| test('Does not send unwrapped EncodableLists', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'Api', methods: <Method>[ |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| 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: const TypeDeclaration( |
| baseName: 'List', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'Object', isNullable: true) |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'aMap', |
| type: const TypeDeclaration( |
| baseName: 'Map', |
| typeArguments: <TypeDeclaration>[ |
| TypeDeclaration(baseName: 'String', isNullable: true), |
| TypeDeclaration(baseName: 'Object', isNullable: true), |
| ], |
| isNullable: false, |
| )), |
| Parameter( |
| name: 'anObject', |
| type: TypeDeclaration( |
| baseName: 'ParameterObject', |
| isNullable: false, |
| associatedClass: emptyClass, |
| )), |
| ], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| ), |
| ]) |
| ], classes: <Class>[ |
| Class(name: 'ParameterObject', fields: <NamedType>[ |
| NamedType( |
| type: const TypeDeclaration( |
| baseName: 'bool', |
| isNullable: false, |
| ), |
| name: 'aValue'), |
| ]), |
| ], enums: <Enum>[]); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect(code, isNot(contains('reply(wrap'))); |
| expect(code, contains('reply(EncodableValue(')); |
| }); |
| |
| test('does not keep unowned references in async handlers', () { |
| final Root root = Root(apis: <Api>[ |
| AstHostApi(name: 'HostApi', methods: <Method>[ |
| Method( |
| name: 'noop', |
| location: ApiLocation.host, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| isAsynchronous: true, |
| ), |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.host, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: false, |
| ), |
| name: '') |
| ], |
| returnType: |
| const TypeDeclaration(baseName: 'double', isNullable: false), |
| isAsynchronous: true, |
| ), |
| ]), |
| AstFlutterApi(name: 'FlutterApi', methods: <Method>[ |
| Method( |
| name: 'noop', |
| location: ApiLocation.flutter, |
| parameters: <Parameter>[], |
| returnType: const TypeDeclaration.voidDeclaration(), |
| isAsynchronous: true, |
| ), |
| Method( |
| name: 'doSomething', |
| location: ApiLocation.flutter, |
| parameters: <Parameter>[ |
| Parameter( |
| type: const TypeDeclaration( |
| baseName: 'String', |
| isNullable: false, |
| ), |
| name: '') |
| ], |
| returnType: |
| const TypeDeclaration(baseName: 'bool', isNullable: false), |
| isAsynchronous: true, |
| ), |
| ]) |
| ], classes: <Class>[], enums: <Enum>[]); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| // Nothing should be captured by reference for async handlers, since their |
| // lifetime is unknown (and expected to be longer than the stack's). |
| expect(code, isNot(contains('&reply'))); |
| expect(code, isNot(contains('&wrapped'))); |
| // Check for the exact capture format that is currently being used, to |
| // ensure that the negative tests above get updated if there are any |
| // changes to lambda capture. |
| expect(code, contains('[reply](')); |
| }); |
| |
| test('connection error contains channel name', () { |
| final Root root = Root( |
| apis: <Api>[ |
| AstFlutterApi( |
| name: 'Api', |
| methods: <Method>[ |
| Method( |
| name: 'method', |
| location: ApiLocation.flutter, |
| returnType: const TypeDeclaration.voidDeclaration(), |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'field', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| ), |
| ), |
| ], |
| ) |
| ], |
| ) |
| ], |
| classes: <Class>[], |
| enums: <Enum>[], |
| ); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, |
| contains( |
| '"Unable to establish connection on channel: \'" + channel_name + "\'."')); |
| expect(code, contains('on_error(CreateConnectionError(channel_name));')); |
| }); |
| |
| test('stack allocates the message channel.', () { |
| final Root root = Root( |
| apis: <Api>[ |
| AstFlutterApi( |
| name: 'Api', |
| methods: <Method>[ |
| Method( |
| name: 'method', |
| location: ApiLocation.flutter, |
| returnType: const TypeDeclaration.voidDeclaration(), |
| parameters: <Parameter>[ |
| Parameter( |
| name: 'field', |
| type: const TypeDeclaration( |
| baseName: 'int', |
| isNullable: true, |
| ), |
| ), |
| ], |
| ) |
| ], |
| ) |
| ], |
| classes: <Class>[], |
| enums: <Enum>[], |
| ); |
| final StringBuffer sink = StringBuffer(); |
| const CppGenerator generator = CppGenerator(); |
| final OutputFileOptions<CppOptions> generatorOptions = |
| OutputFileOptions<CppOptions>( |
| fileType: FileType.source, |
| languageOptions: const CppOptions(), |
| ); |
| generator.generate( |
| generatorOptions, |
| root, |
| sink, |
| dartPackageName: DEFAULT_PACKAGE_NAME, |
| ); |
| final String code = sink.toString(); |
| expect( |
| code, |
| contains( |
| 'BasicMessageChannel<> channel(binary_messenger_, channel_name, &GetCodec());')); |
| expect(code, contains('channel.Send')); |
| }); |
| } |
