public void ReadFromStreamAsyncCallsOnReadFromStreamInTask()
{
Type calledType = null;
Stream calledStream = null;
HttpContentHeaders calledHeaders = null;
SMediaTypeFormatter formatter = new SMediaTypeFormatter()
{
CallBase = true
};
formatter.OnReadFromStreamTypeStreamHttpContentHeaders = (type, stream, headers) =>
{
calledType = type;
calledStream = stream;
calledHeaders = headers;
return(5);
};
SHttpContent content = new SHttpContent();
HttpContentHeaders contentHeaders = content.Headers;
Task <object> createdTask =
StreamAssert.WriteAndReadResult <Task <object> >(
(stream) => { },
(stream) => formatter.ReadFromStreamAsync(typeof(int), stream, contentHeaders));
object readObject = TaskAssert.SucceedsWithResult(createdTask);
Assert.AreEqual(5, readObject, "ReadFromStreamAsync should have returned this value from stub.");
Assert.AreEqual(typeof(int), calledType, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.IsNotNull(calledStream, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.AreSame(contentHeaders, calledHeaders, "OnReadFromStreamAsync was not called or did not pass ContentHeaders.");
}
public void ReadFromStreamAsyncCallsOnReadFromStreamAsync()
{
Type calledType = null;
Stream calledStream = null;
HttpContentHeaders calledHeaders = null;
SMediaTypeFormatter formatter = new SMediaTypeFormatter()
{
CallBase = true
};
formatter.OnReadFromStreamAsyncTypeStreamHttpContentHeaders = (type, stream, headers) =>
{
calledType = type;
calledStream = stream;
calledHeaders = headers;
return(null);
};
SHttpContent content = new SHttpContent();
HttpContentHeaders contentHeaders = content.Headers;
StreamAssert.WriteAndRead(
(stream) => { },
(stream) => formatter.ReadFromStreamAsync(typeof(int), stream, contentHeaders));
Assert.AreEqual(typeof(int), calledType, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.IsNotNull(calledStream, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.AreSame(contentHeaders, calledHeaders, "OnReadFromStreamAsync was not called or did not pass ContentHeaders.");
}
public void TestRecreatePKCompressed()
{
const string inputArchivePath = @"TestArchives\PKCompressed.w3x";
using var inputArchive = MpqArchive.Open(inputArchivePath);
using var recreatedArchive = MpqArchive.Create(
(Stream?)null,
inputArchive.GetMpqFiles().ToArray(),
(ushort)inputArchive.Header.HashTableSize,
inputArchive.Header.BlockSize);
for (var i = 0; i < inputArchive.Header.BlockTableSize; i++)
{
inputArchive.BaseStream.Position = inputArchive[i].FilePosition;
recreatedArchive.BaseStream.Position = recreatedArchive[i].FilePosition;
var size1 = inputArchive[i].CompressedSize;
var size2 = recreatedArchive[i].CompressedSize;
StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream, size1 > size2 ? size1 : size2);
}
inputArchive.BaseStream.Position = 0;
recreatedArchive.BaseStream.Position = 0;
StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream, MpqHeader.Size);
}
public void WriteToStreamAsyncCallsOnWriteToStreamInTask()
{
Type calledType = null;
object calledObj = null;
Stream calledStream = null;
HttpContentHeaders calledHeaders = null;
Task createdTask = null;
SMediaTypeFormatter formatter = new SMediaTypeFormatter()
{
CallBase = true
};
formatter.OnWriteToStreamTypeObjectStreamHttpContentHeadersTransportContext = (type, obj, stream, headers, context) =>
{
calledType = type;
calledObj = obj;
calledStream = stream;
calledHeaders = headers;
};
SHttpContent content = new SHttpContent();
HttpContentHeaders contentHeaders = content.Headers;
StreamAssert.WriteAndRead(
(stream) => createdTask = formatter.WriteToStreamAsync(typeof(int), 5, stream, contentHeaders, /*transportContext*/ null),
(stream) => { });
TaskAssert.Succeeds(createdTask);
Assert.AreEqual(typeof(int), calledType, "OnWriteToStream was not called or did not pass Type.");
Assert.AreEqual(5, calledObj, "OnWriteToStream was not called or did not pass the object value.");
Assert.IsNotNull(calledStream, "OnWriteToStream was not called or did not pass Type.");
Assert.AreSame(contentHeaders, calledHeaders, "OnWriteToStream was not called or did not pass ContentHeaders.");
}
internal static void RunStreamRWTest(
string filePath,
Type type,
Encoding?encoding = null,
string?readMethodName = null,
string writeMethodName = nameof(StreamWriter.Write),
params object[] additionalReadParameters)
{
var readMethod = typeof(StreamReaderExtensions).GetMethod(readMethodName ?? $"Read{type.Name}");
Assert.IsNotNull(readMethod, $"Could not find extension method to read {type.Name}.");
var writeMethod = typeof(StreamWriterExtensions).GetMethod(writeMethodName, new[] { typeof(StreamWriter), type });
Assert.IsNotNull(writeMethod, $"Could not find extension method to write {type.Name}.");
using var expectedStream = FileProvider.GetFile(filePath);
using var reader = new StreamReader(expectedStream, encoding ?? new UTF8Encoding(false, true));
var parsedFile = readMethod !.Invoke(null, new[] { reader }.Concat(additionalReadParameters).ToArray());
Assert.AreEqual(type, parsedFile.GetType());
using var actualStream = new MemoryStream();
using var writer = new StreamWriter(actualStream, reader.CurrentEncoding);
writeMethod !.Invoke(null, new[] { writer, parsedFile });
writer.Flush();
StreamAssert.AreEqualText(expectedStream, actualStream, true);
}
public void TestDefaultMapInfo()
{
// Get World Editor default info file.
using var defaultInfoStream = File.OpenRead(TestDataProvider.GetFile(@"MapFiles\DefaultMapFiles\war3map.w3i"));
var defaultMapInfo = MapInfo.Parse(defaultInfoStream, true);
defaultInfoStream.Position = 0;
// Get War3Net default info file.
var mapInfo = MapInfo.Default;
// Update defaults that are different.
mapInfo.EditorVersion = 6072;
mapInfo.ScriptLanguage = ScriptLanguage.Jass;
var player0 = mapInfo.GetPlayerData(0);
player0.PlayerName = "TRIGSTR_001";
player0.StartPosition = defaultMapInfo.GetPlayerData(0).StartPosition;
mapInfo.SetPlayerData(player0);
var team0 = mapInfo.GetForceData(0);
team0.ForceName = "TRIGSTR_002";
team0.IncludeAllPlayers();
mapInfo.SetForceData(team0);
// Compare files.
using var mapInfoStream = new MemoryStream();
mapInfo.SerializeTo(mapInfoStream, true);
mapInfoStream.Position = 0;
StreamAssert.AreEqual(defaultInfoStream, mapInfoStream);
}
public void TestDefaultMapEnvironment()
{
// Get World Editor default environment file.
using var defaultEnvironmentStream = File.OpenRead(TestDataProvider.GetFile(@"MapFiles\DefaultMapFiles\war3map.w3e"));
var defaultMapEnvironment = MapEnvironment.Parse(defaultEnvironmentStream, true);
defaultEnvironmentStream.Position = 0;
// Get War3Net default environment file.
var mapEnvironment = MapEnvironment.Default;
// Update defaults that are different.
var tileEnumerator = defaultMapEnvironment.GetEnumerator();
foreach (var tile in mapEnvironment)
{
tileEnumerator.MoveNext();
tile.Variation = tileEnumerator.Current.Variation;
tile.CliffVariation = tileEnumerator.Current.CliffVariation;
}
// Compare files.
using var mapEnvironmentStream = new MemoryStream();
mapEnvironment.SerializeTo(mapEnvironmentStream, true);
mapEnvironmentStream.Position = 0;
StreamAssert.AreEqual(defaultEnvironmentStream, mapEnvironmentStream);
}
internal static void RunStreamRWTest(
string filePath,
Type type,
string writeMethodName)
{
var readMethod = typeof(StreamReaderExtensions).GetMethod($"Read{type.Name}");
Assert.IsNotNull(readMethod, $"Could not find extension method to read {type.Name}.");
var writeMethod = typeof(StreamWriterExtensions).GetMethod(writeMethodName, new[] { typeof(StreamWriter), type });
Assert.IsNotNull(writeMethod, $"Could not find extension method to write {type.Name}.");
using var expectedStream = MpqFile.OpenRead(filePath);
using var reader = new StreamReader(expectedStream, new UTF8Encoding(false, true));
var parsedFile = readMethod !.Invoke(null, new[] { reader });
Assert.AreEqual(type, parsedFile !.GetType());
using var actualStream = new MemoryStream();
using var writer = new StreamWriter(actualStream, reader.CurrentEncoding);
writeMethod !.Invoke(null, new[] { writer, parsedFile });
writer.Flush();
StreamAssert.AreEqualText(expectedStream, actualStream, true);
}
public void NewToOld()
{
var oldMsg = new OldRemoveSubscription("the message", new Uri("http://bob/phil"));
var oldold = Factory.ConvertToOldRemoveSubscription(oldMsg);
using (var newStream = new MemoryStream())
{
PlainFormatter.Serialize(newStream, oldold);
newStream.Position = 0;
using (var oldStream = new MemoryStream())
{
using (var str = File.OpenRead(_pathToFile))
{
var buff = new byte[str.Length];
str.Read(buff, 0, buff.Length);
oldStream.Write(buff, 0, buff.Length);
}
var newFileName = ".\\new-{0}.txt".FormatWith(oldMsg.GetType().Name);
if (File.Exists(newFileName))
{
File.Delete(newFileName);
}
using (var fs = File.OpenWrite(newFileName))
{
fs.Write(newStream.ToArray(), 0, newStream.ToArray().Length);
}
StreamAssert.AreEqual(oldStream, newStream);
}
}
}
private static void TestParseMapCustomTextTriggers(string mapCustomTextTriggersFilePath)
{
using var original = FileProvider.GetFile(mapCustomTextTriggersFilePath);
using var recreated = new MemoryStream();
MapCustomTextTriggers.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParseMapDoodads(string mapDoodadsFilePath)
{
using var original = FileProvider.GetFile(mapDoodadsFilePath);
using var recreated = new MemoryStream();
MapDoodads.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParseMapEnvironment(string environmentFilePath)
{
using var original = FileProvider.GetFile(environmentFilePath);
using var recreated = new MemoryStream();
MapEnvironment.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParseMapInfo(string mapInfoFilePath)
{
using var recreated = new MemoryStream();
using var original = File.OpenRead(mapInfoFilePath);
MapInfo.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParsePathingMap(string pathingMapFile)
{
using var original = FileProvider.GetFile(pathingMapFile);
using var recreated = new MemoryStream();
PathingMap.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParseCampaignUnitObjectData(string campaignUnitObjectDataFilePath)
{
using var original = FileProvider.GetFile(campaignUnitObjectDataFilePath);
using var recreated = new MemoryStream();
CampaignUnitObjectData.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true, true);
}
public void TestPathingMap(string pathingMapFile)
{
using var fileStream = File.OpenRead(pathingMapFile);
var pathingMap = PathingMap.Parse(fileStream, true);
using var memoryStream = new MemoryStream();
pathingMap.SerializeTo(memoryStream, true);
StreamAssert.AreEqual(fileStream, memoryStream, true);
}
public void TestParseMapUnits(string mapUnitsFilePath)
{
using var recreated = new MemoryStream();
using var original = File.OpenRead(mapUnitsFilePath);
var data = MapUnits.Parse(original, true);
Assert.AreEqual(original.Length, original.Position);
data.SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
private void TestParseObjectDataInternal(string objectDataFilePath, bool fromCampaign)
{
using var original = MpqFile.OpenRead(objectDataFilePath);
using var recreated = new MemoryStream();
using var objectDataReader = new BinaryReader(original);
var objectData = objectDataReader.ReadObjectData(fromCampaign);
using var objectDataWriter = new BinaryWriter(recreated);
objectDataWriter.Write(objectData);
StreamAssert.AreEqual(original, recreated, true, true);
}
public void TestStoreThenRetrieveFile(string filename)
{
var fileStream = File.OpenRead(filename);
var mpqFile = MpqFile.New(fileStream, filename, true);
var archive = MpqArchive.Create(new MemoryStream(), new List <MpqFile>()
{
mpqFile
});
var openedArchive = MpqArchive.Open(archive.BaseStream);
var openedStream = openedArchive.OpenFile(filename);
StreamAssert.AreEqual(fileStream, openedStream, true);
}
public void TestStoreThenRetrieveFileWithFlags(string fileName, MpqFileFlags flags)
{
using var fileStream = File.OpenRead(fileName);
var mpqFile = MpqFile.New(fileStream, fileName, true);
mpqFile.TargetFlags = flags;
using var archive = MpqArchive.Create(new MemoryStream(), new List <MpqFile>()
{
mpqFile
}, new MpqArchiveCreateOptions { BlockSize = BlockSize });
using var openedArchive = MpqArchive.Open(archive.BaseStream);
var openedStream = openedArchive.OpenFile(fileName);
StreamAssert.AreEqual(fileStream, openedStream, true);
}
public void TestParseMapDoodads(string mapDoodadsFilePath)
{
using var recreated = new MemoryStream();
using var original = File.OpenRead(mapDoodadsFilePath);
var data = MapDoodads.Parse(original, true);
Assert.AreEqual(original.Length, original.Position);
data.SerializeTo(recreated, true);
// TODO: skip header, since it's ignored in SerializeTo method (so always saves as TFT version)
//if (data.)
StreamAssert.AreEqual(original, recreated, true);
}
public void TestStoreThenRetrieveFile(string filename)
{
var fileStream = File.OpenRead(filename);
// var mpqFile = new MpqKnownFile(filename, fileStream, MpqFileFlags.Exists, MpqLocale.Neutral, true);
var mpqFile = MpqFile.New(fileStream, filename);
var archive = MpqArchive.Create(new MemoryStream(), new List <MpqFile>()
{
mpqFile
});
var openedArchive = MpqArchive.Open(archive.BaseStream);
var openedStream = openedArchive.OpenFile(filename);
fileStream.Position = 0;
StreamAssert.AreEqual(fileStream, openedStream);
}
internal static void RunBinaryRWTest(
string filePath,
Type type,
string?readMethodName = null,
object?[]?additionalReadParameters = null,
object?[]?additionalWriteParameters = null)
{
var expectedReadTypes = new[] { typeof(BinaryReader) };
if (additionalReadParameters is not null)
{
expectedReadTypes = expectedReadTypes.Concat(additionalReadParameters.Select(p => p.GetType())).ToArray();
}
var readMethod = typeof(BinaryReaderExtensions).GetMethod(readMethodName ?? $"Read{type.Name}", expectedReadTypes);
Assert.IsNotNull(readMethod, $"Could not find extension method to read {type.Name}.");
var expectedWriteTypes = new[] { typeof(BinaryWriter), type };
if (additionalWriteParameters is not null)
{
expectedWriteTypes = expectedWriteTypes.Concat(additionalWriteParameters.Select(p => p.GetType())).ToArray();
}
var writeMethod = typeof(BinaryWriterExtensions).GetMethod(nameof(BinaryWriter.Write), expectedWriteTypes);
Assert.IsNotNull(writeMethod, $"Could not find extension method to write {type.Name}.");
using var expectedStream = FileProvider.GetFile(filePath);
using var reader = new BinaryReader(expectedStream);
var parsedFile = readMethod !.Invoke(null, new object?[] { reader }.Concat(additionalReadParameters ?? Array.Empty <object?[]>()).ToArray());
Assert.AreEqual(type, parsedFile.GetType());
using var actualStream = new MemoryStream();
using var writer = new BinaryWriter(actualStream);
writeMethod !.Invoke(null, new object?[] { writer, parsedFile }.Concat(additionalWriteParameters ?? Array.Empty <object?[]>()).ToArray());
writer.Flush();
StreamAssert.AreEqual(expectedStream, actualStream, true);
}
public void ReadFromStreamAsyncRoundTripsWriteToStreamAsync()
{
TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
HttpContentHeaders contentHeaders = new StringContent(string.Empty).Headers;
TestDataAssert.Execute(
TestData.RepresentativeValueAndRefTypeTestDataCollection,
(type, obj) =>
{
bool canSerialize = IsTypeSerializableWithJsonSerializer(type, obj) && HttpTestData.CanRoundTrip(type);
if (canSerialize)
{
object readObj = null;
StreamAssert.WriteAndRead(
(stream) => TaskAssert.Succeeds(formatter.WriteToStreamAsync(type, obj, stream, contentHeaders, /*transportContext*/ null)),
(stream) => readObj = TaskAssert.SucceedsWithResult(formatter.ReadFromStreamAsync(type, stream, contentHeaders)));
TestDataAssert.AreEqual(obj, readObj, "Failed to round trip object.");
}
});
}
public void ReadFromStreamRoundTripsWriteToStreamUsingDataContractSerializer()
{
TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
HttpContentHeaders contentHeaders = new StringContent(string.Empty).Headers;
TestDataAssert.Execute(
TestData.ValueAndRefTypeTestDataCollection,
(type, obj) =>
{
bool canSerialize = IsSerializableWithDataContractSerializer(type, obj) && HttpTestData.CanRoundTrip(type);
if (canSerialize)
{
formatter.SetSerializer(type, new DataContractSerializer(type));
object readObj = null;
StreamAssert.WriteAndRead(
(stream) => formatter.WriteToStream(type, obj, stream, contentHeaders, /*transportContext*/ null),
(stream) => readObj = formatter.ReadFromStream(type, stream, contentHeaders));
TestDataAssert.AreEqual(obj, readObj, "Failed to round trip object");
}
});
}
public void TestRecreatePKCompressed()
{
var inputArchivePath = TestDataProvider.GetPath(@"Maps\PKCompressed.w3x");
using var inputArchive = MpqArchive.Open(inputArchivePath);
using var recreatedArchive = MpqArchive.Create((Stream?)null, inputArchive.GetMpqFiles().ToArray(), new MpqArchiveCreateOptions { BlockSize = inputArchive.Header.BlockSize, HashTableSize = (ushort)inputArchive.Header.HashTableSize, ListFileCreateMode = MpqFileCreateMode.None, AttributesCreateMode = MpqFileCreateMode.None });
for (var i = 0; i < inputArchive.Header.BlockTableSize; i++)
{
inputArchive.BaseStream.Position = inputArchive[i].FilePosition;
recreatedArchive.BaseStream.Position = recreatedArchive[i].FilePosition;
// var size1 = inputArchive[i].CompressedSize;
// var size2 = recreatedArchive[i].CompressedSize;
// StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream, size1 > size2 ? size1 : size2);
StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream);
}
inputArchive.BaseStream.Position = 0;
recreatedArchive.BaseStream.Position = 0;
StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream, MpqHeader.Size);
}
public void TestParseMapUnits(string mapUnitsFilePath)
{
using var recreated = new MemoryStream();
using var original = File.OpenRead(mapUnitsFilePath);
var data = MapUnits.Parse(original, true);
Assert.AreEqual(original.Length, original.Position);
data.SerializeTo(recreated, true);
original.Position = 4;
using (var reader = new BinaryReader(original, new UTF8Encoding(false, true), true))
{
var version = (MapWidgetsVersion)reader.ReadUInt32();
if (version != MapWidgetsVersion.TFT)
{
// Can't compare streams, because serialize always saves as TFT, which sets header version to 8 and has additional data per unit.
return;
}
}
StreamAssert.AreEqual(original, recreated, true);
}
public void ReadFromStreamRoundTripsWriteToStreamUsingXmlSerializer()
{
TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
HttpContentHeaders contentHeaders = new StringContent(string.Empty).Headers;
// Excludes ReferenceDataContractType tests because XmlSerializer cannot handle circular references
TestDataAssert.Execute(
TestData.ValueAndRefTypeTestDataCollection.Where((td) => !(typeof(RefTypeTestData <ReferenceDataContractType>).IsAssignableFrom(td.GetType()))),
(type, obj) =>
{
bool canSerialize = IsSerializableWithXmlSerializer(type, obj) && HttpTestData.CanRoundTrip(type);
if (canSerialize)
{
formatter.SetSerializer(type, new XmlSerializer(type));
object readObj = null;
StreamAssert.WriteAndRead(
(stream) => formatter.WriteToStream(type, obj, stream, contentHeaders, /*transportContext*/ null),
(stream) => readObj = formatter.ReadFromStream(type, stream, contentHeaders));
TestDataAssert.AreEqual(obj, readObj, "Failed to round trip object");
}
});
}
public void TestRecreateArchive(string inputArchivePath, bool loadListFile)
{
using var inputArchive = MpqArchive.Open(inputArchivePath, loadListFile);
if (loadListFile && !inputArchive.FileExists(ListFile.FileName))
{
return;
}
var mpqFiles = inputArchive.GetMpqFiles().ToArray();
using var recreatedArchive = MpqArchive.Create((Stream?)null, mpqFiles, new MpqArchiveCreateOptions { BlockSize = inputArchive.Header.BlockSize, ListFileCreateMode = MpqFileCreateMode.None, AttributesCreateMode = MpqFileCreateMode.None });
// TODO: fix assumption that recreated archive's hashtable cannot be smaller than original
// TODO: fix assumption of how recreated blocktable's entries are laid out relative to input mpqFiles array? (aka: replace the 'offset' variable)
var offsetPerUnknownFile = (recreatedArchive.HashTable.Size / inputArchive.HashTable.Size) - 1;
var mpqEncryptedFileCount = mpqFiles.Where(mpqFile => mpqFile.IsFilePositionFixed).Count();
var offset = mpqEncryptedFileCount * (offsetPerUnknownFile + 1);
mpqEncryptedFileCount = 0;
for (var index = 0; index < mpqFiles.Length; index++)
{
var mpqFile = mpqFiles[index];
MpqEntry?inputEntry;
if (mpqFile is MpqKnownFile knownFile)
{
inputEntry = inputArchive.GetMpqEntries(knownFile.FileName).FirstOrDefault();
}
else if (mpqFile is MpqUnknownFile unknownFile)
{
inputArchive.TryGetEntryFromHashTable(mpqFile.HashIndex & inputArchive.HashTable.Mask, out inputEntry);
}
else if (mpqFile is MpqOrphanedFile orphanedFile)
{
// TODO
throw new NotSupportedException("found orphaned mpqfile");
}
else
{
throw new NotImplementedException();
}
var blockIndex = index + (int)offset;
if (mpqFile.IsFilePositionFixed)
{
blockIndex = mpqEncryptedFileCount * ((int)offsetPerUnknownFile + 1);
mpqEncryptedFileCount++;
}
var recreatedEntry = recreatedArchive[blockIndex];
if (inputEntry is not null)
{
if (!mpqFile.MpqStream.CanBeDecrypted)
{
// Check if both files have the same encryption seed.
Assert.IsTrue(!mpqFile.TargetFlags.HasFlag(MpqFileFlags.BlockOffsetAdjustedKey) || inputEntry.FileOffset == recreatedEntry.FileOffset);
inputArchive.BaseStream.Position = inputEntry.FilePosition;
recreatedArchive.BaseStream.Position = recreatedEntry.FilePosition;
var size1 = inputEntry.CompressedSize;
var size2 = recreatedEntry.CompressedSize;
StreamAssert.AreEqual(inputArchive.BaseStream, recreatedArchive.BaseStream, size1 > size2 ? size1 : size2);
}
else
{
using var inputStream = inputArchive.OpenFile(inputEntry);
using var recreatedStream = recreatedArchive.OpenFile(recreatedEntry);
StreamAssert.AreEqual(inputStream, recreatedStream, mpqFile is MpqKnownFile known ? known.FileName : "<unknown file>");
}
}
else
{
Assert.IsFalse(recreatedEntry.Flags.HasFlag(MpqFileFlags.Exists));
}
if (mpqFile is MpqUnknownFile && !mpqFile.IsFilePositionFixed)
{
offset += offsetPerUnknownFile;
}
}
}
