public void TestReadingDummyEntry()
{
var entry = new ModuleEntryStruct();
using (var reader = new BinaryReader(new MemoryStream(DummyEntryBytes)))
entry.Read(reader);
Assert.AreEqual(1U, entry.NameOffset);
Assert.AreEqual(2, entry.ParentFileIndex);
Assert.AreEqual(3, entry.Unknown8);
Assert.AreEqual(4, entry.UnknownC);
Assert.AreEqual(5, entry.CompressedBlockCount);
Assert.AreEqual(6, entry.FirstCompressedBlockIndex);
Assert.AreEqual(7U, entry.CompressedOffset);
Assert.AreEqual(8U, entry.TotalCompressedSize);
Assert.AreEqual(9U, entry.TotalUncompressedSize);
Assert.AreEqual(10, entry.Unknown28);
Assert.AreEqual(11, entry.Unknown29);
Assert.AreEqual(12, entry.Unknown2A);
Assert.AreEqual(13, entry.Unknown2B);
Assert.AreEqual(14, entry.GlobalTagId);
Assert.AreEqual(15, entry.SourceTagId);
Assert.AreEqual(16, entry.Unknown38);
Assert.AreEqual(new MagicNumber("abcd"), entry.GroupTag);
Assert.AreEqual(17U, entry.UncompressedHeaderSize);
Assert.AreEqual(18U, entry.UncompressedTagDataSize);
Assert.AreEqual(19U, entry.UncompressedResourceDataSize);
Assert.AreEqual(20, entry.Unknown50);
Assert.AreEqual(21, entry.Unknown52);
Assert.AreEqual(22, entry.Unknown54);
}
internal void BuildResourceList(ModuleEntryStruct data, List <ModuleEntry> resources)
{
for (var i = 0; i < data.ResourceCount; i++)
{
_resources.Add(resources[data.FirstResourceIndex + i]);
}
}
private static List <ModuleDataBlock> GetBlockList(ModuleEntryStruct data, ModuleStruct module)
{
var blocks = new List <ModuleDataBlock>(data.BlockCount);
if (data.TotalCompressedSize == 0)
{
return(blocks);
}
if ((data.Flags & ModuleEntryFlags.HasBlocks) != 0)
{
for (var i = 0; i < data.BlockCount; i++)
{
var block = module.DataBlocks[data.FirstBlockIndex + i];
blocks.Add(new ModuleDataBlock(block));
}
}
else
{
// If an entry has 0 blocks, then make one
var blockStruct = new ModuleDataBlockStruct
{
Checksum = data.AssetChecksum,
CompressedOffset = 0,
CompressedSize = data.TotalCompressedSize,
Compression = (data.Flags & ModuleEntryFlags.Compressed) != 0 ? 1 : 0,
UncompressedOffset = 0,
UncompressedSize = data.TotalUncompressedSize,
};
blocks.Add(new ModuleDataBlock(blockStruct));
}
return(blocks);
}
internal ModuleEntry(int index, ModuleEntryStruct data, ModuleStruct module)
{
Index = index;
Name = module.StringTable.GetStringAtOffset((int)data.NameOffset);
ParentIndex = data.ParentFileIndex;
Resources = _resources.AsReadOnly();
Blocks = GetBlockList(data, module).AsReadOnly();
DataOffset = data.DataOffset;
TotalCompressedSize = data.TotalCompressedSize;
TotalUncompressedSize = data.TotalUncompressedSize;
HeaderAlignment = data.HeaderAlignment;
TagDataAlignment = data.TagDataAlignment;
ResourceDataAlignment = data.ResourceDataAlignment;
IsRawFile = (data.Flags & ModuleEntryFlags.RawFile) != 0;
GlobalId = data.GlobalId;
AssetId = data.AssetId;
AssetChecksum = data.AssetChecksum;
GroupTag = data.GroupTag;
UncompressedHeaderSize = data.UncompressedHeaderSize;
UncompressedTagDataSize = data.UncompressedTagDataSize;
UncompressedResourceDataSize = data.UncompressedResourceDataSize;
HeaderBlockCount = data.HeaderBlockCount;
TagDataBlockCount = data.TagDataBlockCount;
ResourceBlockCount = data.ResourceBlockCount;
}
public void TestReadingDummyEntry()
{
var entry = new ModuleEntryStruct();
using (var serializer = new BinarySerializer(new BinaryReader(new MemoryStream(DummyEntryBytes))))
entry.Serialize(serializer);
Assert.AreEqual(1U, entry.NameOffset);
Assert.AreEqual(2, entry.ParentFileIndex);
Assert.AreEqual(3, entry.ResourceCount);
Assert.AreEqual(4, entry.FirstResourceIndex);
Assert.AreEqual(5, entry.BlockCount);
Assert.AreEqual(6, entry.FirstBlockIndex);
Assert.AreEqual(7, entry.DataOffset);
Assert.AreEqual(8U, entry.TotalCompressedSize);
Assert.AreEqual(9U, entry.TotalUncompressedSize);
Assert.AreEqual(10, entry.HeaderAlignment);
Assert.AreEqual(11, entry.TagDataAlignment);
Assert.AreEqual(12, entry.ResourceDataAlignment);
Assert.AreEqual((ModuleEntryFlags)13, entry.Flags);
Assert.AreEqual(14U, entry.GlobalId);
Assert.AreEqual(15U, entry.AssetId);
Assert.AreEqual(16U, entry.AssetChecksum);
Assert.AreEqual(new MagicNumber("abcd"), entry.GroupTag);
Assert.AreEqual(17U, entry.UncompressedHeaderSize);
Assert.AreEqual(18U, entry.UncompressedTagDataSize);
Assert.AreEqual(19U, entry.UncompressedResourceDataSize);
Assert.AreEqual(20, entry.HeaderBlockCount);
Assert.AreEqual(21, entry.TagDataBlockCount);
Assert.AreEqual(22, entry.ResourceBlockCount);
}
internal ModuleEntry(ModuleEntryStruct data, ModuleStruct module)
{
Name = module.StringTable.GetStringAtOffset((int)data.NameOffset);
ParentIndex = data.ParentFileIndex;
Unknown8 = data.Unknown8;
UnknownC = data.UnknownC;
Blocks = GetBlockList(data, module).AsReadOnly();
CompressedOffset = data.CompressedOffset;
TotalCompressedSize = data.TotalCompressedSize;
TotalUncompressedSize = data.TotalUncompressedSize;
Unknown28 = data.Unknown28;
Unknown29 = data.Unknown29;
Unknown2A = data.Unknown2A;
Unknown2B = data.Unknown2B;
GlobalTagId = data.GlobalTagId;
SourceTagId = data.SourceTagId;
Unknown38 = data.Unknown38;
GroupTag = data.GroupTag;
UncompressedHeaderSize = data.UncompressedHeaderSize;
UncompressedTagDataSize = data.UncompressedTagDataSize;
UncompressedResourceDataSize = data.UncompressedResourceDataSize;
Unknown50 = data.Unknown50;
Unknown52 = data.Unknown52;
Unknown54 = data.Unknown54;
}
private static List <ModuleEntryBlock> GetBlockList(ModuleEntryStruct data, ModuleStruct module)
{
var blocks = new List <ModuleEntryBlock>(data.CompressedBlockCount);
for (var i = 0; i < data.CompressedBlockCount; i++)
{
var block = module.CompressedBlocks[data.FirstCompressedBlockIndex + i];
blocks.Add(new ModuleEntryBlock(block));
}
return(blocks);
}
public void TestWritingDummyEntry()
{
var entry = new ModuleEntryStruct
{
NameOffset = 1,
ParentFileIndex = 2,
Unknown8 = 3,
UnknownC = 4,
CompressedBlockCount = 5,
FirstCompressedBlockIndex = 6,
CompressedOffset = 7,
TotalCompressedSize = 8,
TotalUncompressedSize = 9,
Unknown28 = 10,
Unknown29 = 11,
Unknown2A = 12,
Unknown2B = 13,
GlobalTagId = 14,
SourceTagId = 15,
Unknown38 = 16,
GroupTag = new MagicNumber("abcd"),
UncompressedHeaderSize = 17,
UncompressedTagDataSize = 18,
UncompressedResourceDataSize = 19,
Unknown50 = 20,
Unknown52 = 21,
Unknown54 = 22
};
byte[] writtenBytes;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
entry.Write(writer);
writtenBytes = new byte[stream.Length];
Buffer.BlockCopy(stream.GetBuffer(), 0, writtenBytes, 0, writtenBytes.Length);
}
}
CollectionAssert.AreEqual(DummyEntryBytes, writtenBytes);
}
public void TestWritingDummyEntry()
{
var entry = new ModuleEntryStruct
{
NameOffset = 1,
ParentFileIndex = 2,
ResourceCount = 3,
FirstResourceIndex = 4,
BlockCount = 5,
FirstBlockIndex = 6,
DataOffset = 7,
TotalCompressedSize = 8,
TotalUncompressedSize = 9,
HeaderAlignment = 10,
TagDataAlignment = 11,
ResourceDataAlignment = 12,
Flags = (ModuleEntryFlags)13,
GlobalId = 14,
AssetId = 15,
AssetChecksum = 16,
GroupTag = new MagicNumber("abcd"),
UncompressedHeaderSize = 17,
UncompressedTagDataSize = 18,
UncompressedResourceDataSize = 19,
HeaderBlockCount = 20,
TagDataBlockCount = 21,
ResourceBlockCount = 22
};
byte[] writtenBytes;
using (var stream = new MemoryStream())
{
using (var serializer = new BinarySerializer(new BinaryWriter(stream)))
{
entry.Serialize(serializer);
writtenBytes = new byte[stream.Length];
Buffer.BlockCopy(stream.GetBuffer(), 0, writtenBytes, 0, writtenBytes.Length);
}
}
CollectionAssert.AreEqual(DummyEntryBytes, writtenBytes);
}
