// 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);
    });
  }
}