mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
c417c4623c
Refactors `ShaderTarget` to make it opaque as to whether it's using Impeller or SkSL and instead has it focus on the target platform it's generating for. ImpellerC includes SkSL right now whether you ask for it or not. The tester target also might need SkSL or Vulkan depending on whether `--enable-impeller` is passed.
1049 lines
37 KiB
Dart
1049 lines
37 KiB
Dart
// Copyright 2014 The Flutter Authors. 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:convert';
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:file/memory.dart';
|
|
import 'package:flutter_tools/src/artifacts.dart';
|
|
import 'package:flutter_tools/src/asset.dart';
|
|
import 'package:flutter_tools/src/base/file_system.dart';
|
|
import 'package:flutter_tools/src/base/logger.dart';
|
|
import 'package:flutter_tools/src/base/platform.dart';
|
|
import 'package:flutter_tools/src/base/user_messages.dart';
|
|
import 'package:flutter_tools/src/build_info.dart';
|
|
import 'package:flutter_tools/src/bundle_builder.dart';
|
|
import 'package:flutter_tools/src/cache.dart';
|
|
import 'package:flutter_tools/src/devfs.dart';
|
|
import 'package:flutter_tools/src/device.dart';
|
|
import 'package:flutter_tools/src/globals.dart' as globals;
|
|
import 'package:flutter_tools/src/project.dart';
|
|
import 'package:standard_message_codec/standard_message_codec.dart';
|
|
|
|
import '../src/common.dart';
|
|
import '../src/context.dart';
|
|
|
|
void main() {
|
|
const String shaderLibDir = '/./shader_lib';
|
|
|
|
group('AssetBundle.build (using context)', () {
|
|
late FileSystem testFileSystem;
|
|
late Platform platform;
|
|
|
|
setUp(() async {
|
|
testFileSystem = MemoryFileSystem();
|
|
testFileSystem.currentDirectory = testFileSystem.systemTempDirectory.createTempSync('flutter_asset_bundle_test.');
|
|
platform = FakePlatform();
|
|
});
|
|
|
|
testUsingContext('nonempty', () async {
|
|
final AssetBundle ab = AssetBundleFactory.instance.createBundle();
|
|
expect(await ab.build(packagesPath: '.packages'), 0);
|
|
expect(ab.entries.length, greaterThan(0));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('empty pubspec', () async {
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync('');
|
|
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys,
|
|
unorderedEquals(<String>['AssetManifest.json', 'AssetManifest.bin'])
|
|
);
|
|
const String expectedJsonAssetManifest = '{}';
|
|
const Map<Object, Object> expectedBinAssetManifest = <Object, Object>{};
|
|
expect(
|
|
utf8.decode(await bundle.entries['AssetManifest.json']!.contentsAsBytes()),
|
|
expectedJsonAssetManifest,
|
|
);
|
|
expect(
|
|
const StandardMessageCodec().decodeMessage(ByteData.sublistView(Uint8List.fromList(await bundle.entries['AssetManifest.bin']!.contentsAsBytes()))),
|
|
expectedBinAssetManifest
|
|
);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('wildcard directories do not include subdirectories', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file('pubspec.yaml').writeAsStringSync(
|
|
'''
|
|
name: test
|
|
dependencies:
|
|
flutter:
|
|
sdk: flutter
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
- assets/bar/lizard.png
|
|
'''
|
|
);
|
|
|
|
final List<String> assets = <String>[
|
|
'assets/foo/dog.png',
|
|
'assets/foo/sub/cat.png',
|
|
'assets/bar/lizard.png',
|
|
'assets/bar/sheep.png'
|
|
];
|
|
|
|
for (final String asset in assets) {
|
|
final File assetFile = globals.fs.file(
|
|
globals.fs.path.joinAll(asset.split('/'))
|
|
);
|
|
assetFile.createSync(recursive: true);
|
|
}
|
|
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
|
|
expect(bundle.entries.keys, unorderedEquals(<String>[
|
|
'AssetManifest.json',
|
|
'AssetManifest.bin',
|
|
'FontManifest.json',
|
|
'NOTICES.Z',
|
|
'assets/foo/dog.png',
|
|
'assets/bar/lizard.png'
|
|
]));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('wildcard directories are updated when filesystem changes', () async {
|
|
final File packageFile = globals.fs.file('.packages')..createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt']));
|
|
// Simulate modifying the files by updating the filestat time manually.
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'fizz.txt'))
|
|
..createSync(recursive: true)
|
|
..setLastModifiedSync(packageFile.lastModifiedSync().add(const Duration(hours: 1)));
|
|
|
|
expect(bundle.needsBuild(), true);
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt',
|
|
'assets/foo/fizz.txt']));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('handle removal of wildcard directories', () async {
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
final File pubspec = globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
''');
|
|
globals.fs.file('.packages').createSync();
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt']));
|
|
expect(bundle.needsBuild(), false);
|
|
|
|
// Delete the wildcard directory and update pubspec file.
|
|
final DateTime modifiedTime = pubspec.lastModifiedSync().add(const Duration(hours: 1));
|
|
globals.fs.directory(globals.fs.path.join('assets', 'foo')).deleteSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example''')
|
|
..setLastModifiedSync(modifiedTime);
|
|
|
|
// touch .packages to make sure its change time is after pubspec.yaml's
|
|
globals.fs.file('.packages')
|
|
.setLastModifiedSync(modifiedTime);
|
|
|
|
// Even though the previous file was removed, it is left in the
|
|
// asset manifest and not updated. This is due to the devfs not
|
|
// supporting file deletion.
|
|
expect(bundle.needsBuild(), true);
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt']));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
// https://github.com/flutter/flutter/issues/42723
|
|
testUsingContext('Test regression for mistyped file', () async {
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
// Create a directory in the same path to test that we're only looking at File
|
|
// objects.
|
|
globals.fs.directory(globals.fs.path.join('assets', 'foo', 'bar')).createSync();
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
''');
|
|
globals.fs.file('.packages').createSync();
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt']));
|
|
expect(bundle.needsBuild(), false);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('deferred assets are parsed', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'bar', 'barbie.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'wild', 'dash.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
deferred-components:
|
|
- name: component1
|
|
assets:
|
|
- assets/bar/barbie.txt
|
|
- assets/wild/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.defaultInstance(
|
|
logger: globals.logger,
|
|
fileSystem: globals.fs,
|
|
platform: globals.platform,
|
|
splitDeferredAssets: true,
|
|
).createBundle();
|
|
await bundle.build(packagesPath: '.packages', deferredComponentsEnabled: true);
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z', 'assets/foo/bar.txt']));
|
|
expect(bundle.deferredComponentsEntries.length, 1);
|
|
expect(bundle.deferredComponentsEntries['component1']!.length, 2);
|
|
expect(bundle.needsBuild(), false);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('deferred assets are parsed regularly when splitDeferredAssets Disabled', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'bar', 'barbie.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'wild', 'dash.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
deferred-components:
|
|
- name: component1
|
|
assets:
|
|
- assets/bar/barbie.txt
|
|
- assets/wild/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['assets/foo/bar.txt',
|
|
'assets/bar/barbie.txt', 'assets/wild/dash.txt', 'AssetManifest.json',
|
|
'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z']));
|
|
expect(bundle.deferredComponentsEntries.isEmpty, true);
|
|
expect(bundle.needsBuild(), false);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('deferred assets wildcard parsed', () async {
|
|
final File packageFile = globals.fs.file('.packages')..createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'bar', 'barbie.txt')).createSync(recursive: true);
|
|
globals.fs.file(globals.fs.path.join('assets', 'wild', 'dash.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/
|
|
deferred-components:
|
|
- name: component1
|
|
assets:
|
|
- assets/bar/barbie.txt
|
|
- assets/wild/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.defaultInstance(
|
|
logger: globals.logger,
|
|
fileSystem: globals.fs,
|
|
platform: globals.platform,
|
|
splitDeferredAssets: true,
|
|
).createBundle();
|
|
await bundle.build(packagesPath: '.packages', deferredComponentsEnabled: true);
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['assets/foo/bar.txt',
|
|
'AssetManifest.json', 'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z']));
|
|
expect(bundle.deferredComponentsEntries.length, 1);
|
|
expect(bundle.deferredComponentsEntries['component1']!.length, 2);
|
|
expect(bundle.needsBuild(), false);
|
|
|
|
// Simulate modifying the files by updating the filestat time manually.
|
|
globals.fs.file(globals.fs.path.join('assets', 'wild', 'fizz.txt'))
|
|
..createSync(recursive: true)
|
|
..setLastModifiedSync(packageFile.lastModifiedSync().add(const Duration(hours: 1)));
|
|
|
|
expect(bundle.needsBuild(), true);
|
|
await bundle.build(packagesPath: '.packages', deferredComponentsEnabled: true);
|
|
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['assets/foo/bar.txt',
|
|
'AssetManifest.json', 'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z']));
|
|
expect(bundle.deferredComponentsEntries.length, 1);
|
|
expect(bundle.deferredComponentsEntries['component1']!.length, 3);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => platform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
});
|
|
|
|
group('AssetBundle.build', () {
|
|
testWithoutContext('throws ToolExit when directory entry contains invalid characters (Windows only)', () async {
|
|
final MemoryFileSystem fileSystem = MemoryFileSystem(style: FileSystemStyle.windows);
|
|
final BufferLogger logger = BufferLogger.test();
|
|
final FakePlatform platform = FakePlatform(operatingSystem: 'windows');
|
|
final String flutterRoot = Cache.defaultFlutterRoot(
|
|
platform: platform,
|
|
fileSystem: fileSystem,
|
|
userMessages: UserMessages(),
|
|
);
|
|
|
|
fileSystem.file('.packages').createSync();
|
|
fileSystem.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- https://mywebsite.com/images/
|
|
''');
|
|
final ManifestAssetBundle bundle = ManifestAssetBundle(
|
|
logger: logger,
|
|
fileSystem: fileSystem,
|
|
platform: platform,
|
|
flutterRoot: flutterRoot,
|
|
);
|
|
|
|
expect(
|
|
() => bundle.build(
|
|
packagesPath: '.packages',
|
|
flutterProject: FlutterProject.fromDirectoryTest(
|
|
fileSystem.currentDirectory,
|
|
),
|
|
),
|
|
throwsToolExit(
|
|
message: 'Unable to search for asset files in directory path "https%3A//mywebsite.com/images/". '
|
|
'Please ensure that this entry in pubspec.yaml is a valid file path.\n'
|
|
'Error details:\n'
|
|
'Unsupported operation: Illegal character in path: https:',
|
|
),
|
|
);
|
|
});
|
|
|
|
testWithoutContext('throws ToolExit when file entry contains invalid characters (Windows only)', () async {
|
|
final FileSystem fileSystem = MemoryFileSystem(
|
|
style: FileSystemStyle.windows,
|
|
opHandle: (String context, FileSystemOp operation) {
|
|
if (operation == FileSystemOp.exists && context == r'C:\http:\\website.com') {
|
|
throw const FileSystemException(
|
|
r"FileSystemException: Exists failed, path = 'C:\http:\\website.com' "
|
|
'(OS Error: The filename, directory name, or volume label syntax is '
|
|
'incorrect., errno = 123)',
|
|
);
|
|
}
|
|
},
|
|
);
|
|
final BufferLogger logger = BufferLogger.test();
|
|
final FakePlatform platform = FakePlatform(operatingSystem: 'windows');
|
|
final String flutterRoot = Cache.defaultFlutterRoot(
|
|
platform: platform,
|
|
fileSystem: fileSystem,
|
|
userMessages: UserMessages(),
|
|
);
|
|
fileSystem.file('.packages').createSync();
|
|
fileSystem.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- http://website.com/hi.png
|
|
''');
|
|
final ManifestAssetBundle bundle = ManifestAssetBundle(
|
|
logger: logger,
|
|
fileSystem: fileSystem,
|
|
platform: platform,
|
|
flutterRoot: flutterRoot,
|
|
);
|
|
|
|
expect(
|
|
() => bundle.build(
|
|
packagesPath: '.packages',
|
|
flutterProject: FlutterProject.fromDirectoryTest(
|
|
fileSystem.currentDirectory,
|
|
),
|
|
),
|
|
throwsToolExit(
|
|
message: 'Unable to check the existence of asset file ',
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
group('AssetBundle.build (web builds)', () {
|
|
late FileSystem testFileSystem;
|
|
late Platform testPlatform;
|
|
|
|
setUp(() async {
|
|
testFileSystem = MemoryFileSystem();
|
|
testFileSystem.currentDirectory = testFileSystem.systemTempDirectory.createTempSync('flutter_asset_bundle_test.');
|
|
testPlatform = FakePlatform();
|
|
});
|
|
|
|
testUsingContext('empty pubspec', () async {
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync('');
|
|
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages', targetPlatform: TargetPlatform.web_javascript);
|
|
|
|
expect(bundle.entries.keys,
|
|
unorderedEquals(<String>[
|
|
'AssetManifest.json',
|
|
'AssetManifest.bin',
|
|
'AssetManifest.bin.json',
|
|
])
|
|
);
|
|
expect(
|
|
utf8.decode(await bundle.entries['AssetManifest.json']!.contentsAsBytes()),
|
|
'{}',
|
|
);
|
|
expect(
|
|
utf8.decode(await bundle.entries['AssetManifest.bin.json']!.contentsAsBytes()),
|
|
'""',
|
|
);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => testPlatform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('pubspec contains an asset', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file('pubspec.yaml').writeAsStringSync(r'''
|
|
name: test
|
|
dependencies:
|
|
flutter:
|
|
sdk: flutter
|
|
flutter:
|
|
assets:
|
|
- assets/bar/lizard.png
|
|
''');
|
|
globals.fs.file(
|
|
globals.fs.path.joinAll(<String>['assets', 'bar', 'lizard.png'])
|
|
).createSync(recursive: true);
|
|
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages', targetPlatform: TargetPlatform.web_javascript);
|
|
|
|
expect(bundle.entries.keys,
|
|
unorderedEquals(<String>[
|
|
'AssetManifest.json',
|
|
'AssetManifest.bin',
|
|
'AssetManifest.bin.json',
|
|
'FontManifest.json',
|
|
'NOTICES', // not .Z
|
|
'assets/bar/lizard.png',
|
|
])
|
|
);
|
|
final Map<Object?, Object?> manifestJson = json.decode(
|
|
utf8.decode(
|
|
await bundle.entries['AssetManifest.json']!.contentsAsBytes()
|
|
)
|
|
) as Map<Object?, Object?>;
|
|
expect(manifestJson, isNotEmpty);
|
|
expect(manifestJson['assets/bar/lizard.png'], isNotNull);
|
|
|
|
final Uint8List manifestBinJsonBytes = base64.decode(
|
|
json.decode(
|
|
utf8.decode(
|
|
await bundle.entries['AssetManifest.bin.json']!.contentsAsBytes()
|
|
)
|
|
) as String
|
|
);
|
|
|
|
final Uint8List manifestBinBytes = Uint8List.fromList(
|
|
await bundle.entries['AssetManifest.bin']!.contentsAsBytes()
|
|
);
|
|
|
|
expect(manifestBinJsonBytes, equals(manifestBinBytes),
|
|
reason: 'JSON-encoded binary content should be identical to BIN file.');
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => testFileSystem,
|
|
Platform: () => testPlatform,
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
});
|
|
|
|
testUsingContext('Failed directory delete shows message', () async {
|
|
final FileExceptionHandler handler = FileExceptionHandler();
|
|
final FileSystem fileSystem = MemoryFileSystem.test(opHandle: handler.opHandle);
|
|
|
|
final Directory directory = fileSystem.directory('foo')
|
|
..createSync();
|
|
handler.addError(directory, FileSystemOp.delete, const FileSystemException('Expected Error Text'));
|
|
|
|
await writeBundle(
|
|
directory,
|
|
const <String, AssetBundleEntry>{},
|
|
loggerOverride: testLogger,
|
|
targetPlatform: TargetPlatform.android,
|
|
impellerStatus: ImpellerStatus.disabled,
|
|
);
|
|
|
|
expect(testLogger.warningText, contains('Expected Error Text'));
|
|
});
|
|
|
|
testUsingContext('does not unnecessarily recreate asset manifest, font manifest, license', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/foo/bar.txt
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
await bundle.build(packagesPath: '.packages');
|
|
|
|
final AssetBundleEntry? assetManifest = bundle.entries['AssetManifest.json'];
|
|
final AssetBundleEntry? fontManifest = bundle.entries['FontManifest.json'];
|
|
final AssetBundleEntry? license = bundle.entries['NOTICES'];
|
|
|
|
await bundle.build(packagesPath: '.packages');
|
|
|
|
expect(assetManifest, bundle.entries['AssetManifest.json']);
|
|
expect(fontManifest, bundle.entries['FontManifest.json']);
|
|
expect(license, bundle.entries['NOTICES']);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
Platform: () => FakePlatform(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('inserts dummy file into additionalDependencies when '
|
|
'wildcards are used', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect(bundle.additionalDependencies.single.path, contains('DOES_NOT_EXIST_RERUN_FOR_WILDCARD'));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
Platform: () => FakePlatform(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
testUsingContext('Does not insert dummy file into additionalDependencies '
|
|
'when wildcards are not used', () async {
|
|
globals.fs.file('.packages').createSync();
|
|
globals.fs.file(globals.fs.path.join('assets', 'bar.txt')).createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- assets/bar.txt
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect(bundle.additionalDependencies, isEmpty);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
Platform: () => FakePlatform(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
});
|
|
|
|
|
|
group('Shaders: ', () {
|
|
late MemoryFileSystem fileSystem;
|
|
late Artifacts artifacts;
|
|
late String impellerc;
|
|
late Directory output;
|
|
late String assetsPath;
|
|
late String shaderPath;
|
|
late String outputPath;
|
|
|
|
setUp(() {
|
|
artifacts = Artifacts.test();
|
|
fileSystem = MemoryFileSystem.test();
|
|
impellerc = artifacts.getHostArtifact(HostArtifact.impellerc).path;
|
|
|
|
fileSystem.file(impellerc).createSync(recursive: true);
|
|
|
|
output = fileSystem.directory('asset_output')..createSync(recursive: true);
|
|
assetsPath = 'assets';
|
|
shaderPath = fileSystem.path.join(assetsPath, 'shader.frag');
|
|
outputPath = fileSystem.path.join(output.path, assetsPath, 'shader.frag');
|
|
fileSystem.file(shaderPath).createSync(recursive: true);
|
|
});
|
|
|
|
testUsingContext('Including a shader triggers the shader compiler', () async {
|
|
fileSystem.file('.packages').createSync();
|
|
fileSystem.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
shaders:
|
|
- assets/shader.frag
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
|
|
await writeBundle(
|
|
output,
|
|
bundle.entries,
|
|
loggerOverride: testLogger,
|
|
targetPlatform: TargetPlatform.android,
|
|
impellerStatus: ImpellerStatus.disabled,
|
|
);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
Artifacts: () => artifacts,
|
|
FileSystem: () => fileSystem,
|
|
ProcessManager: () => FakeProcessManager.list(<FakeCommand>[
|
|
FakeCommand(
|
|
command: <String>[
|
|
impellerc,
|
|
'--sksl',
|
|
'--runtime-stage-gles',
|
|
'--runtime-stage-vulkan',
|
|
'--iplr',
|
|
'--sl=$outputPath',
|
|
'--spirv=$outputPath.spirv',
|
|
'--input=/$shaderPath',
|
|
'--input-type=frag',
|
|
'--include=/$assetsPath',
|
|
'--include=$shaderLibDir',
|
|
],
|
|
onRun: (_) {
|
|
fileSystem.file(outputPath).createSync(recursive: true);
|
|
fileSystem.file('$outputPath.spirv').createSync(recursive: true);
|
|
},
|
|
),
|
|
]),
|
|
});
|
|
|
|
testUsingContext('Included shaders are compiled for the web', () async {
|
|
fileSystem.file('.packages').createSync();
|
|
fileSystem.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
shaders:
|
|
- assets/shader.frag
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages', targetPlatform: TargetPlatform.web_javascript), 0);
|
|
|
|
await writeBundle(
|
|
output,
|
|
bundle.entries,
|
|
loggerOverride: testLogger,
|
|
targetPlatform: TargetPlatform.web_javascript,
|
|
impellerStatus: ImpellerStatus.disabled,
|
|
);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
Artifacts: () => artifacts,
|
|
FileSystem: () => fileSystem,
|
|
ProcessManager: () => FakeProcessManager.list(<FakeCommand>[
|
|
FakeCommand(
|
|
command: <String>[
|
|
impellerc,
|
|
'--sksl',
|
|
'--iplr',
|
|
'--json',
|
|
'--sl=$outputPath',
|
|
'--spirv=$outputPath.spirv',
|
|
'--input=/$shaderPath',
|
|
'--input-type=frag',
|
|
'--include=/$assetsPath',
|
|
'--include=$shaderLibDir',
|
|
],
|
|
onRun: (_) {
|
|
fileSystem.file(outputPath).createSync(recursive: true);
|
|
fileSystem.file('$outputPath.spirv').createSync(recursive: true);
|
|
},
|
|
),
|
|
]),
|
|
});
|
|
|
|
testUsingContext('Material shaders are compiled for the web', () async {
|
|
fileSystem.file('.packages').createSync();
|
|
|
|
final String materialIconsPath = fileSystem.path.join(
|
|
getFlutterRoot(),
|
|
'bin', 'cache', 'artifacts', 'material_fonts',
|
|
'MaterialIcons-Regular.otf',
|
|
);
|
|
fileSystem.file(materialIconsPath).createSync(recursive: true);
|
|
|
|
final String materialPath = fileSystem.path.join(
|
|
getFlutterRoot(),
|
|
'packages', 'flutter', 'lib', 'src', 'material',
|
|
);
|
|
final Directory materialDir = fileSystem.directory(materialPath)..createSync(recursive: true);
|
|
for (final String shader in kMaterialShaders) {
|
|
materialDir.childFile(shader).createSync(recursive: true);
|
|
}
|
|
|
|
(globals.processManager as FakeProcessManager)
|
|
.addCommand(FakeCommand(
|
|
command: <String>[
|
|
impellerc,
|
|
'--sksl',
|
|
'--iplr',
|
|
'--json',
|
|
'--sl=${fileSystem.path.join(output.path, 'shaders', 'ink_sparkle.frag')}',
|
|
'--spirv=${fileSystem.path.join(output.path, 'shaders', 'ink_sparkle.frag.spirv')}',
|
|
'--input=${fileSystem.path.join(materialDir.path, 'shaders', 'ink_sparkle.frag')}',
|
|
'--input-type=frag',
|
|
'--include=${fileSystem.path.join(materialDir.path, 'shaders')}',
|
|
'--include=$shaderLibDir',
|
|
],
|
|
onRun: (_) {
|
|
fileSystem.file(outputPath).createSync(recursive: true);
|
|
fileSystem.file('$outputPath.spirv').createSync(recursive: true);
|
|
},
|
|
));
|
|
|
|
fileSystem.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
uses-material-design: true
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages', targetPlatform: TargetPlatform.web_javascript), 0);
|
|
|
|
await writeBundle(
|
|
output,
|
|
bundle.entries,
|
|
loggerOverride: testLogger,
|
|
targetPlatform: TargetPlatform.web_javascript,
|
|
impellerStatus: ImpellerStatus.disabled,
|
|
);
|
|
expect((globals.processManager as FakeProcessManager).hasRemainingExpectations, false);
|
|
}, overrides: <Type, Generator>{
|
|
Artifacts: () => artifacts,
|
|
FileSystem: () => fileSystem,
|
|
ProcessManager: () => FakeProcessManager.list(<FakeCommand>[]),
|
|
});
|
|
});
|
|
|
|
testUsingContext('Does not insert dummy file into additionalDependencies '
|
|
'when wildcards are used by dependencies', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
foo:foo/lib/
|
|
''');
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt'))
|
|
.createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
dependencies:
|
|
foo: any
|
|
''');
|
|
globals.fs.file('foo/pubspec.yaml')
|
|
..createSync(recursive: true)
|
|
..writeAsStringSync(r'''
|
|
name: foo
|
|
|
|
flutter:
|
|
assets:
|
|
- bar/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
globals.fs.file('foo/bar/fizz.txt').createSync(recursive: true);
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect(bundle.additionalDependencies, isEmpty);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('does not track wildcard directories from dependencies', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
foo:foo/lib/
|
|
''');
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt'))
|
|
.createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
dependencies:
|
|
foo: any
|
|
''');
|
|
globals.fs.file('foo/pubspec.yaml')
|
|
..createSync(recursive: true)
|
|
..writeAsStringSync(r'''
|
|
name: foo
|
|
|
|
flutter:
|
|
assets:
|
|
- bar/
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
globals.fs.file('foo/bar/fizz.txt').createSync(recursive: true);
|
|
|
|
await bundle.build(packagesPath: '.packages');
|
|
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['packages/foo/bar/fizz.txt',
|
|
'AssetManifest.json', 'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z']));
|
|
expect(bundle.needsBuild(), false);
|
|
|
|
// Does not track dependency's wildcard directories.
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt'))
|
|
.deleteSync();
|
|
|
|
expect(bundle.needsBuild(), false);
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('reports package that causes asset bundle error when it is '
|
|
'a dependency', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
foo:foo/lib/
|
|
''');
|
|
globals.fs.file(globals.fs.path.join('assets', 'foo', 'bar.txt'))
|
|
.createSync(recursive: true);
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
dependencies:
|
|
foo: any
|
|
''');
|
|
globals.fs.file('foo/pubspec.yaml')
|
|
..createSync(recursive: true)
|
|
..writeAsStringSync(r'''
|
|
name: foo
|
|
|
|
flutter:
|
|
assets:
|
|
- bar.txt
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 1);
|
|
expect(testLogger.errorText, contains('This asset was included from package foo'));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('does not report package that causes asset bundle error '
|
|
'when it is from own pubspec', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
''');
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
flutter:
|
|
assets:
|
|
- bar.txt
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 1);
|
|
expect(testLogger.errorText, isNot(contains('This asset was included from')));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('does not include Material Design assets if uses-material-design: true is '
|
|
'specified only by a dependency', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
foo:foo/lib/
|
|
''');
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
dependencies:
|
|
foo: any
|
|
|
|
flutter:
|
|
uses-material-design: false
|
|
''');
|
|
globals.fs.file('foo/pubspec.yaml')
|
|
..createSync(recursive: true)
|
|
..writeAsStringSync(r'''
|
|
name: foo
|
|
|
|
flutter:
|
|
uses-material-design: true
|
|
''');
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect((bundle.entries['FontManifest.json']!.content as DevFSStringContent).string, '[]');
|
|
expect((bundle.entries['AssetManifest.json']!.content as DevFSStringContent).string, '{}');
|
|
expect(testLogger.errorText, contains(
|
|
'package:foo has `uses-material-design: true` set'
|
|
));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('does not include assets in project directories as asset variants', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
''');
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
|
|
flutter:
|
|
assets:
|
|
- assets/foo.txt
|
|
''');
|
|
globals.fs.file('assets/foo.txt').createSync(recursive: true);
|
|
|
|
// Potential build artifacts outside of build directory.
|
|
globals.fs.file('linux/flutter/foo.txt').createSync(recursive: true);
|
|
globals.fs.file('windows/flutter/foo.txt').createSync(recursive: true);
|
|
globals.fs.file('windows/CMakeLists.txt').createSync();
|
|
globals.fs.file('macos/Flutter/foo.txt').createSync(recursive: true);
|
|
globals.fs.file('ios/foo.txt').createSync(recursive: true);
|
|
globals.fs.file('build/foo.txt').createSync(recursive: true);
|
|
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect(bundle.entries.keys, unorderedEquals(<String>['assets/foo.txt',
|
|
'AssetManifest.json', 'AssetManifest.bin', 'FontManifest.json', 'NOTICES.Z']));
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
|
|
testUsingContext('deferred and regular assets are included in manifest alphabetically', () async {
|
|
globals.fs.file('.packages').writeAsStringSync(r'''
|
|
example:lib/
|
|
''');
|
|
globals.fs.file('pubspec.yaml')
|
|
..createSync()
|
|
..writeAsStringSync(r'''
|
|
name: example
|
|
|
|
flutter:
|
|
assets:
|
|
- assets/zebra.jpg
|
|
- assets/foo.jpg
|
|
|
|
deferred-components:
|
|
- name: component1
|
|
assets:
|
|
- assets/bar.jpg
|
|
- assets/apple.jpg
|
|
''');
|
|
globals.fs.file('assets/foo.jpg').createSync(recursive: true);
|
|
globals.fs.file('assets/bar.jpg').createSync();
|
|
globals.fs.file('assets/apple.jpg').createSync();
|
|
globals.fs.file('assets/zebra.jpg').createSync();
|
|
final AssetBundle bundle = AssetBundleFactory.instance.createBundle();
|
|
|
|
expect(await bundle.build(packagesPath: '.packages'), 0);
|
|
expect((bundle.entries['FontManifest.json']!.content as DevFSStringContent).string, '[]');
|
|
// The assets from deferred components and regular assets
|
|
// are both included in alphabetical order
|
|
expect((bundle.entries['AssetManifest.json']!.content as DevFSStringContent).string, '{"assets/apple.jpg":["assets/apple.jpg"],"assets/bar.jpg":["assets/bar.jpg"],"assets/foo.jpg":["assets/foo.jpg"],"assets/zebra.jpg":["assets/zebra.jpg"]}');
|
|
}, overrides: <Type, Generator>{
|
|
FileSystem: () => MemoryFileSystem.test(),
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
Platform: () => FakePlatform(),
|
|
});
|
|
}
|