/// <summary>
/// Creates an item from header data.
/// </summary>
/// <param name="id">The item id.</param>
/// <param name="header">The header data.</param>
/// <param name="dataSourceList">The item list to use as the item data source.</param>
/// <returns>A new <see cref="NefsItem"/>.</returns>
public static NefsItem CreateFromHeader(NefsItemId id, NefsHeader header, NefsItemList dataSourceList)
{
var p1 = header.Part1.EntriesById[id];
var p2 = header.Part2.EntriesById[id];
// Check if part 6 exists
NefsHeaderPart6Entry p6 = null;
if (header.Part6.EntriesById.ContainsKey(id))
{
p6 = header.Part6.EntriesById[id];
}
// Determine type
var type = p2.Data0x0c_ExtractedSize.Value == 0 ? NefsItemType.Directory : NefsItemType.File;
// Find parent
var parentId = header.GetItemDirectoryId(id);
// Offset and size
var dataOffset = p1.Data0x00_OffsetToData.Value;
var extractedSize = p2.Data0x0c_ExtractedSize.Value;
// Data source
INefsDataSource dataSource;
if (type == NefsItemType.Directory)
{
// Item is a directory
dataSource = new NefsEmptyDataSource();
}
else if (p1.IndexIntoPart4 == 0xFFFFFFFFU)
{
// Item is not compressed
var size = new NefsItemSize(extractedSize);
dataSource = new NefsItemListDataSource(dataSourceList, dataOffset, size);
}
else
{
// Item is compressed
var p4 = header.Part4.EntriesByIndex[p1.IndexIntoPart4];
var size = new NefsItemSize(extractedSize, p4.ChunkSizes);
dataSource = new NefsItemListDataSource(dataSourceList, dataOffset, size);
}
// File name and path
var fileName = header.GetItemFileName(id);
// Gather unknown metadata
var unknown = new NefsItemUnknownData
{
Part6Unknown0x00 = p6?.Byte0 ?? 0,
Part6Unknown0x01 = p6?.Byte1 ?? 0,
Part6Unknown0x02 = p6?.Byte2 ?? 0,
Part6Unknown0x03 = p6?.Byte3 ?? 0,
};
// Create item
return(new NefsItem(id, fileName, parentId, type, dataSource, unknown));
}
public void NefsHeaderPart1_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
11, 12, 13
}));
var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData());
items.Add(file1);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
14, 15, 16
}));
var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData());
items.Add(file2);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData());
items.Add(dir1);
var p4 = new NefsHeaderPart4(items);
var p1 = new NefsHeaderPart1(items, p4);
Assert.Equal(3, p1.EntriesById.Count);
/*
* dir1
*/
// Offset to data and index to p4 are both 0 since this is a directory
Assert.Equal(2, (int)p1.EntriesById[dir1.Id].Id.Value);
Assert.Equal(0, (int)p1.EntriesById[dir1.Id].OffsetToData);
Assert.Equal(0, (int)p1.EntriesById[dir1.Id].MetadataIndex);
Assert.Equal(0, (int)p1.EntriesById[dir1.Id].IndexIntoPart4);
/*
* file1
*/
Assert.Equal(0, (int)p1.EntriesById[file1.Id].Id.Value);
Assert.Equal(123, (int)p1.EntriesById[file1.Id].OffsetToData);
Assert.Equal(1, (int)p1.EntriesById[file1.Id].MetadataIndex);
Assert.Equal(0, (int)p1.EntriesById[file1.Id].IndexIntoPart4);
/*
* file2
*/
Assert.Equal(1, (int)p1.EntriesById[file2.Id].Id.Value);
Assert.Equal(456, (int)p1.EntriesById[file2.Id].OffsetToData);
Assert.Equal(2, (int)p1.EntriesById[file2.Id].MetadataIndex);
// There are 3 chunks for file1, so file2's chunks start right after that (hence p4
// index == 3)
Assert.Equal(3, (int)p1.EntriesById[file2.Id].IndexIntoPart4);
}
public void NefsHeaderPart7_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Id = new NefsItemId(31);
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
11, 12, 13
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
var file1 = TestHelpers.CreateFile(file1Id.Value, file1Id.Value, "file1", file1DataSource);
items.Add(file1);
var file2Id = new NefsItemId(41);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
14, 15, 16
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
var file2 = TestHelpers.CreateFile(file2Id.Value, file2Id.Value, "file2", file2DataSource);
items.Add(file2);
var dir2Id = new NefsItemId(51);
var dir1 = TestHelpers.CreateDirectory(dir2Id.Value, dir2Id.Value, "dir1");
items.Add(dir1);
var p7 = new NefsHeaderPart7(items);
Assert.Equal(3, p7.EntriesByIndex.Count);
// NOTES : Part 7 items are ordered in the same way that part 2 items are ordered (depth
// first by name).
/*
* dir1
*/
Assert.Equal(51U, p7.EntriesByIndex[0].Id.Value);
Assert.Equal(51U, p7.EntriesByIndex[0].SiblingId.Value);
/*
* file1
*/
Assert.Equal(31U, p7.EntriesByIndex[1].Id.Value);
Assert.Equal(41U, p7.EntriesByIndex[1].SiblingId.Value);
/*
* file2
*/
Assert.Equal(41U, p7.EntriesByIndex[2].Id.Value);
Assert.Equal(51U, p7.EntriesByIndex[2].SiblingId.Value);
}
public void NefsHeaderPart3_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
11, 12, 13
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
var file1 = TestHelpers.CreateFile(0, 0, "file1", file1DataSource);
items.Add(file1);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
14, 15, 16
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
var file2 = TestHelpers.CreateFile(1, 1, "file2", file2DataSource);
items.Add(file2);
var dir1 = TestHelpers.CreateDirectory(2, 2, "dir1");
items.Add(dir1);
var file3Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
22, 23, 24
}, TestHelpers.TestTransform);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, file3Chunks));
var file3 = TestHelpers.CreateFile(3, dir1.Id.Value, "file3", file3DataSource);
items.Add(file3);
var p3 = new NefsHeaderPart3(items);
Assert.Equal(5, p3.OffsetsByFileName.Count);
Assert.Equal(5, p3.FileNamesByOffset.Count);
// Four file names plus a null terminal for each.
Assert.Equal(36, (int)p3.Size);
// Strings table is sorted alphabetically - and also contains data file name
Assert.Equal("archive.nefs", p3.FileNamesByOffset[0]);
Assert.Equal("dir1", p3.FileNamesByOffset[13]);
Assert.Equal("file1", p3.FileNamesByOffset[18]);
Assert.Equal("file2", p3.FileNamesByOffset[24]);
Assert.Equal("file3", p3.FileNamesByOffset[30]);
Assert.Equal(18, (int)p3.OffsetsByFileName[file1.FileName]);
Assert.Equal(24, (int)p3.OffsetsByFileName[file2.FileName]);
Assert.Equal(13, (int)p3.OffsetsByFileName[dir1.FileName]);
Assert.Equal(30, (int)p3.OffsetsByFileName[file3.FileName]);
}
/// <inheritdoc/>
public NefsItem CreateItemInfo(Guid guid, NefsItemList dataSourceList)
{
var p1 = this.Part1.EntriesByGuid[guid];
var p2 = this.Part2.EntriesByIndex[(int)p1.IndexPart2];
var p6 = this.Part6.EntriesByGuid[guid];
var id = p1.Id;
// Gather attributes
var attributes = p6.CreateAttributes();
// Find parent
var parentId = this.GetItemDirectoryId(p1.IndexPart2);
// Offset and size
var dataOffset = p1.Data0x00_OffsetToData.Value;
var extractedSize = p2.Data0x0c_ExtractedSize.Value;
// Transform
var transform = new NefsDataTransform(this.TableOfContents.BlockSize, true, this.Intro.IsEncrypted ? this.Intro.GetAesKey() : null);
// Data source
INefsDataSource dataSource;
if (attributes.IsDirectory)
{
// Item is a directory
dataSource = new NefsEmptyDataSource();
transform = null;
}
else if (p1.IndexPart4 == 0xFFFFFFFFU)
{
// Item is not compressed
var size = new NefsItemSize(extractedSize);
dataSource = new NefsItemListDataSource(dataSourceList, dataOffset, size);
}
else
{
// Item is compressed
var numChunks = this.TableOfContents.ComputeNumChunks(p2.ExtractedSize);
var chunkSize = this.TableOfContents.BlockSize;
var chunks = this.Part4.CreateChunksList(p1.IndexPart4, numChunks, chunkSize, this.Intro.GetAesKey());
var size = new NefsItemSize(extractedSize, chunks);
dataSource = new NefsItemListDataSource(dataSourceList, dataOffset, size);
}
// File name and path
var fileName = this.GetItemFileName(p1.IndexPart2);
// Create item
return(new NefsItem(p1.Guid, id, fileName, parentId, dataSource, transform, attributes));
}
public void NefsHeaderPart3_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
11, 12, 13
}));
var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData());
items.Add(file1);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
14, 15, 16
}));
var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData());
items.Add(file2);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData());
items.Add(dir1);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, new List <UInt32> {
22, 23, 24
}));
var file3 = new NefsItem(new NefsItemId(3), "file3", dir1.Id, NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData());
items.Add(file3);
var p3 = new NefsHeaderPart3(items);
Assert.Equal(5, p3.OffsetsByFileName.Count);
Assert.Equal(5, p3.FileNamesByOffset.Count);
// Four file names plus a null terminal for each.
Assert.Equal(36, (int)p3.Size);
// Strings table is sorted alphabetically - and also contains data file name
Assert.Equal("archive.nefs", p3.FileNamesByOffset[0]);
Assert.Equal("dir1", p3.FileNamesByOffset[13]);
Assert.Equal("file1", p3.FileNamesByOffset[18]);
Assert.Equal("file2", p3.FileNamesByOffset[24]);
Assert.Equal("file3", p3.FileNamesByOffset[30]);
Assert.Equal(18, (int)p3.OffsetsByFileName[file1.FileName]);
Assert.Equal(24, (int)p3.OffsetsByFileName[file2.FileName]);
Assert.Equal(13, (int)p3.OffsetsByFileName[dir1.FileName]);
Assert.Equal(30, (int)p3.OffsetsByFileName[file3.FileName]);
}
/// <summary>
/// Creates a test archive. Does not write an archive to disk. Just creates a <see
/// cref="NefsArchive"/> object.
/// </summary>
/// <param name="filePath">The file path to use for the archive.</param>
/// <returns>A <see cref="NefsArchive"/>.</returns>
public static NefsArchive Create(string filePath)
{
var items = new NefsItemList(filePath);
var aesString = "44927647059D3D73CDCC8D4C6E808538CAD7622D076A507E16C43A8DD8E3B5AB";
var file1Attributes = new NefsItemAttributes(v20IsZlib: true);
var file1Chunks = NefsDataChunk.CreateChunkList(File1ChunkSizes, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, file1Chunks));
var file1 = new NefsItem(File1Guid, new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), file1DataSource, TestHelpers.TestTransform, file1Attributes);
items.Add(file1);
var dir1Attributes = new NefsItemAttributes(isDirectory: true);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(Dir1Guid, new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), dir1DataSource, null, dir1Attributes);
items.Add(dir1);
var file2Attributes = new NefsItemAttributes(v20IsZlib: true);
var file2Chunks = NefsDataChunk.CreateChunkList(File2ChunkSizes, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, file2Chunks));
var file2 = new NefsItem(File2Guid, new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), file2DataSource, TestHelpers.TestTransform, file2Attributes);
items.Add(file2);
var file3Attributes = new NefsItemAttributes(v20IsZlib: true);
var file3Transform = new NefsDataTransform(File3ExtractedSize);
var file3Chunks = NefsDataChunk.CreateChunkList(File3ChunkSizes, file3Transform);
var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, file3Chunks));
var file3 = new NefsItem(File3Guid, new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), file3DataSource, file3Transform, file3Attributes);
items.Add(file3);
Assert.Equal((int)NumItems, items.Count);
var intro = new NefsHeaderIntro();
intro.Data0x6c_NumberOfItems.Value = (uint)items.Count;
intro.Data0x24_AesKeyHexString.Value = Encoding.ASCII.GetBytes(aesString);
var toc = new Nefs20HeaderIntroToc();
var header = new Nefs20Header(intro, toc, items);
return(new NefsArchive(header, items));
}
/// <summary>
/// Creates a test archive. Does not write an archive to disk. Just creates a <see
/// cref="NefsArchive"/> object.
/// </summary>
/// <param name="filePath">The file path to use for the archive.</param>
/// <returns>A <see cref="NefsArchive"/>.</returns>
public static NefsArchive Create(string filePath)
{
var items = new NefsItemList(filePath);
var file1Attributes = new NefsItemAttributes(v20IsZlib: true);
var file1Chunks = NefsDataChunk.CreateChunkList(File1ChunkSizes, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, file1Chunks));
var file1 = new NefsItem(File1Guid, new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), file1DataSource, TestHelpers.TestTransform, file1Attributes);
items.Add(file1);
var dir1Attributes = new NefsItemAttributes(isDirectory: true);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(Dir1Guid, new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), dir1DataSource, null, dir1Attributes);
items.Add(dir1);
var file2Attributes = new NefsItemAttributes(v20IsZlib: true);
var file2Chunks = NefsDataChunk.CreateChunkList(File2ChunkSizes, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, file2Chunks));
var file2 = new NefsItem(File2Guid, new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), file2DataSource, TestHelpers.TestTransform, file2Attributes);
items.Add(file2);
var file3Attributes = new NefsItemAttributes(v20IsZlib: true);
var file3Chunks = NefsDataChunk.CreateChunkList(File3ChunkSizes, TestHelpers.TestTransform);
var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, file3Chunks));
var file3 = new NefsItem(File3Guid, new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), file3DataSource, TestHelpers.TestTransform, file3Attributes);
items.Add(file3);
Assert.Equal((int)NumItems, items.Count);
var intro = new NefsHeaderIntro();
intro.Data0x6c_NumberOfItems.Value = (uint)items.Count;
var toc = new Nefs20HeaderIntroToc();
var header = new Nefs20Header(intro, toc, items);
return(new NefsArchive(header, items));
}
/// <summary>
/// Writes items' data to the output stream.
/// </summary>
/// <param name="stream">The stream to write to.</param>
/// <param name="items">List of items to write.</param>
/// <param name="firstDataOffset">
/// The offset from the beginning of the stream to write the first data.
/// </param>
/// <param name="p">Progress info.</param>
/// <returns>The offset to the end of the last data written.</returns>
private async Task <UInt64> WriteItemsAsync(
Stream stream,
NefsItemList items,
UInt64 firstDataOffset,
NefsProgress p)
{
var nextDataOffset = firstDataOffset;
// Prepare stream
stream.Seek((long)firstDataOffset, SeekOrigin.Begin);
// Update item info and write out item data
var i = 1;
foreach (var item in items.EnumerateById())
{
using (var t = p.BeginSubTask(1.0f / items.Count, $"Writing data for item {i}/{items.Count}"))
{
// Get item
var itemOffset = nextDataOffset;
var itemSize = item.DataSource.Size;
// Nothing to write if item is directory
if (item.Type == NefsItemType.Directory)
{
continue;
}
// Write out item data
nextDataOffset = await this.WriteItemAsync(stream, itemOffset, item, p);
// Update item data source to point to the newly written data
var dataSource = new NefsItemListDataSource(items, itemOffset, itemSize);
item.UpdateDataSource(dataSource, NefsItemState.None);
}
i++;
}
// Return the next data offset, which is the end of the written data
return(nextDataOffset);
}
public void Nefs20HeaderFlags_FlagsSet()
{
var items = new NefsItemList(@"C:\archive.nefs");
var item1Attributes = new NefsItemAttributes(
v20IsZlib: true,
v20IsAes: true,
isDirectory: true,
isDuplicated: true,
v20Unknown0x10: true,
v20Unknown0x20: true,
v20Unknown0x40: true,
v20Unknown0x80: true);
var item1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456));
var item1 = new NefsItem(Guid.NewGuid(), new NefsItemId(0), "file1", new NefsItemId(0), item1DataSource, TestHelpers.TestTransform, item1Attributes);
items.Add(item1);
var p6 = new Nefs20HeaderPart6(items);
Assert.Equal(0xFF, (byte)p6.EntriesByIndex[0].Flags);
}
public NefsHeaderPart4Tests()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
1, 11, 21
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
this.file1 = TestHelpers.CreateFile(0, 0, "file1", file1DataSource);
items.Add(this.file1);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
2, 22, 52
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
this.file2 = TestHelpers.CreateFile(1, 1, "file2", file2DataSource);
items.Add(this.file2);
this.dir1 = TestHelpers.CreateDirectory(2, 2, "dir1");
items.Add(this.dir1);
var file3Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
3, 13, 23
}, TestHelpers.TestTransform);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, file3Chunks));
this.file3 = TestHelpers.CreateFile(3, this.dir1.Id.Value, "file3", file3DataSource);
items.Add(this.file3);
var file4DataSource = new NefsItemListDataSource(items, 777, new NefsItemSize(444));
this.file4NotCompressed = TestHelpers.CreateFile(4, this.dir1.Id.Value, "file4", file4DataSource);
items.Add(this.file4NotCompressed);
this.testItems = items;
}
public NefsHeaderPart4Tests()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
1, 11, 21
}));
this.file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData());
items.Add(this.file1);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
2, 22, 52
}));
this.file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData());
items.Add(this.file2);
var dir1DataSource = new NefsEmptyDataSource();
this.dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData());
items.Add(this.dir1);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, new List <UInt32> {
3, 13, 23
}));
this.file3 = new NefsItem(new NefsItemId(3), "file3", this.dir1.Id, NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData());
items.Add(this.file3);
var file4DataSource = new NefsItemListDataSource(items, 777, new NefsItemSize(444));
this.file4NotCompressed = new NefsItem(new NefsItemId(4), "file4", this.dir1.Id, NefsItemType.File, file4DataSource, TestHelpers.CreateUnknownData());
items.Add(this.file4NotCompressed);
this.testItems = items;
}
/// <summary>
/// Creates a test archive. Does not write an archive to disk. Just creates a <see
/// cref="NefsArchive"/> object.
/// </summary>
/// <param name="filePath">The file path to use for the archive.</param>
/// <returns>A <see cref="NefsArchive"/>.</returns>
public static NefsArchive Create(string filePath)
{
var items = new NefsItemList(filePath);
var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, File1ChunkSizes));
var file1 = new NefsItem(new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData());
items.Add(file1);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData());
items.Add(dir1);
var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, File2ChunkSizes));
var file2 = new NefsItem(new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData());
items.Add(file2);
var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, File3ChunkSizes));
var file3 = new NefsItem(new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData());
items.Add(file3);
Assert.Equal((int)NumItems, items.Count);
var intro = new NefsHeaderIntro();
intro.Data0x6c_NumberOfItems.Value = (uint)items.Count;
var toc = new NefsHeaderIntroToc();
var header = new NefsHeader(intro, toc, items);
return(new NefsArchive(header, items));
}
/// <summary>
/// Creates a <see cref="NefsArchive"/> to be used for testing.
/// </summary>
/// <param name="filePath">The file path to associate with the archive.</param>
/// <returns>An archive object.</returns>
/// <remarks><![CDATA[ Test archive items: /file1 /dir1 /dir1/file2 ]]></remarks>
internal static NefsArchive CreateTestArchive(string filePath)
{
var items = new NefsItemList(filePath);
var transform = new NefsDataTransform(50, true);
var file1Attributes = new NefsItemAttributes(v20IsZlib: true);
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
2, 3, 4
}, transform);
var file1DataSource = new NefsItemListDataSource(items, 100, new NefsItemSize(20, file1Chunks));
var file1 = new NefsItem(Guid.NewGuid(), new NefsItemId(0), "file1", new NefsItemId(0), file1DataSource, transform, file1Attributes);
items.Add(file1);
var dir1Attributes = new NefsItemAttributes(isDirectory: true);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(Guid.NewGuid(), new NefsItemId(1), "dir1", new NefsItemId(1), dir1DataSource, null, dir1Attributes);
items.Add(dir1);
var file2Attributes = new NefsItemAttributes(v20IsZlib: true);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
5, 6, 7
}, transform);
var file2DataSource = new NefsItemListDataSource(items, 104, new NefsItemSize(15, file2Chunks));
var file2 = new NefsItem(Guid.NewGuid(), new NefsItemId(2), "file2", dir1.Id, file2DataSource, transform, file2Attributes);
items.Add(file2);
var intro = new NefsHeaderIntro();
var toc = new Nefs20HeaderIntroToc();
var header = new Nefs20Header(intro, toc, items);
return(new NefsArchive(header, items));
}
public void NefsHeaderPart1_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
11, 12, 13
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
var file1 = TestHelpers.CreateFile(0, 0, "file1", file1DataSource);
items.Add(file1);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
14, 15, 16
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
var file2 = TestHelpers.CreateFile(1, 1, "file2", file2DataSource);
items.Add(file2);
var dir1 = TestHelpers.CreateDirectory(2, 2, "dir1");
items.Add(dir1);
var p4 = new Nefs20HeaderPart4(items);
var p1 = new NefsHeaderPart1(items, p4);
Assert.Equal(3, p1.EntriesByGuid.Count);
Assert.Equal(3, p1.EntriesByIndex.Count);
/*
* dir1
*/
// Offset to data and index to p4 are both 0 since this is a directory
Assert.Equal(2, (int)p1.EntriesByGuid[dir1.Guid].Id.Value);
Assert.Equal(0, (int)p1.EntriesByGuid[dir1.Guid].OffsetToData);
Assert.Equal(0, (int)p1.EntriesByGuid[dir1.Guid].IndexPart2);
Assert.Equal(0, (int)p1.EntriesByGuid[dir1.Guid].IndexPart4);
/*
* file1
*/
Assert.Equal(0, (int)p1.EntriesByGuid[file1.Guid].Id.Value);
Assert.Equal(123, (int)p1.EntriesByGuid[file1.Guid].OffsetToData);
Assert.Equal(1, (int)p1.EntriesByGuid[file1.Guid].IndexPart2);
Assert.Equal(0, (int)p1.EntriesByGuid[file1.Guid].IndexPart4);
/*
* file2
*/
Assert.Equal(1, (int)p1.EntriesByGuid[file2.Guid].Id.Value);
Assert.Equal(456, (int)p1.EntriesByGuid[file2.Guid].OffsetToData);
Assert.Equal(2, (int)p1.EntriesByGuid[file2.Guid].IndexPart2);
// There are 3 chunks for file1, so file2's chunks start right after that (hence p4
// index == 3)
Assert.Equal(3, (int)p1.EntriesByGuid[file2.Guid].IndexPart4);
}
public void NefsHeaderPart2_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
11, 12, 13
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
var file1 = TestHelpers.CreateFile(0, 0, "file1", file1DataSource);
items.Add(file1);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
14, 15, 16
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
var file2 = TestHelpers.CreateFile(1, 1, "file2", file2DataSource);
items.Add(file2);
var dir1 = TestHelpers.CreateDirectory(2, 2, "dir1");
items.Add(dir1);
var file3Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
22, 23, 24
}, TestHelpers.TestTransform);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, file3Chunks));
var file3 = TestHelpers.CreateFile(3, dir1.Id.Value, "file3", file3DataSource);
items.Add(file3);
var p3 = new NefsHeaderPart3(items);
var p2 = new NefsHeaderPart2(items, p3);
Assert.Equal(4, p2.EntriesByIndex.Count);
// NOTE: Part 3 is the strings table. So offset into p3 must take into account null
// terminated file/dir names. Also note strings table is alphabetized. Also note the
// data file name is added to the strings table.
// NOTE: The order of part 2 is generated by depth first traversal of the file tree,
// with items sorted by filename.
/*
* dir1
*/
Assert.Equal(2, (int)p2.EntriesByIndex[0].Id.Value);
Assert.Equal(2, (int)p2.EntriesByIndex[0].Data0x00_DirectoryId.Value);
Assert.Equal(3, (int)p2.EntriesByIndex[0].Data0x04_FirstChildId.Value);
Assert.Equal(0, (int)p2.EntriesByIndex[0].Data0x0c_ExtractedSize.Value);
Assert.Equal(13, (int)p2.EntriesByIndex[0].Data0x08_OffsetIntoPart3.Value);
/*
* file3
*/
Assert.Equal(3, (int)p2.EntriesByIndex[1].Id.Value);
Assert.Equal(2, (int)p2.EntriesByIndex[1].Data0x00_DirectoryId.Value);
Assert.Equal(3, (int)p2.EntriesByIndex[1].Data0x04_FirstChildId.Value);
Assert.Equal(333, (int)p2.EntriesByIndex[1].Data0x0c_ExtractedSize.Value);
Assert.Equal(30, (int)p2.EntriesByIndex[1].Data0x08_OffsetIntoPart3.Value);
/*
* file1
*/
Assert.Equal(0, (int)p2.EntriesByIndex[2].Id.Value);
Assert.Equal(0, (int)p2.EntriesByIndex[2].DirectoryId.Value);
Assert.Equal(0, (int)p2.EntriesByIndex[2].FirstChildId.Value);
Assert.Equal(456, (int)p2.EntriesByIndex[2].ExtractedSize);
Assert.Equal(18, (int)p2.EntriesByIndex[2].OffsetIntoPart3);
/*
* file2
*/
Assert.Equal(1, (int)p2.EntriesByIndex[3].Id.Value);
Assert.Equal(1, (int)p2.EntriesByIndex[3].DirectoryId.Value);
Assert.Equal(1, (int)p2.EntriesByIndex[3].FirstChildId.Value);
Assert.Equal(789, (int)p2.EntriesByIndex[3].ExtractedSize);
Assert.Equal(24, (int)p2.EntriesByIndex[3].OffsetIntoPart3);
}
public void NefsHeaderPart2_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
11, 12, 13
}));
var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData());
items.Add(file1);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
14, 15, 16
}));
var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData());
items.Add(file2);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData());
items.Add(dir1);
var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, new List <UInt32> {
22, 23, 24
}));
var file3 = new NefsItem(new NefsItemId(3), "file3", dir1.Id, NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData());
items.Add(file3);
var p3 = new NefsHeaderPart3(items);
var p2 = new NefsHeaderPart2(items, p3);
Assert.Equal(4, p2.EntriesById.Count);
// NOTE: Part 3 is the strings table. So offset into p3 must take into account null
// terminated file/dir names. Also note strings table is alphabetized. Also note the
// data file name is added to the strings table.
/*
* file1
*/
Assert.Equal(0, (int)p2.EntriesById[file1.Id].Id.Value);
Assert.Equal(0, (int)p2.EntriesById[file1.Id].DirectoryId.Value);
Assert.Equal(0, (int)p2.EntriesById[file1.Id].FirstChildId.Value);
Assert.Equal(456, (int)p2.EntriesById[file1.Id].ExtractedSize);
Assert.Equal(18, (int)p2.EntriesById[file1.Id].OffsetIntoPart3);
/*
* file2
*/
Assert.Equal(1, (int)p2.EntriesById[file2.Id].Id.Value);
Assert.Equal(1, (int)p2.EntriesById[file2.Id].DirectoryId.Value);
Assert.Equal(1, (int)p2.EntriesById[file2.Id].FirstChildId.Value);
Assert.Equal(789, (int)p2.EntriesById[file2.Id].ExtractedSize);
Assert.Equal(24, (int)p2.EntriesById[file2.Id].OffsetIntoPart3);
/*
* dir1
*/
Assert.Equal(2, (int)p2.EntriesById[dir1.Id].Id.Value);
Assert.Equal(2, (int)p2.EntriesById[dir1.Id].Data0x00_DirectoryId.Value);
Assert.Equal(3, (int)p2.EntriesById[dir1.Id].Data0x04_FirstChildId.Value);
Assert.Equal(0, (int)p2.EntriesById[dir1.Id].Data0x0c_ExtractedSize.Value);
Assert.Equal(13, (int)p2.EntriesById[dir1.Id].Data0x08_OffsetIntoPart3.Value);
/*
* file3
*/
Assert.Equal(3, (int)p2.EntriesById[file3.Id].Id.Value);
Assert.Equal(2, (int)p2.EntriesById[file3.Id].Data0x00_DirectoryId.Value);
Assert.Equal(3, (int)p2.EntriesById[file3.Id].Data0x04_FirstChildId.Value);
Assert.Equal(333, (int)p2.EntriesById[file3.Id].Data0x0c_ExtractedSize.Value);
Assert.Equal(30, (int)p2.EntriesById[file3.Id].Data0x08_OffsetIntoPart3.Value);
}
public void NefsHeaderPart7_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Id = new NefsItemId(31);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
11, 12, 13
}));
var file1UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 1,
Part6Unknown0x01 = 2,
Part6Unknown0x02 = 3,
Part6Unknown0x03 = 4,
};
var file1 = new NefsItem(file1Id, "file1", file1Id, NefsItemType.File, file1DataSource, file1UnknownData);
items.Add(file1);
var file2Id = new NefsItemId(41);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
14, 15, 16
}));
var file2UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 7,
Part6Unknown0x01 = 8,
Part6Unknown0x02 = 9,
Part6Unknown0x03 = 10,
};
var file2 = new NefsItem(file2Id, "file2", file2Id, NefsItemType.File, file2DataSource, file2UnknownData);
items.Add(file2);
var dir2Id = new NefsItemId(51);
var dir1DataSource = new NefsEmptyDataSource();
var dir1UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 13,
Part6Unknown0x01 = 14,
Part6Unknown0x02 = 15,
Part6Unknown0x03 = 16,
};
var dir1 = new NefsItem(dir2Id, "dir1", dir2Id, NefsItemType.Directory, dir1DataSource, dir1UnknownData);
items.Add(dir1);
var p7 = new NefsHeaderPart7(items);
Assert.Equal(3, p7.EntriesById.Count);
/*
* file1
*/
Assert.Equal(31U, p7.EntriesById[file1.Id].Id.Value);
Assert.Equal(41U, p7.EntriesById[file1.Id].SiblingId.Value);
/*
* file2
*/
Assert.Equal(41U, p7.EntriesById[file2.Id].Id.Value);
Assert.Equal(51U, p7.EntriesById[file2.Id].SiblingId.Value);
/*
* dir1
*/
Assert.Equal(51U, p7.EntriesById[dir1.Id].Id.Value);
Assert.Equal(51U, p7.EntriesById[dir1.Id].SiblingId.Value);
}
public void NefsHeaderPart6_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> {
11, 12, 13
}));
var file1UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 1,
Part6Unknown0x01 = 2,
Part6Unknown0x02 = 3,
Part6Unknown0x03 = 4,
};
var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, file1UnknownData);
items.Add(file1);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> {
14, 15, 16
}));
var file2UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 7,
Part6Unknown0x01 = 8,
Part6Unknown0x02 = 9,
Part6Unknown0x03 = 10,
};
var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, file2UnknownData);
items.Add(file2);
var dir1DataSource = new NefsEmptyDataSource();
var dir1UnknownData = new NefsItemUnknownData
{
Part6Unknown0x00 = 13,
Part6Unknown0x01 = 14,
Part6Unknown0x02 = 15,
Part6Unknown0x03 = 16,
};
var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, dir1UnknownData);
items.Add(dir1);
var p6 = new NefsHeaderPart6(items);
Assert.Equal(3, p6.EntriesById.Count);
/*
* file1
*/
Assert.Equal(1, p6.EntriesById[file1.Id].Byte0);
Assert.Equal(2, p6.EntriesById[file1.Id].Byte1);
Assert.Equal(3, p6.EntriesById[file1.Id].Byte2);
Assert.Equal(4, p6.EntriesById[file1.Id].Byte3);
/*
* file2
*/
Assert.Equal(7, p6.EntriesById[file2.Id].Byte0);
Assert.Equal(8, p6.EntriesById[file2.Id].Byte1);
Assert.Equal(9, p6.EntriesById[file2.Id].Byte2);
Assert.Equal(10, p6.EntriesById[file2.Id].Byte3);
/*
* dir1
*/
Assert.Equal(13, p6.EntriesById[dir1.Id].Byte0);
Assert.Equal(14, p6.EntriesById[dir1.Id].Byte1);
Assert.Equal(15, p6.EntriesById[dir1.Id].Byte2);
Assert.Equal(16, p6.EntriesById[dir1.Id].Byte3);
}
public void NefsHeaderPart6_MultipleItems_EntriesPopulated()
{
var items = new NefsItemList(@"C:\archive.nefs");
var file1Attributes = new NefsItemAttributes(
part6Volume: 12,
part6Unknown0x3: 14);
var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
11, 12, 13
}, TestHelpers.TestTransform);
var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks));
var file1 = new NefsItem(Guid.NewGuid(), new NefsItemId(0), "file1", new NefsItemId(0), file1DataSource, TestHelpers.TestTransform, file1Attributes);
items.Add(file1);
var file2Attributes = new NefsItemAttributes(
part6Volume: 6,
part6Unknown0x3: 7);
var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> {
14, 15, 16
}, TestHelpers.TestTransform);
var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks));
var file2 = new NefsItem(Guid.NewGuid(), new NefsItemId(1), "file2", new NefsItemId(1), file2DataSource, TestHelpers.TestTransform, file2Attributes);
items.Add(file2);
var dir1Attributes = new NefsItemAttributes(
isDirectory: true,
part6Volume: 1,
part6Unknown0x3: 2);
var dir1DataSource = new NefsEmptyDataSource();
var dir1 = new NefsItem(Guid.NewGuid(), new NefsItemId(2), "dir1", new NefsItemId(2), dir1DataSource, null, dir1Attributes);
items.Add(dir1);
var p6 = new Nefs20HeaderPart6(items);
Assert.Equal(3, p6.EntriesByGuid.Count);
Assert.Equal(3, p6.EntriesByIndex.Count);
/*
* file1
*/
Assert.Equal(file1Attributes.Part6Volume, p6.EntriesByGuid[file1.Guid].Volume);
Assert.Equal(file1Attributes.Part6Unknown0x3, p6.EntriesByGuid[file1.Guid].Unknown0x3);
/*
* file2
*/
Assert.Equal(file2Attributes.Part6Volume, p6.EntriesByGuid[file2.Guid].Volume);
Assert.Equal(file2Attributes.Part6Unknown0x3, p6.EntriesByGuid[file2.Guid].Unknown0x3);
/*
* dir1
*/
var attributes = p6.EntriesByGuid[dir1.Guid].CreateAttributes();
Assert.Equal(dir1Attributes.Part6Volume, p6.EntriesByGuid[dir1.Guid].Volume);
Assert.Equal(dir1Attributes.Part6Unknown0x3, p6.EntriesByGuid[dir1.Guid].Unknown0x3);
Assert.True(attributes.IsDirectory);
}
