blob: 47c098d960e4cc45bcba1a941aa05bf7b31a739e [file] [log] [blame]
// 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 'dart:async';
import 'dart:io';
import 'package:pigeon/ast.dart';
import 'package:pigeon/generator_tools.dart';
import 'package:pigeon/pigeon_lib.dart';
import 'package:test/test.dart';
class _ValidatorGeneratorAdapter implements GeneratorAdapter {
_ValidatorGeneratorAdapter(this.sink);
@override
List<FileType> fileTypeList = const <FileType>[FileType.na];
bool didCallValidate = false;
final IOSink? sink;
@override
void generate(
StringSink sink, PigeonOptions options, Root root, FileType fileType) {}
@override
IOSink? shouldGenerate(PigeonOptions options, FileType _) => sink;
@override
List<Error> validate(PigeonOptions options, Root root) {
didCallValidate = true;
return <Error>[
Error(message: '_ValidatorGenerator'),
];
}
}
void main() {
/// Creates a temporary file named [filename] then calls [callback] with a
/// [File] representing that temporary directory. The file will be deleted
/// after the [callback] is executed.
void withTempFile(String filename, void Function(File) callback) {
final Directory dir = Directory.systemTemp.createTempSync();
final String path = '${dir.path}/$filename';
final File file = File(path);
file.createSync();
try {
callback(file);
} finally {
dir.deleteSync(recursive: true);
}
}
ParseResults parseSource(String source) {
final Pigeon dartle = Pigeon.setup();
ParseResults? results;
withTempFile('source.dart', (File file) {
file.writeAsStringSync(source);
results = dartle.parseFile(file.path);
});
return results!;
}
test('parse args - input', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--input', 'foo.dart']);
expect(opts.input, equals('foo.dart'));
});
test('parse args - dart_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--dart_out', 'foo.dart']);
expect(opts.dartOut, equals('foo.dart'));
});
test('parse args - java_package', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--java_package', 'com.google.foo']);
expect(opts.javaOptions?.package, equals('com.google.foo'));
});
test('parse args - input', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--java_out', 'foo.java']);
expect(opts.javaOut, equals('foo.java'));
});
test('parse args - objc_header_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--objc_header_out', 'foo.h']);
expect(opts.objcHeaderOut, equals('foo.h'));
});
test('parse args - objc_source_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--objc_source_out', 'foo.m']);
expect(opts.objcSourceOut, equals('foo.m'));
});
test('parse args - swift_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--swift_out', 'Foo.swift']);
expect(opts.swiftOut, equals('Foo.swift'));
});
test('parse args - kotlin_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--kotlin_out', 'Foo.kt']);
expect(opts.kotlinOut, equals('Foo.kt'));
});
test('parse args - kotlin_package', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--kotlin_package', 'com.google.foo']);
expect(opts.kotlinOptions?.package, equals('com.google.foo'));
});
test('parse args - cpp_header_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--cpp_header_out', 'foo.h']);
expect(opts.cppHeaderOut, equals('foo.h'));
});
test('parse args - java_use_generated_annotation', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--java_use_generated_annotation']);
expect(opts.javaOptions!.useGeneratedAnnotation, isTrue);
});
test('parse args - cpp_source_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--cpp_source_out', 'foo.cpp']);
expect(opts.cppSourceOut, equals('foo.cpp'));
});
test('parse args - one_language', () {
final PigeonOptions opts = Pigeon.parseArgs(<String>['--one_language']);
expect(opts.oneLanguage, isTrue);
});
test('parse args - ast_out', () {
final PigeonOptions opts =
Pigeon.parseArgs(<String>['--ast_out', 'stdout']);
expect(opts.astOut, equals('stdout'));
});
test('simple parse api', () {
const String code = '''
class Input1 {
String? input;
}
class Output1 {
String? output;
}
@HostApi()
abstract class Api1 {
Output1 doit(Input1 input);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(0));
final Root root = parseResult.root;
expect(root.classes.length, equals(2));
expect(root.apis.length, equals(1));
expect(root.apis[0].name, equals('Api1'));
expect(root.apis[0].methods.length, equals(1));
expect(root.apis[0].methods[0].name, equals('doit'));
expect(root.apis[0].methods[0].arguments[0].name, equals('input'));
expect(
root.apis[0].methods[0].arguments[0].type.baseName, equals('Input1'));
expect(root.apis[0].methods[0].returnType.baseName, equals('Output1'));
Class? input;
Class? output;
for (final Class klass in root.classes) {
if (klass.name == 'Input1') {
input = klass;
} else if (klass.name == 'Output1') {
output = klass;
}
}
expect(input, isNotNull);
expect(output, isNotNull);
expect(input?.fields.length, equals(1));
expect(input?.fields[0].name, equals('input'));
expect(input?.fields[0].type.baseName, equals('String'));
expect(input?.fields[0].type.isNullable, isTrue);
expect(output?.fields.length, equals(1));
expect(output?.fields[0].name, equals('output'));
expect(output?.fields[0].type.baseName, equals('String'));
expect(output?.fields[0].type.isNullable, isTrue);
});
test('invalid datatype', () {
const String source = '''
class InvalidDatatype {
dynamic something;
}
@HostApi()
abstract class Api {
InvalidDatatype foo();
}
''';
final ParseResults results = parseSource(source);
expect(results.errors.length, 1);
expect(results.errors[0].message, contains('InvalidDatatype'));
expect(results.errors[0].message, contains('dynamic'));
});
test('enum in classes', () {
const String code = '''
enum Enum1 {
one,
two,
}
class ClassWithEnum {
Enum1? enum1;
}
@HostApi
abstract class Api {
ClassWithEnum foo();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.classes.length, equals(1));
expect(results.root.classes[0].name, equals('ClassWithEnum'));
expect(results.root.classes[0].fields.length, equals(1));
expect(results.root.classes[0].fields[0].type.baseName, equals('Enum1'));
expect(results.root.classes[0].fields[0].type.isNullable, isTrue);
expect(results.root.classes[0].fields[0].name, equals('enum1'));
});
test('two methods', () {
const String code = '''
class Input1 {
String? input;
}
class Output1 {
int? output;
}
@HostApi()
abstract class ApiTwoMethods {
Output1 method1(Input1 input);
Output1 method2(Input1 input);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(2));
expect(results.root.apis[0].methods[0].name, equals('method1'));
expect(results.root.apis[0].methods[1].name, equals('method2'));
});
test('nested', () {
const String code = '''
class Input1 {
String? input;
}
class Nested {
Input1? input;
}
@HostApi()
abstract class Api {
Nested foo();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.classes.length, equals(2));
final Class nested =
results.root.classes.firstWhere((Class x) => x.name == 'Nested');
expect(nested.fields.length, equals(1));
expect(nested.fields[0].type.baseName, equals('Input1'));
expect(nested.fields[0].type.isNullable, isTrue);
});
test('flutter api', () {
const String code = '''
class Input1 {
String? input;
}
class Output1 {
int? output;
}
@FlutterApi()
abstract class AFlutterApi {
Output1 doit(Input1 input);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.apis.length, equals(1));
expect(results.root.apis[0].name, equals('AFlutterApi'));
expect(results.root.apis[0].location, equals(ApiLocation.flutter));
});
test('void host api', () {
const String code = '''
class Input1 {
String? input;
}
@HostApi()
abstract class VoidApi {
void doit(Input1 input);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.apis.length, equals(1));
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].name, equals('VoidApi'));
expect(results.root.apis[0].methods[0].returnType.isVoid, isTrue);
});
test('void arg host api', () {
const String code = '''
class Output1 {
String? output;
}
@HostApi()
abstract class VoidArgApi {
Output1 doit();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.apis.length, equals(1));
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].name, equals('VoidArgApi'));
expect(
results.root.apis[0].methods[0].returnType.baseName, equals('Output1'));
expect(results.root.apis[0].methods[0].arguments.isEmpty, isTrue);
});
test('mockDartClass', () {
const String code = '''
class Output1 {
String? output;
}
@HostApi(dartHostTestHandler: 'ApiWithMockDartClassMock')
abstract class ApiWithMockDartClass {
Output1 doit();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, equals(0));
expect(results.root.apis.length, equals(1));
expect(results.root.apis[0].dartHostTestHandler,
equals('ApiWithMockDartClassMock'));
});
test('only visible from nesting', () {
const String code = '''
class OnlyVisibleFromNesting {
String? foo;
}
class Nestor {
OnlyVisibleFromNesting? nested;
}
@HostApi()
abstract class NestorApi {
Nestor getit();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
final List<String> classNames =
results.root.classes.map((Class x) => x.name).toList();
expect(classNames.length, 2);
expect(classNames.contains('Nestor'), true);
expect(classNames.contains('OnlyVisibleFromNesting'), true);
});
test('copyright flag', () {
final PigeonOptions results =
Pigeon.parseArgs(<String>['--copyright_header', 'foobar.txt']);
expect(results.copyrightHeader, 'foobar.txt');
});
test('Dart generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options =
PigeonOptions(copyrightHeader: './copyright_header.txt');
final DartGeneratorAdapter dartGeneratorAdapter = DartGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
dartGeneratorAdapter.generate(buffer, options, root, FileType.na);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('Java generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options = PigeonOptions(
javaOut: 'Foo.java', copyrightHeader: './copyright_header.txt');
final JavaGeneratorAdapter javaGeneratorAdapter = JavaGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
javaGeneratorAdapter.generate(buffer, options, root, FileType.na);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('Objc header generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options =
PigeonOptions(copyrightHeader: './copyright_header.txt');
final ObjcGeneratorAdapter objcHeaderGeneratorAdapter =
ObjcGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
objcHeaderGeneratorAdapter.generate(buffer, options, root, FileType.header);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('Objc source generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options =
PigeonOptions(copyrightHeader: './copyright_header.txt');
final ObjcGeneratorAdapter objcSourceGeneratorAdapter =
ObjcGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
objcSourceGeneratorAdapter.generate(buffer, options, root, FileType.source);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('Swift generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options = PigeonOptions(
swiftOut: 'Foo.swift', copyrightHeader: './copyright_header.txt');
final SwiftGeneratorAdapter swiftGeneratorAdapter = SwiftGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
swiftGeneratorAdapter.generate(buffer, options, root, FileType.na);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('C++ header generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options = PigeonOptions(
cppHeaderOut: 'Foo.h', copyrightHeader: './copyright_header.txt');
final CppGeneratorAdapter cppHeaderGeneratorAdapter = CppGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
cppHeaderGeneratorAdapter.generate(buffer, options, root, FileType.header);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('C++ source generater copyright flag', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options =
PigeonOptions(copyrightHeader: './copyright_header.txt');
final CppGeneratorAdapter cppSourceGeneratorAdapter =
CppGeneratorAdapter(fileTypeList: <FileType>[FileType.source]);
final StringBuffer buffer = StringBuffer();
cppSourceGeneratorAdapter.generate(buffer, options, root, FileType.source);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('nested enum', () {
const String code = '''
enum NestedEnum { one, two }
class NestedEnum1 {
NestedEnum? test;
}
class NestedEnum2 {
NestedEnum1? class1;
}
class NestedEnum3 {
NestedEnum2? class1;
int? n;
}
@HostApi()
abstract class NestedEnumApi {
void method(NestedEnum3 foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(0));
expect(parseResult.root.apis.length, 1);
expect(parseResult.root.classes.length, 3);
expect(parseResult.root.enums.length, 1);
});
test('test circular references', () {
const String code = '''
class Foo {
Bar? bar;
}
class Bar {
Foo? foo;
}
@HostApi()
abstract class NotificationsHostApi {
void doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.classes.length, 2);
final Class foo =
results.root.classes.firstWhere((Class aClass) => aClass.name == 'Foo');
expect(foo.fields.length, 1);
expect(foo.fields[0].type.baseName, 'Bar');
});
test('test compilation error', () {
const String code = 'Hello\n';
final ParseResults results = parseSource(code);
expect(results.errors.length, greaterThanOrEqualTo(1));
expect(results.errors[0].lineNumber, 1);
});
test('test method in data class error', () {
const String code = '''
class Foo {
int? x;
int? foo() { return x; }
}
@HostApi()
abstract class Api {
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message, contains('Method'));
});
test('test field initialization', () {
const String code = '''
class Foo {
int? x = 123;
}
@HostApi()
abstract class Api {
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 2);
expect(results.errors[0].message, contains('Initialization'));
});
test('test field in api error', () {
const String code = '''
class Foo {
int? x;
}
@HostApi()
abstract class Api {
int? x;
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 7);
expect(results.errors[0].message, contains('Field'));
});
test('constructor in data class', () {
const String code = '''
class Foo {
int? x;
Foo({this.x});
}
@HostApi()
abstract class Api {
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
});
test('constructor body in data class', () {
const String code = '''
class Foo {
int? x;
Foo({this.x}) { print('hi'); }
}
@HostApi()
abstract class Api {
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message, contains('Constructor'));
});
test('constructor body in data class', () {
const String code = '''
class Foo {
int? x;
Foo() : x = 0;
}
@HostApi()
abstract class Api {
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message, contains('Constructor'));
});
test('constructor in api class', () {
const String code = '''
class Foo {
int? x;
}
@HostApi()
abstract class Api {
Api() { print('hi'); }
Foo doit(Foo foo);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 7);
expect(results.errors[0].message, contains('Constructor'));
});
test('test invalid import', () {
const String code = "import 'foo.dart';\n";
final ParseResults results = parseSource(code);
expect(results.errors.length, greaterThanOrEqualTo(1));
expect(results.errors[0].lineNumber, 1);
});
test('test valid import', () {
const String code = "import 'package:pigeon/pigeon.dart';\n";
final ParseResults parseResults = parseSource(code);
expect(parseResults.errors.length, 0);
});
test('error with static field', () {
const String code = '''
class WithStaticField {
static int? x;
int? y;
}
@HostApi()
abstract class WithStaticFieldApi {
void doit(WithStaticField withTemplate);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('static field'));
expect(parseResult.errors[0].lineNumber, isNotNull);
});
test('parse generics', () {
const String code = '''
class Foo {
List<int?>? list;
}
@HostApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(0));
final NamedType field = parseResult.root.classes[0].fields[0];
expect(field.type.typeArguments.length, 1);
expect(field.type.typeArguments[0].baseName, 'int');
});
test('parse recursive generics', () {
const String code = '''
class Foo {
List<List<int?>?>? list;
}
@HostApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(0));
final NamedType field = parseResult.root.classes[0].fields[0];
expect(field.type.typeArguments.length, 1);
expect(field.type.typeArguments[0].baseName, 'List');
expect(field.type.typeArguments[0].typeArguments[0].baseName, 'int');
});
test('error nonnull type argument', () {
const String code = '''
class Foo {
List<int> list;
}
@HostApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message,
contains('Generic type arguments must be nullable'));
expect(parseResult.errors[0].message, contains('"list"'));
expect(parseResult.errors[0].lineNumber, 2);
});
test('enums argument host', () {
const String code = '''
enum Foo {
one,
two,
}
@HostApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(0));
});
test('enums argument flutter', () {
// TODO(gaaclarke): Make this not an error: https://github.com/flutter/flutter/issues/87307
const String code = '''
enum Foo {
one,
two,
}
@FlutterApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('Enums'));
});
test('enums list argument', () {
// TODO(tarrinneal): Make this not an error: https://github.com/flutter/flutter/issues/87307
const String code = '''
enum Foo { one, two }
@HostApi()
abstract class Api {
void doit(List<Foo> foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('Enums'));
});
test('enums map argument key', () {
// TODO(tarrinneal): Make this not an error: https://github.com/flutter/flutter/issues/87307
const String code = '''
enum Foo { one, two }
@HostApi()
abstract class Api {
void doit(Map<Foo, Object> foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('Enums'));
});
test('enums map argument value', () {
// TODO(tarrinneal): Make this not an error: https://github.com/flutter/flutter/issues/87307
const String code = '''
enum Foo { one, two }
@HostApi()
abstract class Api {
void doit(Map<Foo, Object> foo);
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('Enums'));
});
test('enums return value', () {
// TODO(gaaclarke): Make this not an error: https://github.com/flutter/flutter/issues/87307
const String code = '''
enum Foo {
one,
two,
}
@HostApi()
abstract class Api {
Foo doit();
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.errors.length, equals(1));
expect(parseResult.errors[0].message, contains('Enums'));
});
test('return type generics', () {
const String code = '''
@HostApi()
abstract class Api {
List<double?> doit();
}
''';
final ParseResults parseResult = parseSource(code);
expect(parseResult.root.apis[0].methods[0].returnType.baseName, 'List');
expect(
parseResult
.root.apis[0].methods[0].returnType.typeArguments[0].baseName,
'double');
expect(
parseResult
.root.apis[0].methods[0].returnType.typeArguments[0].isNullable,
isTrue);
});
test('argument generics', () {
const String code = '''
@HostApi()
abstract class Api {
void doit(int x, List<double?> value);
}
''';
final ParseResults parseResult = parseSource(code);
expect(
parseResult.root.apis[0].methods[0].arguments[1].type.baseName, 'List');
expect(
parseResult.root.apis[0].methods[0].arguments[1].type.typeArguments[0]
.baseName,
'double');
expect(
parseResult.root.apis[0].methods[0].arguments[1].type.typeArguments[0]
.isNullable,
isTrue);
});
test('map generics', () {
const String code = '''
class Foo {
Map<String?, int?> map;
}
@HostApi()
abstract class Api {
void doit(Foo foo);
}
''';
final ParseResults parseResult = parseSource(code);
final NamedType field = parseResult.root.classes[0].fields[0];
expect(field.type.typeArguments.length, 2);
expect(field.type.typeArguments[0].baseName, 'String');
expect(field.type.typeArguments[1].baseName, 'int');
});
test('two arguments', () {
const String code = '''
class Input {
String? input;
}
@HostApi()
abstract class Api {
void method(Input input1, Input input2);
}
''';
final ParseResults results = parseSource(code);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].methods[0].name, equals('method'));
expect(results.root.apis[0].methods[0].arguments.length, 2);
});
test('no type name argument', () {
const String code = '''
@HostApi()
abstract class Api {
void method(x);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message,
contains('Arguments must specify their type'));
});
test('custom objc selector', () {
const String code = '''
@HostApi()
abstract class Api {
@ObjCSelector('subtractValue:by:')
void subtract(int x, int y);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].methods[0].objcSelector,
equals('subtractValue:by:'));
});
test('custom objc invalid selector', () {
const String code = '''
@HostApi()
abstract class Api {
@ObjCSelector('subtractValue:by:error:')
void subtract(int x, int y);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message,
contains('Invalid selector, expected 2 arguments'));
});
test('custom objc no arguments', () {
const String code = '''
@HostApi()
abstract class Api {
@ObjCSelector('foobar')
void initialize();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].methods[0].objcSelector, equals('foobar'));
});
test('custom swift valid function signature', () {
const String code = '''
@HostApi()
abstract class Api {
@SwiftFunction('subtractValue(_:by:)')
void subtract(int x, int y);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].methods[0].swiftFunction,
equals('subtractValue(_:by:)'));
});
test('custom swift invalid function signature', () {
const String code = '''
@HostApi()
abstract class Api {
@SwiftFunction('subtractValue(_:by:error:)')
void subtract(int x, int y);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message,
contains('Invalid function signature, expected 2 arguments'));
});
test('custom swift function signature no arguments', () {
const String code = '''
@HostApi()
abstract class Api {
@SwiftFunction('foobar()')
void initialize();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis.length, 1);
expect(results.root.apis[0].methods.length, equals(1));
expect(results.root.apis[0].methods[0].swiftFunction, equals('foobar()'));
});
test('dart test has copyright', () {
final Root root = Root(apis: <Api>[], classes: <Class>[], enums: <Enum>[]);
const PigeonOptions options = PigeonOptions(
copyrightHeader: './copyright_header.txt',
dartTestOut: 'stdout',
dartOut: 'stdout',
);
final DartTestGeneratorAdapter dartTestGeneratorAdapter =
DartTestGeneratorAdapter();
final StringBuffer buffer = StringBuffer();
dartTestGeneratorAdapter.generate(buffer, options, root, FileType.source);
expect(buffer.toString(), startsWith('// Copyright 2013'));
});
test('only class reference is type argument for return value', () {
const String code = '''
class Foo {
int? foo;
}
@HostApi()
abstract class Api {
List<Foo?> grabAll();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.classes.length, 1);
expect(results.root.classes[0].name, 'Foo');
});
test('only class reference is type argument for argument', () {
const String code = '''
class Foo {
int? foo;
}
@HostApi()
abstract class Api {
void storeAll(List<Foo?> foos);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.classes.length, 1);
expect(results.root.classes[0].name, 'Foo');
});
test('recurse into type arguments', () {
const String code = '''
class Foo {
int? foo;
List<Bar?> bars;
}
class Bar {
int? bar;
}
@HostApi()
abstract class Api {
void storeAll(List<Foo?> foos);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.classes.length, 2);
expect(
results.root.classes
.where((Class element) => element.name == 'Foo')
.length,
1);
expect(
results.root.classes
.where((Class element) => element.name == 'Bar')
.length,
1);
});
test('undeclared class in argument type argument', () {
const String code = '''
@HostApi()
abstract class Api {
void storeAll(List<Foo?> foos);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].lineNumber, 3);
expect(results.errors[0].message, contains('Unknown type: Foo'));
});
test('Object type argument', () {
const String code = '''
@HostApi()
abstract class Api {
void storeAll(List<Object?> foos);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
});
test('Enum key not supported', () {
const String code = '''
enum MessageKey {
title,
subtitle,
description,
}
class Message {
int? id;
Map<MessageKey?, String?>? additionalProperties;
}
@HostApi()
abstract class HostApiBridge {
void sendMessage(Message message);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
});
test('Export unreferenced enums', () {
const String code = '''
enum MessageKey {
title,
subtitle,
description,
}
class Message {
int? id;
Map<int?, String?>? additionalProperties;
}
@HostApi()
abstract class HostApiBridge {
void sendMessage(Message message);
}
''';
final ParseResults results = parseSource(code);
expect(results.root.enums.length, 1);
expect(results.root.enums[0].name, 'MessageKey');
});
test('@ConfigurePigeon JavaOptions.copyrightHeader', () {
const String code = '''
@ConfigurePigeon(PigeonOptions(
javaOptions: JavaOptions(copyrightHeader: <String>['A', 'Header']),
))
class Message {
int? id;
}
''';
final ParseResults results = parseSource(code);
final PigeonOptions options = PigeonOptions.fromMap(results.pigeonOptions!);
expect(options.javaOptions!.copyrightHeader, <String>['A', 'Header']);
});
test('@ConfigurePigeon DartOptions.copyrightHeader', () {
const String code = '''
@ConfigurePigeon(PigeonOptions(
dartOptions: DartOptions(copyrightHeader: <String>['A', 'Header']),
))
class Message {
int? id;
}
''';
final ParseResults results = parseSource(code);
final PigeonOptions options = PigeonOptions.fromMap(results.pigeonOptions!);
expect(options.dartOptions!.copyrightHeader, <String>['A', 'Header']);
});
test('@ConfigurePigeon ObjcOptions.copyrightHeader', () {
const String code = '''
@ConfigurePigeon(PigeonOptions(
objcOptions: ObjcOptions(copyrightHeader: <String>['A', 'Header']),
))
class Message {
int? id;
}
''';
final ParseResults results = parseSource(code);
final PigeonOptions options = PigeonOptions.fromMap(results.pigeonOptions!);
expect(options.objcOptions!.copyrightHeader, <String>['A', 'Header']);
});
test('return nullable', () {
const String code = '''
@HostApi()
abstract class Api {
int? calc();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis[0].methods[0].returnType.isNullable, isTrue);
});
test('nullable parameters', () {
const String code = '''
@HostApi()
abstract class Api {
void calc(int? value);
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(
results.root.apis[0].methods[0].arguments[0].type.isNullable, isTrue);
});
test('task queue specified', () {
const String code = '''
@HostApi()
abstract class Api {
@TaskQueue(type: TaskQueueType.serialBackgroundThread)
int? calc();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis[0].methods[0].taskQueueType,
equals(TaskQueueType.serialBackgroundThread));
});
test('task queue unspecified', () {
const String code = '''
@HostApi()
abstract class Api {
int? calc();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 0);
expect(results.root.apis[0].methods[0].taskQueueType,
equals(TaskQueueType.serial));
});
test('unsupported task queue on FlutterApi', () {
const String code = '''
@FlutterApi()
abstract class Api {
@TaskQueue(type: TaskQueueType.serialBackgroundThread)
int? calc();
}
''';
final ParseResults results = parseSource(code);
expect(results.errors.length, 1);
expect(results.errors[0].message,
contains('Unsupported TaskQueue specification'));
});
test('generator validation', () async {
final Completer<void> completer = Completer<void>();
withTempFile('foo.dart', (File input) async {
final _ValidatorGeneratorAdapter generator =
_ValidatorGeneratorAdapter(stdout);
final int result = await Pigeon.run(<String>['--input', input.path],
adapters: <GeneratorAdapter>[generator]);
expect(generator.didCallValidate, isTrue);
expect(result, isNot(0));
completer.complete();
});
await completer.future;
});
test('generator validation skipped', () async {
final Completer<void> completer = Completer<void>();
withTempFile('foo.dart', (File input) async {
final _ValidatorGeneratorAdapter generator =
_ValidatorGeneratorAdapter(null);
final int result = await Pigeon.run(
<String>['--input', input.path, '--dart_out', 'foo.dart'],
adapters: <GeneratorAdapter>[generator]);
expect(generator.didCallValidate, isFalse);
expect(result, equals(0));
completer.complete();
});
await completer.future;
});
test('run with PigeonOptions', () async {
final Completer<void> completer = Completer<void>();
withTempFile('foo.dart', (File input) async {
final _ValidatorGeneratorAdapter generator =
_ValidatorGeneratorAdapter(null);
final int result = await Pigeon.runWithOptions(
PigeonOptions(input: input.path, dartOut: 'foo.dart'),
adapters: <GeneratorAdapter>[generator]);
expect(generator.didCallValidate, isFalse);
expect(result, equals(0));
completer.complete();
});
await completer.future;
});
}