| // Copyright (c) 2014, 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. |
| |
| // Checks that dart2js produces the expected static type warnings and |
| // compile-time errors for the provided multitests. |
| |
| import 'dart:async'; |
| import 'dart:io'; |
| |
| import 'package:async_helper/async_helper.dart'; |
| import 'package:compiler/src/commandline_options.dart'; |
| import 'package:compiler/src/util/uri_extras.dart' show relativize; |
| import 'memory_compiler.dart'; |
| |
| import '../../../tools/testing/dart/multitest.dart' |
| show ExtractTestsFromMultitest; |
| import '../../../tools/testing/dart/path.dart' show Path; |
| |
| /// Check the analysis of the multitests in [testFiles] to result in the |
| /// expected static warnings and compile-time errors. |
| /// |
| /// [testFiles] is a map of the test files to be checked together with their |
| /// associated white listing. |
| /// |
| /// For instance if [testFiles] contain the mapping |
| /// 'language/async_await_syntax_test.dart': const ['a03b', 'a04b'] |
| /// the multitests in 'language/async_await_syntax_test.dart' are checked but |
| /// the subtests 'a03b' and 'a04c' are expected to fail. |
| void check(Map<String, List<String>> testFiles, |
| {List<String> arguments: const <String>[], |
| List<String> options: const <String>[]}) { |
| bool outcomeMismatch = false; |
| bool verbose = arguments.contains('-v'); |
| var cachedCompiler; |
| asyncTest(() => Future.forEach(testFiles.keys, (String testFile) { |
| Map<String, String> testSources = {}; |
| Map<String, Set<String>> testOutcomes = {}; |
| String fileName = 'tests/$testFile'; |
| ExtractTestsFromMultitest( |
| new Path(fileName), testSources, testOutcomes); |
| return Future.forEach(testSources.keys, (String testName) async { |
| String testFileName = '$fileName/$testName'; |
| Set<String> expectedOutcome = testOutcomes[testName]; |
| bool expectFailure = testFiles[testFile].contains(testName); |
| DiagnosticCollector collector = new DiagnosticCollector(); |
| CompilationResult result = await runCompiler( |
| entryPoint: Uri.parse('memory:$testFileName'), |
| memorySourceFiles: {testFileName: testSources[testName]}, |
| diagnosticHandler: collector, |
| options: [Flags.analyzeOnly]..addAll(options), |
| showDiagnostics: verbose, |
| cachedCompiler: cachedCompiler); |
| var compiler = result.compiler; |
| bool unexpectedResult = false; |
| if (expectedOutcome.contains('compile-time error')) { |
| if (collector.errors.isEmpty) { |
| print('$testFileName: Missing compile-time error.'); |
| unexpectedResult = true; |
| } |
| } else if (expectedOutcome.contains('static type warning')) { |
| if (collector.warnings.isEmpty) { |
| print('$testFileName: Missing static type warning.'); |
| unexpectedResult = true; |
| } |
| } else { |
| // Expect ok. |
| if (!collector.errors.isEmpty || !collector.warnings.isEmpty) { |
| collector.errors.forEach((message) { |
| print('$testFileName: Unexpected error: ${message.message}'); |
| }); |
| collector.warnings.forEach((message) { |
| print('$testFileName: Unexpected warning: ${message.message}'); |
| }); |
| unexpectedResult = true; |
| } |
| } |
| if (expectFailure) { |
| if (unexpectedResult) { |
| unexpectedResult = false; |
| } else { |
| print('$testFileName: The test is white-listed ' |
| 'and therefore expected to fail.'); |
| unexpectedResult = true; |
| } |
| } |
| if (unexpectedResult) { |
| outcomeMismatch = true; |
| } |
| cachedCompiler = compiler; |
| }); |
| }).then((_) { |
| if (outcomeMismatch) { |
| String testFileName = |
| relativize(Uri.base, Platform.script, Platform.isWindows); |
| print(''' |
| |
| === |
| === ERROR: Unexpected result of analysis. |
| === |
| === Please update the white-listing in $testFileName |
| === |
| |
| '''); |
| exit(1); |
| } |
| })); |
| } |