private static void SaveAndLoadMaterialAndCompare(Material material)
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(material);
var loadedMaterial = BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <Material>(data);
Assert.AreEqual(material, loadedMaterial);
}
private static void SaveDataTypeAndLoadAgain <Primitive>(Primitive input)
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(input);
var output = BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <Primitive>(data);
Assert.AreEqual(input, output);
}
public void SaveAndLoadPlatformsResult()
{
var result = new SupportedPlatformsResult(new[] { PlatformName.Android, PlatformName.Web });
var stream = BinaryDataExtensions.SaveDataIntoMemoryStream(result);
var loaded = BinaryDataExtensions.
LoadDataWithKnownTypeFromMemoryStream<SupportedPlatformsResult>(stream);
Assert.AreEqual(2, loaded.Platforms.Length);
}
public void SaveAndLoadArrayWithMixedNumbersAndNullElements()
{
var instance = new object[] { 1, null };
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
var retrieved = BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <object[]>(data);
Assert.IsTrue(instance.Compare(retrieved));
}
private static void SaveAndLoadArray <T>(T[] array)
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(array);
var retrievedArray = BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <T[]>(data);
Assert.AreEqual(array.Length, retrievedArray.Length);
Assert.IsTrue(array.Compare(retrievedArray));
}
public void SaveAndLoadRange()
{
var range = new Range <Vector2D>(Vector2D.Zero, new Vector2D(3.0f, 3.0f));
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(range);
var output =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <Range <Vector2D> >(data);
Assert.AreEqual(range.Start, output.Start);
Assert.AreEqual(range.End, output.End);
}
public void LoadingAndSavingKnownTypeShouldNotCauseLoggerMessage()
{
using (var logger = new MockLogger())
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(Vector2D.One);
var loaded = BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <Vector2D>(data);
Assert.AreEqual(Vector2D.One, loaded);
Assert.AreEqual(0, logger.NumberOfMessages);
}
}
public void SaveAndLoadClassWithEmptyByteArray()
{
var instance = new ClassWithByteArray {
data = new byte[] { 1, 2, 3 }
};
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
var retrieved =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ClassWithByteArray>(data);
Assert.IsTrue(instance.data.Compare(retrieved.data));
}
public void TestLoadContentType()
{
ContentLoader.Use <MockContentLoader>();
const string ContentName = "SomeXml";
var instance = new ObjectWithContent(ContentLoader.Load <MockXmlContent>(ContentName));
var stream = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
var loadedInstance =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ObjectWithContent>(stream);
Assert.AreEqual(instance.xmlContent, loadedInstance.xmlContent);
ContentLoader.DisposeIfInitialized();
}
public void LoadingContentDataFromBinaryDataWillLoadItFromName()
{
var content = new ImageAnimation(new[] { ContentLoader.Load <Image>("DeltaEngineLogo") }, 1);
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(content);
Assert.AreEqual(63, data.Length);
var loadedContent =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ImageAnimation>(data);
Assert.AreEqual(content.Name, loadedContent.Name);
Assert.AreEqual(content.Frames.Length, loadedContent.Frames.Length);
Assert.AreEqual(content.Frames[0], loadedContent.Frames[0]);
}
private static void SaveAndLoadDictionary <Key, Value>(Dictionary <Key, Value> dictionaryData)
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(dictionaryData);
var retrievedDictionary =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <Dictionary <Key, Value> >(data);
Assert.AreEqual(dictionaryData.Count, retrievedDictionary.Count);
if (typeof(Key).IsValueType && typeof(Value).IsValueType)
{
Assert.IsTrue(dictionaryData.Compare(retrievedDictionary));
}
Assert.IsTrue(!dictionaryData.Except(retrievedDictionary).Any());
}
public void SaveAndLoadExplicitLayoutStruct()
{
var explicitLayoutTest = new ExplicitLayoutTestClass
{
someValue = 8,
anotherValue = 5,
unionValue = 7
};
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(explicitLayoutTest);
var retrieved =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ExplicitLayoutTestClass>(data);
Assert.AreEqual(8, retrieved.someValue);
Assert.AreEqual(7, retrieved.anotherValue);
Assert.AreEqual(7, retrieved.unionValue);
}
private static void SaveAndLoadList <Primitive>(List <Primitive> listData)
{
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(listData);
var retrievedList =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <List <Primitive> >(data);
Assert.AreEqual(listData.Count, retrievedList.Count);
if (typeof(Primitive).IsValueType)
{
Assert.IsTrue(listData.Compare(retrievedList));
}
for (int index = 0; index < listData.Count; index++)
{
Assert.AreEqual(listData[index].GetType(), retrievedList[index].GetType());
}
}
public void SaveAndLoadClassWithArrays()
{
var instance = new ClassWithArrays();
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
var retrieved =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ClassWithArrays>(data);
Assert.IsTrue(retrieved.byteData.Compare(new byte[] { 1, 2, 3, 4, 5 }),
retrieved.byteData.ToText());
Assert.IsTrue(retrieved.charData.Compare(new[] { 'a', 'b', 'c' }),
retrieved.charData.ToText());
Assert.IsTrue(retrieved.intData.Compare(new[] { 10, 20, 30 }), retrieved.intData.ToText());
Assert.IsTrue(retrieved.stringData.Compare(new[] { "Hi", "there" }),
retrieved.stringData.ToText());
Assert.IsTrue(retrieved.enumData.Compare(new[] { DayOfWeek.Monday, DayOfWeek.Sunday }),
retrieved.enumData.ToText());
Assert.IsTrue(retrieved.byteEnumData.Compare(new[] { ByteEnum.Normal, ByteEnum.High }),
retrieved.byteEnumData.ToText());
}
public void LoadAndSaveClassWithMemoryStream()
{
var instance = new ClassWithMemoryStream(new byte[] { 1, 2, 3, 4 });
instance.Writer.Write(true);
instance.Version = 3;
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
// Only the internal data should be saved, 1 byte memory stream not null, 1 byte data length,
// memory stream data: 4 bytes+1 bool byte, 4 byte for the int Version
Assert.AreEqual(11, data.Length);
var retrieved =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ClassWithMemoryStream>(data);
Assert.IsNotNull(retrieved.reader);
Assert.AreEqual(instance.Version, retrieved.Version);
Assert.AreEqual(instance.Length, retrieved.Length);
Assert.IsTrue(instance.Bytes.Compare(retrieved.Bytes), retrieved.Bytes.ToText());
}
public void SaveAndLoadClassWithAnotherClassInside()
{
var instance = new ClassWithAnotherClassInside
{
Number = 17,
Data =
new ClassWithAnotherClassInside.InnerDerivedClass {
Value = 1.5, additionalFlag = true
},
SecondInstanceNotSet = null
};
var data = BinaryDataExtensions.SaveDataIntoMemoryStream(instance);
var retrieved =
BinaryDataExtensions.LoadDataWithKnownTypeFromMemoryStream <ClassWithAnotherClassInside>(
data);
Assert.AreEqual(instance.Number, retrieved.Number);
Assert.AreEqual(instance.Data.Value, retrieved.Data.Value);
Assert.AreEqual(instance.Data.additionalFlag, retrieved.Data.additionalFlag);
Assert.AreEqual(instance.SecondInstanceNotSet, retrieved.SecondInstanceNotSet);
}
