blob: 78c9a7ba9d79ecf0b68e2db4fa29af4fd5a5a2c5 [file] [log] [blame]
import 'dart:async' show StreamController;
import 'dart:convert' show utf8, LineSplitter;
import 'dart:io' show Directory, File, FileSystemEntity, IOSink, exitCode;
import 'package:kernel/ast.dart' show Component;
import 'package:kernel/kernel.dart' show loadComponentFromBytes;
import 'package:kernel/verifier.dart' show verifyComponent;
import 'package:front_end/src/api_prototype/language_version.dart'
show uriUsesLegacyLanguageVersion;
import 'package:front_end/src/api_unstable/vm.dart'
show CompilerOptions, NnbdMode, StandardFileSystem;
import '../lib/frontend_server.dart';
main(List<String> args) async {
String flutterDir;
String flutterPlatformDir;
for (String arg in args) {
if (arg.startsWith("--flutterDir=")) {
flutterDir = arg.substring(13);
} else if (arg.startsWith("--flutterPlatformDir=")) {
flutterPlatformDir = arg.substring(21);
}
}
await compileTests(flutterDir, flutterPlatformDir, new StdoutLogger());
}
Future<NnbdMode> _getNNBDMode(Uri script, Uri packagesFileUri) async {
final CompilerOptions compilerOptions = new CompilerOptions()
..sdkRoot = null
..fileSystem = StandardFileSystem.instance
..packagesFileUri = packagesFileUri
..sdkSummary = null
..nnbdMode = NnbdMode.Weak;
if (await uriUsesLegacyLanguageVersion(script, compilerOptions)) {
return NnbdMode.Weak;
}
return NnbdMode.Strong;
}
Future compileTests(String flutterDir, String flutterPlatformDir, Logger logger,
{String filter, int shards: 1, int shard: 0}) async {
if (flutterDir == null || !(new Directory(flutterDir).existsSync())) {
throw "Didn't get a valid flutter directory to work with.";
}
if (shards < 1) {
throw "Shards must be >= 1";
}
if (shard < 0) {
throw "Shard must be >= 0";
}
if (shard >= shards) {
throw "Shard must be < shards";
}
// Ensure the path ends in a slash.
final Directory flutterDirectory =
new Directory.fromUri(new Directory(flutterDir).uri);
List<FileSystemEntity> allFlutterFiles =
flutterDirectory.listSync(recursive: true, followLinks: false);
Directory flutterPlatformDirectoryTmp;
if (flutterPlatformDir == null) {
List<File> platformFiles = new List<File>.from(allFlutterFiles.where((f) =>
f.uri
.toString()
.endsWith("/flutter_patched_sdk/platform_strong.dill")));
if (platformFiles.length < 1) {
throw "Expected to find a flutter platform file but didn't.";
}
flutterPlatformDirectoryTmp = platformFiles.first.parent;
} else {
flutterPlatformDirectoryTmp = Directory(flutterPlatformDir);
}
if (!flutterPlatformDirectoryTmp.existsSync()) {
throw "$flutterPlatformDirectoryTmp doesn't exist.";
}
// Ensure the path ends in a slash.
final Directory flutterPlatformDirectory =
new Directory.fromUri(flutterPlatformDirectoryTmp.uri);
if (!new File.fromUri(
flutterPlatformDirectory.uri.resolve("platform_strong.dill"))
.existsSync()) {
throw "$flutterPlatformDirectory doesn't contain a "
"platform_strong.dill file.";
}
logger.notice("Using $flutterPlatformDirectory as platform directory.");
List<File> dotPackagesFiles = new List<File>.from(allFlutterFiles.where((f) =>
(f.uri.toString().contains("/examples/") ||
f.uri.toString().contains("/packages/")) &&
f.uri.toString().endsWith("/.packages")));
List<String> allCompilationErrors = [];
final Directory systemTempDir = Directory.systemTemp;
List<_QueueEntry> queue = [];
int totalFiles = 0;
for (int i = 0; i < dotPackagesFiles.length; i++) {
File dotPackage = dotPackagesFiles[i];
Directory testDir =
new Directory.fromUri(dotPackage.parent.uri.resolve("test/"));
if (!testDir.existsSync()) continue;
if (testDir.toString().contains("packages/flutter_web_plugins/test/")) {
// TODO(jensj): Figure out which tests are web-tests, and compile those
// in a setup that can handle that.
continue;
}
List<File> testFiles =
new List<File>.from(testDir.listSync(recursive: true).where((f) {
if (!f.path.endsWith("_test.dart")) return false;
if (filter != null) {
String testName = f.path.substring(flutterDirectory.path.length);
if (!testName.startsWith(filter)) return false;
}
return true;
}));
// Split into NNBD Strong and Weak so only the ones that match are
// compiled togeher. If mixing-and-matching the first file (which could
// be either) will setup the compiler which can lead to compilation errors
// for another file, for instance if the first one is strong but a
// subsequent one tries to opt out (i.e. is weak) an error is issued that
// that's not possible.
List<File> weak = [];
List<File> strong = [];
for (File file in testFiles) {
if (await _getNNBDMode(file.uri, dotPackage.uri) == NnbdMode.Weak) {
weak.add(file);
} else {
strong.add(file);
}
}
for (List<File> files in [weak, strong]) {
if (files.isEmpty) continue;
queue.add(new _QueueEntry(files, dotPackage, testDir));
totalFiles += files.length;
}
}
// Process queue, taking shards into account.
// This involves ignoring some queue entries and cutting others up to
// process exactly the files assigned to this shard.
int shardChunkSize = (totalFiles + shards - 1) ~/ shards;
int chunkStart = shard * shardChunkSize;
int chunkEnd = (shard + 1) * shardChunkSize;
int processedFiles = 0;
for (_QueueEntry queueEntry in queue) {
if (processedFiles < chunkEnd &&
processedFiles + queueEntry.files.length >= chunkStart) {
List<File> chunk = [];
for (File file in queueEntry.files) {
if (processedFiles >= chunkStart && processedFiles < chunkEnd) {
chunk.add(file);
}
processedFiles++;
}
await _processFiles(
systemTempDir,
chunk,
flutterPlatformDirectory,
queueEntry.dotPackage,
queueEntry.testDir,
flutterDirectory,
logger,
filter,
allCompilationErrors);
} else {
// None of these files are part of the chunk.
processedFiles += queueEntry.files.length;
}
}
if (allCompilationErrors.isNotEmpty) {
logger.notice(
"Had a total of ${allCompilationErrors.length} compilation errors:");
allCompilationErrors.forEach(logger.notice);
exitCode = 1;
}
}
class _QueueEntry {
final List<File> files;
final File dotPackage;
final Directory testDir;
_QueueEntry(this.files, this.dotPackage, this.testDir);
}
Future<void> _processFiles(
Directory systemTempDir,
List<File> files,
Directory flutterPlatformDirectory,
File dotPackage,
Directory testDir,
Directory flutterDirectory,
Logger logger,
String filter,
List<String> allCompilationErrors) async {
Directory tempDir = systemTempDir.createTempSync('flutter_frontend_test');
try {
List<String> compilationErrors = await attemptStuff(
files,
tempDir,
flutterPlatformDirectory,
dotPackage,
testDir,
flutterDirectory,
logger,
filter);
if (compilationErrors.isNotEmpty) {
logger.notice("Notice that we had ${compilationErrors.length} "
"compilation errors for $testDir");
allCompilationErrors.addAll(compilationErrors);
}
} finally {
tempDir.delete(recursive: true);
}
}
Future<List<String>> attemptStuff(
List<File> testFiles,
Directory tempDir,
Directory flutterPlatformDirectory,
File dotPackage,
Directory testDir,
Directory flutterDirectory,
Logger logger,
String filter) async {
if (testFiles.isEmpty) return [];
File dillFile = new File('${tempDir.path}/dill.dill');
if (dillFile.existsSync()) {
throw "$dillFile already exists.";
}
List<int> platformData = new File.fromUri(
flutterPlatformDirectory.uri.resolve("platform_strong.dill"))
.readAsBytesSync();
final List<String> args = <String>[
'--sdk-root',
flutterPlatformDirectory.path,
'--incremental',
'--target=flutter',
'--packages',
dotPackage.path,
'--output-dill=${dillFile.path}',
// '--unsafe-package-serialization',
];
Stopwatch stopwatch = new Stopwatch()..start();
final StreamController<List<int>> inputStreamController =
new StreamController<List<int>>();
final StreamController<List<int>> stdoutStreamController =
new StreamController<List<int>>();
final IOSink ioSink = new IOSink(stdoutStreamController.sink);
StreamController<Result> receivedResults = new StreamController<Result>();
final outputParser = new OutputParser(receivedResults);
stdoutStreamController.stream
.transform(utf8.decoder)
.transform(const LineSplitter())
.listen(outputParser.listener);
Iterator<File> testFileIterator = testFiles.iterator;
testFileIterator.moveNext();
final Future<int> result =
starter(args, input: inputStreamController.stream, output: ioSink);
String testName =
testFileIterator.current.path.substring(flutterDirectory.path.length);
logger.logTestStart(testName);
logger.notice(" => $testName");
Stopwatch stopwatch2 = new Stopwatch()..start();
inputStreamController
.add('compile ${testFileIterator.current.path}\n'.codeUnits);
int compilations = 0;
List<String> compilationErrors = [];
receivedResults.stream.listen((Result compiledResult) {
logger.notice(" --- done in ${stopwatch2.elapsedMilliseconds} ms\n");
stopwatch2.reset();
bool error = false;
try {
compiledResult.expectNoErrors();
logger.logExpectedResult(testName);
} catch (e) {
logger.log("Got errors. Compiler output for this compile:");
outputParser.allReceived.forEach(logger.log);
compilationErrors.add(testFileIterator.current.path);
error = true;
logger.logUnexpectedResult(testName);
}
if (!error) {
List<int> resultBytes = dillFile.readAsBytesSync();
Component component = loadComponentFromBytes(platformData);
component = loadComponentFromBytes(resultBytes, component);
verifyComponent(component);
logger
.log(" => verified in ${stopwatch2.elapsedMilliseconds} ms.");
}
stopwatch2.reset();
inputStreamController.add('accept\n'.codeUnits);
inputStreamController.add('reset\n'.codeUnits);
compilations++;
outputParser.allReceived.clear();
if (!testFileIterator.moveNext()) {
inputStreamController.add('quit\n'.codeUnits);
return;
}
testName =
testFileIterator.current.path.substring(flutterDirectory.path.length);
logger.logTestStart(testName);
logger.notice(" => $testName");
inputStreamController.add('recompile ${testFileIterator.current.path} abc\n'
'${testFileIterator.current.uri}\n'
'abc\n'
.codeUnits);
});
int resultDone = await result;
if (resultDone != 0) {
throw "Got $resultDone, expected 0";
}
inputStreamController.close();
logger.log("Did $compilations compilations and verifications in "
"${stopwatch.elapsedMilliseconds} ms.");
return compilationErrors;
}
// The below is copied from incremental_compiler_test.dart,
// but with expect stuff replaced with ifs and throws
// (expect can only be used in tests via the test framework).
class OutputParser {
OutputParser(this._receivedResults);
bool expectSources = true;
StreamController<Result> _receivedResults;
List<String> _receivedSources;
String _boundaryKey;
bool _readingSources;
List<String> allReceived = <String>[];
void listener(String s) {
allReceived.add(s);
if (_boundaryKey == null) {
const String RESULT_OUTPUT_SPACE = 'result ';
if (s.startsWith(RESULT_OUTPUT_SPACE)) {
_boundaryKey = s.substring(RESULT_OUTPUT_SPACE.length);
}
_readingSources = false;
_receivedSources?.clear();
return;
}
if (s.startsWith(_boundaryKey)) {
// First boundaryKey separates compiler output from list of sources
// (if we expect list of sources, which is indicated by receivedSources
// being not null)
if (expectSources && !_readingSources) {
_readingSources = true;
return;
}
// Second boundaryKey indicates end of frontend server response
expectSources = true;
_receivedResults.add(new Result(
s.length > _boundaryKey.length
? s.substring(_boundaryKey.length + 1)
: null,
_receivedSources));
_boundaryKey = null;
} else {
if (_readingSources) {
if (_receivedSources == null) {
_receivedSources = <String>[];
}
_receivedSources.add(s);
}
}
}
}
class Result {
String status;
List<String> sources;
Result(this.status, this.sources);
void expectNoErrors({String filename}) {
CompilationResult result = new CompilationResult.parse(status);
if (result.errorsCount != 0) {
throw "Got ${result.errorsCount} errors. Expected 0.";
}
if (filename != null) {
if (result.filename != filename) {
throw "Got ${result.filename} errors. Expected $filename.";
}
}
}
}
class CompilationResult {
String filename;
int errorsCount;
CompilationResult.parse(String filenameAndErrorCount) {
if (filenameAndErrorCount == null) {
return;
}
int delim = filenameAndErrorCount.lastIndexOf(' ');
if (delim <= 0) {
throw "Expected $delim > 0...";
}
filename = filenameAndErrorCount.substring(0, delim);
errorsCount = int.parse(filenameAndErrorCount.substring(delim + 1).trim());
}
}
abstract class Logger {
void logTestStart(String testName);
void logExpectedResult(String testName);
void logUnexpectedResult(String testName);
void log(String s);
void notice(String s);
}
class StdoutLogger extends Logger {
List<String> _log = <String>[];
@override
void logExpectedResult(String testName) {
print("$testName: OK.");
for (String s in _log) {
print(s);
}
}
@override
void logTestStart(String testName) {
_log.clear();
}
@override
void logUnexpectedResult(String testName) {
print("$testName: Fail.");
for (String s in _log) {
print(s);
}
}
void log(String s) {
_log.add(s);
}
void notice(String s) {
print(s);
}
}