| @TestOn('linux && vm') // We currently use gnu tar to create test inputs | |
| library; | |
| import 'dart:io'; | |
| import 'dart:math'; | |
| import 'dart:typed_data'; | |
| import 'package:async/async.dart'; | |
| import 'package:tar/src/sparse.dart'; | |
| import 'package:tar/tar.dart'; | |
| import 'package:test/test.dart'; | |
| import 'system_tar.dart'; | |
| // ignore_for_file: discarded_futures | |
| /// Writes [size] random bytes to [path]. | |
| Future<void> createTestFile(String path, int size) { | |
| final random = Random(); | |
| final file = File(path); | |
| final sink = file.openWrite(); | |
| const chunkSize = 1024; | |
| for (var i = 0; i < size ~/ chunkSize; i++) { | |
| final buffer = Uint8List(chunkSize); | |
| fillRandomBytes(buffer, random); | |
| sink.add(buffer); | |
| } | |
| final remaining = Uint8List(size % chunkSize); | |
| fillRandomBytes(remaining, random); | |
| sink.add(remaining); | |
| return sink.close(); | |
| } | |
| /// Creates a sparse file with a logical size of [size]. The file will be all | |
| /// zeroes. | |
| Future<void> createCleanSparseTestFile(String path, int size) async { | |
| await Process.run('truncate', ['--size=$size', path]); | |
| } | |
| /// Creates a file with [size], where some chunks are zeroes. | |
| Future<void> createSparseTestFile(String path, int size) { | |
| final sink = File(path).openWrite(); | |
| final random = Random(); | |
| var remaining = size; | |
| while (remaining > 0) { | |
| final nextBlockSize = min(remaining, 512); | |
| if (random.nextBool()) { | |
| sink.add(Uint8List(nextBlockSize)); | |
| } else { | |
| final block = Uint8List(nextBlockSize); | |
| fillRandomBytes(block, random); | |
| sink.add(block); | |
| } | |
| remaining -= nextBlockSize; | |
| } | |
| return sink.close(); | |
| } | |
| void fillRandomBytes(List<int> bytes, Random random) { | |
| for (var i = 0; i < bytes.length; i++) { | |
| bytes[i] = random.nextInt(256); | |
| } | |
| } | |
| Future<void> validate(Stream<List<int>> tar, Map<String, String> files) async { | |
| final reader = TarReader(tar); | |
| for (var i = 0; i < files.length; i++) { | |
| expect(await reader.moveNext(), isTrue); | |
| final fileName = reader.current.name; | |
| final matchingFile = files[fileName]; | |
| if (matchingFile == null) { | |
| fail('Unexpected file $fileName in tar file'); | |
| } | |
| final actualContents = ChunkedStreamReader(File(matchingFile).openRead()); | |
| final tarContents = ChunkedStreamReader(reader.current.contents); | |
| while (true) { | |
| final actualChunk = await actualContents.readBytes(1024); | |
| final tarChunk = await tarContents.readBytes(1024); | |
| expect(tarChunk, actualChunk); | |
| if (actualChunk.isEmpty) break; | |
| } | |
| } | |
| } | |
| void main() { | |
| // map from file names to desired size | |
| const testFiles = { | |
| 'reg_1': 65023, | |
| 'reg_2': 65539, | |
| 'reg_3': 65534, | |
| 'sparse_1': 131076, | |
| 'sparse_2': 65534, | |
| 'clean_sparse_1': 131076, | |
| 'clean_sparse_2': 65534, | |
| }; | |
| late String baseDirectory; | |
| String path(String fileName) => '$baseDirectory/$fileName'; | |
| setUpAll(() async { | |
| baseDirectory = | |
| '${Directory.systemTemp.path}/tar_test/${DateTime.now().millisecondsSinceEpoch}'; | |
| await Directory(baseDirectory).create(recursive: true); | |
| for (final entry in testFiles.entries) { | |
| final name = entry.key; | |
| final size = entry.value; | |
| if (name.contains('clean')) { | |
| await createCleanSparseTestFile(path(name), size); | |
| } else if (name.contains('sparse')) { | |
| await createSparseTestFile(path(name), size); | |
| } else { | |
| await createTestFile(path(entry.key), entry.value); | |
| } | |
| } | |
| }); | |
| tearDownAll(() { | |
| Directory(baseDirectory).delete(recursive: true); | |
| }); | |
| Future<void> testSubset( | |
| Iterable<String> keys, String format, String? sparse) { | |
| final files = {for (final file in keys) file: path(file)}; | |
| final tar = createTarStream(files.keys, | |
| baseDir: baseDirectory, archiveFormat: format, sparseVersion: sparse); | |
| return validate(tar, files); | |
| } | |
| for (final format in ['gnu', 'v7', 'oldgnu', 'posix', 'ustar']) { | |
| group('reads large files in $format', () { | |
| test('single file', () { | |
| return testSubset(['reg_1'], format, null); | |
| }); | |
| test('reads multiple large files successfully', () { | |
| return testSubset(['reg_1', 'reg_2', 'reg_3'], format, null); | |
| }); | |
| }); | |
| } | |
| for (final format in ['gnu', 'posix']) { | |
| for (final sparseVersion in ['0.0', '0.1', '1.0']) { | |
| group('sparse format $format, version $sparseVersion', () { | |
| test('reads a clean sparse file', () { | |
| return testSubset(['clean_sparse_1'], format, sparseVersion); | |
| }); | |
| test('reads a sparse file', () { | |
| return testSubset(['sparse_1'], format, sparseVersion); | |
| }); | |
| test('reads clean sparse / regular files', () { | |
| return testSubset( | |
| ['reg_1', 'clean_sparse_1', 'reg_3', 'clean_sparse_2'], | |
| format, | |
| sparseVersion, | |
| ); | |
| }); | |
| test('reads mixed regular / sparse / clean sparse files', () { | |
| return testSubset( | |
| ['reg_1', 'sparse_2', 'clean_sparse_1', 'reg_3'], | |
| format, | |
| sparseVersion, | |
| ); | |
| }); | |
| }); | |
| } | |
| } | |
| group('sparse entries', () { | |
| final tests = [ | |
| _SparseTestcase( | |
| input: [], | |
| size: 0, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 5000)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(0, 5000)], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(5000, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(1000, 4000)], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 1000), SparseEntry(5000, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(0, 3000)], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(3000, 2000)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(3000, 2000)], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 3000), SparseEntry(5000, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(2000, 2000)], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 2000), SparseEntry(4000, 1000)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(0, 2000), SparseEntry(8000, 2000)], | |
| size: 10000, | |
| isValid: true, | |
| inverted: [SparseEntry(2000, 6000), SparseEntry(10000, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [ | |
| SparseEntry(0, 2000), | |
| SparseEntry(2000, 2000), | |
| SparseEntry(4000, 0), | |
| SparseEntry(4000, 3000), | |
| SparseEntry(7000, 1000), | |
| SparseEntry(8000, 0), | |
| SparseEntry(8000, 2000) | |
| ], | |
| size: 10000, | |
| isValid: true, | |
| inverted: [SparseEntry(10000, 0)], | |
| ), | |
| _SparseTestcase( | |
| input: [ | |
| SparseEntry(0, 0), | |
| SparseEntry(1000, 0), | |
| SparseEntry(2000, 0), | |
| SparseEntry(3000, 0), | |
| SparseEntry(4000, 0), | |
| SparseEntry(5000, 0), | |
| ], | |
| size: 5000, | |
| isValid: true, | |
| inverted: [SparseEntry(0, 5000)], | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(1, 0)], | |
| size: 0, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(-1, 0)], | |
| size: 100, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(0, -1)], | |
| size: 100, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(0, 1)], | |
| size: -100, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(9223372036854775807, 3), SparseEntry(6, -5)], | |
| size: 35, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(1, 3), SparseEntry(6, -5)], | |
| size: 35, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(9223372036854775807, 9223372036854775807)], | |
| size: 9223372036854775807, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(3, 3)], | |
| size: 5, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(2, 0), SparseEntry(1, 0), SparseEntry(0, 0)], | |
| size: 3, | |
| isValid: false, | |
| ), | |
| _SparseTestcase( | |
| input: [SparseEntry(1, 3), SparseEntry(2, 2)], | |
| size: 10, | |
| isValid: false, | |
| ), | |
| ]; | |
| for (var i = 0; i < tests.length; i++) { | |
| final testcase = tests[i]; | |
| test('validateSparseEntries #$i', () { | |
| expect(validateSparseEntries(testcase.input, testcase.size), | |
| testcase.isValid); | |
| }); | |
| if (testcase.isValid) { | |
| test('invertSparseEntries #$i', () { | |
| expect(invertSparseEntries(testcase.input, testcase.size), | |
| testcase.inverted); | |
| }); | |
| } | |
| } | |
| }); | |
| } | |
| class _SparseTestcase { | |
| final List<SparseEntry> input; | |
| final int size; | |
| final bool isValid; | |
| final List<SparseEntry>? inverted; | |
| _SparseTestcase({ | |
| required this.input, | |
| required this.size, | |
| required this.isValid, | |
| this.inverted, | |
| }); | |
| } |