protected async Task Read_Archive_Folder_File_Async_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "folder_file"; await using (MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName)) { await using (TarReader reader = new TarReader(ms)) { if (testFormat is TestTarFormat.pax_gea) { TarEntry entry = await reader.GetNextEntryAsync(); VerifyGlobalExtendedAttributes(entry); } TarEntry directory = await reader.GetNextEntryAsync(); VerifyDirectoryEntry(directory, format, "folder/"); TarEntry file = await reader.GetNextEntryAsync(); VerifyRegularFileEntry(file, format, "folder/file.txt", $"Hello {testCaseName}"); Assert.Null(await reader.GetNextEntryAsync()); } } }
public void Verify_Checksum_RegularFile(TarEntryFormat format) => Verify_Checksum_Internal( format, // Convert to V7RegularFile if format is V7 GetTarEntryTypeForTarEntryFormat(TarEntryType.RegularFile, format), longLink: false, longPath: false);
private void VerifyDirectoryEntry(TarEntry directory, TarEntryFormat format, string expectedFileName) { Assert.NotNull(directory); VerifyType(directory, format); Assert.True(directory.Checksum > 0); Assert.Null(directory.DataStream); Assert.Equal(TarEntryType.Directory, directory.EntryType); Assert.Equal(AssetGid, directory.Gid); Assert.Equal(0, directory.Length); Assert.Equal(DefaultLinkName, directory.LinkName); Assert.Equal(AssetMode, directory.Mode); Assert.True(directory.ModificationTime > DateTimeOffset.UnixEpoch); Assert.Equal(expectedFileName, directory.Name); Assert.Equal(AssetUid, directory.Uid); if (directory is PosixTarEntry posix) { Assert.Equal(DefaultDeviceMajor, posix.DeviceMajor); Assert.Equal(DefaultDeviceMinor, posix.DeviceMinor); Assert.Equal(AssetGName, posix.GroupName); Assert.Equal(AssetUName, posix.UserName); } if (directory is PaxTarEntry pax) { VerifyExtendedAttributeTimestamps(pax); } else if (directory is GnuTarEntry gnu) { VerifyGnuTimestamps(gnu); } }
private void VerifyFifoEntry(PosixTarEntry fifo, TarEntryFormat format, string expectedFileName) { Assert.NotNull(fifo); VerifyType(fifo, format); Assert.True(fifo.Checksum > 0); Assert.Null(fifo.DataStream); Assert.Equal(TarEntryType.Fifo, fifo.EntryType); Assert.Equal(AssetGid, fifo.Gid); Assert.Equal(0, fifo.Length); Assert.Equal(DefaultLinkName, fifo.LinkName); Assert.Equal(AssetSpecialFileMode, fifo.Mode); Assert.True(fifo.ModificationTime > DateTimeOffset.UnixEpoch); Assert.Equal(expectedFileName, fifo.Name); Assert.Equal(AssetUid, fifo.Uid); Assert.Equal(DefaultDeviceMajor, fifo.DeviceMajor); Assert.Equal(DefaultDeviceMinor, fifo.DeviceMinor); Assert.Equal(AssetGName, fifo.GroupName); Assert.Equal(AssetUName, fifo.UserName); if (fifo is PaxTarEntry pax) { VerifyExtendedAttributeTimestamps(pax); } else if (fifo is GnuTarEntry gnu) { VerifyGnuTimestamps(gnu); } }
private void VerifyType(TarEntry entry, TarEntryFormat format, bool isGea = false) { Assert.Equal(format, entry.Format); switch (format) { case TarEntryFormat.V7: Assert.True(entry is V7TarEntry, "Entry was not V7"); break; case TarEntryFormat.Ustar: Assert.True(entry is UstarTarEntry, "Entry was not Ustar"); break; case TarEntryFormat.Gnu: Assert.True(entry is GnuTarEntry, "Entry was not Gnu"); break; case TarEntryFormat.Pax: if (isGea) { Assert.Equal(TarEntryType.GlobalExtendedAttributes, entry.EntryType); Assert.True(entry is PaxGlobalExtendedAttributesTarEntry, "Entry was not PAX GEA"); } else { Assert.True(entry is PaxTarEntry, "Entry was not PAX"); } break; default: throw new Exception($"Unexpected format: {format}"); } }
private void VerifySymbolicLinkEntry(TarEntry symbolicLink, TarEntryFormat format, string expectedFileName, string expectedTargetName) { Assert.NotNull(symbolicLink); VerifyType(symbolicLink, format); Assert.True(symbolicLink.Checksum > 0); Assert.Null(symbolicLink.DataStream); Assert.Equal(TarEntryType.SymbolicLink, symbolicLink.EntryType); Assert.Equal(AssetGid, symbolicLink.Gid); Assert.Equal(0, symbolicLink.Length); Assert.Equal(expectedTargetName, symbolicLink.LinkName); Assert.Equal(AssetSymbolicLinkMode, symbolicLink.Mode); Assert.True(symbolicLink.ModificationTime > DateTimeOffset.UnixEpoch); Assert.Equal(expectedFileName, symbolicLink.Name); Assert.Equal(AssetUid, symbolicLink.Uid); if (symbolicLink is PosixTarEntry posix) { Assert.Equal(DefaultDeviceMajor, posix.DeviceMajor); Assert.Equal(DefaultDeviceMinor, posix.DeviceMinor); Assert.Equal(AssetGName, posix.GroupName); Assert.Equal(AssetUName, posix.UserName); } if (symbolicLink is PaxTarEntry pax) { VerifyExtendedAttributeTimestamps(pax); } else if (symbolicLink is GnuTarEntry gnu) { VerifyGnuTimestamps(gnu); } }
protected async Task Read_Archive_LongPath_Over255_Async_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "longpath_over255"; await using (MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName)) { await using (TarReader reader = new TarReader(ms)) { if (testFormat is TestTarFormat.pax_gea) { TarEntry entry = await reader.GetNextEntryAsync(); VerifyGlobalExtendedAttributes(entry); } TarEntry directory = await reader.GetNextEntryAsync(); VerifyDirectoryEntry(directory, format, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/"); TarEntry file = await reader.GetNextEntryAsync(); VerifyRegularFileEntry(file, format, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt", $"Hello {testCaseName}"); Assert.Null(await reader.GetNextEntryAsync()); } } }
protected async Task Read_Archive_File_HardLink_Async_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "file_hardlink"; await using (MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName)) { await using (TarReader reader = new TarReader(ms)) { if (testFormat is TestTarFormat.pax_gea) { TarEntry entry = await reader.GetNextEntryAsync(); VerifyGlobalExtendedAttributes(entry); } TarEntry file = await reader.GetNextEntryAsync(); VerifyRegularFileEntry(file, format, "file.txt", $"Hello {testCaseName}"); TarEntry hardLink = await reader.GetNextEntryAsync(); // The 'tar' tool detects hardlinks as regular files and saves them as such in the archives, for all formats VerifyRegularFileEntry(hardLink, format, "hardlink.txt", $"Hello {testCaseName}"); Assert.Null(await reader.GetNextEntryAsync()); } } }
protected async Task Read_Archive_SpecialFiles_Async_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "specialfiles"; await using (MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName)) { await using (TarReader reader = new TarReader(ms)) { if (testFormat is TestTarFormat.pax_gea) { TarEntry entry = await reader.GetNextEntryAsync(); VerifyGlobalExtendedAttributes(entry); } PosixTarEntry blockDevice = await reader.GetNextEntryAsync() as PosixTarEntry; VerifyBlockDeviceEntry(blockDevice, format, AssetBlockDeviceFileName); PosixTarEntry characterDevice = await reader.GetNextEntryAsync() as PosixTarEntry; VerifyCharacterDeviceEntry(characterDevice, format, AssetCharacterDeviceFileName); PosixTarEntry fifo = await reader.GetNextEntryAsync() as PosixTarEntry; VerifyFifoEntry(fifo, format, "fifofile"); Assert.Null(await reader.GetNextEntryAsync()); } } }
protected void Read_Archive_File_LongSymbolicLink_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "file_longsymlink"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat is TestTarFormat.pax_gea) { VerifyGlobalExtendedAttributes(reader); } TarEntry directory = reader.GetNextEntry(); VerifyDirectoryEntry(directory, format, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/"); TarEntry file = reader.GetNextEntry(); VerifyRegularFileEntry(file, format, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt", $"Hello {testCaseName}"); TarEntry symbolicLink = reader.GetNextEntry(); VerifySymbolicLinkEntry(symbolicLink, format, "link.txt", "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt"); Assert.Null(reader.GetNextEntry()); }
protected void Read_Archive_SpecialFiles_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "specialfiles"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat is TestTarFormat.pax_gea) { VerifyGlobalExtendedAttributes(reader); } PosixTarEntry blockDevice = reader.GetNextEntry() as PosixTarEntry; VerifyBlockDeviceEntry(blockDevice, format, AssetBlockDeviceFileName); PosixTarEntry characterDevice = reader.GetNextEntry() as PosixTarEntry; VerifyCharacterDeviceEntry(characterDevice, format, AssetCharacterDeviceFileName); PosixTarEntry fifo = reader.GetNextEntry() as PosixTarEntry; VerifyFifoEntry(fifo, format, "fifofile"); Assert.Null(reader.GetNextEntry()); }
private int GetNameChecksum(TarEntryFormat format, bool longPath, out string entryName) { int expectedChecksum = 0; if (!longPath) { // 'a.b' = 97 + 46 + 98 = 241 entryName = "a.b"; expectedChecksum += 241; } else { entryName = new string('a', 150); // 100 * 97 = 9700 (first 100 bytes go into 'name' field) expectedChecksum += 9700; // - V7 does not support name fields larger than 100, writes what it can // - Gnu writes first 100 bytes in 'name' field, then the full name is written in a LonPath entry // that precedes this one. if (format is TarEntryFormat.Ustar or TarEntryFormat.Pax) { // 50 * 97 = 4850 (rest of bytes go into 'prefix' field) expectedChecksum += 4850; } } return(expectedChecksum); }
public void Write_RegularFileEntry_As_V7RegularFileEntry(TarEntryFormat entryFormat) { using MemoryStream archive = new MemoryStream(); using (TarWriter writer = new TarWriter(archive, archiveFormat: TarEntryFormat.V7, leaveOpen: true)) { TarEntry entry = entryFormat switch { TarEntryFormat.Ustar => new UstarTarEntry(TarEntryType.RegularFile, InitialEntryName), TarEntryFormat.Pax => new PaxTarEntry(TarEntryType.RegularFile, InitialEntryName), TarEntryFormat.Gnu => new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName), _ => throw new FormatException() }; // Should be written as V7RegularFile writer.WriteEntry(entry); } archive.Seek(0, SeekOrigin.Begin); using (TarReader reader = new TarReader(archive)) { TarEntry entry = reader.GetNextEntry(); Assert.True(entry is V7TarEntry); Assert.Equal(TarEntryType.V7RegularFile, entry.EntryType); Assert.Null(reader.GetNextEntry()); } }
protected void Read_Archive_Folder_Subfolder_File_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "folder_subfolder_file"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat is TestTarFormat.pax_gea) { VerifyGlobalExtendedAttributes(reader); } TarEntry parent = reader.GetNextEntry(); VerifyDirectoryEntry(parent, format, "parent/"); TarEntry child = reader.GetNextEntry(); VerifyDirectoryEntry(child, format, "parent/child/"); TarEntry file = reader.GetNextEntry(); VerifyRegularFileEntry(file, format, "parent/child/file.txt", $"Hello {testCaseName}"); Assert.Null(reader.GetNextEntry()); }
protected void VerifyDirectory(TarEntry entry, TarEntryFormat format, string name) { Assert.NotNull(entry); Assert.Equal(format, entry.Format); Assert.Equal(TarEntryType.Directory, entry.EntryType); Assert.Equal(name, entry.Name); }
private static TarHeader?TryReadAttributes(TarEntryFormat initialFormat, Span <byte> buffer) { // Confirms if v7 or pax, or tentatively selects ustar TarHeader?header = TryReadCommonAttributes(buffer, initialFormat); if (header != null) { // Confirms if gnu, or tentatively selects ustar header.ReadMagicAttribute(buffer); if (header._format != TarEntryFormat.V7) { // Confirms if gnu header.ReadVersionAttribute(buffer); // Fields that ustar, pax and gnu share identically header.ReadPosixAndGnuSharedAttributes(buffer); Debug.Assert(header._format is TarEntryFormat.Ustar or TarEntryFormat.Pax or TarEntryFormat.Gnu); if (header._format == TarEntryFormat.Ustar) { header.ReadUstarAttributes(buffer); } else if (header._format == TarEntryFormat.Gnu) { header.ReadGnuAttributes(buffer); } // In PAX, there is nothing to read in this section (empty space) } } return(header); }
public void ReadAndWriteMultipleGlobalExtendedAttributesEntries(TarEntryFormat format) { Dictionary <string, string> attrs = new Dictionary <string, string>() { { "hello", "world" }, { "dotnet", "runtime" } }; using MemoryStream archiveStream = new MemoryStream(); using (TarWriter writer = new TarWriter(archiveStream, leaveOpen: true)) { PaxGlobalExtendedAttributesTarEntry gea1 = new PaxGlobalExtendedAttributesTarEntry(attrs); writer.WriteEntry(gea1); TarEntry entry1 = InvokeTarEntryCreationConstructor(format, TarEntryType.Directory, "dir1"); writer.WriteEntry(entry1); PaxGlobalExtendedAttributesTarEntry gea2 = new PaxGlobalExtendedAttributesTarEntry(attrs); writer.WriteEntry(gea2); TarEntry entry2 = InvokeTarEntryCreationConstructor(format, TarEntryType.Directory, "dir2"); writer.WriteEntry(entry2); } archiveStream.Position = 0; using (TarReader reader = new TarReader(archiveStream, leaveOpen: false)) { VerifyGlobalExtendedAttributesEntry(reader.GetNextEntry(), attrs); VerifyDirectory(reader.GetNextEntry(), format, "dir1"); VerifyGlobalExtendedAttributesEntry(reader.GetNextEntry(), attrs); VerifyDirectory(reader.GetNextEntry(), format, "dir2"); Assert.Null(reader.GetNextEntry()); } }
public void WriteEntry_RespectDefaultWriterFormat(TarEntryFormat expectedFormat) { using TempDirectory root = new TempDirectory(); string path = Path.Join(root.Path, "file.txt"); File.Create(path).Dispose(); using MemoryStream archiveStream = new MemoryStream(); using (TarWriter writer = new TarWriter(archiveStream, expectedFormat, leaveOpen: true)) { writer.WriteEntry(path, "file.txt"); } archiveStream.Position = 0; using (TarReader reader = new TarReader(archiveStream, leaveOpen: false)) { TarEntry entry = reader.GetNextEntry(); Assert.Equal(expectedFormat, entry.Format); Type expectedType = GetTypeForFormat(expectedFormat); Assert.Equal(expectedType, entry.GetType()); } }
public async Task Write_V7RegularFileEntry_In_OtherFormatsWriter_Async(TarEntryFormat writerFormat) { using MemoryStream archive = new MemoryStream(); TarWriter writer = new TarWriter(archive, format: writerFormat, leaveOpen: true); await using (writer) { V7TarEntry entry = new V7TarEntry(TarEntryType.V7RegularFile, InitialEntryName); // Should be written in the format of the entry await writer.WriteEntryAsync(entry); } archive.Seek(0, SeekOrigin.Begin); TarReader reader = new TarReader(archive); await using (reader) { TarEntry entry = await reader.GetNextEntryAsync(); Assert.NotNull(entry); Assert.Equal(TarEntryFormat.V7, entry.Format); Assert.True(entry is V7TarEntry); Assert.Null(await reader.GetNextEntryAsync()); } }
public void Constructor_ConversionFromUstar_From_UnseekableTarReader(TarEntryFormat writerFormat) { using MemoryStream source = GetTarMemoryStream(CompressionMethod.Uncompressed, TestTarFormat.ustar, "file"); using WrappedStream wrappedSource = new WrappedStream(source, canRead: true, canWrite: false, canSeek: false); using TarReader sourceReader = new TarReader(wrappedSource, leaveOpen: true); UstarTarEntry ustarEntry = sourceReader.GetNextEntry(copyData: false) as UstarTarEntry; V7TarEntry v7Entry = new V7TarEntry(other: ustarEntry); // Convert, and avoid advancing wrappedSource position using MemoryStream destination = new MemoryStream(); using (TarWriter writer = new TarWriter(destination, writerFormat, leaveOpen: true)) { writer.WriteEntry(v7Entry); // Write DataStream exactly where the wrappedSource position was left } destination.Position = 0; // Rewind using (TarReader destinationReader = new TarReader(destination, leaveOpen: false)) { V7TarEntry resultEntry = destinationReader.GetNextEntry() as V7TarEntry; Assert.NotNull(resultEntry); using (StreamReader streamReader = new StreamReader(resultEntry.DataStream)) { Assert.Equal("Hello file", streamReader.ReadToEnd()); } } }
// Constructor called when creating a new 'TarEntry*' instance that can be passed to a TarWriter. internal TarEntry(TarEntryType entryType, string entryName, TarEntryFormat format) { ArgumentException.ThrowIfNullOrEmpty(entryName); // Throws if format is unknown or out of range TarHelpers.VerifyEntryTypeIsSupported(entryType, format, forWriting: false); _readerOfOrigin = null; _header = default; _header._extendedAttributes = new Dictionary <string, string>(); _header._name = entryName; _header._linkName = string.Empty; _header._typeFlag = entryType; _header._mode = (int)TarHelpers.DefaultMode; _header._gName = string.Empty; _header._uName = string.Empty; DateTimeOffset now = DateTimeOffset.Now; _header._mTime = now; _header._aTime = now; _header._cTime = now; }
public void Read_Archive_File_HardLink(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "file_hardlink"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat == TestTarFormat.pax_gea) { // The GEA are collected after reading the first entry, not on the constructor Assert.Null(reader.GlobalExtendedAttributes); } // Format is determined after reading the first entry, not on the constructor Assert.Equal(TarEntryFormat.Unknown, reader.Format); TarEntry file = reader.GetNextEntry(); Assert.Equal(format, reader.Format); if (testFormat == TestTarFormat.pax_gea) { Assert.NotNull(reader.GlobalExtendedAttributes); Assert.True(reader.GlobalExtendedAttributes.Any()); Assert.Contains(AssetPaxGeaKey, reader.GlobalExtendedAttributes); Assert.Equal(AssetPaxGeaValue, reader.GlobalExtendedAttributes[AssetPaxGeaKey]); } Verify_Archive_RegularFile(file, format, reader.GlobalExtendedAttributes, "file.txt", $"Hello {testCaseName}"); TarEntry hardLink = reader.GetNextEntry(); // The 'tar' tool detects hardlinks as regular files and saves them as such in the archives, for all formats Verify_Archive_RegularFile(hardLink, format, reader.GlobalExtendedAttributes, "hardlink.txt", $"Hello {testCaseName}"); Assert.Null(reader.GetNextEntry()); }
public void Read_Archive_LongPath_Over255(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "longpath_over255"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat == TestTarFormat.pax_gea) { // The GEA are collected after reading the first entry, not on the constructor Assert.Null(reader.GlobalExtendedAttributes); } // Format is determined after reading the first entry, not on the constructor Assert.Equal(TarEntryFormat.Unknown, reader.Format); TarEntry directory = reader.GetNextEntry(); Assert.Equal(format, reader.Format); if (testFormat == TestTarFormat.pax_gea) { Assert.NotNull(reader.GlobalExtendedAttributes); Assert.True(reader.GlobalExtendedAttributes.Any()); Assert.Contains(AssetPaxGeaKey, reader.GlobalExtendedAttributes); Assert.Equal(AssetPaxGeaValue, reader.GlobalExtendedAttributes[AssetPaxGeaKey]); } Verify_Archive_Directory(directory, reader.GlobalExtendedAttributes, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/"); TarEntry file = reader.GetNextEntry(); Verify_Archive_RegularFile(file, format, reader.GlobalExtendedAttributes, "000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt", $"Hello {testCaseName}"); Assert.Null(reader.GetNextEntry()); }
protected void Read_Archive_LongPath_Splitable_Under255_Internal(TarEntryFormat format, TestTarFormat testFormat) { string testCaseName = "longpath_splitable_under255"; using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName); using TarReader reader = new TarReader(ms); if (testFormat is TestTarFormat.pax_gea) { VerifyGlobalExtendedAttributes(reader); } TarEntry directory = reader.GetNextEntry(); VerifyDirectoryEntry(directory, format, "00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999/"); TarEntry file = reader.GetNextEntry(); VerifyRegularFileEntry(file, format, $"00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999.txt", $"Hello {testCaseName}"); Assert.Null(reader.GetNextEntry()); }
// Constructor called when reading a TarEntry from a TarReader. internal TarEntry(TarHeader header, TarReader readerOfOrigin, TarEntryFormat format) { // This constructor is called after reading a header from the archive, // and we should've already detected the format of the header. Debug.Assert(header._format == format); _header = header; _readerOfOrigin = readerOfOrigin; }
public Task ExtractToFileAsync_Cancel(TarEntryFormat format) { TarEntry entry = InvokeTarEntryCreationConstructor(format, TarEntryType.Directory, "dir"); CancellationTokenSource cs = new CancellationTokenSource(); cs.Cancel(); return(Assert.ThrowsAsync <TaskCanceledException>(() => entry.ExtractToFileAsync("dir", overwrite: true, cs.Token))); }
// Constructor called when the user creates a TarEntry instance from scratch. internal PosixTarEntry(TarEntryType entryType, string entryName, TarEntryFormat format, bool isGea) : base(entryType, entryName, format, isGea) { _header._uName = string.Empty; _header._gName = string.Empty; _header._devMajor = 0; _header._devMinor = 0; }
public void Extract(TarEntryFormat format, TarEntryType entryType) { using TempDirectory root = new TempDirectory(); (string entryName, string destination, TarEntry entry) = Prepare_Extract(root, format, entryType); entry.ExtractToFile(destination, overwrite: true); Verify_Extract(destination, entry, entryType); }
protected async Task WriteEntry_Null_Throws_Async_Internal(TarEntryFormat format) { await using (MemoryStream archiveStream = new MemoryStream()) { await using (TarWriter writer = new TarWriter(archiveStream, format, leaveOpen: false)) { await Assert.ThrowsAsync <ArgumentNullException>(() => writer.WriteEntryAsync(null)); } } }
public async Task Extract_SpecialFiles_Async(TarEntryFormat format, TarEntryType entryType) { using TempDirectory root = new TempDirectory(); (string entryName, string destination, PosixTarEntry entry) = Prepare_Extract_SpecialFiles(root, format, entryType); await entry.ExtractToFileAsync(destination, overwrite : true); Verify_Extract_SpecialFiles(destination, entry, entryType); }