| // Copyright (c) 2013, 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:unittest/unittest.dart'; |
| |
| import 'package:analyzer_experimental/src/generated/scanner.dart'; |
| import 'package:analyzer_experimental/src/services/formatter_impl.dart'; |
| import 'package:analyzer_experimental/src/services/writer.dart'; |
| |
| main() { |
| |
| /// Formatter tests |
| group('formatter', () { |
| |
| test('failed parse', () { |
| var formatter = new CodeFormatter(); |
| expect(() => formatter.format(CodeKind.COMPILATION_UNIT, '~'), |
| throwsA(new isInstanceOf<FormatterException>())); |
| }); |
| |
| test('CU (1)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' var z;\n' |
| ' inc(int x) => ++x;\n' |
| '}\n', |
| 'class A {\n' |
| ' var z;\n' |
| ' inc(int x) => ++x;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (2)', () { |
| expectCUFormatsTo( |
| 'class A { \n' |
| '}\n', |
| 'class A {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (3)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' }', |
| 'class A {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (4)', () { |
| expectCUFormatsTo( |
| ' class A {\n' |
| '}\n', |
| 'class A {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (5)', () { |
| expectCUFormatsTo( |
| 'class A { int meaningOfLife() => 42; }', |
| 'class A {\n' |
| ' int meaningOfLife() => 42;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - EOL comments', () { |
| expectCUFormatsTo( |
| '//comment one\n\n' |
| '//comment two\n\n', |
| '//comment one\n\n' |
| '//comment two\n\n' |
| ); |
| expectCUFormatsTo( |
| 'var x; //x\n', |
| 'var x; //x\n' |
| ); |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '\n' |
| '//comment one\n' |
| '\n' |
| 'class C {\n' |
| '}\n', |
| 'library foo;\n' |
| '\n' |
| '//comment one\n' |
| '\n' |
| 'class C {\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '\n' |
| '//comment one\n' |
| '\n' |
| '//comment two\n' |
| '\n' |
| 'class C {\n' |
| '}\n', |
| 'library foo;\n' |
| '\n' |
| '//comment one\n' |
| '\n' |
| '//comment two\n' |
| '\n' |
| 'class C {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - nested functions', () { |
| expectCUFormatsTo( |
| 'x() {\n' |
| ' y() {\n' |
| ' }\n' |
| '}\n', |
| 'x() {\n' |
| ' y() {\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - top level', () { |
| expectCUFormatsTo( |
| '\n\n' |
| 'foo() {\n' |
| '}\n' |
| 'bar() {\n' |
| '}\n', |
| '\n\n' |
| 'foo() {\n' |
| '}\n' |
| 'bar() {\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'const A = 42;\n' |
| 'final foo = 32;\n', |
| 'const A = 42;\n' |
| 'final foo = 32;\n' |
| ); |
| }); |
| |
| test('CU - imports', () { |
| expectCUFormatsTo( |
| 'import "dart:io";\n\n' |
| 'import "package:unittest/unittest.dart";\n' |
| 'foo() {\n' |
| '}\n', |
| 'import "dart:io";\n\n' |
| 'import "package:unittest/unittest.dart";\n' |
| 'foo() {\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'library a; class B { }', |
| 'library a;\n' |
| 'class B {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - method invocations', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' foo() {\n' |
| ' bar();\n' |
| ' for (int i = 0; i < 42; i++) {\n' |
| ' baz();\n' |
| ' }\n' |
| ' }\n' |
| '}\n', |
| 'class A {\n' |
| ' foo() {\n' |
| ' bar();\n' |
| ' for (int i = 0; i < 42; i++) {\n' |
| ' baz();\n' |
| ' }\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU w/class decl comment', () { |
| expectCUFormatsTo( |
| 'import "foo";\n\n' |
| '//Killer class\n' |
| 'class A {\n' |
| '}', |
| 'import "foo";\n\n' |
| '//Killer class\n' |
| 'class A {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (method body)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' foo(path) {\n' |
| ' var buffer = new StringBuffer();\n' |
| ' var file = new File(path);\n' |
| ' return file;\n' |
| ' }\n' |
| '}\n', |
| 'class A {\n' |
| ' foo(path) {\n' |
| ' var buffer = new StringBuffer();\n' |
| ' var file = new File(path);\n' |
| ' return file;\n' |
| ' }\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' foo(files) {\n' |
| ' for (var file in files) {\n' |
| ' print(file);\n' |
| ' }\n' |
| ' }\n' |
| '}\n', |
| 'class A {\n' |
| ' foo(files) {\n' |
| ' for (var file in files) {\n' |
| ' print(file);\n' |
| ' }\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (method indent)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| 'void x(){\n' |
| '}\n' |
| '}\n', |
| 'class A {\n' |
| ' void x() {\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (method indent - 2)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' static bool x(){\n' |
| 'return true; }\n' |
| ' }\n', |
| 'class A {\n' |
| ' static bool x() {\n' |
| ' return true;\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (method indent - 3)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int x() => 42 + 3 ; \n' |
| ' }\n', |
| 'class A {\n' |
| ' int x() => 42 + 3;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (method indent - 4)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int x() { \n' |
| 'if (true) {\n' |
| 'return 42;\n' |
| '} else {\n' |
| 'return 13;\n }\n' |
| ' }' |
| '}\n', |
| 'class A {\n' |
| ' int x() {\n' |
| ' if (true) {\n' |
| ' return 42;\n' |
| ' } else {\n' |
| ' return 13;\n' |
| ' }\n' |
| ' }\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (multiple members)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| '}\n' |
| 'class B {\n' |
| '}\n', |
| 'class A {\n' |
| '}\n' |
| 'class B {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU (multiple members w/blanks)', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| '}\n\n' |
| 'class B {\n\n\n' |
| ' int b() => 42;\n\n' |
| ' int c() => b();\n\n' |
| '}\n', |
| 'class A {\n' |
| '}\n\n' |
| 'class B {\n\n\n' |
| ' int b() => 42;\n\n' |
| ' int c() => b();\n\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - Block comments', () { |
| expectCUFormatsTo( |
| '/** Old school class comment */\n' |
| 'class C {\n' |
| ' /** Foo! */ int foo() => 42;\n' |
| '}\n', |
| '/** Old school class comment */\n' |
| 'class C {\n' |
| ' /** Foo! */\n' |
| ' int foo() => 42;\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'library foo;\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n', |
| 'library foo;\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '/* A long\n' |
| ' * Comment\n' |
| '*/\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n', |
| 'library foo;\n' |
| '/* A long\n' |
| ' * Comment\n' |
| '*/\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '/* A long\n' |
| ' * Comment\n' |
| '*/\n' |
| '\n' |
| '/* And\n' |
| ' * another...\n' |
| '*/\n' |
| '\n' |
| '// Mixing it up\n' |
| '\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n', |
| 'library foo;\n' |
| '/* A long\n' |
| ' * Comment\n' |
| '*/\n' |
| '\n' |
| '/* And\n' |
| ' * another...\n' |
| '*/\n' |
| '\n' |
| '// Mixing it up\n' |
| '\n' |
| 'class C /* is cool */ {\n' |
| ' /* int */ foo() => 42;\n' |
| '}\n' |
| ); |
| expectCUFormatsTo( |
| '/// Copyright info\n' |
| '\n' |
| 'library foo;\n' |
| '/// Class comment\n' |
| '//TODO: implement\n' |
| 'class C {\n' |
| '}\n', |
| '/// Copyright info\n' |
| '\n' |
| 'library foo;\n' |
| '/// Class comment\n' |
| '//TODO: implement\n' |
| 'class C {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - mixed comments', () { |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '\n' |
| '\n' |
| '/* Comment 1 */\n' |
| '\n' |
| '// Comment 2\n' |
| '\n' |
| '/* Comment 3 */', |
| 'library foo;\n' |
| '\n' |
| '\n' |
| '/* Comment 1 */\n' |
| '\n' |
| '// Comment 2\n' |
| '\n' |
| '/* Comment 3 */\n' |
| ); |
| }); |
| |
| test('CU - comments (EOF)', () { |
| expectCUFormatsTo( |
| 'library foo; //zamm', |
| 'library foo; //zamm\n' //<-- note extra NEWLINE |
| ); |
| }); |
| |
| test('CU - comments (0)', () { |
| expectCUFormatsTo( |
| 'library foo; //zamm\n' |
| '\n' |
| 'class A {\n' |
| '}\n', |
| 'library foo; //zamm\n' |
| '\n' |
| 'class A {\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - comments (1)', () { |
| expectCUFormatsTo( |
| '/* foo */ /* bar */\n', |
| '/* foo */ /* bar */\n' |
| ); |
| }); |
| |
| test('CU - comments (2)', () { |
| expectCUFormatsTo( |
| '/** foo */ /** bar */\n', |
| '/** foo */\n' |
| '/** bar */\n' |
| ); |
| }); |
| |
| test('CU - comments (3)', () { |
| expectCUFormatsTo( |
| 'var x; //x\n', |
| 'var x; //x\n' |
| ); |
| }); |
| |
| test('CU - comments (4)', () { |
| expectCUFormatsTo( |
| 'class X { //X!\n' |
| '}', |
| 'class X { //X!\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - comments (5)', () { |
| expectCUFormatsTo( |
| '//comment one\n\n' |
| '//comment two\n\n', |
| '//comment one\n\n' |
| '//comment two\n\n' |
| ); |
| }); |
| |
| test('CU - comments (6)', () { |
| expectCUFormatsTo( |
| 'var x; //x\n', |
| 'var x; //x\n' |
| ); |
| }); |
| |
| test('CU - comments (6)', () { |
| expectCUFormatsTo( |
| 'var /* int */ x; //x\n', |
| 'var /* int */ x; //x\n' |
| ); |
| }); |
| |
| test('CU - comments (7)', () { |
| expectCUFormatsTo( |
| 'library foo;\n' |
| '\n' |
| '/// Docs\n' |
| '/// spanning\n' |
| '/// lines.\n' |
| 'class A {\n' |
| '}\n' |
| '\n' |
| '/// ... and\n' |
| '\n' |
| '/// Dangling ones too\n' |
| 'int x;\n', |
| 'library foo;\n' |
| '\n' |
| '/// Docs\n' |
| '/// spanning\n' |
| '/// lines.\n' |
| 'class A {\n' |
| '}\n' |
| '\n' |
| '/// ... and\n' |
| '\n' |
| '/// Dangling ones too\n' |
| 'int x;\n' |
| ); |
| }); |
| |
| test('CU - EOF nl', () { |
| expectCUFormatsTo( |
| 'var x = 1;', |
| 'var x = 1;\n' |
| ); |
| }); |
| |
| test('CU - constructor', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' const _a;\n' |
| ' A();\n' |
| ' int a() => _a;\n' |
| '}\n', |
| 'class A {\n' |
| ' const _a;\n' |
| ' A();\n' |
| ' int a() => _a;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - method decl w/ named params', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int a(var x, {optional: null}) => null;\n' |
| '}\n', |
| 'class A {\n' |
| ' int a(var x, {optional: null}) => null;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - method decl w/ optional params', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int a(var x, [optional = null]) => null;\n' |
| '}\n', |
| 'class A {\n' |
| ' int a(var x, [optional = null]) => null;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - factory constructor redirects', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' const factory A() = B;\n' |
| '}\n', |
| 'class A {\n' |
| ' const factory A() = B;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - constructor initializers', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int _a;\n' |
| ' A(a) : _a = a;\n' |
| '}\n', |
| 'class A {\n' |
| ' int _a;\n' |
| ' A(a) : _a = a;\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - constructor auto field inits', () { |
| expectCUFormatsTo( |
| 'class A {\n' |
| ' int _a;\n' |
| ' A(this._a);\n' |
| '}\n', |
| 'class A {\n' |
| ' int _a;\n' |
| ' A(this._a);\n' |
| '}\n' |
| ); |
| }); |
| |
| test('CU - parts', () { |
| expectCUFormatsTo( |
| 'part of foo;', |
| 'part of foo;\n' |
| ); |
| }); |
| |
| test('stmt', () { |
| expectStmtFormatsTo( |
| 'if (true){\n' |
| 'if (true){\n' |
| 'if (true){\n' |
| 'return true;\n' |
| '} else{\n' |
| 'return false;\n' |
| '}\n' |
| '}\n' |
| '}else{\n' |
| 'return false;\n' |
| '}', |
| 'if (true) {\n' |
| ' if (true) {\n' |
| ' if (true) {\n' |
| ' return true;\n' |
| ' } else {\n' |
| ' return false;\n' |
| ' }\n' |
| ' }\n' |
| '} else {\n' |
| ' return false;\n' |
| '}' |
| ); |
| }); |
| |
| test('stmt (switch)', () { |
| expectStmtFormatsTo( |
| 'switch (fruit) {\n' |
| 'case "apple":\n' |
| 'print("delish");\n' |
| 'break;\n' |
| 'case "fig":\n' |
| 'print("bleh");\n' |
| 'break;\n' |
| '}', |
| 'switch (fruit) {\n' |
| ' case "apple":\n' |
| ' print("delish");\n' |
| ' break;\n' |
| ' case "fig":\n' |
| ' print("bleh");\n' |
| ' break;\n' |
| '}' |
| ); |
| }); |
| |
| test('stmt (generics)', () { |
| expectStmtFormatsTo( |
| 'var numbers = <int>[1, 2, (3 + 4)];', |
| 'var numbers = <int>[1, 2, (3 + 4)];' |
| ); |
| }); |
| |
| test('stmt (lists)', () { |
| expectStmtFormatsTo( |
| 'var l = [1,2,3,4];', |
| 'var l = [1, 2, 3, 4];' |
| ); |
| //Dangling ',' |
| expectStmtFormatsTo( |
| 'var l = [1,];', |
| 'var l = [1,];' |
| ); |
| }); |
| |
| test('stmt (maps)', () { |
| expectStmtFormatsTo( |
| 'var map = const {"foo": "bar", "fuz": null};', |
| 'var map = const {"foo": "bar", "fuz": null};' |
| ); |
| |
| //Dangling ',' |
| expectStmtFormatsTo( |
| 'var map = {"foo": "bar",};', |
| 'var map = {"foo": "bar",};' |
| ); |
| }); |
| |
| test('stmt (try/catch)', () { |
| expectStmtFormatsTo( |
| 'try {\n' |
| 'doSomething();\n' |
| '} catch (e) {\n' |
| 'print(e);\n' |
| '}', |
| 'try {\n' |
| ' doSomething();\n' |
| '} catch (e) {\n' |
| ' print(e);\n' |
| '}' |
| ); |
| }); |
| |
| test('stmt (binary/ternary ops)', () { |
| expectStmtFormatsTo( |
| 'var a = 1 + 2 / (3 * -b);', |
| 'var a = 1 + 2 / (3 * -b);' |
| ); |
| expectStmtFormatsTo( |
| 'var c = !condition == a > b;', |
| 'var c = !condition == a > b;' |
| ); |
| expectStmtFormatsTo( |
| 'var d = condition ? b : object.method(a, b, c);', |
| 'var d = condition ? b : object.method(a, b, c);' |
| ); |
| expectStmtFormatsTo( |
| 'var d = obj is! SomeType;', |
| 'var d = obj is! SomeType;' |
| ); |
| }); |
| |
| test('stmt (for in)', () { |
| expectStmtFormatsTo( |
| 'for (Foo foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}', |
| 'for (Foo foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}' |
| ); |
| expectStmtFormatsTo( |
| 'for (final Foo foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}', |
| 'for (final Foo foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}' |
| ); |
| expectStmtFormatsTo( |
| 'for (final foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}', |
| 'for (final foo in bar.foos) {\n' |
| ' print(foo);\n' |
| '}' |
| ); |
| }); |
| |
| test('initialIndent', () { |
| var formatter = new CodeFormatter( |
| new FormatterOptions(initialIndentationLevel: 2)); |
| var formattedSource = |
| formatter.format(CodeKind.STATEMENT, 'var x;').source; |
| expect(formattedSource, startsWith(' ')); |
| }); |
| |
| test('selections', () { |
| expectSelectedPostFormat('class X {}', '}'); |
| expectSelectedPostFormat('class X{}', '{'); |
| expectSelectedPostFormat('class X{int y;}', ';'); |
| expectSelectedPostFormat('class X{int y;}', '}'); |
| expectSelectedPostFormat('class X {}', ' {'); |
| }); |
| |
| }); |
| |
| |
| /// Token streams |
| group('token streams', () { |
| |
| test('string tokens', () { |
| expectTokenizedEqual('class A{}', 'class A{ }'); |
| expectTokenizedEqual('class A{}', 'class A{\n }\n'); |
| expectTokenizedEqual('class A {}', 'class A{ }'); |
| expectTokenizedEqual(' class A {}', 'class A{ }'); |
| }); |
| |
| test('string tokens - w/ comments', () { |
| expectTokenizedEqual('//foo\nint bar;', '//foo\nint bar;'); |
| expectTokenizedNotEqual('int bar;', '//foo\nint bar;'); |
| expectTokenizedNotEqual('//foo\nint bar;', 'int bar;'); |
| }); |
| |
| test('INDEX', () { |
| /// '[' ']' => '[]' |
| var t1 = openSqBracket()..setNext(closeSqBracket()..setNext(eof())); |
| var t2 = index()..setNext(eof()); |
| expectStreamsEqual(t1, t2); |
| }); |
| |
| test('GT_GT', () { |
| /// '>' '>' => '>>' |
| var t1 = gt()..setNext(gt()..setNext(eof())); |
| var t2 = gt_gt()..setNext(eof()); |
| expectStreamsEqual(t1, t2); |
| }); |
| |
| test('t1 < t2', () { |
| var t1 = string('foo')..setNext(eof()); |
| var t2 = string('foo')..setNext(string('bar')..setNext(eof())); |
| expectStreamsNotEqual(t1, t2); |
| }); |
| |
| test('t1 > t2', () { |
| var t1 = string('foo')..setNext(string('bar')..setNext(eof())); |
| var t2 = string('foo')..setNext(eof()); |
| expectStreamsNotEqual(t1, t2); |
| }); |
| |
| }); |
| |
| |
| /// Line tests |
| group('line', () { |
| |
| test('space', () { |
| var line = new Line(indent: 0); |
| line.addSpaces(2); |
| expect(line.toString(), equals(' ')); |
| }); |
| |
| test('initial indent', () { |
| var line = new Line(indent: 2); |
| expect(line.toString(), equals(' ')); |
| }); |
| |
| test('initial indent (tabbed)', () { |
| var line = new Line(indent:1, useTabs: true); |
| expect(line.toString(), equals('\t')); |
| }); |
| |
| test('addToken', () { |
| var line = new Line(); |
| line.addToken(new LineToken('foo')); |
| expect(line.toString(), equals('foo')); |
| }); |
| |
| test('addToken (2)', () { |
| var line = new Line(indent: 1); |
| line.addToken(new LineToken('foo')); |
| expect(line.toString(), equals(' foo')); |
| }); |
| |
| test('isWhitespace', () { |
| var line = new Line(indent: 1); |
| expect(line.isWhitespace(), isTrue); |
| }); |
| |
| }); |
| |
| |
| /// Writer tests |
| group('writer', () { |
| |
| test('basic print', () { |
| var writer = new SourceWriter(); |
| writer.print('foo'); |
| writer.print(' '); |
| writer.print('bar'); |
| expect(writer.toString(), equals('foo bar')); |
| }); |
| |
| test('newline', () { |
| var writer = new SourceWriter(); |
| writer.print('foo'); |
| writer.newline(); |
| expect(writer.toString(), equals('foo\n')); |
| }); |
| |
| test('newline trims whitespace', () { |
| var writer = new SourceWriter(indentCount:2); |
| writer.newline(); |
| expect(writer.toString(), equals('\n')); |
| }); |
| |
| test('basic print (with indents)', () { |
| var writer = new SourceWriter(); |
| writer.print('foo'); |
| writer.indent(); |
| writer.newline(); |
| writer.print('bar'); |
| writer.unindent(); |
| writer.newline(); |
| writer.print('baz'); |
| expect(writer.toString(), equals('foo\n bar\nbaz')); |
| }); |
| |
| }); |
| |
| |
| /// Helper method tests |
| group('helpers', () { |
| |
| test('indentString', () { |
| expect(getIndentString(0), ''); |
| expect(getIndentString(1), ' '); |
| expect(getIndentString(4), ' '); |
| }); |
| |
| test('indentString (tabbed)', () { |
| expect(getIndentString(0, useTabs: true), ''); |
| expect(getIndentString(1, useTabs: true), '\t'); |
| expect(getIndentString(3, useTabs: true), '\t\t\t'); |
| }); |
| |
| test('repeat', () { |
| expect(repeat('x', 0), ''); |
| expect(repeat('x', 1), 'x'); |
| expect(repeat('x', 4), 'xxxx'); |
| }); |
| |
| }); |
| |
| } |
| |
| Token closeSqBracket() => new Token(TokenType.CLOSE_SQUARE_BRACKET, 0); |
| |
| Token eof() => new Token(TokenType.EOF, 0); |
| |
| Token gt() => new Token(TokenType.GT, 0); |
| |
| Token gt_gt() => new Token(TokenType.GT_GT, 0); |
| |
| Token index() => new Token(TokenType.INDEX, 0); |
| |
| Token openSqBracket() => new BeginToken(TokenType.OPEN_SQUARE_BRACKET, 0); |
| |
| Token string(String lexeme) => new StringToken(TokenType.STRING, lexeme, 0); |
| |
| Token classKeyword(int offset) => new KeywordToken(Keyword.CLASS, offset); |
| |
| Token identifier(String value, int offset) => |
| new StringToken(TokenType.IDENTIFIER, value, offset); |
| |
| Token openParen(int offset) => |
| new StringToken(TokenType.OPEN_PAREN, '{', offset); |
| |
| Token closeParen(int offset) => |
| new StringToken(TokenType.CLOSE_PAREN, '}', offset); |
| |
| Token chain(List<Token> tokens) { |
| for (var i = 0; i < tokens.length - 1; ++i) { |
| tokens[i].setNext(tokens[i + 1]); |
| } |
| return tokens[0]; |
| } |
| |
| FormattedSource formatCU(src, {options: const FormatterOptions(), selection}) => |
| new CodeFormatter(options).format( |
| CodeKind.COMPILATION_UNIT, src, selection: selection); |
| |
| String formatStatement(src, {options: const FormatterOptions()}) => |
| new CodeFormatter(options).format(CodeKind.STATEMENT, src).source; |
| |
| Token tokenize(String str) => new StringScanner(null, str, null).tokenize(); |
| |
| expectSelectedPostFormat(src, token) { |
| var preOffset = src.indexOf(token); |
| var length = token.length; |
| var formatted = formatCU(src, selection: new Selection(preOffset, length)); |
| var postOffset = formatted.selection.offset; |
| expect(formatted.source.substring(postOffset, postOffset + length), |
| equals(src.substring(preOffset, preOffset + length))); |
| } |
| |
| expectTokenizedEqual(String s1, String s2) => |
| expectStreamsEqual(tokenize(s1), tokenize(s2)); |
| |
| expectTokenizedNotEqual(String s1, String s2) => |
| expect(()=> expectStreamsEqual(tokenize(s1), tokenize(s2)), |
| throwsA(new isInstanceOf<FormatterException>())); |
| |
| expectStreamsEqual(Token t1, Token t2) => |
| new TokenStreamComparator(null, t1, t2).verifyEquals(); |
| |
| expectStreamsNotEqual(Token t1, Token t2) => |
| expect(() => new TokenStreamComparator(null, t1, t2).verifyEquals(), |
| throwsA(new isInstanceOf<FormatterException>())); |
| |
| expectCUFormatsTo(src, expected) => |
| expect(formatCU(src).source, equals(expected)); |
| |
| expectStmtFormatsTo(src, expected) => |
| expect(formatStatement(src), equals(expected)); |
