blob: fa3df1e28d0d95f684feae459a548e22194e73ea [file] [log] [blame]
// 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.
import 'dart:async';
import 'dart:io';
import 'package:analyzer/error/error.dart';
import 'package:analyzer/source/error_processor.dart';
import 'package:analyzer/src/analysis_options/analysis_options_provider.dart';
import 'package:analyzer/src/error/codes.dart';
import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/summary/idl.dart';
import 'package:analyzer/src/util/sdk.dart';
import 'package:analyzer_cli/src/ansi.dart' as ansi;
import 'package:analyzer_cli/src/driver.dart';
import 'package:analyzer_cli/src/options.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'package:yaml/src/yaml_node.dart';
import 'utils.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(BuildModeTest);
defineReflectiveTests(ExitCodesTest);
defineReflectiveTests(ExitCodesTest_PreviewDart2);
defineReflectiveTests(ExitCodesTest_UseCFE);
defineReflectiveTests(LinterTest);
defineReflectiveTests(LinterTest_PreviewDart2);
defineReflectiveTests(LinterTest_UseCFE);
defineReflectiveTests(NonDartFilesTest);
defineReflectiveTests(OptionsTest);
defineReflectiveTests(OptionsTest_PreviewDart2);
defineReflectiveTests(OptionsTest_UseCFE);
}, name: 'Driver');
}
class BaseTest {
static const emptyOptionsFile = 'data/empty_options.yaml';
StringSink _savedOutSink, _savedErrorSink;
int _savedExitCode;
ExitHandler _savedExitHandler;
Driver driver;
AnalysisOptions get analysisOptions => driver.analysisDriver.analysisOptions;
bool get useCFE => false;
bool get usePreviewDart2 => false;
/// Normalize text with bullets.
String bulletToDash(item) => '$item'.replaceAll('•', '-');
/// Start a driver for the given [source], optionally providing additional
/// [args] and an [options] file path. The value of [options] defaults to an
/// empty options file to avoid unwanted configuration from an otherwise
/// discovered options file.
Future<Null> drive(
String source, {
String options: emptyOptionsFile,
List<String> args: const <String>[],
}) {
return driveMany([source], options: options, args: args);
}
/// Like [drive], but takes an array of sources.
Future<Null> driveMany(
List<String> sources, {
String options: emptyOptionsFile,
List<String> args: const <String>[],
}) async {
driver = new Driver(isTesting: true);
var cmd = <String>[];
if (options != null) {
cmd = <String>[
'--options',
path.join(testDirectory, options),
];
}
cmd..addAll(sources.map(_adjustFileSpec))..addAll(args);
if (usePreviewDart2) {
cmd.insert(0, '--preview-dart-2');
}
if (useCFE) {
cmd.insert(0, '--use-cfe');
}
await driver.start(cmd);
}
void setUp() {
ansi.runningTests = true;
_savedOutSink = outSink;
_savedErrorSink = errorSink;
_savedExitHandler = exitHandler;
_savedExitCode = exitCode;
exitHandler = (code) => exitCode = code;
outSink = new StringBuffer();
errorSink = new StringBuffer();
}
void tearDown() {
outSink = _savedOutSink;
errorSink = _savedErrorSink;
exitCode = _savedExitCode;
exitHandler = _savedExitHandler;
ansi.runningTests = false;
}
/// Convert a file specification from a relative path to an absolute path.
/// Handles the case where the file specification is of the form "$uri|$path".
String _adjustFileSpec(String fileSpec) {
int uriPrefixLength = fileSpec.indexOf('|') + 1;
String uriPrefix = fileSpec.substring(0, uriPrefixLength);
String relativePath = fileSpec.substring(uriPrefixLength);
return '$uriPrefix${path.join(testDirectory, relativePath)}';
}
}
@reflectiveTest
class BuildModeTest extends BaseTest {
test_buildLinked() async {
await withTempDirAsync((tempDir) async {
var outputPath = path.join(tempDir, 'test_file.dart.sum');
await _doDrive(path.join('data', 'test_file.dart'), additionalArgs: [
'--build-summary-only',
'--build-summary-output=$outputPath'
]);
var output = new File(outputPath);
expect(output.existsSync(), isTrue);
PackageBundle bundle =
new PackageBundle.fromBuffer(await output.readAsBytes());
var testFileUri = 'file:///test_file.dart';
expect(bundle.unlinkedUnitUris, equals([testFileUri]));
expect(bundle.linkedLibraryUris, equals([testFileUri]));
expect(exitCode, 0);
});
}
test_buildLinked_buildSummaryOutputSemantic() async {
await withTempDirAsync((tempDir) async {
var testDart = path.join(tempDir, 'test.dart');
var testSumFull = path.join(tempDir, 'test.sum.full');
var testSumSemantic = path.join(tempDir, 'test.sum.sem');
new File(testDart).writeAsStringSync('var v = 42;');
await _doDrive(testDart, additionalArgs: [
'--build-summary-only',
'--build-summary-output=$testSumFull',
'--build-summary-output-semantic=$testSumSemantic',
]);
expect(exitCode, 0);
// The full summary is produced.
{
var file = new File(testSumFull);
expect(file.existsSync(), isTrue);
var bytes = file.readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
var v = bundle.unlinkedUnits[0].variables[0];
expect(v.name, 'v');
expect(v.nameOffset, 4);
}
// The semantic summary is produced.
{
var file = new File(testSumSemantic);
expect(file.existsSync(), isTrue);
var bytes = file.readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
var v = bundle.unlinkedUnits[0].variables[0];
expect(v.name, 'v');
expect(v.nameOffset, 0);
}
});
}
test_buildLinked_fromUnlinked() async {
await withTempDirAsync((tempDir) async {
var aDart = path.join(tempDir, 'a.dart');
var bDart = path.join(tempDir, 'b.dart');
var aUri = 'package:aaa/a.dart';
var bUri = 'package:bbb/b.dart';
var aUnlinked = path.join(tempDir, 'a.unlinked');
var bUnlinked = path.join(tempDir, 'b.unlinked');
var abLinked = path.join(tempDir, 'ab.linked');
new File(aDart).writeAsStringSync('var a = 1;');
new File(bDart).writeAsStringSync('''
import 'package:aaa/a.dart';
var b = a;
''');
Future<Null> buildUnlinked(String uri, String path, String output) async {
await _doDrive(path, uri: uri, additionalArgs: [
'--build-summary-only',
'--build-summary-only-unlinked',
'--build-summary-output=$output'
]);
expect(exitCode, 0);
expect(new File(output).existsSync(), isTrue);
}
await buildUnlinked(aUri, aDart, aUnlinked);
await buildUnlinked(bUri, bDart, bUnlinked);
await new Driver(isTesting: true).start([
'--dart-sdk',
_findSdkDirForSummaries(),
'--strong',
'--build-mode',
'--build-summary-unlinked-input=$aUnlinked,$bUnlinked',
'--build-summary-output=$abLinked'
]);
expect(exitCode, 0);
var bytes = new File(abLinked).readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
// Only linked information.
expect(bundle.unlinkedUnitUris, isEmpty);
expect(bundle.linkedLibraryUris, unorderedEquals([aUri, bUri]));
// Strong mode type inference was performed.
expect(bundle.linkedLibraries[0].units[0].types, isNotEmpty);
expect(bundle.linkedLibraries[1].units[0].types, isNotEmpty);
});
}
test_buildSuppressExitCode_fail_whenFileNotFound() async {
await _doDrive(path.join('data', 'non_existent_file.dart'),
additionalArgs: ['--build-suppress-exit-code']);
expect(exitCode, isNot(0));
}
test_buildSuppressExitCode_success_evenIfHasError() async {
await _doDrive(path.join('data', 'file_with_error.dart'),
additionalArgs: ['--build-suppress-exit-code']);
expect(exitCode, 0);
}
test_buildUnlinked() async {
await withTempDirAsync((tempDir) async {
var outputPath = path.join(tempDir, 'test_file.dart.sum');
await _doDrive(path.join('data', 'test_file.dart'), additionalArgs: [
'--build-summary-only',
'--build-summary-only-unlinked',
'--build-summary-output=$outputPath'
]);
var output = new File(outputPath);
expect(output.existsSync(), isTrue);
PackageBundle bundle =
new PackageBundle.fromBuffer(await output.readAsBytes());
var testFileUri = 'file:///test_file.dart';
expect(bundle.unlinkedUnits.length, 1);
expect(bundle.unlinkedUnitUris, equals([testFileUri]));
expect(bundle.linkedLibraryUris, isEmpty);
expect(exitCode, 0);
});
}
test_consumeLinked() async {
await withTempDirAsync((tempDir) async {
var aDart = path.join(tempDir, 'a.dart');
var bDart = path.join(tempDir, 'b.dart');
var cDart = path.join(tempDir, 'c.dart');
var aUri = 'package:aaa/a.dart';
var bUri = 'package:bbb/b.dart';
var cUri = 'package:ccc/c.dart';
var aSum = path.join(tempDir, 'a.sum');
var bSum = path.join(tempDir, 'b.sum');
var cSum = path.join(tempDir, 'c.sum');
new File(aDart).writeAsStringSync('class A {}');
new File(bDart).writeAsStringSync('''
export 'package:aaa/a.dart';
class B {}
''');
new File(cDart).writeAsStringSync('''
import 'package:bbb/b.dart';
var a = new A();
var b = new B();
''');
// Analyze package:aaa/a.dart and compute summary.
{
await _doDrive(aDart,
uri: aUri, additionalArgs: ['--build-summary-output=$aSum']);
expect(exitCode, 0);
var bytes = new File(aSum).readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
expect(bundle.unlinkedUnitUris, equals([aUri]));
expect(bundle.linkedLibraryUris, equals([aUri]));
}
// Analyze package:bbb/b.dart and compute summary.
{
await _doDrive(bDart, uri: bUri, additionalArgs: [
'--build-summary-input=$aSum',
'--build-summary-output=$bSum'
]);
expect(exitCode, 0);
var bytes = new File(bSum).readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
expect(bundle.unlinkedUnitUris, equals([bUri]));
expect(bundle.linkedLibraryUris, equals([bUri]));
}
// Analyze package:ccc/c.dart and compute summary.
{
await _doDrive(cDart, uri: cUri, additionalArgs: [
'--build-summary-input=$aSum,$bSum',
'--build-summary-output=$cSum'
]);
expect(exitCode, 0);
var bytes = new File(cSum).readAsBytesSync();
var bundle = new PackageBundle.fromBuffer(bytes);
expect(bundle.unlinkedUnitUris, equals([cUri]));
expect(bundle.linkedLibraryUris, equals([cUri]));
}
});
}
test_dartSdkSummaryPath_strong() async {
await withTempDirAsync((tempDir) async {
String sdkPath = _findSdkDirForSummaries();
String strongSummaryPath =
path.join(sdkPath, 'lib', '_internal', 'strong.sum');
var testDart = path.join(tempDir, 'test.dart');
var testSum = path.join(tempDir, 'test.sum');
new File(testDart).writeAsStringSync('var v = 42;');
await _doDrive(testDart,
additionalArgs: [
'--strong',
'--build-summary-only',
'--build-summary-output=$testSum'
],
dartSdkSummaryPath: strongSummaryPath);
var output = new File(testSum);
expect(output.existsSync(), isTrue);
expect(exitCode, 0);
});
}
test_error_linkedAsUnlinked() async {
await withTempDirAsync((tempDir) async {
var aDart = path.join(tempDir, 'a.dart');
var bDart = path.join(tempDir, 'b.dart');
var aUri = 'package:aaa/a.dart';
var bUri = 'package:bbb/b.dart';
var aSum = path.join(tempDir, 'a.sum');
var bSum = path.join(tempDir, 'b.sum');
new File(aDart).writeAsStringSync('class A {}');
// Build linked a.sum
await _doDrive(aDart, uri: aUri, additionalArgs: [
'--build-summary-only',
'--build-summary-output=$aSum'
]);
expect(new File(aSum).existsSync(), isTrue);
// Try to consume linked a.sum as unlinked.
try {
await _doDrive(bDart, uri: bUri, additionalArgs: [
'--build-summary-unlinked-input=$aSum',
'--build-summary-output=$bSum'
]);
fail('ArgumentError expected.');
} on ArgumentError catch (e) {
expect(
e.message,
contains(
'Got a linked summary for --build-summary-input-unlinked'));
}
});
}
test_error_notUriPipePath() async {
await withTempDirAsync((tempDir) async {
var testDart = path.join(tempDir, 'test.dart');
new File(testDart).writeAsStringSync('var v = 42;');
// We pass just path, not "uri|path", this is a fatal error.
await drive(testDart, args: ['--build-mode', '--format=machine']);
expect(exitCode, ErrorSeverity.ERROR.ordinal);
});
}
test_error_unlinkedAsLinked() async {
await withTempDirAsync((tempDir) async {
var aDart = path.join(tempDir, 'a.dart');
var bDart = path.join(tempDir, 'b.dart');
var aUri = 'package:aaa/a.dart';
var bUri = 'package:bbb/b.dart';
var aSum = path.join(tempDir, 'a.sum');
var bSum = path.join(tempDir, 'b.sum');
new File(aDart).writeAsStringSync('class A {}');
// Build unlinked a.sum
await _doDrive(aDart, uri: aUri, additionalArgs: [
'--build-summary-only',
'--build-summary-only-unlinked',
'--build-summary-output=$aSum'
]);
expect(new File(aSum).existsSync(), isTrue);
// Try to consume unlinked a.sum as linked.
try {
await _doDrive(bDart, uri: bUri, additionalArgs: [
'--build-summary-input=$aSum',
'--build-summary-output=$bSum'
]);
fail('ArgumentError expected.');
} on ArgumentError catch (e) {
expect(e.message,
contains('Got an unlinked summary for --build-summary-input'));
}
});
}
test_fail_whenHasError() async {
await _doDrive(path.join('data', 'file_with_error.dart'));
expect(exitCode, isNot(0));
}
test_noStatistics() async {
await _doDrive(path.join('data', 'test_file.dart'));
// Should not print statistics summary.
expect(outSink.toString(), isEmpty);
expect(errorSink.toString(), isEmpty);
expect(exitCode, 0);
}
test_onlyErrors_partFirst() async {
await withTempDirAsync((tempDir) async {
var aDart = path.join(tempDir, 'a.dart');
var bDart = path.join(tempDir, 'b.dart');
var aUri = 'package:aaa/a.dart';
var bUri = 'package:aaa/b.dart';
new File(aDart).writeAsStringSync(r'''
library lib;
part 'b.dart';
class A {}
''');
new File(bDart).writeAsStringSync('''
part of lib;
class B {}
var a = new A();
var b = new B();
''');
// Analyze b.dart (part) and then a.dart (its library).
// No errors should be reported - the part should know its library.
await _doDrive(bDart, uri: bUri, additionalArgs: ['$aUri|$aDart']);
expect(errorSink, isEmpty);
});
}
Future<Null> _doDrive(String path,
{String uri,
List<String> additionalArgs: const [],
String dartSdkSummaryPath}) async {
var optionsFileName = AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
List<String> args = <String>[];
if (dartSdkSummaryPath != null) {
args.add('--dart-sdk-summary');
args.add(dartSdkSummaryPath);
} else {
String sdkPath = _findSdkDirForSummaries();
args.add('--dart-sdk');
args.add(sdkPath);
}
args.add('--build-mode');
args.add('--format=machine');
args.addAll(additionalArgs);
uri ??= 'file:///test_file.dart';
String source = '$uri|$path';
await drive(source,
args: args, options: 'data/options_tests_project/$optionsFileName');
}
/// Try to find a appropriate directory to pass to "--dart-sdk" that will
/// allow summaries to be found.
String _findSdkDirForSummaries() {
Set<String> triedDirectories = new Set<String>();
bool isSuitable(String sdkDir) {
triedDirectories.add(sdkDir);
return new File(path.join(sdkDir, 'lib', '_internal', 'spec.sum'))
.existsSync();
}
// Usually the sdk directory is the parent of the parent of the "dart"
// executable.
Directory executableParent = new File(Platform.executable).parent;
Directory executableGrandparent = executableParent.parent;
if (isSuitable(executableGrandparent.path)) {
return executableGrandparent.path;
}
// During build bot execution, the sdk directory is simply the parent of the
// "dart" executable.
if (isSuitable(executableParent.path)) {
return executableParent.path;
}
// If neither of those are suitable, assume we are running locally within the
// SDK project (e.g. within an IDE). Find the build output directory and
// search all built configurations.
Directory sdkRootDir =
new File(Platform.script.toFilePath()).parent.parent.parent.parent;
for (String outDirName in ['out', 'xcodebuild']) {
Directory outDir = new Directory(path.join(sdkRootDir.path, outDirName));
if (outDir.existsSync()) {
for (FileSystemEntity subdir in outDir.listSync()) {
if (subdir is Directory) {
String candidateSdkDir = path.join(subdir.path, 'dart-sdk');
if (isSuitable(candidateSdkDir)) {
return candidateSdkDir;
}
}
}
}
}
throw new Exception('Could not find an SDK directory containing summaries.'
' Tried: ${triedDirectories.toList()}');
}
}
@reflectiveTest
class ExitCodesTest extends BaseTest {
test_bazelWorkspace_relativePath() async {
// Copy to temp dir so that existing analysis options
// in the test directory hierarchy do not interfere
await withTempDirAsync((String tempDirPath) async {
String dartSdkPath = path.absolute(getSdkPath());
await recursiveCopy(
new Directory(path.join(testDirectory, 'data', 'bazel')),
tempDirPath);
Directory origWorkingDir = Directory.current;
try {
Directory.current = path.join(tempDirPath, 'proj');
Driver driver = new Driver(isTesting: true);
try {
await driver.start([
path.join('lib', 'file.dart'),
'--dart-sdk',
dartSdkPath,
]);
} catch (e) {
print('=== debug info ===');
print('dartSdkPath: $dartSdkPath');
print('stderr:\n${errorSink.toString()}');
rethrow;
}
expect(errorSink.toString(), isEmpty);
expect(outSink.toString(), contains('No issues found'));
expect(exitCode, 0);
} finally {
Directory.current = origWorkingDir;
}
});
}
test_enableAssertInitializer() async {
await drive('data/file_with_assert_initializers.dart',
args: ['--enable-assert-initializers']);
expect(exitCode, 0);
}
test_fatalErrors() async {
await drive('data/file_with_error.dart');
expect(exitCode, 3);
}
test_fatalHints() async {
await drive('data/file_with_hint.dart', args: ['--fatal-hints']);
expect(exitCode, 1);
}
test_fatalWarnings() async {
await drive('data/file_with_warning.dart', args: ['--fatal-warnings']);
expect(exitCode, 2);
}
test_missingDartFile() async {
await drive('data/NO_DART_FILE_HERE.dart');
expect(exitCode, 3);
}
test_missingOptionsFile() async {
await drive('data/test_file.dart', options: 'data/NO_OPTIONS_HERE');
expect(exitCode, 3);
}
test_notFatalHints() async {
await drive('data/file_with_hint.dart');
expect(exitCode, 0);
}
test_notFatalWarnings() async {
await drive('data/file_with_warning.dart');
expect(exitCode, 0);
}
test_partFile() async {
await driveMany([
path.join(testDirectory, 'data/library_and_parts/lib.dart'),
path.join(testDirectory, 'data/library_and_parts/part1.dart')
]);
expect(exitCode, 0);
}
test_partFile_dangling() async {
await drive('data/library_and_parts/part2.dart');
expect(exitCode, 3);
}
test_partFile_extra() async {
await driveMany([
path.join(testDirectory, 'data/library_and_parts/lib.dart'),
path.join(testDirectory, 'data/library_and_parts/part1.dart'),
path.join(testDirectory, 'data/library_and_parts/part2.dart')
]);
expect(exitCode, 3);
}
test_partFile_reversed() async {
Driver driver = new Driver(isTesting: true);
await driver.start([
path.join(testDirectory, 'data/library_and_parts/part1.dart'),
path.join(testDirectory, 'data/library_and_parts/lib.dart')
]);
expect(exitCode, 0);
}
}
@reflectiveTest
class ExitCodesTest_PreviewDart2 extends ExitCodesTest {
@override
bool get usePreviewDart2 => true;
}
@reflectiveTest
class ExitCodesTest_UseCFE extends ExitCodesTest {
@override
bool get useCFE => true;
@override
@failingTest
test_fatalWarnings() => callFailingTest(super.test_fatalWarnings);
}
@reflectiveTest
class LinterTest extends BaseTest {
String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
test_containsLintRuleEntry() async {
YamlMap options = _parseOptions('''
linter:
rules:
- foo
''');
expect(containsLintRuleEntry(options), true);
options = _parseOptions('''
''');
expect(containsLintRuleEntry(options), false);
options = _parseOptions('''
linter:
rules:
# - foo
''');
expect(containsLintRuleEntry(options), true);
options = _parseOptions('''
linter:
# rules:
# - foo
''');
expect(containsLintRuleEntry(options), false);
}
test_defaultLints_generatedLints() async {
await _runLinter_defaultLints();
expect(bulletToDash(outSink),
contains('lint - Name types using UpperCamelCase'));
}
test_defaultLints_getsDefaultLints() async {
await _runLinter_defaultLints();
/// Lints should be enabled.
expect(analysisOptions.lint, isTrue);
/// Default list should include camel_case_types.
var lintNames = analysisOptions.lintRules.map((r) => r.name);
expect(lintNames, contains('camel_case_types'));
}
test_lintsInOptions_generatedLints() async {
await _runLinter_lintsInOptions();
expect(bulletToDash(outSink),
contains('lint - Name types using UpperCamelCase'));
}
test_lintsInOptions_getAnalysisOptions() async {
await _runLinter_lintsInOptions();
/// Lints should be enabled.
expect(analysisOptions.lint, isTrue);
/// The analysis options file only specifies 'camel_case_types'.
var lintNames = analysisOptions.lintRules.map((r) => r.name);
expect(lintNames, orderedEquals(['camel_case_types']));
}
test_noLints_lintsDisabled() async {
await _runLinter_noLintsFlag();
expect(analysisOptions.lint, isFalse);
}
test_noLints_noGeneratedWarnings() async {
await _runLinter_noLintsFlag();
expect(outSink.toString(), contains('No issues found'));
}
test_noLints_noRegisteredLints() async {
await _runLinter_noLintsFlag();
expect(analysisOptions.lintRules, isEmpty);
}
YamlMap _parseOptions(String src) =>
new AnalysisOptionsProvider().getOptionsFromString(src);
Future<Null> _runLinter_defaultLints() async {
await drive('data/linter_project/test_file.dart',
options: 'data/linter_project/$optionsFileName', args: ['--lints']);
}
Future<Null> _runLinter_lintsInOptions() async {
await drive('data/linter_project/test_file.dart',
options: 'data/linter_project/$optionsFileName', args: ['--lints']);
}
Future<Null> _runLinter_noLintsFlag() async {
await drive('data/no_lints_project/test_file.dart',
options: 'data/no_lints_project/$optionsFileName');
}
}
@reflectiveTest
class LinterTest_PreviewDart2 extends LinterTest {
@override
bool get usePreviewDart2 => true;
}
@reflectiveTest
class LinterTest_UseCFE extends LinterTest {
@override
bool get useCFE => true;
}
@reflectiveTest
class NonDartFilesTest extends BaseTest {
test_analysisOptionsYaml() async {
await withTempDirAsync((tempDir) async {
String filePath =
path.join(tempDir, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
new File(filePath).writeAsStringSync('''
analyzer:
string-mode: true
''');
await drive(filePath);
expect(
bulletToDash(outSink),
contains(
"warning - The option 'string-mode' isn't supported by 'analyzer'"));
expect(exitCode, 0);
});
}
test_pubspecYaml() async {
await withTempDirAsync((tempDir) async {
String filePath = path.join(tempDir, AnalysisEngine.PUBSPEC_YAML_FILE);
new File(filePath).writeAsStringSync('''
name: foo
flutter:
assets:
doesNotExist.gif
''');
await drive(filePath);
expect(
bulletToDash(outSink),
contains(
"warning - The value of the 'asset' field is expected to be a list of relative file paths"));
expect(exitCode, 0);
});
}
}
@reflectiveTest
class OptionsTest extends BaseTest {
String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
List<ErrorProcessor> get processors => analysisOptions.errorProcessors;
ErrorProcessor processorFor(AnalysisError error) =>
processors.firstWhere((p) => p.appliesTo(error));
test_analysisOptions_excludes() async {
await drive('data/exclude_test_project',
options: 'data/exclude_test_project/$optionsFileName');
_expectUndefinedClassErrorsWithoutExclusions();
}
test_analysisOptions_excludesRelativeToAnalysisOptions_explicit() async {
// The exclude is relative to the project, not/ the analyzed path, and it
// has to then understand that.
await drive('data/exclude_test_project',
options: 'data/exclude_test_project/$optionsFileName');
_expectUndefinedClassErrorsWithoutExclusions();
}
test_analysisOptions_excludesRelativeToAnalysisOptions_inferred() async {
// By passing no options, and the path `lib`, it should discover the
// analysis_options above lib. The exclude is relative to the project, not
// the analyzed path, and it has to then understand that.
await drive('data/exclude_test_project/lib', options: null);
_expectUndefinedClassErrorsWithoutExclusions();
}
test_analyzeFilesInDifferentContexts() async {
await driveMany([
'data/linter_project/test_file.dart',
'data/no_lints_project/test_file.dart',
], options: null);
// Should have the lint in the project with lint rules enabled.
expect(
bulletToDash(outSink),
contains(path.join('linter_project', 'test_file.dart') +
':7:7 - camel_case_types'));
// Should be just one lint in total.
expect(outSink.toString(), contains('1 lint found.'));
}
test_basic_filters() async {
await _driveBasic();
expect(processors, hasLength(3));
// unused_local_variable: ignore
var unused_local_variable = new AnalysisError(
new TestSource(), 0, 1, HintCode.UNUSED_LOCAL_VARIABLE, [
['x']
]);
expect(processorFor(unused_local_variable).severity, isNull);
// missing_return: error
var missing_return =
new AnalysisError(new TestSource(), 0, 1, HintCode.MISSING_RETURN, [
['x']
]);
expect(processorFor(missing_return).severity, ErrorSeverity.ERROR);
expect(bulletToDash(outSink),
contains("error - This function declares a return type of 'int'"));
expect(outSink.toString(), contains("1 error and 1 warning found."));
}
test_basic_language() async {
await _driveBasic();
expect(analysisOptions.enableSuperMixins, isTrue);
}
test_basic_strongMode() async {
await _driveBasic();
expect(analysisOptions.strongMode, isTrue);
// https://github.com/dart-lang/sdk/issues/26129
AnalysisContext sdkContext =
driver.analysisDriver.sourceFactory.dartSdk.context;
expect(sdkContext.analysisOptions.strongMode, isTrue);
}
test_includeDirective() async {
String testDir = path.join(
testDirectory, 'data', 'options_include_directive_tests_project');
await drive(
path.join(testDir, 'lib', 'test_file.dart'),
args: [
'--fatal-warnings',
'--packages',
path.join(testDir, '_packages'),
],
options: path.join(testDir, 'analysis_options.yaml'),
);
expect(exitCode, 3);
expect(outSink.toString(),
contains('but doesn\'t end with a return statement'));
expect(outSink.toString(), contains('isn\'t defined'));
expect(outSink.toString(), contains('Avoid empty else statements'));
}
test_previewDart2() async {
await drive('data/options_tests_project/test_file.dart',
args: ['--preview-dart-2']);
expect(analysisOptions.useFastaParser, isFalse);
}
test_strongSdk() async {
String testDir = path.join(testDirectory, 'data', 'strong_sdk');
await drive(path.join(testDir, 'main.dart'), args: ['--strong']);
expect(analysisOptions.strongMode, isTrue);
expect(outSink.toString(), contains('No issues found'));
}
test_todo() async {
await drive('data/file_with_todo.dart');
expect(outSink.toString().contains('[info]'), isFalse);
}
@failingTest
test_useCFE() async {
// Disabled until integration with the CFE has been restarted.
fail('Times out when run on a VM with --preview-dart-2 enabled');
// await drive('data/options_tests_project/test_file.dart',
// args: ['--use-cfe']);
// expect(driver.context.analysisOptions.useFastaParser, isTrue);
}
test_withFlags_overrideFatalWarning() async {
await drive('data/options_tests_project/test_file.dart',
args: ['--fatal-warnings'],
options: 'data/options_tests_project/$optionsFileName');
// missing_return: error
var undefined_function = new AnalysisError(
new TestSource(), 0, 1, StaticTypeWarningCode.UNDEFINED_FUNCTION, [
['x']
]);
expect(processorFor(undefined_function).severity, ErrorSeverity.WARNING);
// Should not be made fatal by `--fatal-warnings`.
expect(bulletToDash(outSink),
contains("warning - The function 'baz' isn't defined"));
expect(outSink.toString(), contains("1 error and 1 warning found."));
}
Future<Null> _driveBasic() async {
await drive('data/options_tests_project/test_file.dart',
options: 'data/options_tests_project/$optionsFileName');
}
void _expectUndefinedClassErrorsWithoutExclusions() {
bool isStrong = usePreviewDart2 || new AnalysisOptionsImpl().previewDart2;
final String issueType = isStrong ? 'error' : 'warning';
expect(bulletToDash(outSink),
contains("$issueType - Undefined class 'IncludedUndefinedClass'"));
expect(
bulletToDash(outSink),
isNot(
contains("$issueType - Undefined class 'ExcludedUndefinedClass'")));
expect(outSink.toString(), contains("1 $issueType found."));
}
}
@reflectiveTest
class OptionsTest_PreviewDart2 extends OptionsTest {
@override
bool get usePreviewDart2 => true;
}
@reflectiveTest
class OptionsTest_UseCFE extends OptionsTest {
@override
bool get useCFE => true;
@override
@failingTest
test_analysisOptions_excludes() =>
callFailingTest(super.test_analysisOptions_excludes);
@override
@failingTest
test_analysisOptions_excludesRelativeToAnalysisOptions_explicit() =>
callFailingTest(super
.test_analysisOptions_excludesRelativeToAnalysisOptions_explicit);
@override
@failingTest
test_analysisOptions_excludesRelativeToAnalysisOptions_inferred() =>
callFailingTest(super
.test_analysisOptions_excludesRelativeToAnalysisOptions_inferred);
@override
@failingTest
test_basic_filters() => callFailingTest(super.test_basic_filters);
@override
@failingTest
test_basic_language() => callFailingTest(super.test_basic_language);
@override
@failingTest
test_basic_strongMode() => callFailingTest(super.test_basic_strongMode);
@override
@failingTest
test_includeDirective() => callFailingTest(super.test_includeDirective);
@override
@failingTest
test_previewDart2() => callFailingTest(super.test_previewDart2);
@override
@failingTest
test_withFlags_overrideFatalWarning() =>
callFailingTest(super.test_withFlags_overrideFatalWarning);
}
class TestSource implements Source {
TestSource();
@override
noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}
typedef dynamic NoArgFunction();
/**
* Call a test that we think will fail.
*
* Ensure that we return any thrown exception correctly (avoiding the
* package:test zone error handler).
*/
callFailingTest(NoArgFunction expectedFailingTestFn) {
final Completer completer = new Completer();
try {
runZoned(
() async => await expectedFailingTestFn(),
onError: (error) {
completer.completeError(error);
},
).then((result) {
completer.complete(result);
}).catchError((error) {
completer.completeError(error);
});
} catch (error) {
completer.completeError(error);
}
return completer.future;
}