| // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file |
| // for details. 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:code_builder/code_builder.dart'; |
| import 'package:test/test.dart'; |
| |
| import '../../common.dart'; |
| |
| void main() { |
| useDartfmt(); |
| |
| test('should emit a simple expression', () { |
| expect(literalNull, equalsDart('null')); |
| }); |
| |
| group('literal', () { |
| test('forwards values that are already expressions', () { |
| expect(literal(refer('foo')), equalsDart('foo')); |
| expect(literal([refer('foo')]), equalsDart('[foo]')); |
| }); |
| group('wraps', () { |
| test('bool values', () { |
| expect(literal(true), equalsDart('true')); |
| }); |
| test('numeric values', () { |
| expect(literal(1), equalsDart('1')); |
| expect(literal(1.0), equalsDart('1.0')); |
| }); |
| test('string values', () { |
| expect(literal('foo'), equalsDart("'foo'")); |
| }); |
| test('list values', () { |
| expect(literal([1]), equalsDart('[1]')); |
| }); |
| test('set values', () { |
| expect(literal({1}), equalsDart('{1}')); |
| }); |
| test('map values', () { |
| expect(literal({'foo': 1}), equalsDart("{'foo': 1}")); |
| }); |
| test('null', () { |
| expect(literal(null), equalsDart('null')); |
| }); |
| }); |
| test('uses `onError` for unhandled types', () { |
| expect( |
| literal( |
| Uri.https('google.com'), |
| onError: (value) { |
| if (value is Uri) { |
| return refer( |
| 'Uri', |
| ).newInstanceNamed('parse', [literalString(value.toString())]); |
| } |
| throw UnsupportedError('Not supported: $value'); |
| }, |
| ), |
| equalsDart("Uri.parse('https://google.com')"), |
| ); |
| }); |
| }); |
| |
| test('should emit a String', () { |
| expect(literalString(r'$monkey'), equalsDart(r"'$monkey'")); |
| }); |
| |
| test('should emit a raw String', () { |
| expect(literalString(r'$monkey', raw: true), equalsDart(r"r'$monkey'")); |
| }); |
| |
| test('should escape single quotes in a String', () { |
| expect(literalString(r"don't"), equalsDart(r"'don\'t'")); |
| }); |
| |
| test('does not allow single quote in raw string', () { |
| expect(() => literalString(r"don't", raw: true), throwsArgumentError); |
| }); |
| |
| test('should escape a newline in a string', () { |
| expect(literalString('some\nthing'), equalsDart(r"'some\nthing'")); |
| }); |
| |
| test('should emit a && expression', () { |
| expect(literalTrue.and(literalFalse), equalsDart('true && false')); |
| }); |
| |
| test('should emit a || expression', () { |
| expect(literalTrue.or(literalFalse), equalsDart('true || false')); |
| }); |
| |
| test('should emit a ! expression', () { |
| expect(literalTrue.negate(), equalsDart('!true')); |
| }); |
| |
| test('should emit a list', () { |
| expect(literalList([]), equalsDart('[]')); |
| }); |
| |
| test('should emit a const list', () { |
| expect(literalConstList([]), equalsDart('const []')); |
| }); |
| |
| test('should emit an explicitly typed list', () { |
| expect(literalList([], refer('int')), equalsDart('<int>[]')); |
| }); |
| |
| test('should emit a set', () { |
| // ignore: prefer_collection_literals |
| expect(literalSet(Set()), equalsDart('{}')); |
| }); |
| |
| test('should emit a const set', () { |
| // ignore: prefer_collection_literals |
| expect(literalConstSet(Set()), equalsDart('const {}')); |
| }); |
| |
| test('should emit an explicitly typed set', () { |
| // ignore: prefer_collection_literals |
| expect(literalSet(Set(), refer('int')), equalsDart('<int>{}')); |
| }); |
| |
| test('should emit a map', () { |
| expect(literalMap({}), equalsDart('{}')); |
| }); |
| |
| test('should emit a const map', () { |
| expect(literalConstMap({}), equalsDart('const {}')); |
| }); |
| |
| test('should emit an explicitly typed map', () { |
| expect( |
| literalMap({}, refer('int'), refer('bool')), |
| equalsDart('<int, bool>{}'), |
| ); |
| }); |
| |
| test('should emit a map of other literals and expressions', () { |
| expect( |
| literalMap({ |
| 1: 'one', |
| 2: refer('two'), |
| refer('three'): 3, |
| refer('Map').newInstance([]): null, |
| }), |
| equalsDart(r"{1: 'one', 2: two, three: 3, Map(): null, }"), |
| ); |
| }); |
| |
| test('should emit a map with spreads', () { |
| expect( |
| literalMap({ |
| literalSpread(): refer('one'), |
| 2: refer('two'), |
| literalNullSafeSpread(): refer('three'), |
| refer('Map').newInstance([]): null, |
| }), |
| equalsDart('{...one, 2: two, ...?three, Map(): null, }'), |
| ); |
| }); |
| |
| test('should emit a list of other literals and expressions', () { |
| expect( |
| literalList([ |
| <dynamic>[], |
| // ignore: prefer_collection_literals |
| Set<dynamic>(), |
| true, |
| null, |
| refer('Map').newInstance([]), |
| ]), |
| equalsDart('[[], {}, true, null, Map(), ]'), |
| ); |
| }); |
| |
| test('can toString a list literal with an expression as a value', () { |
| expect(literalList([refer('foo')]).toString, isNot(throwsA(anything))); |
| }); |
| |
| test('should emit a set of other literals and expressions', () { |
| expect( |
| literalSet([ |
| <dynamic>[], |
| // ignore: prefer_collection_literals |
| Set<dynamic>(), |
| true, |
| null, |
| refer('Map').newInstance([]), |
| ]), |
| equalsDart('{[], {}, true, null, Map(), }'), |
| ); |
| }); |
| |
| test('should emit an empty record', () { |
| expect(literalRecord([], {}), equalsDart('()')); |
| }); |
| |
| test('should emit a const empty record', () { |
| expect(literalConstRecord([], {}), equalsDart('const ()')); |
| }); |
| |
| test('should emit a record with only positional fields', () { |
| expect(literalRecord([1, ''], {}), equalsDart("(1, '')")); |
| }); |
| |
| test('should correctly emit a record with a single positional field', () { |
| expect(literalRecord([1], {}), equalsDart('(1,)')); |
| }); |
| |
| test('should emit a record with only named fields', () { |
| expect( |
| literalRecord([], {'named': 1, 'other': []}), |
| equalsDart('(named: 1, other: [])'), |
| ); |
| }); |
| |
| test('should emit a record with both positional and named fields', () { |
| expect( |
| literalRecord([0], {'x': true, 'y': 0}), |
| equalsDart('(0, x: true, y: 0)'), |
| ); |
| }); |
| |
| test('should emit a record of other literals and expressions', () { |
| expect( |
| literalRecord( |
| [1, refer('one'), 'one'], |
| { |
| 'named': refer('Foo').newInstance([literalNum(1)]), |
| }, |
| ), |
| equalsDart("(1, one, 'one', named: Foo(1))"), |
| ); |
| }); |
| |
| test('should emit a type as an expression', () { |
| expect(refer('Map'), equalsDart('Map')); |
| }); |
| |
| test('should emit a scoped type as an expression', () { |
| expect( |
| refer('Foo', 'package:foo/foo.dart'), |
| equalsDart( |
| '_i1.Foo', |
| DartEmitter(allocator: Allocator.simplePrefixing()), |
| ), |
| ); |
| }); |
| |
| test('should emit invoking Type()', () { |
| expect(refer('Map').newInstance([]), equalsDart('Map()')); |
| }); |
| |
| test('should emit invoking named constructor', () { |
| expect(refer('Foo').newInstanceNamed('bar', []), equalsDart('Foo.bar()')); |
| }); |
| |
| test('should emit invoking unnamed constructor when name is empty', () { |
| expect(refer('Foo').newInstanceNamed('', []), equalsDart('Foo()')); |
| }); |
| |
| test('should emit invoking const Type()', () { |
| expect(refer('Object').constInstance([]), equalsDart('const Object()')); |
| }); |
| |
| test('should emit invoking a property accessor', () { |
| expect(refer('foo').property('bar'), equalsDart('foo.bar')); |
| }); |
| |
| test('should emit invoking a cascade property accessor', () { |
| expect(refer('foo').cascade('bar'), equalsDart('foo..bar')); |
| }); |
| |
| test('should emit invoking a null safe property accessor', () { |
| expect(refer('foo').nullSafeProperty('bar'), equalsDart('foo?.bar')); |
| }); |
| |
| test('should emit invoking a method with a single positional argument', () { |
| expect(refer('foo').call([literal(1)]), equalsDart('foo(1)')); |
| }); |
| |
| test('should emit invoking a method with positional arguments', () { |
| expect( |
| refer('foo').call([literal(1), literal(2), literal(3)]), |
| equalsDart('foo(1, 2, 3, )'), |
| ); |
| }); |
| |
| test('should emit invoking a method with a single named argument', () { |
| expect( |
| refer('foo').call([], {'bar': literal(1)}), |
| equalsDart('foo(bar: 1)'), |
| ); |
| }); |
| |
| test('should emit invoking a method with named arguments', () { |
| expect( |
| refer('foo').call([], {'bar': literal(1), 'baz': literal(2)}), |
| equalsDart('foo(bar: 1, baz: 2, )'), |
| ); |
| }); |
| |
| test('should emit invoking a method with positional and named arguments', () { |
| expect( |
| refer('foo').call([literal(1)], {'bar': literal(2), 'baz': literal(3)}), |
| equalsDart('foo(1, bar: 2, baz: 3, )'), |
| ); |
| }); |
| |
| test('should emit invoking a method with a single type argument', () { |
| expect( |
| refer('foo').call([], {}, [refer('String')]), |
| equalsDart('foo<String>()'), |
| ); |
| }); |
| |
| test('should emit invoking a method with type arguments', () { |
| expect( |
| refer('foo').call([], {}, [refer('String'), refer('int')]), |
| equalsDart('foo<String, int>()'), |
| ); |
| }); |
| |
| test('should emit a function type', () { |
| expect( |
| FunctionType((b) => b.returnType = refer('void')), |
| equalsDart('void Function()'), |
| ); |
| }); |
| |
| test('should emit a typedef statement', () { |
| expect( |
| FunctionType((b) => b.returnType = refer('void')).toTypeDef('Void0'), |
| equalsDart('typedef Void0 = void Function();'), |
| ); |
| }); |
| |
| test('should emit a function type with type parameters', () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..returnType = refer('T') |
| ..types.add(refer('T')), |
| ), |
| equalsDart('T Function<T>()'), |
| ); |
| }); |
| |
| test('should emit a function type a single parameter', () { |
| expect( |
| FunctionType((b) => b..requiredParameters.add(refer('String'))), |
| equalsDart('Function(String)'), |
| ); |
| }); |
| |
| test('should emit a function type with parameters', () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..requiredParameters.add(refer('String')) |
| ..optionalParameters.add(refer('int')), |
| ), |
| equalsDart('Function(String, [int, ])'), |
| ); |
| }); |
| |
| test('should emit a function type with named parameters', () { |
| expect( |
| FunctionType( |
| (b) => |
| b..namedParameters.addAll({'x': refer('int'), 'y': refer('int')}), |
| ), |
| equalsDart('Function({int x, int y, })'), |
| ); |
| }); |
| |
| test( |
| 'should emit a function type with named required and optional parameters', |
| () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..namedRequiredParameters.addAll({'x': refer('int')}) |
| ..namedParameters.addAll({'y': refer('int')}), |
| ), |
| equalsDart('Function({required int x, int y, })'), |
| ); |
| }, |
| ); |
| |
| test('should emit a function type with named required parameters', () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..namedRequiredParameters.addAll({ |
| 'x': refer('int'), |
| 'y': refer('int'), |
| }), |
| ), |
| equalsDart('Function({required int x, required int y, })'), |
| ); |
| }); |
| |
| test('should emit a nullable function type in a Null Safety library', () { |
| final emitter = DartEmitter.scoped(useNullSafetySyntax: true); |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..requiredParameters.add(refer('String')) |
| ..isNullable = true, |
| ), |
| equalsDart('Function(String)?', emitter), |
| ); |
| }); |
| |
| test('should emit a nullable function type in pre-Null Safety library', () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..requiredParameters.add(refer('String')) |
| ..isNullable = true, |
| ), |
| equalsDart('Function(String)'), |
| ); |
| }); |
| |
| test('should emit a non-nullable function type in a Null Safety library', () { |
| final emitter = DartEmitter.scoped(useNullSafetySyntax: true); |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..requiredParameters.add(refer('String')) |
| ..isNullable = false, |
| ), |
| equalsDart('Function(String)', emitter), |
| ); |
| }); |
| |
| test( |
| 'should emit a non-nullable function type in pre-Null Safety library', |
| () { |
| expect( |
| FunctionType( |
| (b) => |
| b |
| ..requiredParameters.add(refer('String')) |
| ..isNullable = false, |
| ), |
| equalsDart('Function(String)'), |
| ); |
| }, |
| ); |
| |
| test('should emit a closure', () { |
| expect( |
| refer('map').property('putIfAbsent').call([ |
| literalString('foo'), |
| Method((b) => b..body = literalTrue.code).closure, |
| ]), |
| equalsDart("map.putIfAbsent('foo', () => true, )"), |
| ); |
| }); |
| |
| test('should emit a generic closure', () { |
| expect( |
| refer('map').property('putIfAbsent').call([ |
| literalString('foo'), |
| Method( |
| (b) => |
| b |
| ..types.add(refer('T')) |
| ..body = literalTrue.code, |
| ).genericClosure, |
| ]), |
| equalsDart("map.putIfAbsent('foo', <T>() => true, )"), |
| ); |
| }); |
| |
| test('should emit an assignment', () { |
| expect(refer('foo').assign(literalTrue), equalsDart('foo = true')); |
| }); |
| |
| test('should emit an if null assignment', () { |
| expect(refer('foo').ifNullThen(literalTrue), equalsDart('foo ?? true')); |
| }); |
| |
| test('should emit a null check', () { |
| expect(refer('foo').nullChecked, equalsDart('foo!')); |
| }); |
| |
| test('should emit an if null index operator set', () { |
| expect( |
| refer('bar') |
| .index(literalTrue) |
| .ifNullThen(literalFalse) |
| // ignore: deprecated_member_use_from_same_package |
| .assignVar('foo') |
| .statement, |
| equalsDart('var foo = bar[true] ?? false;'), |
| ); |
| }); |
| |
| test('should emit a null-aware assignment', () { |
| expect( |
| refer('foo').assignNullAware(literalTrue), |
| equalsDart('foo ??= true'), |
| ); |
| }); |
| |
| test('should emit an index operator', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| refer('bar').index(literalString('key')).assignVar('foo').statement, |
| equalsDart("var foo = bar['key'];"), |
| ); |
| }); |
| |
| test('should emit an index operator set', () { |
| expect( |
| refer('bar') |
| .index(literalString('key')) |
| .assign(literalFalse) |
| // ignore: deprecated_member_use_from_same_package |
| .assignVar('foo') |
| .statement, |
| equalsDart("var foo = bar['key'] = false;"), |
| ); |
| }); |
| |
| test('should emit a null-aware index operator set', () { |
| expect( |
| refer('bar') |
| .index(literalTrue) |
| .assignNullAware(literalFalse) |
| // ignore: deprecated_member_use_from_same_package |
| .assignVar('foo') |
| .statement, |
| equalsDart('var foo = bar[true] ??= false;'), |
| ); |
| }); |
| |
| test('should emit assigning to a var', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| literalTrue.assignVar('foo'), |
| equalsDart('var foo = true'), |
| ); |
| }); |
| |
| test('should emit assigning to a type', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| literalTrue.assignVar('foo', refer('bool')), |
| equalsDart('bool foo = true'), |
| ); |
| }); |
| |
| test('should emit assigning to a final', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| literalTrue.assignFinal('foo'), |
| equalsDart('final foo = true'), |
| ); |
| }); |
| |
| test('should emit assigning to a const', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| literalTrue.assignConst('foo'), |
| equalsDart('const foo = true'), |
| ); |
| }); |
| |
| test('should emit await', () { |
| expect(refer('future').awaited, equalsDart('await future')); |
| }); |
| |
| test('should emit return', () { |
| expect(literalNull.returned, equalsDart('return null')); |
| }); |
| |
| test('should emit spread', () { |
| expect(refer('foo').spread, equalsDart('...foo')); |
| }); |
| |
| test('should emit null safe spread', () { |
| expect(refer('foo').nullSafeSpread, equalsDart('...?foo')); |
| }); |
| |
| test('should emit throw', () { |
| expect(literalNull.thrown, equalsDart('throw null')); |
| }); |
| |
| test('should emit an explicit cast', () { |
| expect( |
| refer('foo').asA(refer('String')).property('length'), |
| equalsDart('(foo as String).length'), |
| ); |
| }); |
| |
| test('should emit an is check', () { |
| expect(refer('foo').isA(refer('String')), equalsDart('foo is String')); |
| }); |
| |
| test('should emit an is! check', () { |
| expect(refer('foo').isNotA(refer('String')), equalsDart('foo is! String')); |
| }); |
| |
| test('should emit an equality check', () { |
| expect( |
| refer('foo').equalTo(literalString('bar')), |
| equalsDart("foo == 'bar'"), |
| ); |
| }); |
| |
| test('should emit an inequality check', () { |
| expect( |
| refer('foo').notEqualTo(literalString('bar')), |
| equalsDart("foo != 'bar'"), |
| ); |
| }); |
| |
| test('should emit an greater than check', () { |
| expect( |
| refer('foo').greaterThan(literalString('bar')), |
| equalsDart("foo > 'bar'"), |
| ); |
| }); |
| |
| test('should emit an less than check', () { |
| expect( |
| refer('foo').lessThan(literalString('bar')), |
| equalsDart("foo < 'bar'"), |
| ); |
| }); |
| |
| test('should emit an greater or equals check', () { |
| expect( |
| refer('foo').greaterOrEqualTo(literalString('bar')), |
| equalsDart("foo >= 'bar'"), |
| ); |
| }); |
| |
| test('should emit an less or equals check', () { |
| expect( |
| refer('foo').lessOrEqualTo(literalString('bar')), |
| equalsDart("foo <= 'bar'"), |
| ); |
| }); |
| |
| test('should emit a conditional', () { |
| expect( |
| refer('foo').conditional(literal(1), literal(2)), |
| equalsDart('foo ? 1 : 2'), |
| ); |
| }); |
| |
| test('should emit an operator add call', () { |
| expect(refer('foo').operatorAdd(refer('foo2')), equalsDart('foo + foo2')); |
| }); |
| |
| test('should emit an operator subtract call', () { |
| expect( |
| // ignore: deprecated_member_use_from_same_package |
| refer('foo').operatorSubstract(refer('foo2')), |
| equalsDart('foo - foo2'), |
| ); |
| |
| expect( |
| refer('foo').operatorSubtract(refer('foo2')), |
| equalsDart('foo - foo2'), |
| ); |
| }); |
| |
| test('should emit an operator divide call', () { |
| expect( |
| refer('foo').operatorDivide(refer('foo2')), |
| equalsDart('foo / foo2'), |
| ); |
| }); |
| |
| test('should emit an operator multiply call', () { |
| expect( |
| refer('foo').operatorMultiply(refer('foo2')), |
| equalsDart('foo * foo2'), |
| ); |
| }); |
| |
| test('should emit an euclidean modulo operator call', () { |
| expect( |
| refer('foo').operatorEuclideanModulo(refer('foo2')), |
| equalsDart('foo % foo2'), |
| ); |
| }); |
| |
| test('should emit an operator int divide call', () { |
| expect( |
| refer('foo').operatorIntDivide(refer('foo2')), |
| equalsDart('foo ~/ foo2'), |
| ); |
| }); |
| |
| test('should emit a unary prefix increment operator call', () { |
| expect(refer('foo').operatorUnaryPrefixIncrement(), equalsDart('++foo')); |
| }); |
| |
| test('should emit a unary postfix increment operator call', () { |
| expect(refer('foo').operatorUnaryPostfixIncrement(), equalsDart('foo++')); |
| }); |
| |
| test('should emit a unary prefix minus operator call', () { |
| expect(refer('foo').operatorUnaryMinus(), equalsDart('-foo')); |
| }); |
| |
| test('should emit a unary prefix decrement operator call', () { |
| expect(refer('foo').operatorUnaryPrefixDecrement(), equalsDart('--foo')); |
| }); |
| |
| test('should emit a unary postfix decrement operator call', () { |
| expect(refer('foo').operatorUnaryPostfixDecrement(), equalsDart('foo--')); |
| }); |
| |
| test('should emit a bitwise AND operator call', () { |
| expect( |
| refer('foo').operatorBitwiseAnd(refer('foo2')), |
| equalsDart('foo & foo2'), |
| ); |
| }); |
| |
| test('should emit a bitwise OR operator call', () { |
| expect( |
| refer('foo').operatorBitwiseOr(refer('foo2')), |
| equalsDart('foo | foo2'), |
| ); |
| }); |
| |
| test('should emit a bitwise XOR operator call', () { |
| expect( |
| refer('foo').operatorBitwiseXor(refer('foo2')), |
| equalsDart('foo ^ foo2'), |
| ); |
| }); |
| |
| test('should emit a unary bitwise complement operator call', () { |
| expect(refer('foo').operatorUnaryBitwiseComplement(), equalsDart('~foo')); |
| }); |
| |
| test('should emit a shift left operator call', () { |
| expect( |
| refer('foo').operatorShiftLeft(refer('foo2')), |
| equalsDart('foo << foo2'), |
| ); |
| }); |
| |
| test('should emit a shift right operator call', () { |
| expect( |
| refer('foo').operatorShiftRight(refer('foo2')), |
| equalsDart('foo >> foo2'), |
| ); |
| }); |
| |
| test('should emit a shift right unsigned operator call', () { |
| expect( |
| refer('foo').operatorShiftRightUnsigned(refer('foo2')), |
| equalsDart('foo >>> foo2'), |
| ); |
| }); |
| |
| test('should emit a const variable declaration', () { |
| expect( |
| declareConst('foo').assign(refer('bar')), |
| equalsDart('const foo = bar'), |
| ); |
| }); |
| |
| test('should emit a typed const variable declaration', () { |
| expect( |
| declareConst('foo', type: refer('String')).assign(refer('bar')), |
| equalsDart('const String foo = bar'), |
| ); |
| }); |
| |
| test('should emit a final variable declaration', () { |
| expect( |
| declareFinal('foo').assign(refer('bar')), |
| equalsDart('final foo = bar'), |
| ); |
| }); |
| |
| test('should emit a typed final variable declaration', () { |
| expect( |
| declareFinal('foo', type: refer('String')).assign(refer('bar')), |
| equalsDart('final String foo = bar'), |
| ); |
| }); |
| |
| test( |
| 'should emit a nullable typed final variable declaration', |
| () { |
| final emitter = DartEmitter.scoped(useNullSafetySyntax: true); |
| expect( |
| declareFinal( |
| 'foo', |
| type: TypeReference( |
| (b) => |
| b |
| ..symbol = 'String' |
| ..isNullable = true, |
| ), |
| ).assign(refer('bar')), |
| equalsDart('final String? foo = bar', emitter), |
| ); |
| }, |
| skip: 'https://github.com/dart-lang/code_builder/issues/315', |
| ); |
| |
| test('should emit a late final variable declaration', () { |
| expect( |
| declareFinal('foo', late: true).assign(refer('bar')), |
| equalsDart('late final foo = bar'), |
| ); |
| }); |
| |
| test('should emit a late typed final variable declaration', () { |
| expect( |
| declareFinal( |
| 'foo', |
| type: refer('String'), |
| late: true, |
| ).assign(refer('bar')), |
| equalsDart('late final String foo = bar'), |
| ); |
| }); |
| |
| test('should emit a variable declaration', () { |
| expect(declareVar('foo').assign(refer('bar')), equalsDart('var foo = bar')); |
| }); |
| |
| test('should emit a typed variable declaration', () { |
| expect( |
| declareVar('foo', type: refer('String')).assign(refer('bar')), |
| equalsDart('String foo = bar'), |
| ); |
| }); |
| |
| test('should emit a late variable declaration', () { |
| expect( |
| declareVar('foo', late: true).assign(refer('bar')), |
| equalsDart('late var foo = bar'), |
| ); |
| }); |
| |
| test('should emit a late typed variable declaration', () { |
| expect( |
| declareVar('foo', type: refer('String'), late: true).assign(refer('bar')), |
| equalsDart('late String foo = bar'), |
| ); |
| }); |
| |
| test('should emit a perenthesized epression', () { |
| expect( |
| refer('foo').ifNullThen( |
| refer( |
| 'FormatException', |
| ).newInstance([literalString('missing foo')]).thrown.parenthesized, |
| ), |
| equalsDart('foo ?? (throw FormatException(\'missing foo\'))'), |
| ); |
| }); |
| |
| test('should emit an addition assigment expression', () { |
| expect(refer('foo').addAssign(refer('bar')), equalsDart('foo += bar')); |
| }); |
| |
| test('should emit a subtraction assigment expression', () { |
| expect(refer('foo').subtractAssign(refer('bar')), equalsDart('foo -= bar')); |
| }); |
| |
| test('should emit a multiplication assigment expression', () { |
| expect(refer('foo').multiplyAssign(refer('bar')), equalsDart('foo *= bar')); |
| }); |
| |
| test('should emit a division assigment expression', () { |
| expect(refer('foo').divideAssign(refer('bar')), equalsDart('foo /= bar')); |
| }); |
| |
| test('should emit an int division assigment expression', () { |
| expect( |
| refer('foo').intDivideAssign(refer('bar')), |
| equalsDart('foo ~/= bar'), |
| ); |
| }); |
| |
| test('should emit a euclidean modulo assigment expression', () { |
| expect( |
| refer('foo').euclideanModuloAssign(refer('bar')), |
| equalsDart('foo %= bar'), |
| ); |
| }); |
| |
| test('should emit a shift left assigment expression', () { |
| expect( |
| refer('foo').shiftLeftAssign(refer('bar')), |
| equalsDart('foo <<= bar'), |
| ); |
| }); |
| |
| test('should emit a shift right assigment expression', () { |
| expect( |
| refer('foo').shiftRightAssign(refer('bar')), |
| equalsDart('foo >>= bar'), |
| ); |
| }); |
| |
| test('should emit a shift right unsigned assigment expression', () { |
| expect( |
| refer('foo').shiftRightUnsignedAssign(refer('bar')), |
| equalsDart('foo >>>= bar'), |
| ); |
| }); |
| |
| test('should emit a bitwise AND assigment expression', () { |
| expect( |
| refer('foo').bitwiseAndAssign(refer('bar')), |
| equalsDart('foo &= bar'), |
| ); |
| }); |
| |
| test('should emit a bitwise XOR assigment expression', () { |
| expect( |
| refer('foo').bitwiseXorAssign(refer('bar')), |
| equalsDart('foo ^= bar'), |
| ); |
| }); |
| |
| test('should emit a bitwise OR assigment expression', () { |
| expect( |
| refer('foo').bitwiseOrAssign(refer('bar')), |
| equalsDart('foo |= bar'), |
| ); |
| }); |
| } |
