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