public void IsContainerIfFormatNodeContainer()
{
NodeContainerFormat format = new NodeContainerFormat();
using Node node = new Node("NodeTest", format);
Assert.IsTrue(node.IsContainer);
}
public void CanWriteEmptyFiles()
{
byte[] expected =
{
0xF9, 0x7D, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
var expectedStream = DataStreamFactory.FromArray(expected, 0, expected.Length);
var writer = new StandardBinWriter();
var parameters = new WriterParameters {
BlockSize = 0x20
};
writer.Initialize(parameters);
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("empty");
node.Tags["Type"] = FileType.Empty;
node.Tags["Index"] = 1;
container.Root.Add(node);
var binaryFormat = writer.Convert(container);
Assert.AreEqual(expected.Length, binaryFormat.Stream.Length);
Assert.IsTrue(binaryFormat.Stream.Compare(expectedStream));
}
public void ZeroChildrenContainerThrowsException()
{
var writer = new StandardBinWriter();
var container = new NodeContainerFormat();
Assert.Throws <FormatException>(() => writer.Convert(container));
}
private static void Export(string format, Node n, string outputPath)
{
log.Info("Exporting...");
switch (format)
{
case FORMATPREFIX + "BinTutorial":
n.TransformWith <BinaryFormat2BinTutorial>()
.TransformWith <Bin2Po>()
.TransformWith <Po2Binary>()
.Stream.WriteTo(Path.Combine(outputPath, n.Name + ".po"));
break;
case FORMATPREFIX + "BinInfoTitle":
n.TransformWith <Binary2BinInfoTitle>()
.TransformWith <BinInfoTitle2Po>()
.TransformWith <Po2Binary>()
.Stream.WriteTo(Path.Combine(outputPath, n.Name + ".po"));
break;
case FORMATPREFIX + "BinQuiz":
var quizs = n.TransformWith <Binary2BinQuiz>()
.TransformWith <Quiz2Po>();
foreach (Node po in quizs.Children)
{
string outputFile = Path.Combine(outputPath, po.Name + ".po");
log.Info("Saving " + outputFile);
po.TransformWith <Po2Binary>()
.Stream.WriteTo(outputFile);
}
break;
case FORMATPREFIX + "ALAR.ALAR3":
NodeContainerFormat folder = n.TransformWith <BinaryFormat2Alar3>()
.TransformWith <Alar3ToNodes>().GetFormatAs <NodeContainerFormat>();
SaveContainerToDir(folder, outputPath);
break;
case FORMATPREFIX + "ALAR.ALAR2":
var root = n.TransformWith <BinaryFormat2Alar2>()
.TransformWith <Alar2ToNodes>();
SaveNodeToDir(root, outputPath);
break;
}
log.Info("Finished exporting");
}
public void SetContainerFormatAddChildren()
{
Node node = new Node("MyTest");
NodeContainerFormat format = new NodeContainerFormat();
format.Root.Add(new Node("Child"));
node.Format = format;
Assert.AreEqual(1, node.Children.Count);
Assert.AreSame(format.Root.Children[0], node.Children[0]);
}
public void UnknownFileTypeThrowsException()
{
var writer = new StandardBinWriter();
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("empty");
node.Tags["Type"] = (FileType)27;
node.Tags["Index"] = 1;
container.Root.Add(node);
Assert.Throws <FormatException>(() => writer.Convert(container));
}
public void SetContainerFormatAddChildren()
{
using Node node = new Node("MyTest");
NodeContainerFormat format = new NodeContainerFormat();
format.Root.Add(new Node("Child"));
node.ChangeFormat(format);
Assert.AreEqual(1, node.Children.Count);
Assert.AreSame(format.Root.Children[0], node.Children[0]);
Assert.AreEqual("/MyTest/Child", node.Children[0].Path);
Assert.AreSame(node, node.Children[0].Parent);
}
public void SetFromContainerToDifferentCleanChildren()
{
using Node node = new Node("mytest");
NodeContainerFormat format = new NodeContainerFormat();
format.Root.Add(new Node("Child"));
node.ChangeFormat(format);
Assert.IsNotEmpty(node.Children);
StringFormatTest newFormat = new StringFormatTest("3");
node.ChangeFormat(newFormat);
Assert.IsEmpty(node.Children);
}
public void SetContainerFormatTransferHandlingToNode()
{
using Node node = new Node("MyTest");
NodeContainerFormat format = new NodeContainerFormat();
format.Root.Add(new Node("Child"));
node.ChangeFormat(format);
// It must be the same parent
Assert.AreSame(node, format.Root);
format.Dispose();
Assert.IsFalse(node.Disposed);
Assert.IsNotEmpty(node.Children);
Assert.IsFalse(node.Children[0].Disposed);
}
public void CanWriteBigEndianFiles()
{
byte[] expected =
{
0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D,
};
var expectedStream = DataStreamFactory.FromArray(expected, 0, expected.Length);
var writer = new DlcBinWriter();
writer.Initialize(new WriterParameters
{
Endianness = EndiannessMode.BigEndian,
});
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("normal");
node.Stream.Write(new byte[]
{
0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D, 0xBA, 0xAD, 0xF0, 0x0D,
});
node.Tags["Index"] = 1;
container.Root.Add(node);
var binaryFormat = writer.Convert(container);
Assert.AreEqual(expected.Length, binaryFormat.Stream.Length);
Assert.IsTrue(binaryFormat.Stream.Compare(expectedStream));
}
public void DefaultBlockSize()
{
var writer = new StandardBinWriter();
var parameters = new WriterParameters {
Endianness = EndiannessMode.BigEndian
};
writer.Initialize(parameters);
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("empty");
node.Tags["Type"] = FileType.Empty;
node.Tags["Index"] = 1;
container.Root.Add(node);
var binaryFormat = writer.Convert(container);
Assert.AreEqual(0x800, binaryFormat.Stream.Length);
}
private static void SaveContainerToDir(NodeContainerFormat folder, string output)
{
// PROBLEMA ACTUAL
// Tenemos un string llamado output con el nombre de la carpeta destino
// child.Path tiene la ruta del fichero a extraer
// QUeremos combinar output con child.Path, pero no funciona!
// outputFile debería valer "/output/demo.aar/demo"
Directory.CreateDirectory(output);
foreach (var child in Navigator.IterateNodes(folder.Root))
{
string outputFile = output + child.Path;
if (!child.IsContainer)
{
child.GetFormatAs <BinaryFormat>().Stream.WriteTo(outputFile);
log.Info("Saving " + outputFile);
}
}
log.Info("Saved in " + output);
}
public void CanWriteDummyFiles()
{
byte[] expected =
{
0x00, 0x07, 0x7D, 0xF9, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x83, 0x5F, 0x83, 0x7E,
0x83, 0x5F, 0x83, 0x7E, 0x81, 0x5B, 0x82, 0xC5, 0x82, 0xB7, 0x2E, 0x0D, 0x0A, 0x90, 0xB3, 0x8E,
0xAE, 0x82, 0xC8, 0x83, 0x66, 0x81, 0x5B, 0x83, 0x5E, 0x82, 0xAA, 0x93, 0xFC, 0x82, 0xE9, 0x82,
0xDC, 0x82, 0xC5, 0x81, 0x41, 0x82, 0xD0, 0x82, 0xC6, 0x82, 0xDC, 0x82, 0xB8, 0x83, 0x8A, 0x83,
0x93, 0x83, 0x4E, 0x83, 0x66, 0x81, 0x5B, 0x83, 0x5E, 0x82, 0xF0, 0x8D, 0xEC, 0x90, 0xAC, 0x82,
0xB7, 0x82, 0xE9, 0x82, 0xBD, 0x82, 0xDF, 0x82, 0xCC, 0x83, 0x5F, 0x83, 0x7E, 0x81, 0x5B, 0x83,
0x74, 0x83, 0x40, 0x83, 0x43, 0x83, 0x8B, 0x82, 0xC6, 0x82, 0xB5, 0x82, 0xC4, 0x8D, 0xEC, 0x90,
0xAC, 0x82, 0xB3, 0x82, 0xEA, 0x82, 0xC4, 0x82, 0xA2, 0x82, 0xDC, 0x82, 0xB7, 0x2E, 0x0D, 0x0A,
};
var expectedStream = DataStreamFactory.FromArray(expected, 0, expected.Length);
var writer = new StandardBinWriter();
var parameters = new WriterParameters
{
Endianness = EndiannessMode.BigEndian,
BlockSize = 0x20,
};
writer.Initialize(parameters);
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("dummy");
node.Tags["Type"] = FileType.Dummy;
node.Tags["Index"] = 1;
container.Root.Add(node);
var binaryFormat = writer.Convert(container);
Assert.AreEqual(expected.Length, binaryFormat.Stream.Length);
Assert.IsTrue(binaryFormat.Stream.Compare(expectedStream));
}
public ParFile Convert(NodeContainerFormat source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
DataStream dataStream = string.IsNullOrEmpty(this.parameters.OutputPath) ? DataStreamFactory.FromMemory() : DataStreamFactory.FromFile(this.parameters.OutputPath, FileOpenMode.Write);
var writer = new DataWriter(dataStream)
{
DefaultEncoding = Encoding.GetEncoding(1252),
Endianness = EndiannessMode.BigEndian,
};
var folders = new List <Node>();
var files = new List <Node>();
if (this.parameters.IncludeDots)
{
var parFolderRootNode = new Node(".", new NodeContainerFormat());
source.MoveChildrenTo(parFolderRootNode);
folders.Add(parFolderRootNode);
}
GetFoldersAndFiles(source.Root, folders, files, this.parameters);
CompressFiles(files, this.parameters.CompressorVersion);
int headerSize = 32 + (64 * folders.Count) + (64 * files.Count);
int folderTableOffset = headerSize;
int fileTableOffset = folderTableOffset + (folders.Count * 32);
long dataPosition = fileTableOffset + (files.Count * 32);
dataPosition = Align(dataPosition, 2048);
writer.Write("PARC", 4, false);
if (source.Root.Tags.ContainsKey("PlatformId"))
{
writer.Write((byte)source.Root.Tags["PlatformId"]);
}
else
{
writer.Write((byte)0x02);
}
if (source.Root.Tags.ContainsKey("Endianness"))
{
var endianness = (byte)source.Root.Tags["Endianness"];
writer.Write(endianness);
writer.Endianness = endianness == 0x00 ? EndiannessMode.LittleEndian : EndiannessMode.BigEndian;
}
else
{
writer.Write((byte)0x01);
}
writer.Write((ushort)0x0000); // extended size and relocated
if (source.Root.Tags.ContainsKey("Version"))
{
writer.Write((int)source.Root.Tags["Version"]);
}
else
{
writer.Write(0x00020001);
}
writer.Write(0x00000000); // data size
writer.Write(folders.Count);
writer.Write(folderTableOffset);
writer.Write(files.Count);
writer.Write(fileTableOffset);
WriteNames(writer, folders);
WriteNames(writer, files);
WriteFolders(writer, folders);
WriteFiles(writer, files, dataPosition);
dataStream.Seek(0, SeekMode.End);
writer.WritePadding(0, 2048);
var result = new ParFile(dataStream)
{
CanBeCompressed = false,
};
return(result);
}
public NodeContainerFormat Convert(BinaryFormat source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
source.Stream.Position = 0;
var result = new NodeContainerFormat();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var reader = new DataReader(source.Stream)
{
DefaultEncoding = Encoding.GetEncoding(1252),
Endianness = EndiannessMode.BigEndian,
};
string magicId = reader.ReadString(4);
if (magicId == "SLLZ")
{
var subStream = new DataStream(source.Stream, 0, source.Stream.Length);
var compressed = new ParFile(subStream);
source = (ParFile)ConvertFormat.With <Sllz.Decompressor>(compressed);
source.Stream.Position = 0;
reader = new DataReader(source.Stream)
{
DefaultEncoding = Encoding.GetEncoding(1252),
Endianness = EndiannessMode.BigEndian,
};
magicId = reader.ReadString(4);
}
if (magicId != "PARC")
{
throw new FormatException("PARC: Bad magic Id.");
}
result.Root.Tags["PlatformId"] = reader.ReadByte();
byte endianness = reader.ReadByte();
result.Root.Tags["Endianness"] = endianness;
result.Root.Tags["SizeExtended"] = reader.ReadByte();
result.Root.Tags["Relocated"] = reader.ReadByte();
if (endianness == 0x00)
{
reader.Endianness = EndiannessMode.LittleEndian;
}
result.Root.Tags["Version"] = reader.ReadInt32();
result.Root.Tags["DataSize"] = reader.ReadInt32();
int totalFolderCount = reader.ReadInt32();
int folderInfoOffset = reader.ReadInt32();
int totalFileCount = reader.ReadInt32();
int fileInfoOffset = reader.ReadInt32();
var folderNames = new string[totalFolderCount];
for (var i = 0; i < totalFolderCount; i++)
{
folderNames[i] = reader.ReadString(0x40).TrimEnd('\0');
if (folderNames[i].Length < 1)
{
folderNames[i] = ".";
}
}
var fileNames = new string[totalFileCount];
for (var i = 0; i < totalFileCount; i++)
{
fileNames[i] = reader.ReadString(0x40).TrimEnd('\0');
}
reader.Stream.Seek(folderInfoOffset);
var folders = new Node[totalFolderCount];
for (var i = 0; i < totalFolderCount; i++)
{
folders[i] = new Node(folderNames[i], new NodeContainerFormat())
{
Tags =
{
["FolderCount"] = reader.ReadInt32(),
["FirstFolderIndex"] = reader.ReadInt32(),
["FileCount"] = reader.ReadInt32(),
["FirstFileIndex"] = reader.ReadInt32(),
["Attributes"] = reader.ReadInt32(),
["Unused1"] = reader.ReadInt32(),
["Unused2"] = reader.ReadInt32(),
["Unused3"] = reader.ReadInt32(),
},
};
}
reader.Stream.Seek(fileInfoOffset);
var files = new Node[totalFileCount];
for (var i = 0; i < totalFileCount; i++)
{
uint compressionFlag = reader.ReadUInt32();
uint size = reader.ReadUInt32();
uint compressedSize = reader.ReadUInt32();
uint baseOffset = reader.ReadUInt32();
int attributes = reader.ReadInt32();
uint extendedOffset = reader.ReadUInt32();
ulong timestamp = reader.ReadUInt64();
long offset = ((long)extendedOffset << 32) | baseOffset;
var file = new ParFile(source.Stream, offset, compressedSize)
{
CanBeCompressed = false, // Don't try to compress if the original was not compressed.
IsCompressed = compressionFlag == 0x80000000,
DecompressedSize = size,
Attributes = attributes,
Timestamp = timestamp,
};
files[i] = new Node(fileNames[i], file)
{
Tags = { ["Timestamp"] = timestamp, },
};
}
BuildTree(folders[0], folders, files, this.parameters);
result.Root.Add(folders[0]);
return(result);
}
public ALAR3()
{
AlarFiles = new NodeContainerFormat();
}
public NodeContainerFormat Convert(BinaryFormat source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
source.Stream.Position = 0;
var result = new NodeContainerFormat();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var reader = new DataReader(source.Stream)
{
DefaultEncoding = Encoding.GetEncoding(1252),
Endianness = EndiannessMode.BigEndian,
};
string magicId = reader.ReadString(4);
if (magicId == "SLLZ")
{
var subStream = new DataStream(source.Stream, 0, source.Stream.Length);
var compressed = new ParFile(subStream);
source = (ParFile)ConvertFormat.With <Sllz.Decompressor>(compressed);
source.Stream.Position = 0;
reader = new DataReader(source.Stream)
{
DefaultEncoding = Encoding.GetEncoding(1252),
Endianness = EndiannessMode.BigEndian,
};
magicId = reader.ReadString(4);
}
if (magicId != "PARC")
{
throw new FormatException("PARC: Bad magic Id.");
}
result.Root.Tags["Unknown#1"] = reader.ReadInt32();
result.Root.Tags["Unknown#2"] = reader.ReadInt32();
result.Root.Tags["Unknown#3"] = reader.ReadInt32();
int totalFolderCount = reader.ReadInt32();
int folderInfoOffset = reader.ReadInt32();
int totalFileCount = reader.ReadInt32();
int fileInfoOffset = reader.ReadInt32();
var folderNames = new string[totalFolderCount];
for (int i = 0; i < totalFolderCount; i++)
{
folderNames[i] = reader.ReadString(0x40).TrimEnd('\0');
}
var fileNames = new string[totalFileCount];
for (int i = 0; i < totalFileCount; i++)
{
fileNames[i] = reader.ReadString(0x40).TrimEnd('\0');
}
reader.Stream.Seek(folderInfoOffset);
var folders = new Node[totalFolderCount];
for (int i = 0; i < totalFolderCount; i++)
{
folders[i] = new Node(folderNames[i], new NodeContainerFormat())
{
Tags =
{
["FolderCount"] = reader.ReadInt32(),
["FirstFolderIndex"] = reader.ReadInt32(),
["FileCount"] = reader.ReadInt32(),
["FirstFileIndex"] = reader.ReadInt32(),
["Attributes"] = reader.ReadInt32(),
["Unknown2"] = reader.ReadInt32(),
["Unknown3"] = reader.ReadInt32(),
["Unknown4"] = reader.ReadInt32(),
},
};
}
reader.Stream.Seek(fileInfoOffset);
var files = new Node[totalFileCount];
for (int i = 0; i < totalFileCount; i++)
{
uint compressionFlag = reader.ReadUInt32();
uint size = reader.ReadUInt32();
uint compressedSize = reader.ReadUInt32();
uint offset = reader.ReadUInt32();
int attributes = reader.ReadInt32();
int unknown2 = reader.ReadInt32();
int unknown3 = reader.ReadInt32();
int date = reader.ReadInt32();
var file = new ParFile(source.Stream, offset, compressedSize)
{
CanBeCompressed = false, // Don't try to compress if the original was not compressed.
IsCompressed = compressionFlag == 0x80000000,
DecompressedSize = size,
Attributes = attributes,
Unknown2 = unknown2,
Unknown3 = unknown3,
Date = date,
};
files[i] = new Node(fileNames[i], file)
{
Tags = { ["Date"] = date, },
};
}
BuildTree(folders[0], folders, files, this.parameters);
result.Root.Add(folders[0]);
return(result);
}
public void CanWriteCompressedFilesChangingEndianness()
{
byte[] expected =
{
0xF9, 0x7D, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x31, 0x78, 0xDA, 0x4D, 0x91, 0xCB, 0x6D, 0xC4, 0x30,
0x0C, 0x44, 0x5B, 0x99, 0x02, 0x8C, 0xED, 0x21, 0xF7, 0x24, 0xC8, 0x25, 0x05, 0xD0, 0x32, 0xE3,
0x25, 0x40, 0x49, 0x0E, 0x3F, 0x8B, 0x94, 0x1F, 0x7A, 0xF3, 0xBD, 0x48, 0x10, 0x35, 0x22, 0xE7,
0x8D, 0x1E, 0xA7, 0x71, 0x87, 0x1C, 0x9E, 0x1D, 0xDB, 0xD4, 0x69, 0x70, 0x09, 0x50, 0xE7, 0x58,
0xD0, 0xE6, 0x70, 0x6E, 0xC1, 0x91, 0x06, 0xDA, 0xE4, 0x10, 0x6F, 0x32, 0x76, 0xB0, 0x4A, 0x5C,
0xF0, 0x34, 0x6D, 0x15, 0x1C, 0x57, 0x32, 0x0E, 0x23, 0x64, 0xE0, 0x76, 0x5E, 0x80, 0x77, 0x0E,
0x1C, 0xD3, 0x82, 0x2E, 0x78, 0x0D, 0xA4, 0x2A, 0xF5, 0x36, 0xED, 0x60, 0x5B, 0x30, 0x64, 0xBD,
0x82, 0x20, 0xBD, 0x4E, 0x9B, 0x94, 0x4E, 0xA8, 0xA5, 0x8A, 0x2F, 0xE8, 0xB4, 0x0F, 0x82, 0x89,
0xA7, 0xA3, 0xA5, 0x9D, 0xDB, 0xE0, 0xF7, 0xE4, 0x05, 0xA5, 0x72, 0xDA, 0x25, 0x42, 0xBC, 0x54,
0xEE, 0x54, 0xC7, 0x43, 0x78, 0x80, 0x5A, 0xF5, 0x73, 0xF9, 0x71, 0xF2, 0x63, 0x1B, 0xEC, 0x7F,
0x2F, 0x96, 0x2F, 0x27, 0x88, 0x5A, 0x4F, 0x34, 0xDE, 0x16, 0xF8, 0x54, 0x95, 0x26, 0x91, 0x9B,
0x0C, 0xBC, 0x95, 0x67, 0xBF, 0xE0, 0x99, 0x7A, 0xD9, 0xF7, 0x90, 0x35, 0xB5, 0x82, 0x50, 0xD9,
0x53, 0x09, 0x54, 0x8D, 0xF8, 0xF4, 0x8A, 0x9B, 0xDC, 0xD8, 0xAC, 0x88, 0x5E, 0xAE, 0xE4, 0xAC,
0x7A, 0xB7, 0xD7, 0xA0, 0x54, 0xE9, 0x9D, 0xB8, 0x69, 0x59, 0x5D, 0x9E, 0x88, 0x1B, 0x0F, 0xF2,
0x33, 0x89, 0xAF, 0x1A, 0x64, 0x44, 0xA1, 0x66, 0x5F, 0xB0, 0x2A, 0x8D, 0xAD, 0x3C, 0xAA, 0xAC,
0x6C, 0xB3, 0x2E, 0x16, 0xEC, 0x46, 0x37, 0xD9, 0x6A, 0x4E, 0xEE, 0xC9, 0xD5, 0xDB, 0x66, 0x39,
0x62, 0xE5, 0xCE, 0x23, 0xCE, 0xEF, 0x48, 0x81, 0x6C, 0xDF, 0xD1, 0x44, 0x65, 0x13, 0x52, 0x89,
0xFC, 0xB2, 0x9D, 0xF3, 0xD2, 0xEE, 0xA9, 0x7C, 0x48, 0xAF, 0x59, 0xFF, 0x24, 0x5C, 0x03, 0x2B,
0x9F, 0x43, 0xA9, 0xB1, 0x15, 0x86, 0xF2, 0x44, 0x14, 0x4A, 0xA9, 0x0A, 0xE2, 0x41, 0x4B, 0x55,
0xC4, 0x55, 0xBD, 0x7C, 0x02, 0x79, 0xB7, 0xBB, 0xBF, 0x00, 0x00, 0x00, 0x00,
};
var expectedStream = DataStreamFactory.FromArray(expected, 0, expected.Length);
var writer = new StandardBinWriter();
var parameters = new WriterParameters
{
BlockSize = 0x20,
};
writer.Initialize(parameters);
var container = new NodeContainerFormat();
var node = NodeFactory.FromMemory("compressed");
node.Stream.Write(new byte[]
{
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x31, 0x78, 0xDA, 0x4D, 0x91, 0xCB, 0x6D, 0xC4, 0x30,
0x0C, 0x44, 0x5B, 0x99, 0x02, 0x8C, 0xED, 0x21, 0xF7, 0x24, 0xC8, 0x25, 0x05, 0xD0, 0x32, 0xE3,
0x25, 0x40, 0x49, 0x0E, 0x3F, 0x8B, 0x94, 0x1F, 0x7A, 0xF3, 0xBD, 0x48, 0x10, 0x35, 0x22, 0xE7,
0x8D, 0x1E, 0xA7, 0x71, 0x87, 0x1C, 0x9E, 0x1D, 0xDB, 0xD4, 0x69, 0x70, 0x09, 0x50, 0xE7, 0x58,
0xD0, 0xE6, 0x70, 0x6E, 0xC1, 0x91, 0x06, 0xDA, 0xE4, 0x10, 0x6F, 0x32, 0x76, 0xB0, 0x4A, 0x5C,
0xF0, 0x34, 0x6D, 0x15, 0x1C, 0x57, 0x32, 0x0E, 0x23, 0x64, 0xE0, 0x76, 0x5E, 0x80, 0x77, 0x0E,
0x1C, 0xD3, 0x82, 0x2E, 0x78, 0x0D, 0xA4, 0x2A, 0xF5, 0x36, 0xED, 0x60, 0x5B, 0x30, 0x64, 0xBD,
0x82, 0x20, 0xBD, 0x4E, 0x9B, 0x94, 0x4E, 0xA8, 0xA5, 0x8A, 0x2F, 0xE8, 0xB4, 0x0F, 0x82, 0x89,
0xA7, 0xA3, 0xA5, 0x9D, 0xDB, 0xE0, 0xF7, 0xE4, 0x05, 0xA5, 0x72, 0xDA, 0x25, 0x42, 0xBC, 0x54,
0xEE, 0x54, 0xC7, 0x43, 0x78, 0x80, 0x5A, 0xF5, 0x73, 0xF9, 0x71, 0xF2, 0x63, 0x1B, 0xEC, 0x7F,
0x2F, 0x96, 0x2F, 0x27, 0x88, 0x5A, 0x4F, 0x34, 0xDE, 0x16, 0xF8, 0x54, 0x95, 0x26, 0x91, 0x9B,
0x0C, 0xBC, 0x95, 0x67, 0xBF, 0xE0, 0x99, 0x7A, 0xD9, 0xF7, 0x90, 0x35, 0xB5, 0x82, 0x50, 0xD9,
0x53, 0x09, 0x54, 0x8D, 0xF8, 0xF4, 0x8A, 0x9B, 0xDC, 0xD8, 0xAC, 0x88, 0x5E, 0xAE, 0xE4, 0xAC,
0x7A, 0xB7, 0xD7, 0xA0, 0x54, 0xE9, 0x9D, 0xB8, 0x69, 0x59, 0x5D, 0x9E, 0x88, 0x1B, 0x0F, 0xF2,
0x33, 0x89, 0xAF, 0x1A, 0x64, 0x44, 0xA1, 0x66, 0x5F, 0xB0, 0x2A, 0x8D, 0xAD, 0x3C, 0xAA, 0xAC,
0x6C, 0xB3, 0x2E, 0x16, 0xEC, 0x46, 0x37, 0xD9, 0x6A, 0x4E, 0xEE, 0xC9, 0xD5, 0xDB, 0x66, 0x39,
0x62, 0xE5, 0xCE, 0x23, 0xCE, 0xEF, 0x48, 0x81, 0x6C, 0xDF, 0xD1, 0x44, 0x65, 0x13, 0x52, 0x89,
0xFC, 0xB2, 0x9D, 0xF3, 0xD2, 0xEE, 0xA9, 0x7C, 0x48, 0xAF, 0x59, 0xFF, 0x24, 0x5C, 0x03, 0x2B,
0x9F, 0x43, 0xA9, 0xB1, 0x15, 0x86, 0xF2, 0x44, 0x14, 0x4A, 0xA9, 0x0A, 0xE2, 0x41, 0x4B, 0x55,
0xC4, 0x55, 0xBD, 0x7C, 0x02, 0x79, 0xB7, 0xBB, 0xBF, 0x00, 0x00, 0x00, 0x00,
});
node.Tags["Type"] = FileType.CompressedAlternateEndian;
node.Tags["Index"] = 1;
node.Tags["InflatedSize"] = 0x200;
container.Root.Add(node);
var binaryFormat = writer.Convert(container);
Assert.AreEqual(expected.Length, binaryFormat.Stream.Length);
Assert.IsTrue(binaryFormat.Stream.Compare(expectedStream));
}
