| // 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. |
| |
| library formatter_test; |
| |
| import 'dart:io'; |
| |
| import 'package:path/path.dart'; |
| import 'package:unittest/unittest.dart'; |
| |
| import 'package:analyzer/src/generated/scanner.dart'; |
| import 'package:analyzer/src/services/formatter_impl.dart'; |
| import 'package:analyzer/src/services/writer.dart'; |
| |
| // Test data location ('pkg/analyzer/test/services/data') |
| final TEST_DATA_DIR = join(dirname(fromUri(Platform.script)), 'data'); |
| |
| main() { |
| |
| /// Data-driven statement tests |
| group('stmt_tests.data', () { |
| // NOTE: statement tests are run with transforms enabled |
| runTests('stmt_tests.data', (input, expectedOutput) { |
| expect(formatStatement(input, |
| options: new FormatterOptions(codeTransforms: true)) + |
| '\n', equals(expectedOutput)); |
| }); |
| }); |
| |
| /// Data-driven compilation unit tests |
| group('cu_tests.data', () { |
| runTests('cu_tests.data', (input, expectedOutput) { |
| expectCUFormatsTo(input, expectedOutput); |
| }); |
| }); |
| |
| /// Data-driven Style Guide acceptance tests |
| group('style_guide_tests.data', () { |
| runTests('style_guide_tests.data', (input, expectedOutput) { |
| expectCUFormatsTo(input, expectedOutput); |
| }); |
| }); |
| |
| /// Data-driven wrapping tests |
| group('wrap_tests.data', () { |
| runTests('wrap_tests.data', (input, expectedOutput) { |
| expectCUFormatsTo(input, expectedOutput); |
| }); |
| }); |
| |
| /// Formatter tests |
| group('formatter', () { |
| test('failed parse', () { |
| var formatter = new CodeFormatter(); |
| expect(() => formatter.format(CodeKind.COMPILATION_UNIT, '~'), |
| throwsA(new isInstanceOf<FormatterException>())); |
| }); |
| |
| test('indent', () { |
| var original = 'class A {\n' |
| ' var z;\n' |
| ' inc(int x) => ++x;\n' |
| ' foo(int x) {\n' |
| ' if (x == 0) {\n' |
| ' return true;\n' |
| ' }\n' |
| ' }\n' |
| '}\n'; |
| expectCUFormatsTo(original, original); |
| expectIndentFormatsTo(3, false, original, 'class A {\n' |
| ' var z;\n' |
| ' inc(int x) => ++x;\n' |
| ' foo(int x) {\n' |
| ' if (x == 0) {\n' |
| ' return true;\n' |
| ' }\n' |
| ' }\n' |
| '}\n'); |
| expectIndentFormatsTo(1, true, original, 'class A {\n' |
| '\tvar z;\n' |
| '\tinc(int x) => ++x;\n' |
| '\tfoo(int x) {\n' |
| '\t\tif (x == 0) {\n' |
| '\t\t\treturn true;\n' |
| '\t\t}\n' |
| '\t}\n' |
| '}\n'); |
| }); |
| |
| 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'); |
| expectCUFormatsTo('main() {\n' |
| '// print(1);\n' |
| '// print(2);\n' |
| ' print(3);\n' |
| '}\n', 'main() {\n' |
| '// print(1);\n' |
| '// print(2);\n' |
| ' print(3);\n' |
| '}\n'); |
| expectCUFormatsTo('class A {\n' |
| '// int a;\n' |
| '// int b;\n' |
| ' int c;\n' |
| '}\n', 'class A {\n' |
| '// int a;\n' |
| '// int b;\n' |
| ' int 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'); |
| }); |
| |
| 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 - comments (8)', () { |
| expectCUFormatsTo('var x /* X */, y;\n', 'var x /* X */, y;\n'); |
| }); |
| |
| test('CU - comments (9)', () { |
| expectCUFormatsTo('main() {\n' |
| ' foo(1 /* bang */, 2);\n' |
| '}\n' |
| 'foo(x, y) => null;\n', 'main() {\n' |
| ' foo(1 /* bang */, 2);\n' |
| '}\n' |
| 'foo(x, y) => null;\n'); |
| }); |
| |
| test('CU - comments (10)', () { |
| expectCUFormatsTo( |
| 'var l = [1 /* bang */, 2];\n', 'var l = [1 /* bang */, 2];\n'); |
| }); |
| |
| test('CU - comments (11)', () { |
| expectCUFormatsTo('var m = {1: 2 /* bang */, 3: 4};\n', 'var m = {\n' |
| ' 1: 2 /* bang */,\n' |
| ' 3: 4\n' |
| '};\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 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('CU (cons inits)', () { |
| expectCUFormatsTo('class X {\n' |
| ' var x, y;\n' |
| ' X() : x = 1, y = 2;\n' |
| '}\n', 'class X {\n' |
| ' var x, y;\n' |
| ' X()\n' |
| ' : x = 1,\n' |
| ' y = 2;\n' |
| '}\n'); |
| }); |
| |
| test('CU (empty cons bodies)', () { |
| expectCUFormatsTo('class A {\n' |
| ' A() {\n' |
| ' }\n' |
| '}\n', 'class A {\n' |
| ' A();\n' |
| '}\n', transforms: true); |
| expectCUFormatsTo('class A {\n' |
| ' A() {\n' |
| ' }\n' |
| '}\n', 'class A {\n' |
| ' A() {\n' |
| ' }\n' |
| '}\n', transforms: false); |
| }); |
| |
| 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 (empty while body)', () { |
| expectStmtFormatsTo('while (true);', 'while (true);'); |
| }); |
| |
| test('stmt (empty for body)', () { |
| expectStmtFormatsTo('for ( ; ; );', 'for ( ; ; );'); |
| }); |
| |
| test('stmt (cascades)', () { |
| expectStmtFormatsTo('"foo"\n' |
| '..toString()\n' |
| '..toString();', '"foo"\n' |
| ' ..toString()\n' |
| ' ..toString();'); |
| }); |
| |
| 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];'); |
| expectStmtFormatsTo('var l = [\n' |
| '1,\n' |
| '2,\n' |
| '];', 'var l = [1, 2,];'); |
| //Dangling ',' |
| expectStmtFormatsTo('var l = [1,];', 'var l = [1,];'); |
| }); |
| |
| test('stmt (maps)', () { |
| expectStmtFormatsTo('var map = const {"foo": "bar", "fuz": null};', |
| 'var map = const {\n' |
| ' "foo": "bar",\n' |
| ' "fuz": null\n' |
| '};'); |
| |
| expectStmtFormatsTo('var map = {\n' |
| '"foo": "bar",\n' |
| '"bar": "baz"\n' |
| '};', 'var map = {\n' |
| ' "foo": "bar",\n' |
| ' "bar": "baz"\n' |
| '};'); |
| |
| //Dangling ',' |
| expectStmtFormatsTo('var map = {"foo": "bar",};', 'var map = {\n' |
| ' "foo": "bar",\n' |
| '};'); |
| }); |
| |
| 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' |
| '}'); |
| expectStmtFormatsTo('try{\n' |
| 'doSomething();\n' |
| '}on Exception catch (e){\n' |
| 'print(e);\n' |
| '}', 'try {\n' |
| ' doSomething();\n' |
| '} on Exception 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('Statement (if)', () { |
| expectStmtFormatsTo( |
| 'if (true) print("true!");', 'if (true) print("true!");'); |
| expectStmtFormatsTo('if (true) { print("true!"); }', 'if (true) {\n' |
| ' print("true!");\n' |
| '}'); |
| expectStmtFormatsTo('if (true) print("true!"); else print("false!");', |
| 'if (true) {\n' |
| ' print("true!");\n' |
| '} else {\n' |
| ' print("false!");\n' |
| '}'); |
| expectStmtFormatsTo('if (true) print("true!"); else print("false!");', |
| 'if (true) print("true!"); else print("false!");', transforms: false); |
| }); |
| |
| test('String - multiline - short - same line', () { |
| expectCUFormatsTo('main() {\n' |
| ' print("""01234567890123456789012345678901234567890123456789""");\n' |
| '}\n', 'main() {\n' |
| ' print("""01234567890123456789012345678901234567890123456789""");\n' |
| '}\n'); |
| }); |
| |
| test('String - multiline - short - next line', () { |
| expectCUFormatsTo('main() {\n' |
| ' print("""\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '""");\n' |
| '}\n', 'main() {\n' |
| ' print("""\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '""");\n' |
| '}\n'); |
| }); |
| |
| test('String - multiline - long', () { |
| expectCUFormatsTo('main() {\n' |
| ' print("""\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '""");\n' |
| '}\n', 'main() {\n' |
| ' print("""\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '01234567890123456789012345678901234567890123456789\n' |
| '""");\n' |
| '}\n'); |
| }); |
| |
| // smoketest to ensure we're enforcing the 'no gratuitous linebreaks' |
| // opinion |
| test('CU (eat newlines)', () { |
| expectCUFormatsTo('abstract\n' |
| 'class\n' |
| 'A{}', 'abstract class A {}\n'); |
| }); |
| |
| // test('line continuations - 1', () { |
| // expectStmtFormatsTo( |
| // 'if (x &&\n' |
| // ' y) {\n' |
| // ' print("yes!");\n' |
| // '}', |
| // 'if (x &&\n' |
| // ' y) {\n' |
| // ' print("yes!");\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'var x =\n' |
| // ' 1234567890;', |
| // 'var x =\n' |
| // ' 1234567890;' |
| // ); |
| // expectStmtFormatsTo( |
| // 'foo() {\n' |
| // ' var x = 0;\n' |
| // ' x =\n' |
| // ' 1234567890;\n' |
| // '}', |
| // 'foo() {\n' |
| // ' var x = 0;\n' |
| // ' x =\n' |
| // ' 1234567890;\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'foo() {\n' |
| // ' while (true &&\n' |
| // ' true) {\n' |
| // ' print("!");\n' |
| // ' }\n' |
| // '}', |
| // 'foo() {\n' |
| // ' while (true &&\n' |
| // ' true) {\n' |
| // ' print("!");\n' |
| // ' }\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'foo() {\n' |
| // ' do {\n' |
| // ' print("!");\n' |
| // ' } while (true &&\n' |
| // ' true);\n' |
| // '}', |
| // 'foo() {\n' |
| // ' do {\n' |
| // ' print("!");\n' |
| // ' } while (true &&\n' |
| // ' true);\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'int foo() {\n' |
| // ' return\n' |
| // ' foo();\n' |
| // '}', |
| // 'int foo() {\n' |
| // ' return\n' |
| // ' foo();\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'int foo() {\n' |
| // ' return\n' |
| // ' 13;\n' |
| // '}', |
| // 'int foo() {\n' |
| // ' return\n' |
| // ' 13;\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'foo(fn()) {\n' |
| // ' return foo(() {\n' |
| // ' return 1;\n' |
| // '});\n' |
| // '}', |
| // 'foo(fn()) {\n' |
| // ' return foo(() {\n' |
| // ' return 1;\n' |
| // '});\n' |
| // '}' |
| // ); |
| // expectStmtFormatsTo( |
| // 'true ? foo() :\n' |
| // ' bar();', |
| // 'true ? foo() :\n' |
| // ' bar();' |
| // ); |
| // expectCUFormatsTo( |
| // 'import "dart:core" as\n' |
| // ' core;\n', |
| // 'import "dart:core" as\n' |
| // ' core;\n' |
| // ); |
| // expectCUFormatsTo( |
| // 'export "package:foo/foo.dart" show\n' |
| // ' Foo;\n', |
| // 'export "package:foo/foo.dart" show\n' |
| // ' Foo;\n' |
| // ); |
| // expectCUFormatsTo( |
| // 'class Foo extends Bar implements\n' |
| // ' Baz {\n' |
| // '}\n', |
| // 'class Foo extends Bar implements\n' |
| // ' Baz {\n' |
| // '}\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(indentLevel: 0); |
| line.addSpaces(2); |
| expect(line.toString(), equals(' ')); |
| }); |
| |
| test('initial indent', () { |
| var line = new Line(indentLevel: 2); |
| expect(line.toString(), equals(' ')); |
| }); |
| |
| test('initial indent (tabbed)', () { |
| var line = new Line(indentLevel: 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(indentLevel: 1); |
| line.addToken(new LineToken('foo')); |
| expect(line.toString(), equals(' foo')); |
| }); |
| |
| test('isWhitespace', () { |
| var line = new Line(indentLevel: 1); |
| expect(line.isWhitespace(), isTrue); |
| }); |
| }); |
| |
| /// Writer tests |
| group('writer', () { |
| test('basic print', () { |
| var writer = new SourceWriter(); |
| writer.write('foo'); |
| writer.write(' '); |
| writer.write('bar'); |
| expect(writer.toString(), equals('foo bar')); |
| }); |
| |
| test('newline', () { |
| var writer = new SourceWriter(); |
| writer.write('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.write('foo'); |
| writer.indent(); |
| writer.newline(); |
| writer.write('bar'); |
| writer.unindent(); |
| writer.newline(); |
| writer.write('baz'); |
| expect(writer.toString(), equals('foo\n bar\nbaz')); |
| }); |
| |
| test('write - multiline', () { |
| var writer = new SourceWriter(); |
| writer.indent(); |
| writer.newline(); |
| writer.write('aaa\nbbb\nccc'); |
| expect(writer.toString(), equals('\n aaa\nbbb\nccc')); |
| expect(writer.currentLine.toString(), equals('ccc')); |
| }); |
| }); |
| |
| /// Line breaker tests |
| group('linebreaker', () { |
| List<Chunk> breakLine(Line line, int maxLength) => |
| new SimpleLineBreaker(maxLength).breakLine(line); |
| |
| String printLine(Line line, int maxLength) => |
| new SimpleLineBreaker(maxLength, (n) => new List.filled(n, ' ').join()) |
| .printLine(line); |
| |
| Line line(List tokens) { |
| var line = new Line(); |
| tokens |
| .forEach((t) => line.addToken(t is LineToken ? t : new LineToken(t))); |
| return line; |
| } |
| |
| expectTextsEqual(List<Chunk> chunks, List<String> texts) { |
| expect(chunks.map((chunk) => chunk.toString()), orderedEquals(texts)); |
| } |
| |
| expectTokensEqual(List<LineToken> tokens, List<String> texts) { |
| expect(tokens.map((token) => token.toString()), orderedEquals(texts)); |
| } |
| |
| final SP_1 = new SpaceToken(1, breakWeight: DEFAULT_SPACE_WEIGHT); |
| final SP_w1 = new SpaceToken(1, breakWeight: 1); |
| final SP_w2 = new SpaceToken(1, breakWeight: 2); |
| final SP_i = new SpaceToken(1, breakWeight: SINGLE_SPACE_WEIGHT); |
| |
| // 'foo|1|bar|1|baz|1|foo|1|bar|1|baz' |
| final LINE_1 = line([ |
| 'foo', |
| SP_1, |
| 'bar', |
| SP_1, |
| 'baz', |
| SP_1, |
| 'foo', |
| SP_1, |
| 'bar', |
| SP_1, |
| 'baz' |
| ]); |
| |
| // ' foo|1|bar|1|baz|1|foo|1|bar|1|baz' |
| final LINE_2 = line([ |
| ' foo', |
| SP_1, |
| 'bar', |
| SP_1, |
| 'baz', |
| SP_1, |
| 'foo', |
| SP_1, |
| 'bar', |
| SP_1, |
| 'baz' |
| ]); |
| |
| test('breakLine - 0', () { |
| var chunks = breakLine(line([' foo']), 8); |
| expectTextsEqual(chunks, [' foo']); |
| }); |
| |
| test('breakLine - 1', () { |
| var chunks = breakLine(LINE_1, 1); |
| expectTextsEqual(chunks, ['foo', 'bar', 'baz', 'foo', 'bar', 'baz']); |
| }); |
| |
| test('breakLine - 2', () { |
| var chunks = breakLine(LINE_1, 4); |
| expectTextsEqual(chunks, ['foo', 'bar', 'baz', 'foo', 'bar', 'baz']); |
| }); |
| |
| test('breakLine - 3', () { |
| var chunks = breakLine(LINE_1, 8); |
| expectTextsEqual(chunks, ['foo bar', 'baz foo', 'bar baz']); |
| }); |
| |
| test('breakLine - 4', () { |
| var chunks = breakLine(LINE_1, 12); |
| expectTextsEqual(chunks, ['foo bar baz', 'foo bar baz']); |
| }); |
| |
| test('breakLine - 5', () { |
| var chunks = breakLine(LINE_2, 16); |
| expectTextsEqual(chunks, [' foo bar baz', 'foo bar baz']); |
| }); |
| |
| test('breakLine - use weights - 1', () { |
| var source = line([ |
| '111', |
| SP_w2, |
| '222', |
| SP_w1, |
| '333', |
| SP_w2, |
| '444', |
| SP_w1, |
| '555', |
| SP_w2, |
| '666' |
| ]); |
| var chunks = breakLine(source, 12); |
| expectTextsEqual(chunks, ['111 222', '333 444', '555 666']); |
| }); |
| |
| test('printLine - 1', () { |
| var line = printLine(LINE_1, 1); |
| expect(line, 'foo\n bar\n baz\n foo\n bar\n baz'); |
| }); |
| |
| test('printLine - 2', () { |
| var line = printLine(LINE_1, 4); |
| expect(line, 'foo\n bar\n baz\n foo\n bar\n baz'); |
| }); |
| |
| test('printLine - 3', () { |
| var line = printLine(LINE_1, 8); |
| expect(line, 'foo bar\n baz foo\n bar baz'); |
| }); |
| |
| test('printLine - 4', () { |
| var line = printLine(LINE_1, 12); |
| expect(line, 'foo bar baz\n foo bar baz'); |
| }); |
| |
| test('printLine - use weight - 1', () { |
| var source = line([ |
| '111111', |
| SP_w2, |
| '222222', |
| SP_w1, |
| '333333', |
| SP_w2, |
| '444444', |
| SP_w1, |
| '555555', |
| SP_w2, |
| '666666' |
| ]); |
| var result = printLine(source, 20); |
| expect(result, '111111 222222\n 333333 444444\n 555555 666666'); |
| }); |
| |
| test('printLine - use weight - initializer - success', () { |
| var source = line(['111111', SP_i, '2222', SP_w1, '3333', SP_w1, '4444']); |
| var result = printLine(source, 20); |
| expect(result, '111111\n 2222 3333 4444'); |
| }); |
| |
| test('printLine - use weight - initializer - rest too long', () { |
| var source = line([ |
| '111', |
| SP_i, |
| '222', |
| SP_w1, |
| '333', |
| SP_w1, |
| '444', |
| SP_w1, |
| '555', |
| SP_w1, |
| '666' |
| ]); |
| var result = printLine(source, 15); |
| expect(result, '111 222\n 333\n 444\n 555\n 666'); |
| }); |
| |
| test('printLine - use weight - initializer - decl/rest too long', () { |
| var source = line([ |
| '111', |
| SP_i, |
| '2222222222222', |
| SP_w1, |
| '333', |
| SP_w1, |
| '444', |
| SP_w1, |
| '555', |
| SP_w1, |
| '666' |
| ]); |
| var result = printLine(source, 15); |
| expect(result, '111\n 2222222222222\n' |
| ' 333\n 444\n 555\n 666'); |
| }); |
| |
| test('isWhitespace', () { |
| expect(isWhitespace('foo'), false); |
| expect(isWhitespace(' foo'), false); |
| expect(isWhitespace('foo '), false); |
| expect(isWhitespace(' foo '), false); |
| expect(isWhitespace(' '), true); |
| expect(isWhitespace(' '), true); |
| expect(isWhitespace('\t'), true); |
| expect(isWhitespace('\t\t'), true); |
| expect(isWhitespace('\n'), true); |
| expect(isWhitespace('\r'), true); |
| }); |
| |
| test('preprocess - 1', () { |
| var tokens = line(['f', 'o', 'o', SP_1, 'b', 'a', 'r']).tokens; |
| var processed = SimpleLineBreaker.preprocess(tokens); |
| expectTokensEqual(processed, ['foo', ' ', 'bar']); |
| }); |
| |
| test('preprocess - 2', () { |
| var tokens = line(['f', 'o', 'o', SP_1, SP_1, 'b', 'a', 'r']).tokens; |
| var processed = SimpleLineBreaker.preprocess(tokens); |
| expectTokensEqual(processed, ['foo', ' ', ' ', 'bar']); |
| }); |
| |
| test('preprocess - 3', () { |
| var tokens = line(['f', 'o', 'o', SP_1, 'b', 'a', 'r', SP_1]).tokens; |
| var processed = SimpleLineBreaker.preprocess(tokens); |
| expectTokensEqual(processed, ['foo', ' ', 'bar', ' ']); |
| }); |
| }); |
| |
| /// 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) { |
| var reader = new CharSequenceReader(str); |
| return new Scanner(null, reader, 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, {transforms: true}) => expect(formatCU(src, |
| options: new FormatterOptions(codeTransforms: transforms)).source, |
| equals(expected)); |
| |
| expectIndentFormatsTo(spacesPerIndent, tabsForIndent, src, expected) => expect( |
| formatCU(src, |
| options: new FormatterOptions( |
| spacesPerIndent: spacesPerIndent, |
| tabsForIndent: tabsForIndent)).source, equals(expected)); |
| |
| expectStmtFormatsTo(src, expected, {transforms: true}) => expect( |
| formatStatement(src, |
| options: new FormatterOptions(codeTransforms: transforms)), |
| equals(expected)); |
| |
| runTests(testFileName, expectClause(String input, String output)) { |
| var testIndex = 1; |
| var testFile = new File(join(TEST_DATA_DIR, testFileName)); |
| var lines = testFile.readAsLinesSync(); |
| for (var i = 1; i < lines.length; ++i) { |
| var input = '', |
| expectedOutput = ''; |
| while (!lines[i].startsWith('<<<')) { |
| input += lines[i++] + '\n'; |
| } |
| while (++i < lines.length && !lines[i].startsWith('>>>')) { |
| expectedOutput += lines[i] + '\n'; |
| } |
| test('test - (${testIndex++})', () { |
| expectClause(input, expectedOutput); |
| }); |
| } |
| } |
