test/runner/browser/runner_test.dart - test - Git at Google

 // Copyright (c) 2015, 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.

 @TestOn("vm")

 import 'package:test_descriptor/test_descriptor.dart' as d;

 import 'package:test/test.dart';

 import '../../io.dart';

 final _success = """
 import 'package:test/test.dart';

 void main() {
   test("success", () {});
 }
 """;

 final _failure = """
 import 'package:test/test.dart';

 void main() {
   test("failure", () => throw new TestFailure("oh no"));
 }
 """;

 void main() {
   group("fails gracefully if", () {
     test("a test file fails to compile", () async {
       await d.file("test.dart", "invalid Dart file").create();
       var test = await runTest(["-p", "chrome", "test.dart"]);

       expect(
           test.stdout,
           containsInOrder([
             "Error: Compilation failed.",
             '-1: compiling test.dart [E]',
             'Failed to load "test.dart": dart2js failed.'
           ]));
       await test.shouldExit(1);
     }, tags: 'chrome');

     test("a test file throws", () async {
       await d.file("test.dart", "void main() => throw 'oh no';").create();

       var test = await runTest(["-p", "chrome", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: compiling test.dart [E]',
             'Failed to load "test.dart": oh no'
           ]));
       await test.shouldExit(1);
     }, tags: 'chrome');

     test("a test file doesn't have a main defined", () async {
       await d.file("test.dart", "void foo() {}").create();

       var test = await runTest(["-p", "chrome", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: compiling test.dart [E]',
             'Failed to load "test.dart": No top-level main() function defined.'
           ]));
       await test.shouldExit(1);
     }, tags: 'chrome');

     test("a test file has a non-function main", () async {
       await d.file("test.dart", "int main;").create();

       var test = await runTest(["-p", "chrome", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: compiling test.dart [E]',
             'Failed to load "test.dart": Top-level main getter is not a function.'
           ]));
       await test.shouldExit(1);
     }, tags: 'chrome');

     test("a test file has a main with arguments", () async {
       await d.file("test.dart", "void main(arg) {}").create();

       var test = await runTest(["-p", "chrome", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: compiling test.dart [E]',
             'Failed to load "test.dart": Top-level main() function takes arguments.'
           ]));
       await test.shouldExit(1);
     }, tags: 'chrome');

     test("a custom HTML file has no script tag", () async {
       await d.file("test.dart", "void main() {}").create();

       await d.file("test.html", """
 <html>
 <head>
   <link rel="x-dart-test" href="test.dart">
 </head>
 </html>
 """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: loading test.dart [E]',
             'Failed to load "test.dart": "test.html" must contain '
                 '<script src="packages/test/dart.js"></script>.'
           ]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("a custom HTML file has no link", () async {
       await d.file("test.dart", "void main() {}").create();

       await d.file("test.html", """
 <html>
 <head>
   <script src="packages/test/dart.js"></script>
 </head>
 </html>
 """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: loading test.dart [E]',
             'Failed to load "test.dart": Expected exactly 1 '
                 '<link rel="x-dart-test"> in test.html, found 0.'
           ]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("a custom HTML file has too many links", () async {
       await d.file("test.dart", "void main() {}").create();

       await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test' href='test.dart'>
   <link rel='x-dart-test' href='test.dart'>
   <script src="packages/test/dart.js"></script>
 </head>
 </html>
 """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: loading test.dart [E]',
             'Failed to load "test.dart": Expected exactly 1 '
                 '<link rel="x-dart-test"> in test.html, found 2.'
           ]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("a custom HTML file has no href in the link", () async {
       await d.file("test.dart", "void main() {}").create();

       await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test'>
   <script src="packages/test/dart.js"></script>
 </head>
 </html>
 """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: loading test.dart [E]',
             'Failed to load "test.dart": Expected <link rel="x-dart-test"> in '
                 'test.html to have an "href" attribute.'
           ]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("a custom HTML file has an invalid test URL", () async {
       await d.file("test.dart", "void main() {}").create();

       await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test' href='wrong.dart'>
   <script src="packages/test/dart.js"></script>
 </head>
 </html>
 """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder([
             '-1: loading test.dart [E]',
             'Failed to load "test.dart": Failed to load script at '
           ]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     // TODO(nweiz): test what happens when a test file is unreadable once issue
     // 15078 is fixed.
   });

   group("runs successful tests", () {
     test("on a JS and non-JS browser", () async {
       await d.file("test.dart", _success).create();
       var test =
           await runTest(["-p", "content-shell", "-p", "chrome", "test.dart"]);

       expect(test.stdoutStream(),
           neverEmits(contains("[Dartium Content Shell] compiling")));
       expect(test.stdout, emitsThrough(contains("[Chrome] compiling")));
       await test.shouldExit(0);
     }, tags: ['chrome', 'content-shell']);

     test("on a browser and the VM", () async {
       await d.file("test.dart", _success).create();
       var test =
           await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);

       expect(test.stdout, emitsThrough(contains("+2: All tests passed!")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("with setUpAll", () async {
       await d.file("test.dart", r"""
           import 'package:test/test.dart';

           void main() {
             setUpAll(() => print("in setUpAll"));

             test("test", () {});
           }
           """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains('+0: (setUpAll)')));
       expect(test.stdout, emits('in setUpAll'));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("with tearDownAll", () async {
       await d.file("test.dart", r"""
           import 'package:test/test.dart';

           void main() {
             tearDownAll(() => print("in tearDownAll"));

             test("test", () {});
           }
           """).create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains('+1: (tearDownAll)')));
       expect(test.stdout, emits('in tearDownAll'));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     // Regression test; this broke in 0.12.0-beta.9.
     test("on a file in a subdirectory", () async {
       await d.dir("dir", [d.file("test.dart", _success)]).create();

       var test = await runTest(["-p", "chrome", "dir/test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
       await test.shouldExit(0);
     }, tags: 'chrome');

     group("with a custom HTML file", () {
       setUp(() async {
         await d.file("test.dart", """
 import 'dart:html';

 import 'package:test/test.dart';

 void main() {
   test("success", () {
     expect(document.query('#foo'), isNotNull);
   });
 }
 """).create();

         await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test' href='test.dart'>
   <script src="packages/test/dart.js"></script>
 </head>
 <body>
   <div id="foo"></div>
 </body>
 </html>
 """).create();
       });

       test("on content shell", () async {
         var test = await runTest(["-p", "content-shell", "test.dart"]);
         expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
         await test.shouldExit(0);
       }, tags: 'content-shell');

       test("on Chrome", () async {
         var test = await runTest(["-p", "chrome", "test.dart"]);
         expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
         await test.shouldExit(0);
       }, tags: 'chrome');

       // Regression test for https://github.com/dart-lang/test/issues/82.
       test("ignores irrelevant link tags", () async {
         await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test-not'>
   <link rel='other' href='test.dart'>
   <link rel='x-dart-test' href='test.dart'>
   <script src="packages/test/dart.js"></script>
 </head>
 <body>
   <div id="foo"></div>
 </body>
 </html>
 """).create();

         var test = await runTest(["-p", "content-shell", "test.dart"]);
         expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
         await test.shouldExit(0);
       }, tags: 'content-shell');
     });
   });

   group("runs failing tests", () {
     test("that fail only on the browser", () async {
       await d.file("test.dart", """
 import 'dart:async';

 import 'package:path/path.dart' as p;
 import 'package:test/test.dart';

 void main() {
   test("test", () {
     if (p.style == p.Style.url) throw new TestFailure("oh no");
   });
 }
 """).create();

       var test =
           await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1 -1: Some tests failed.")));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("that fail only on the VM", () async {
       await d.file("test.dart", """
 import 'dart:async';

 import 'package:path/path.dart' as p;
 import 'package:test/test.dart';

 void main() {
   test("test", () {
     if (p.style != p.Style.url) throw new TestFailure("oh no");
   });
 }
 """).create();

       var test =
           await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1 -1: Some tests failed.")));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     group("with a custom HTML file", () {
       setUp(() async {
         await d.file("test.dart", """
 import 'dart:html';

 import 'package:test/test.dart';

 void main() {
   test("failure", () {
     expect(document.query('#foo'), isNull);
   });
 }
 """).create();

         await d.file("test.html", """
 <html>
 <head>
   <link rel='x-dart-test' href='test.dart'>
   <script src="packages/test/dart.js"></script>
 </head>
 <body>
   <div id="foo"></div>
 </body>
 </html>
 """).create();
       });

       test("on content shell", () async {
         var test = await runTest(["-p", "content-shell", "test.dart"]);
         expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
         await test.shouldExit(1);
       }, tags: 'content-shell');

       test("on Chrome", () async {
         var test = await runTest(["-p", "chrome", "test.dart"]);
         expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
         await test.shouldExit(1);
       }, tags: 'chrome');
     });
   });

   test("the compiler uses colors if the test runner uses colors", () async {
     await d.file("test.dart", "String main() => 12;\n").create();

     var test = await runTest(["--color", "-p", "chrome", "test.dart"]);
     expect(test.stdout, emitsThrough(contains('\u001b[35m')));
     await test.shouldExit(1);
   }, tags: 'chrome');

   test("forwards prints from the browser test", () async {
     await d.file("test.dart", """
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("test", () {
     print("Hello,");
     return new Future(() => print("world!"));
   });
 }
 """).create();

     var test = await runTest(["-p", "content-shell", "test.dart"]);
     expect(test.stdout, emitsInOrder([emitsThrough("Hello,"), "world!"]));
     await test.shouldExit(0);
   }, tags: 'content-shell');

   test("dartifies stack traces for JS-compiled tests by default", () async {
     await d.file("test.dart", _failure).create();

     var test = await runTest(["-p", "chrome", "--verbose-trace", "test.dart"]);
     expect(
         test.stdout,
         containsInOrder(
             [" main.<fn>", "package:test", "dart:async/zone.dart"]));
     await test.shouldExit(1);
   }, tags: 'chrome');

   test("doesn't dartify stack traces for JS-compiled tests with --js-trace",
       () async {
     await d.file("test.dart", _failure).create();

     var test = await runTest(
         ["-p", "chrome", "--verbose-trace", "--js-trace", "test.dart"]);
     expect(test.stdoutStream(), neverEmits(endsWith(" main.<fn>")));
     expect(test.stdoutStream(), neverEmits(contains("package:test")));
     expect(test.stdoutStream(), neverEmits(contains("dart:async/zone.dart")));
     expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
     await test.shouldExit(1);
   }, tags: 'chrome');

   test("respects top-level @Timeout declarations", () async {
     await d.file("test.dart", '''
 @Timeout(const Duration(seconds: 0))

 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("timeout", () => new Future.delayed(Duration.ZERO));
 }
 ''').create();

     var test = await runTest(["-p", "content-shell", "test.dart"]);
     expect(
         test.stdout,
         containsInOrder(
             ["Test timed out after 0 seconds.", "-1: Some tests failed."]));
     await test.shouldExit(1);
   }, tags: 'content-shell');

   group("with onPlatform", () {
     test("respects matching Skips", () async {
       await d.file("test.dart", '''
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("fail", () => throw 'oh no', onPlatform: {"browser": new Skip()});
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+0 ~1: All tests skipped.")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("ignores non-matching Skips", () async {
       await d.file("test.dart", '''
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("success", () {}, onPlatform: {"vm": new Skip()});
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("respects matching Timeouts", () async {
       await d.file("test.dart", '''
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("fail", () async {
     await new Future.delayed(Duration.ZERO);
     throw 'oh no';
   }, onPlatform: {
     "browser": new Timeout(Duration.ZERO)
   });
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder(
               ["Test timed out after 0 seconds.", "-1: Some tests failed."]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("ignores non-matching Timeouts", () async {
       await d.file("test.dart", '''
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("success", () {}, onPlatform: {
     "vm": new Timeout(new Duration(seconds: 0))
   });
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("applies matching platforms in order", () async {
       await d.file("test.dart", '''
 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("success", () {}, onPlatform: {
     "browser": new Skip("first"),
     "browser || windows": new Skip("second"),
     "browser || linux": new Skip("third"),
     "browser || mac-os": new Skip("fourth"),
     "browser || android": new Skip("fifth")
   });
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdoutStream(), neverEmits(contains("Skip: first")));
       expect(test.stdoutStream(), neverEmits(contains("Skip: second")));
       expect(test.stdoutStream(), neverEmits(contains("Skip: third")));
       expect(test.stdoutStream(), neverEmits(contains("Skip: fourth")));
       expect(test.stdout, emitsThrough(contains("Skip: fifth")));
       await test.shouldExit(0);
     }, tags: 'content-shell');
   });

   group("with an @OnPlatform annotation", () {
     test("respects matching Skips", () async {
       await d.file("test.dart", '''
 @OnPlatform(const {"browser": const Skip()})

 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("fail", () => throw 'oh no');
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("~1: All tests skipped.")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("ignores non-matching Skips", () async {
       await d.file("test.dart", '''
 @OnPlatform(const {"vm": const Skip()})

 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("success", () {});
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
       await test.shouldExit(0);
     }, tags: 'content-shell');

     test("respects matching Timeouts", () async {
       await d.file("test.dart", '''
 @OnPlatform(const {
   "browser": const Timeout(const Duration(seconds: 0))
 })

 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("fail", () async {
     await new Future.delayed(Duration.ZERO);
     throw 'oh no';
   });
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       expect(
           test.stdout,
           containsInOrder(
               ["Test timed out after 0 seconds.", "-1: Some tests failed."]));
       await test.shouldExit(1);
     }, tags: 'content-shell');

     test("ignores non-matching Timeouts", () async {
       await d.file("test.dart", '''
 @OnPlatform(const {
   "vm": const Timeout(const Duration(seconds: 0))
 })

 import 'dart:async';

 import 'package:test/test.dart';

 void main() {
   test("success", () {});
 }
 ''').create();

       var test = await runTest(["-p", "content-shell", "test.dart"]);
       await test.shouldExit(0);
     }, tags: 'content-shell');
   });
 }
	// Copyright (c) 2015, 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.

	@TestOn("vm")

	import 'package:test_descriptor/test_descriptor.dart' as d;

	import 'package:test/test.dart';

	import '../../io.dart';

	final _success = """
	import 'package:test/test.dart';

	void main() {
	test("success", () {});
	}
	""";

	final _failure = """
	import 'package:test/test.dart';

	void main() {
	test("failure", () => throw new TestFailure("oh no"));
	}
	""";

	void main() {
	group("fails gracefully if", () {
	test("a test file fails to compile", () async {
	await d.file("test.dart", "invalid Dart file").create();
	var test = await runTest(["-p", "chrome", "test.dart"]);

	expect(
	test.stdout,
	containsInOrder([
	"Error: Compilation failed.",
	'-1: compiling test.dart [E]',
	'Failed to load "test.dart": dart2js failed.'
	]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("a test file throws", () async {
	await d.file("test.dart", "void main() => throw 'oh no';").create();

	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: compiling test.dart [E]',
	'Failed to load "test.dart": oh no'
	]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("a test file doesn't have a main defined", () async {
	await d.file("test.dart", "void foo() {}").create();

	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: compiling test.dart [E]',
	'Failed to load "test.dart": No top-level main() function defined.'
	]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("a test file has a non-function main", () async {
	await d.file("test.dart", "int main;").create();

	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: compiling test.dart [E]',
	'Failed to load "test.dart": Top-level main getter is not a function.'
	]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("a test file has a main with arguments", () async {
	await d.file("test.dart", "void main(arg) {}").create();

	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: compiling test.dart [E]',
	'Failed to load "test.dart": Top-level main() function takes arguments.'
	]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("a custom HTML file has no script tag", () async {
	await d.file("test.dart", "void main() {}").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel="x-dart-test" href="test.dart">
	</head>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: loading test.dart [E]',
	'Failed to load "test.dart": "test.html" must contain '
	'<script src="packages/test/dart.js"></script>.'
	]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("a custom HTML file has no link", () async {
	await d.file("test.dart", "void main() {}").create();

	await d.file("test.html", """
	<html>
	<head>
	<script src="packages/test/dart.js"></script>
	</head>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: loading test.dart [E]',
	'Failed to load "test.dart": Expected exactly 1 '
	'<link rel="x-dart-test"> in test.html, found 0.'
	]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("a custom HTML file has too many links", () async {
	await d.file("test.dart", "void main() {}").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test' href='test.dart'>
	<link rel='x-dart-test' href='test.dart'>
	<script src="packages/test/dart.js"></script>
	</head>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: loading test.dart [E]',
	'Failed to load "test.dart": Expected exactly 1 '
	'<link rel="x-dart-test"> in test.html, found 2.'
	]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("a custom HTML file has no href in the link", () async {
	await d.file("test.dart", "void main() {}").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test'>
	<script src="packages/test/dart.js"></script>
	</head>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: loading test.dart [E]',
	'Failed to load "test.dart": Expected <link rel="x-dart-test"> in '
	'test.html to have an "href" attribute.'
	]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("a custom HTML file has an invalid test URL", () async {
	await d.file("test.dart", "void main() {}").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test' href='wrong.dart'>
	<script src="packages/test/dart.js"></script>
	</head>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder([
	'-1: loading test.dart [E]',
	'Failed to load "test.dart": Failed to load script at '
	]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	// TODO(nweiz): test what happens when a test file is unreadable once issue
	// 15078 is fixed.
	});

	group("runs successful tests", () {
	test("on a JS and non-JS browser", () async {
	await d.file("test.dart", _success).create();
	var test =
	await runTest(["-p", "content-shell", "-p", "chrome", "test.dart"]);

	expect(test.stdoutStream(),
	neverEmits(contains("[Dartium Content Shell] compiling")));
	expect(test.stdout, emitsThrough(contains("[Chrome] compiling")));
	await test.shouldExit(0);
	}, tags: ['chrome', 'content-shell']);

	test("on a browser and the VM", () async {
	await d.file("test.dart", _success).create();
	var test =
	await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);

	expect(test.stdout, emitsThrough(contains("+2: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("with setUpAll", () async {
	await d.file("test.dart", r"""
	import 'package:test/test.dart';

	void main() {
	setUpAll(() => print("in setUpAll"));

	test("test", () {});
	}
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains('+0: (setUpAll)')));
	expect(test.stdout, emits('in setUpAll'));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("with tearDownAll", () async {
	await d.file("test.dart", r"""
	import 'package:test/test.dart';

	void main() {
	tearDownAll(() => print("in tearDownAll"));

	test("test", () {});
	}
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains('+1: (tearDownAll)')));
	expect(test.stdout, emits('in tearDownAll'));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	// Regression test; this broke in 0.12.0-beta.9.
	test("on a file in a subdirectory", () async {
	await d.dir("dir", [d.file("test.dart", _success)]).create();

	var test = await runTest(["-p", "chrome", "dir/test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'chrome');

	group("with a custom HTML file", () {
	setUp(() async {
	await d.file("test.dart", """
	import 'dart:html';

	import 'package:test/test.dart';

	void main() {
	test("success", () {
	expect(document.query('#foo'), isNotNull);
	});
	}
	""").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test' href='test.dart'>
	<script src="packages/test/dart.js"></script>
	</head>
	<body>
	<div id="foo"></div>
	</body>
	</html>
	""").create();
	});

	test("on content shell", () async {
	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("on Chrome", () async {
	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'chrome');

	// Regression test for https://github.com/dart-lang/test/issues/82.
	test("ignores irrelevant link tags", () async {
	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test-not'>
	<link rel='other' href='test.dart'>
	<link rel='x-dart-test' href='test.dart'>
	<script src="packages/test/dart.js"></script>
	</head>
	<body>
	<div id="foo"></div>
	</body>
	</html>
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');
	});
	});

	group("runs failing tests", () {
	test("that fail only on the browser", () async {
	await d.file("test.dart", """
	import 'dart:async';

	import 'package:path/path.dart' as p;
	import 'package:test/test.dart';

	void main() {
	test("test", () {
	if (p.style == p.Style.url) throw new TestFailure("oh no");
	});
	}
	""").create();

	var test =
	await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1 -1: Some tests failed.")));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("that fail only on the VM", () async {
	await d.file("test.dart", """
	import 'dart:async';

	import 'package:path/path.dart' as p;
	import 'package:test/test.dart';

	void main() {
	test("test", () {
	if (p.style != p.Style.url) throw new TestFailure("oh no");
	});
	}
	""").create();

	var test =
	await runTest(["-p", "content-shell", "-p", "vm", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1 -1: Some tests failed.")));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	group("with a custom HTML file", () {
	setUp(() async {
	await d.file("test.dart", """
	import 'dart:html';

	import 'package:test/test.dart';

	void main() {
	test("failure", () {
	expect(document.query('#foo'), isNull);
	});
	}
	""").create();

	await d.file("test.html", """
	<html>
	<head>
	<link rel='x-dart-test' href='test.dart'>
	<script src="packages/test/dart.js"></script>
	</head>
	<body>
	<div id="foo"></div>
	</body>
	</html>
	""").create();
	});

	test("on content shell", () async {
	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("on Chrome", () async {
	var test = await runTest(["-p", "chrome", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
	await test.shouldExit(1);
	}, tags: 'chrome');
	});
	});

	test("the compiler uses colors if the test runner uses colors", () async {
	await d.file("test.dart", "String main() => 12;\n").create();

	var test = await runTest(["--color", "-p", "chrome", "test.dart"]);
	expect(test.stdout, emitsThrough(contains('\u001b[35m')));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("forwards prints from the browser test", () async {
	await d.file("test.dart", """
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("test", () {
	print("Hello,");
	return new Future(() => print("world!"));
	});
	}
	""").create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsInOrder([emitsThrough("Hello,"), "world!"]));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("dartifies stack traces for JS-compiled tests by default", () async {
	await d.file("test.dart", _failure).create();

	var test = await runTest(["-p", "chrome", "--verbose-trace", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder(
	[" main.<fn>", "package:test", "dart:async/zone.dart"]));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("doesn't dartify stack traces for JS-compiled tests with --js-trace",
	() async {
	await d.file("test.dart", _failure).create();

	var test = await runTest(
	["-p", "chrome", "--verbose-trace", "--js-trace", "test.dart"]);
	expect(test.stdoutStream(), neverEmits(endsWith(" main.<fn>")));
	expect(test.stdoutStream(), neverEmits(contains("package:test")));
	expect(test.stdoutStream(), neverEmits(contains("dart:async/zone.dart")));
	expect(test.stdout, emitsThrough(contains("-1: Some tests failed.")));
	await test.shouldExit(1);
	}, tags: 'chrome');

	test("respects top-level @Timeout declarations", () async {
	await d.file("test.dart", '''
	@Timeout(const Duration(seconds: 0))

	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("timeout", () => new Future.delayed(Duration.ZERO));
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder(
	["Test timed out after 0 seconds.", "-1: Some tests failed."]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	group("with onPlatform", () {
	test("respects matching Skips", () async {
	await d.file("test.dart", '''
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("fail", () => throw 'oh no', onPlatform: {"browser": new Skip()});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+0 ~1: All tests skipped.")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("ignores non-matching Skips", () async {
	await d.file("test.dart", '''
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("success", () {}, onPlatform: {"vm": new Skip()});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("respects matching Timeouts", () async {
	await d.file("test.dart", '''
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("fail", () async {
	await new Future.delayed(Duration.ZERO);
	throw 'oh no';
	}, onPlatform: {
	"browser": new Timeout(Duration.ZERO)
	});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder(
	["Test timed out after 0 seconds.", "-1: Some tests failed."]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("ignores non-matching Timeouts", () async {
	await d.file("test.dart", '''
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("success", () {}, onPlatform: {
	"vm": new Timeout(new Duration(seconds: 0))
	});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("applies matching platforms in order", () async {
	await d.file("test.dart", '''
	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("success", () {}, onPlatform: {
	"browser": new Skip("first"),
	"browser \|\| windows": new Skip("second"),
	"browser \|\| linux": new Skip("third"),
	"browser \|\| mac-os": new Skip("fourth"),
	"browser \|\| android": new Skip("fifth")
	});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdoutStream(), neverEmits(contains("Skip: first")));
	expect(test.stdoutStream(), neverEmits(contains("Skip: second")));
	expect(test.stdoutStream(), neverEmits(contains("Skip: third")));
	expect(test.stdoutStream(), neverEmits(contains("Skip: fourth")));
	expect(test.stdout, emitsThrough(contains("Skip: fifth")));
	await test.shouldExit(0);
	}, tags: 'content-shell');
	});

	group("with an @OnPlatform annotation", () {
	test("respects matching Skips", () async {
	await d.file("test.dart", '''
	@OnPlatform(const {"browser": const Skip()})

	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("fail", () => throw 'oh no');
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("~1: All tests skipped.")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("ignores non-matching Skips", () async {
	await d.file("test.dart", '''
	@OnPlatform(const {"vm": const Skip()})

	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("success", () {});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(test.stdout, emitsThrough(contains("+1: All tests passed!")));
	await test.shouldExit(0);
	}, tags: 'content-shell');

	test("respects matching Timeouts", () async {
	await d.file("test.dart", '''
	@OnPlatform(const {
	"browser": const Timeout(const Duration(seconds: 0))
	})

	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("fail", () async {
	await new Future.delayed(Duration.ZERO);
	throw 'oh no';
	});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	expect(
	test.stdout,
	containsInOrder(
	["Test timed out after 0 seconds.", "-1: Some tests failed."]));
	await test.shouldExit(1);
	}, tags: 'content-shell');

	test("ignores non-matching Timeouts", () async {
	await d.file("test.dart", '''
	@OnPlatform(const {
	"vm": const Timeout(const Duration(seconds: 0))
	})

	import 'dart:async';

	import 'package:test/test.dart';

	void main() {
	test("success", () {});
	}
	''').create();

	var test = await runTest(["-p", "content-shell", "test.dart"]);
	await test.shouldExit(0);
	}, tags: 'content-shell');
	});
	}