public void SupportedEntryType_RegularFile()
{
GnuTarEntry regularFile = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
SetRegularFile(regularFile);
VerifyRegularFile(regularFile, isWritable: true);
}
public void Constructor_ConversionFromGnu_From_UnseekableTarReader(TarEntryFormat writerFormat)
{
using MemoryStream source = GetTarMemoryStream(CompressionMethod.Uncompressed, TestTarFormat.gnu, "file");
using WrappedStream wrappedSource = new WrappedStream(source, canRead: true, canWrite: false, canSeek: false);
using TarReader sourceReader = new TarReader(wrappedSource, leaveOpen: true);
GnuTarEntry gnuEntry = sourceReader.GetNextEntry(copyData: false) as GnuTarEntry;
V7TarEntry v7Entry = new V7TarEntry(other: gnuEntry); // 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());
}
}
}
public async Task Write_LongName_And_LongLinkName_Async(TarEntryType entryType)
{
// Both the Name and LinkName fields in header only fit 100 bytes
string longName = new string('a', 101);
string longLinkName = new string('a', 101);
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry entry = new GnuTarEntry(entryType, longName);
entry.LinkName = longLinkName;
await writer.WriteEntryAsync(entry);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
Assert.Equal(entryType, entry.EntryType);
Assert.Equal(longName, entry.Name);
Assert.Equal(longLinkName, entry.LinkName);
}
}
}
public void SupportedEntryType_Directory()
{
GnuTarEntry directory = new GnuTarEntry(TarEntryType.Directory, InitialEntryName);
SetDirectory(directory);
VerifyDirectory(directory);
}
public void SupportedEntryType_SymbolicLink()
{
GnuTarEntry symbolicLink = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
SetSymbolicLink(symbolicLink);
VerifySymbolicLink(symbolicLink);
}
public void SupportedEntryType_HardLink()
{
GnuTarEntry hardLink = new GnuTarEntry(TarEntryType.HardLink, InitialEntryName);
SetHardLink(hardLink);
VerifyHardLink(hardLink);
}
public void SupportedEntryType_BlockDevice()
{
GnuTarEntry blockDevice = new GnuTarEntry(TarEntryType.BlockDevice, InitialEntryName);
SetBlockDevice(blockDevice);
VerifyBlockDevice(blockDevice);
}
public void SupportedEntryType_CharacterDevice()
{
GnuTarEntry characterDevice = new GnuTarEntry(TarEntryType.CharacterDevice, InitialEntryName);
SetCharacterDevice(characterDevice);
VerifyCharacterDevice(characterDevice);
}
public void SupportedEntryType_Fifo()
{
GnuTarEntry fifo = new GnuTarEntry(TarEntryType.Fifo, InitialEntryName);
SetFifo(fifo);
VerifyFifo(fifo);
}
protected void SetGnuProperties(GnuTarEntry entry)
{
DateTimeOffset approxNow = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromHours(6));
// ATime: Verify the default value was approximately "now"
Assert.True(entry.AccessTime > approxNow);
Assert.Throws <ArgumentOutOfRangeException>(() => entry.AccessTime = DateTimeOffset.MinValue);
entry.AccessTime = TestAccessTime;
// CTime: Verify the default value was approximately "now"
Assert.True(entry.ChangeTime > approxNow);
Assert.Throws <ArgumentOutOfRangeException>(() => entry.ChangeTime = DateTimeOffset.MinValue);
entry.ChangeTime = TestChangeTime;
}
public void ExtractToFile_Link_Throws(TarEntryType entryType)
{
using TempDirectory root = new TempDirectory();
string fileName = "mylink";
string fullPath = Path.Join(root.Path, fileName);
string linkTarget = PlatformDetection.IsWindows ? @"C:\Windows\system32\notepad.exe" : "/usr/bin/nano";
GnuTarEntry entry = new GnuTarEntry(entryType, fileName);
entry.LinkName = linkTarget;
Assert.Throws <InvalidOperationException>(() => entry.ExtractToFile(fileName, overwrite: false));
Assert.Equal(0, Directory.GetFileSystemEntries(root.Path).Count());
}
public void Constructor_Name_FullPath_DestinationDirectory_Mismatch_Throws()
{
using TempDirectory root = new TempDirectory();
string fullPath = Path.Join(Path.GetPathRoot(root.Path), "dir", "file.txt");
GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, fullPath);
entry.DataStream = new MemoryStream();
entry.DataStream.Write(new byte[] { 0x1 });
entry.DataStream.Seek(0, SeekOrigin.Begin);
Assert.Throws <IOException>(() => entry.ExtractToFile(root.Path, overwrite: false));
Assert.False(File.Exists(fullPath));
}
public void Constructor_Name_FullPath_DestinationDirectory_Match()
{
using TempDirectory root = new TempDirectory();
string fullPath = Path.Join(root.Path, "file.txt");
GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, fullPath);
entry.DataStream = new MemoryStream();
entry.DataStream.Write(new byte[] { 0x1 });
entry.DataStream.Seek(0, SeekOrigin.Begin);
entry.ExtractToFile(fullPath, overwrite: false);
Assert.True(File.Exists(fullPath));
}
public void WriteCharacterDevice()
{
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry charDevice = new GnuTarEntry(TarEntryType.CharacterDevice, InitialEntryName);
SetCharacterDevice(charDevice);
VerifyCharacterDevice(charDevice);
writer.WriteEntry(charDevice);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry charDevice = reader.GetNextEntry() as GnuTarEntry;
VerifyCharacterDevice(charDevice);
}
}
public void WriteSymbolicLink()
{
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry symbolicLink = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
SetSymbolicLink(symbolicLink);
VerifySymbolicLink(symbolicLink);
writer.WriteEntry(symbolicLink);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry symbolicLink = reader.GetNextEntry() as GnuTarEntry;
VerifySymbolicLink(symbolicLink);
}
}
public void WriteRegularFile()
{
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry regularFile = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
SetRegularFile(regularFile);
VerifyRegularFile(regularFile, isWritable: true);
writer.WriteEntry(regularFile);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry regularFile = reader.GetNextEntry() as GnuTarEntry;
VerifyRegularFile(regularFile, isWritable: false);
}
}
public void WriteFifo()
{
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry fifo = new GnuTarEntry(TarEntryType.Fifo, InitialEntryName);
SetFifo(fifo);
VerifyFifo(fifo);
writer.WriteEntry(fifo);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry fifo = reader.GetNextEntry() as GnuTarEntry;
VerifyFifo(fifo);
}
}
public void WriteDirectory()
{
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry directory = new GnuTarEntry(TarEntryType.Directory, InitialEntryName);
SetDirectory(directory);
VerifyDirectory(directory);
writer.WriteEntry(directory);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry directory = reader.GetNextEntry() as GnuTarEntry;
VerifyDirectory(directory);
}
}
public void Write_Long_Name(TarEntryType entryType)
{
// Name field in header only fits 100 bytes
string longName = new string('a', 101);
using MemoryStream archiveStream = new MemoryStream();
using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry entry = new GnuTarEntry(entryType, longName);
writer.WriteEntry(entry);
}
archiveStream.Position = 0;
using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
Assert.Equal(entryType, entry.EntryType);
Assert.Equal(longName, entry.Name);
}
}
public async Task WriteBlockDevice_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry blockDevice = new GnuTarEntry(TarEntryType.BlockDevice, InitialEntryName);
SetBlockDevice(blockDevice);
VerifyBlockDevice(blockDevice);
await writer.WriteEntryAsync(blockDevice);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry blockDevice = await reader.GetNextEntryAsync() as GnuTarEntry;
VerifyBlockDevice(blockDevice);
}
}
}
public async Task WriteFifo_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry fifo = new GnuTarEntry(TarEntryType.Fifo, InitialEntryName);
SetFifo(fifo);
VerifyFifo(fifo);
await writer.WriteEntryAsync(fifo);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry fifo = await reader.GetNextEntryAsync() as GnuTarEntry;
VerifyFifo(fifo);
}
}
}
public async Task WriteRegularFile_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry regularFile = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
SetRegularFile(regularFile);
VerifyRegularFile(regularFile, isWritable: true);
await writer.WriteEntryAsync(regularFile);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry regularFile = await reader.GetNextEntryAsync() as GnuTarEntry;
VerifyRegularFile(regularFile, isWritable: false);
}
}
}
public async Task WriteSymbolicLink_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry symbolicLink = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
SetSymbolicLink(symbolicLink);
VerifySymbolicLink(symbolicLink);
await writer.WriteEntryAsync(symbolicLink);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry symbolicLink = await reader.GetNextEntryAsync() as GnuTarEntry;
VerifySymbolicLink(symbolicLink);
}
}
}
public async Task WriteDirectory_Async()
{
using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Gnu, leaveOpen: true))
{
GnuTarEntry directory = new GnuTarEntry(TarEntryType.Directory, InitialEntryName);
SetDirectory(directory);
VerifyDirectory(directory);
await writer.WriteEntryAsync(directory);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
GnuTarEntry directory = await reader.GetNextEntryAsync() as GnuTarEntry;
VerifyDirectory(directory);
}
}
}
public void Write_V7RegularFileEntry_As_RegularFileEntry()
{
using MemoryStream archive = new MemoryStream();
using (TarWriter writer = new TarWriter(archive, archiveFormat: TarEntryFormat.Gnu, leaveOpen: true))
{
V7TarEntry entry = new V7TarEntry(TarEntryType.V7RegularFile, InitialEntryName);
// Should be written as RegularFile
writer.WriteEntry(entry);
}
archive.Seek(0, SeekOrigin.Begin);
using (TarReader reader = new TarReader(archive))
{
GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
Assert.NotNull(entry);
Assert.Equal(TarEntryType.RegularFile, entry.EntryType);
Assert.Null(reader.GetNextEntry());
}
}
protected void VerifyDirectory(GnuTarEntry directory)
{
VerifyPosixDirectory(directory);
VerifyGnuProperties(directory);
}
protected void VerifyCharacterDevice(GnuTarEntry characterDevice)
{
VerifyPosixCharacterDevice(characterDevice);
VerifyGnuProperties(characterDevice);
}
protected void VerifyHardLink(GnuTarEntry hardLink)
{
VerifyPosixHardLink(hardLink);
VerifyGnuProperties(hardLink);
}
protected void VerifySymbolicLink(GnuTarEntry symbolicLink)
{
VerifyPosixSymbolicLink(symbolicLink);
VerifyGnuProperties(symbolicLink);
}
protected void VerifyRegularFile(GnuTarEntry regularFile, bool isWritable)
{
VerifyPosixRegularFile(regularFile, isWritable);
VerifyGnuProperties(regularFile);
}
