public void Setup()
{
ABSaveResult = new MemoryStream();
//WhoaResult = new MemoryStream();
//NewtonsoftJsonResult = new MemoryStream();
Utf8JsonResult = new MemoryStream();
TextJsonResult = new MemoryStream();
//BinaryFormatterResult = new MemoryStream();
//XMLResult = new MemoryStream();
MessagePackResult = new MemoryStream();
BinaryPackResult = new MemoryStream();
Map = ABSaveMap.Get <JsonResponseModel>(ABSaveSettings.ForSpeed);
Serializer = Map.GetSerializer(ABSaveResult);
var str = File.ReadAllText($@"{Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)}\model.txt");
JsonBytes = Encoding.UTF8.GetBytes(str);
TestObj = JsonSerializer.Deserialize <JsonResponseModel>(str);
// Serialize everyone
ABSave();
UTF8Json();
TextJson();
MessagePack();
BinaryPack();
}
public ABSaveSerializer GetSerializer(Stream destStream, Dictionary <Type, uint>?targetVersions = null)
{
ABSaveSerializer serializer = _serializerPool.TryRent() ?? new ABSaveSerializer(this);
serializer.Initialize(destStream, targetVersions);
return(serializer);
}
public void SerializeType_Version_PublicKey()
{
// Act
var result = ABSaveSerializer.SerializeType(typeof(PublicKeyAndVersionClass));
// Assert
Assert.AreEqual("ABSoftware.ABSave.Tests.PKeyAndVersionAssembly.PublicKeyAndVersionClass,ABSoftware.ABSave.Tests.PKeyAndVersionAssembly,\u0009\0\0\0.\u0005\0\0\0.\u0003\0\0\0.\u0007\0\0\0,,R\tG4 \u0083;¬", result);
}
public void SerializeType_Version_NoPublicKey()
{
// Act
var result = ABSaveSerializer.SerializeType(typeof(VersionClass));
// Assert
Assert.AreEqual("ABSoftware.ABSave.Tests.VersionAssembly.VersionClass,ABSoftware.ABSave.Tests.VersionAssembly,\u0009\0\0\0.\u0005\0\0\0.\u0003\0\0\0.\u0007\0\0\0", result);
}
public void SerializeType_NoVersion_PublicKey()
{
// Act
var result = ABSaveSerializer.SerializeType(typeof(ABSaveSerializer));
// Assert
Assert.AreEqual("ABSoftware.ABSave.Serialization.ABSaveSerializer,ABSoftware.ABSave,,,õ=\u009b\u0006~ò®\u0098", result);
}
public void SerializeType_NoVersion_NoPublicKey()
{
// Act
var result = ABSaveSerializer.SerializeType(typeof(ABSaveSerializerTests));
// Assert
Assert.AreEqual("ABSoftware.ABSave.Tests.UnitTests.ABSaveSerializerTests,ABSoftware.ABSave.Tests.UnitTests", result);
}
public void SerializeTypeBeforeObject_NoVersion_PublicKey()
{
// Act
var result = ABSaveSerializer.SerializeTypeBeforeObject(typeof(ABSaveSerializer), new ABSaveSettings());
// Assert
Assert.AreEqual("ABSoftware.ABSave.Serialization.ABSaveSerializer,ABSoftware.ABSave,,,õ=\u009b\u0006~ò®\u0098\0\0", result);
}
public void Serialize_DateTimeObject()
{
// Arrange
var obj = new DateTime(25325);
// Act
var result = ABSaveSerializer.Serialize(obj, ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\u0007íb", result);
}
public void SerializeDateTime_DateTimeObject()
{
// Arrange
DateTime obj = new DateTime(253253526);
// Act
var result = ABSaveSerializer.SerializeDateTime(obj);
// Assert
Assert.AreEqual("\b\u0004\u0096W\u0018\u000f", result);
}
public void Serialize_StringObject()
{
// Arrange
var obj = "Hello world!";
// Act
var result = ABSaveSerializer.Serialize(obj, ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\u0001Hello world!", result);
}
public void SerializeBool_TrueValue()
{
// Arrange
var obj = true;
// Act
var result = ABSaveSerializer.SerializeBool(obj);
// Assert
Assert.AreEqual("\u0001T", result);
}
public void SerializeObject_SaveObject()
{
// Arrange
var test = new TestClass();
// Act
var result = ABSaveSerializer.SerializeObject(test, ABSaveType.NoNames, test.GetType(), new ABSaveSettings());
// Assert
Assert.AreEqual("\u0001ABSoftware.ABSave.Tests.UnitTests.TestObjects.TestClass,ABSoftware.ABSave.Tests.UnitTests\0\0\u0003Oh, Hello!\am\u0001\u0001ABSoftware.ABSave.Tests.UnitTests.TestObjects.NextClass,ABSoftware.ABSave.Tests.UnitTests\u0001\0\u0003F\u0005\u0004FirstStr\u0001SecondStr\u0005", result);
}
public void Serialize_DoubleObject()
{
// Arrange
var obj = 7.23d;
// Act
var result = ABSaveSerializer.Serialize(obj, ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\b\bìQ¸\u001e\u0085ë\u001c@", result);
}
public void Serialize_LongObject()
{
// Arrange
var obj = 7L;
// Act
var result = ABSaveSerializer.Serialize(obj, ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\u0001\a", result);
}
public void SerializeArray_SingleItemArray()
{
// Arrange
var test = new List <string>()
{
"cool1"
};
// Act
var result = ABSaveSerializer.SerializeArray(test, typeof(List <string>), ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\u0004cool1\u0005", result);
}
public void Initialize(ABSaveSettings template, Dictionary <Type, uint> targetVersions = null, bool lazyWriteCompressed = false)
{
var settings = template.Customize(b => b
.SetLazyWriteCompressed(lazyWriteCompressed)
.AddConverter <BaseTypeConverter>()
.AddConverter <SubTypeConverter>()
.AddConverter <OtherTypeConverter>()
);
CurrentMap = ABSaveMap.Get <EmptyClass>(settings);
Stream = new MemoryStream();
Serializer = CurrentMap.GetSerializer(Stream, targetVersions);
Deserializer = CurrentMap.GetDeserializer(Stream);
}
public void SerializeDictionary_StringStringDictionary()
{
// Arrange
var test = new Dictionary <string, string>()
{
{ "FirstKey", "FirstValue" },
{ "SecondKey", "SecondValue" }
};
// Act
var result = ABSaveSerializer.SerializeDictionary(test, ABSaveType.NoNames, new ABSaveSettings());
// Assert
Assert.AreEqual("\u0006FirstKey\u0001FirstValue\u0001SecondKey\u0001SecondValue\u0005", result);
}
static void ConvertVariableToABSave(ABSaveType type, StringBuilder sb, ABSaveSettings settings, Helpers.ABSaveObjectItems members, ref bool notFirst, ref ABSavePrimitiveType lastType, int i)
{
// If we're doing it named - write the name.
if (type == ABSaveType.WithNames)
{
// Write the name out, don't write the Next Instruction character if it's the first item or the last item had a "lowerInnerlevel" sign after it.
ABSaveWriter.WriteString(members.Items[i].Info.Name, ABSaveUtils.RequiresLowerInnerLevelSymbol(lastType) ? false : notFirst, true, sb);
// Since we've written the name out... And the "notFirst" variable is used to determine whether to write the next instruction symbol or not... Set "notFirst" to true since it will HAVE to have the next instruction symbol now.
notFirst = true;
}
// Serialize each variable, to the StringBuilder. If the last member was an array or object, then instead of getting it to write the
// "next instruction" character, we need to get it to write the "lower" symbol instead.
ABSaveSerializer.Serialize(members.Items[i].Value, type, settings, out lastType, true, sb, ABSaveUtils.RequiresLowerInnerLevelSymbol(lastType) ? false : notFirst, i == members.Count - 1);
// Update the "notFirst" variable if it's false and we've gone through one item.
if (!notFirst)
{
notFirst = true;
}
}
internal void ReleaseSerializer(ABSaveSerializer serializer) => _serializerPool.Release(serializer);
public byte[] GetByteArr(object[] itms, params short[] data)
{
List <byte> bytes = new List <byte>(64);
ABSaveSerializer serializer = null;
int currentItmsPos = 0;
for (int i = 0; i < data.Length; i++)
{
if (data[i] <= 255)
{
bytes.Add((byte)data[i]);
}
else
{
switch ((GenType)data[i])
{
case GenType.Numerical:
bytes.AddRange(BitConverter.GetBytes((dynamic)itms[currentItmsPos++]));
break;
case GenType.String:
bytes.AddRange(Encoding.UTF8.GetBytes((string)itms[currentItmsPos++]));
break;
case GenType.ByteArr:
bytes.AddRange((byte[])itms[currentItmsPos++]);
break;
case GenType.Action:
SetupSerializer();
((Action <ABSaveSerializer>)itms[currentItmsPos++])(serializer);
bytes.AddRange(((MemoryStream)serializer.Output).ToArray());
break;
case GenType.MapItem:
SetupSerializer();
var genMap = (GenMap)itms[currentItmsPos++];
serializer.SerializeExactNonNullItem(genMap.Obj, genMap.Item);
bytes.AddRange(((MemoryStream)serializer.Output).ToArray());
break;
case GenType.Size:
SetupSerializer();
serializer.WriteCompressedLong((ulong)itms[currentItmsPos++]);
bytes.AddRange(((MemoryStream)serializer.Output).ToArray());
break;
}
}
}
return(bytes.ToArray());
void SetupSerializer()
{
if (serializer == null)
{
serializer = CurrentMap.GetSerializer(new MemoryStream());
}
else
{
serializer.Reset();
serializer.Output.Position = 0;
}
}
}
public static void SerializeNonGeneric(object?obj, ABSaveMap map, Stream stream, Dictionary <Type, uint>?targetVersions = null)
{
using ABSaveSerializer serializer = map.GetSerializer(stream, targetVersions);
serializer.SerializeRoot(obj);
}
