blob: 4070676c351f7833cf2183969ca1f3c713f00ca0 [file] [log] [blame]
// @dart = 2.9
import 'dart:convert';
import 'dart:typed_data';
import 'package:_fe_analyzer_shared/src/scanner/token.dart';
import 'package:front_end/src/api_prototype/memory_file_system.dart';
import 'package:front_end/src/fasta/hybrid_file_system.dart';
import "../tool/dart_doctest_impl.dart" as impl;
main() async {
expectCategory = "comment extraction";
testCommentExtraction();
expectCategory = "test extraction";
testTestExtraction();
expectCategory = "test runs";
await testRunningTests();
}
void testRunningTests() async {
MemoryFileSystem memoryFileSystem =
new MemoryFileSystem(new Uri(scheme: "darttest", path: "/"));
HybridFileSystem hybridFileSystem = new HybridFileSystem(memoryFileSystem);
impl.DartDocTest dartDocTest = new impl.DartDocTest(
underlyingFileSystem: hybridFileSystem, silent: true);
// Good test
Uri test1 = new Uri(scheme: "darttest", path: "/test1.dart");
String test = """
// DartDocTest(1+1, 2)
main() {
print("Hello from main");
}
// DartDocTest(_internal(), 42)
int _internal() {
return 42;
}
""";
List<impl.Test> tests = extractTests(test, test1);
expect(tests.length, 2);
List<impl.TestResult> expected = [
new impl.TestResult(tests[0], impl.TestOutcome.Pass),
new impl.TestResult(tests[1], impl.TestOutcome.Pass),
];
memoryFileSystem.entityForUri(test1).writeAsStringSync(test);
expect(await dartDocTest.process(test1), expected);
// Mixed good/bad.
Uri test2 = new Uri(scheme: "darttest", path: "/test2.dart");
test = """
// DartDocTest(1+1, 3)
main() {
print("Hello from main");
}
// DartDocTest(_internal(), 43)
// DartDocTest(_internal(), 42)
int _internal() {
return 42;
}
""";
tests = extractTests(test, test2);
expect(tests.length, 3);
expected = [
new impl.TestResult(tests[0], impl.TestOutcome.Failed)
..message = "Expected '3'; got '2'.",
new impl.TestResult(tests[1], impl.TestOutcome.Failed)
..message = "Expected '43'; got '42'.",
new impl.TestResult(tests[2], impl.TestOutcome.Pass),
];
memoryFileSystem.entityForUri(test2).writeAsStringSync(test);
expect(await dartDocTest.process(test2), expected);
// Good case using await.
Uri test3 = new Uri(scheme: "darttest", path: "/test3.dart");
test = """
// DartDocTest(await _internal(), 42)
Future<int> _internal() async {
await Future.delayed(new Duration(milliseconds: 1));
return 42;
}
""";
tests = extractTests(test, test3);
expect(tests.length, 1);
expected = [
new impl.TestResult(tests[0], impl.TestOutcome.Pass),
];
memoryFileSystem.entityForUri(test3).writeAsStringSync(test);
expect(await dartDocTest.process(test3), expected);
// One test parse error and one good case.
Uri test4 = new Uri(scheme: "darttest", path: "/test4.dart");
test = """
// DartDocTest(_internal() 42)
// DartDocTest(_internal(), 42)
int _internal() {
return 42;
}
""";
tests = extractTests(test, test4);
expect(tests.length, 2);
expected = [
new impl.TestResult(tests[0], impl.TestOutcome.TestCompilationError)
..message = "Parse error @ 27",
new impl.TestResult(tests[1], impl.TestOutcome.Pass),
];
memoryFileSystem.entityForUri(test4).writeAsStringSync(test);
expect(await dartDocTest.process(test4), expected);
// Test with compile-time error. Note that this means no tests are compiled at
// all and that while the error messages are passed it spills the internals of
// the dartdocs stuff (e.g. the uri "dartdoctest:tester",
// calls to 'dartDocTest.test' etc).
Uri test5 = new Uri(scheme: "darttest", path: "/test5.dart");
test = """
// DartDocTest(_internal() + 2, 42)
// // DartDocTest(2+2, 4)
void _internal() {
return;
}
""";
tests = extractTests(test);
expect(tests.length, 2);
expected = [
new impl.TestResult(null, impl.TestOutcome.CompilationError)
..message =
"""dartdoctest:tester:3:20: Error: This expression has type 'void' and can't be used.
dartDocTest.test(_internal() + 2, 42);
^
dartdoctest:tester:3:32: Error: The operator '+' isn't defined for the class 'void'.
Try correcting the operator to an existing operator, or defining a '+' operator.
dartDocTest.test(_internal() + 2, 42);
^""",
];
memoryFileSystem.entityForUri(test5).writeAsStringSync(test);
expect(await dartDocTest.process(test5), expected);
// Test with runtime error.
Uri test6 = new Uri(scheme: "darttest", path: "/test6.dart");
test = """
// DartDocTest(_internal() + 2, 42)
// // DartDocTest(2+2, 4)
dynamic _internal() {
return "hello";
}
""";
tests = extractTests(test);
expect(tests.length, 2);
expected = [
new impl.TestResult(tests[0], impl.TestOutcome.Crash)
// this weird message is from the VM!
..message = "type 'int' is not a subtype of type 'String' of 'other'",
new impl.TestResult(tests[1], impl.TestOutcome.Pass),
];
memoryFileSystem.entityForUri(test6).writeAsStringSync(test);
expect(await dartDocTest.process(test6), expected);
// Good/bad test with private static class method.
Uri test7 = new Uri(scheme: "darttest", path: "/test7.dart");
test = """
class Foo {
// DartDocTest(Foo._internal(), 42)
// DartDocTest(Foo._internal(), 44)
static int _internal() {
return 42;
}
}
""";
tests = extractTests(test, test7);
expect(tests.length, 2);
expected = [
new impl.TestResult(tests[0], impl.TestOutcome.Pass),
new impl.TestResult(tests[1], impl.TestOutcome.Failed)
..message = "Expected '44'; got '42'.",
];
memoryFileSystem.entityForUri(test7).writeAsStringSync(test);
expect(await dartDocTest.process(test7), expected);
}
void testTestExtraction() {
// No tests.
expect(extractTests(""), <impl.Test>[]);
// One test.
expect(extractTests("// DartDocTest(1+1, 2)"), <impl.Test>[
new impl.ExpectTest("1+1", "2"),
]);
// Two tests.
expect(extractTests("""
// DartDocTest(1+1, 2)
// DartDocTest(2+40, 42)
"""), <impl.Test>[
new impl.ExpectTest("1+1", "2"),
new impl.ExpectTest("2+40", "42"),
]);
// Two valid tests. Four invalid ones.
expect(extractTests("""
// DartDocTest(1+1, 2)
// DartDocTest(2+40; 42]
// DartDocTest(2+40+, 42]
// DartDocTest(2+40, 42]
// DartDocTest(2+40, 42)
// DartDocTest(2+40, 42+)
"""), <impl.Test>[
new impl.ExpectTest("1+1", "2"),
new impl.TestParseError(
"""darttest:/foo.dart:2:20: Expected ',' before this.
// DartDocTest(2+40; 42]
^""", 42),
new impl.TestParseError("""Parse error(s):
darttest:/foo.dart:3:21: Expected an identifier, but got ','.
// DartDocTest(2+40+, 42]
^""", 68),
new impl.TestParseError(
"""darttest:/foo.dart:4:24: Expected ')' before this.
// DartDocTest(2+40, 42]
^""", 97),
new impl.ExpectTest("2+40", "42"),
new impl.TestParseError("""Parse error(s):
darttest:/foo.dart:6:25: Expected an identifier, but got ')'.
// DartDocTest(2+40, 42+)
^""", 148),
]);
// Two tests in block comments with back-ticks around tests.
expect(extractTests("""
/**
* This is a test:
* ```
* DartDocTest(1+1, 2)
* ```
* and so is this:
* ```
* DartDocTest(2+40, 42)
* ```
*/
"""), <impl.Test>[
new impl.ExpectTest("1+1", "2"),
new impl.ExpectTest("2+40", "42"),
]);
// Two tests --- include linebreaks.
expect(extractTests("""
/*
This is a test:
DartDocTest(1+1,
2)
and so is this:
DartDocTest(2+
40,
42)
*/
"""), <impl.Test>[
new impl.ExpectTest("1+1", "2"),
// The linebreak etc here is not stripped (at the moment at least)
new impl.ExpectTest("2+\n 40", "42"),
]);
// Two tests --- with parens and commas as string...
expect(extractTests("""
// DartDocTest("(", "(")
// and so is this:
// DartDocTest(",)", ",)")
"""), <impl.Test>[
new impl.ExpectTest('"("', '"("'),
new impl.ExpectTest('",)"', '",)"'),
]);
// Await expression.
expect(extractTests("""
// DartDocTest(await foo(), 42)
"""), <impl.Test>[
new impl.ExpectTest('await foo()', '42'),
]);
}
void testCommentExtraction() {
// No comment
expect(extractFirstComment(""), null);
// Simple line comment at position 0.
expect(
extractFirstComment("// Hello"), new impl.CommentString(" Hello", 0));
// Simple line comment at position 5.
expect(extractFirstComment(" // Hello"),
new impl.CommentString(" Hello", 5));
// Multiline simple comment at position 20.
expect(extractFirstComment("""
import 'foo.dart';
// This is
// a
// multiline
// comment
import 'bar.dart'"""), new impl.CommentString("""
This is
a
multiline
comment""", 20));
// Multiline simple comment (with 3 slashes) at position 20.
expect(extractFirstComment("""
import 'foo.dart';
/// This is
/// a
/// multiline
/// comment
import 'bar.dart'"""), new impl.CommentString("""
This is
a
multiline
comment""", 20));
// Multiline comments with /* at position 20.
expect(extractFirstComment("""
import 'foo.dart';
/* This is
a
multiline
comment
*/
import 'bar.dart'"""), new impl.CommentString("""
This is
a
multiline
comment
""", 20));
// Multiline comments with /* at position 20. Note that the comment has
// * at the start of the line but that they aren't stripped because the
// comments starts with /* and NOT with /**.
expect(extractFirstComment("""
import 'foo.dart';
/* This is
*a
* multiline
*comment
*/
import 'bar.dart'"""), new impl.CommentString("""
This is
*a
* multiline
*comment
""", 20));
// Multiline comments with /** */ at position 20. Note that the comment has
// * at the start of the line and that they are stripped because the
// comments starts with /** and NOT with only /*.
expect(extractFirstComment("""
import 'foo.dart';
/** This is
*a
* multiline
*comment
*/
import 'bar.dart'"""), new impl.CommentString("""
This is
a
multiline
comment
""", 20));
// Multiline comment with block comment inside at position 20.
// The block comment data is not stripped.
expect(extractFirstComment("""
import 'foo.dart';
/// This is
/// /*a*/
/// multiline comment"""), new impl.CommentString("""
This is
/*a*/
multiline comment""", 20));
}
int expectCalls = 0;
String expectCategory;
void expect(dynamic actual, dynamic expected) {
expectCalls++;
StringBuffer sb = new StringBuffer();
if (!_expectImpl(actual, expected, sb)) {
if (sb.isNotEmpty) {
throw "Error! Expected '$expected' but got '$actual'"
"\n\n"
"Explanation: $sb.";
} else {
throw "Error! Expected '$expected' but got '$actual'";
}
}
print("Expect #$expectCalls ($expectCategory) OK.");
}
bool _expectImpl(dynamic actual, dynamic expected, StringBuffer explainer) {
if (identical(actual, expected)) return true;
if (actual == expected) return true;
if (actual == null || expected == null) return false;
if (actual is List && expected is List) {
if (actual.runtimeType != expected.runtimeType) {
explainer.write("List runtimeType difference: "
"${actual.runtimeType} vs ${expected.runtimeType}");
return false;
}
if (actual.length != expected.length) {
explainer.write("List length difference: "
"${actual.length} vs ${expected.length}");
return false;
}
for (int i = 0; i < actual.length; i++) {
if (actual[i] != expected[i]) {
explainer.write("List difference at index $i: "
"${actual[i]} vs ${expected[i]}");
return false;
}
}
return true;
}
if (actual is List || expected is List) return false;
if (actual is Map && expected is Map) {
if (actual.runtimeType != expected.runtimeType) return false;
if (actual.length != expected.length) return false;
for (dynamic key in actual.keys) {
if (!expected.containsKey(key)) return false;
if (actual[key] != expected[key]) return false;
}
return true;
}
if (actual is Map || expected is Map) return false;
if (actual is Set && expected is Set) {
if (actual.runtimeType != expected.runtimeType) return false;
if (actual.length != expected.length) return false;
for (dynamic value in actual) {
if (!expected.contains(value)) return false;
}
return true;
}
if (actual is Set || expected is Set) return false;
// More stuff?
return false;
}
impl.CommentString extractFirstComment(String test) {
Token firstToken = impl.scanRawBytes(utf8.encode(test) as Uint8List);
Token token = firstToken;
while (true) {
CommentToken comment = token.precedingComments;
if (comment != null) {
return impl.extractComments(comment, test);
}
if (token.isEof) break;
Token next = token.next;
if (next == null) break;
token = next;
}
return null;
}
List<impl.Test> extractTests(String test, [Uri uri]) {
return impl.extractTests(utf8.encode(test) as Uint8List,
uri ?? new Uri(scheme: "darttest", path: "/foo.dart"));
}