475 lines
21 KiB
C#
475 lines
21 KiB
C#
|
#if UNITY_2020_1_OR_NEWER
|
|||
|
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.Diagnostics;
|
|||
|
|
using System.IO;
|
|||
|
|
using System.IO.Compression;
|
|||
|
|
using System.Linq;
|
|||
|
|
using System.Runtime.InteropServices;
|
|||
|
|
using System.Text;
|
|||
|
|
using NUnit.Framework;
|
|||
|
|
using UnityEngine;
|
|||
|
|
using UnityEngine.AddressableAssets.ResourceLocators;
|
|||
|
|
using UnityEngine.ResourceManagement.Util;
|
|||
|
|
using Debug = UnityEngine.Debug;
|
|||
|
|
|
|||
|
|
namespace UnityEditor.AddressableAssets.Tests
|
|||
|
|
{
|
|||
|
|
public class BinaryStorageBufferTests
|
|||
|
|
{
|
|||
|
|
[StructLayout(LayoutKind.Sequential)]
|
|||
|
|
struct SimpleStruct : IEquatable<SimpleStruct>
|
|||
|
|
{
|
|||
|
|
public int intVal;
|
|||
|
|
public float floatVal;
|
|||
|
|
public byte byteVal;
|
|||
|
|
public short shortVal;
|
|||
|
|
public long longVal;
|
|||
|
|
public char charVal;
|
|||
|
|
public SimpleStruct(int multiple)
|
|||
|
|
{
|
|||
|
|
intVal = 8 * multiple;
|
|||
|
|
floatVal = 3.14f * multiple;
|
|||
|
|
byteVal = (byte)(16 * multiple);
|
|||
|
|
shortVal = (short)(125 * multiple);
|
|||
|
|
longVal = 10000000 * multiple;
|
|||
|
|
charVal = 'u';
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool Equals(SimpleStruct other)
|
|||
|
|
{
|
|||
|
|
return intVal.Equals(other.intVal) && floatVal.Equals(other.floatVal) && byteVal.Equals(other.byteVal) && shortVal.Equals(other.shortVal) && longVal.Equals(other.longVal) && charVal.Equals(other.charVal);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueTypes([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var intID = wr.Write(5);
|
|||
|
|
var floatId = wr.Write(3.14f);
|
|||
|
|
var boolId = wr.Write(true);
|
|||
|
|
var structId1 = wr.Write(new SimpleStruct(1));
|
|||
|
|
var structId2 = wr.Write(new SimpleStruct(2));
|
|||
|
|
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(bytes, cacheSize);
|
|||
|
|
Assert.AreEqual(5, re.ReadValue<int>(intID));
|
|||
|
|
Assert.AreEqual(true, re.ReadValue<bool>(boolId));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(1), re.ReadValue<SimpleStruct>(structId1));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(2), re.ReadValue<SimpleStruct>(structId2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueTypesWithReserve([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var intID = wr.Write(wr.Reserve<int>(), 5);
|
|||
|
|
var floatId = wr.Write(wr.Reserve<float>(), 3.14f);
|
|||
|
|
var boolId = wr.Write(wr.Reserve<bool>(), true);
|
|||
|
|
var structId1 = wr.Write(wr.Reserve<SimpleStruct>(), new SimpleStruct(1));
|
|||
|
|
var structId2 = wr.Write(wr.Reserve<SimpleStruct>(), new SimpleStruct(2));
|
|||
|
|
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(bytes, cacheSize);
|
|||
|
|
Assert.AreEqual(5, re.ReadValue<int>(intID));
|
|||
|
|
Assert.AreEqual(true, re.ReadValue<bool>(boolId));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(1), re.ReadValue<SimpleStruct>(structId1));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(2), re.ReadValue<SimpleStruct>(structId2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueTypesWithUnorderedReserve([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var intID = wr.Reserve<int>();
|
|||
|
|
var floatId = wr.Reserve<float>();
|
|||
|
|
var boolId = wr.Write(wr.Reserve<bool>(), true);
|
|||
|
|
var structId1 = wr.Reserve<SimpleStruct>();
|
|||
|
|
var structId2 = wr.Write(wr.Reserve<SimpleStruct>(), new SimpleStruct(2));
|
|||
|
|
wr.Write(floatId, 3.14f);
|
|||
|
|
wr.Write(intID, 5);
|
|||
|
|
wr.Write(structId1, new SimpleStruct(1));
|
|||
|
|
wr.Write(structId1, new SimpleStruct(1));
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(bytes, cacheSize);
|
|||
|
|
Assert.AreEqual(5, re.ReadValue<int>(intID));
|
|||
|
|
Assert.AreEqual(true, re.ReadValue<bool>(boolId));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(1), re.ReadValue<SimpleStruct>(structId1));
|
|||
|
|
Assert.AreEqual(new SimpleStruct(2), re.ReadValue<SimpleStruct>(structId2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueTypeArrays([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 1, 32, 256, 1024)]int count, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var array = new SimpleStruct[count];
|
|||
|
|
var array2 = new SimpleStruct[count];
|
|||
|
|
|
|||
|
|
for (int i = 0; i < array.Length; i++)
|
|||
|
|
{
|
|||
|
|
array2[i] = new SimpleStruct(array2.Length - i);
|
|||
|
|
array[i] = new SimpleStruct(i);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var arrayId2 = wr.Reserve<SimpleStruct>((uint)count);
|
|||
|
|
var arrayId = wr.Write(array);
|
|||
|
|
wr.Write(arrayId2, array2);
|
|||
|
|
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize);
|
|||
|
|
var a1 = re.ReadValueArray<SimpleStruct>(arrayId);
|
|||
|
|
var a2 = re.ReadValueArray<SimpleStruct>(arrayId2);
|
|||
|
|
for (int i = 0; i < array.Length; i++)
|
|||
|
|
{
|
|||
|
|
Assert.AreEqual(array[i], a1[i]);
|
|||
|
|
Assert.AreEqual(array2[i], a2[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueTypeDeduplication([Values(1024, 1024 * 1024)]int chunkSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
wr.Write(new SimpleStruct(1));
|
|||
|
|
wr.Write(new SimpleStruct(2));
|
|||
|
|
wr.Write(new SimpleStruct(3));
|
|||
|
|
wr.Write(new SimpleStruct(4));
|
|||
|
|
wr.Write(new SimpleStruct(5));
|
|||
|
|
var size = wr.Length;
|
|||
|
|
wr.Write(new SimpleStruct(5));
|
|||
|
|
wr.Write(new SimpleStruct(4));
|
|||
|
|
wr.Write(new SimpleStruct(3));
|
|||
|
|
wr.Write(new SimpleStruct(2));
|
|||
|
|
wr.Write(new SimpleStruct(1));
|
|||
|
|
Assert.AreEqual(size, wr.Length);
|
|||
|
|
}
|
|||
|
|
[Test]
|
|||
|
|
public void TestValueArrayTypeDeduplication([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 1, 32, 256, 1024)]int count)
|
|||
|
|
{
|
|||
|
|
var array = new SimpleStruct[count];
|
|||
|
|
for (int i = 0; i < array.Length; i++)
|
|||
|
|
array[i] = new SimpleStruct(i);
|
|||
|
|
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
wr.Write(array);
|
|||
|
|
var size = wr.Length;
|
|||
|
|
for (int i = 0; i < array.Length; i++)
|
|||
|
|
wr.Write(array[i]);
|
|||
|
|
Assert.AreEqual(size, wr.Length);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const string ucSample = "Ё Ђ Ѓ Є Ѕ І Ї Ј Љ Њ Ћ Ќ Ў Џ А Б В Г Д Е Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ё ђ ѓ є ѕ і ї ј љ њ ћ ќ ў џ Ѡ ѡ Ѣ ѣ Ѥ ѥ Ѧ ѧ Ѩ ѩ Ѫ ѫ Ѭ ѭ Ѯ ѯ Ѱ ѱ Ѳ ѳ Ѵ ѵ Ѷ ѷ Ѹ ѹ Ѻ ѻ Ѽ ѽ Ѿ ѿ Ҁ ҁ ҂ ҃ ...";
|
|||
|
|
string RandomText(int len, bool unicode, char sep)
|
|||
|
|
{
|
|||
|
|
var sb = new StringBuilder(len);
|
|||
|
|
var appendCount = 0;
|
|||
|
|
if (unicode)
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < len; i++)
|
|||
|
|
{
|
|||
|
|
if (appendCount++ > UnityEngine.Random.Range(10, 30))
|
|||
|
|
{
|
|||
|
|
sb.Append(sep);
|
|||
|
|
appendCount = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
sb.Append(ucSample[UnityEngine.Random.Range(0, ucSample.Length)]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < len; i++)
|
|||
|
|
{
|
|||
|
|
if (appendCount++ > UnityEngine.Random.Range(10, 30))
|
|||
|
|
{
|
|||
|
|
sb.Append(sep);
|
|||
|
|
appendCount = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
sb.Append((char)UnityEngine.Random.Range((int)'a', (int)'z'));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return sb.ToString();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestStringAsObject()
|
|||
|
|
{
|
|||
|
|
var txt = RandomText(1000, false, '/');
|
|||
|
|
var objTxt = txt as object;
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(1024, new ComplexObject.Serializer());
|
|||
|
|
var headerOffset = wr.Reserve<DateTime>();
|
|||
|
|
var reserve2 = wr.Reserve<DateTime>(100000);
|
|||
|
|
wr.Write(new int[100000]);
|
|||
|
|
for (int i = 0; i < 100000; i++)
|
|||
|
|
wr.WriteString(txt);
|
|||
|
|
//wr.WriteObject(new ComplexObject(i), true);
|
|||
|
|
var str = wr.WriteObject(objTxt, true);
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), 1024);
|
|||
|
|
var rStr = re.ReadObject(str) as string;
|
|||
|
|
//var rStr = re.ReadString(
|
|||
|
|
Assert.AreEqual(txt, rStr);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestASCIIStrings([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 1, 10, 100, 1000, 5000)]int strLen, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var txt = RandomText(strLen, false, '/');
|
|||
|
|
var sep = (char)UnityEngine.Random.Range((int)'a', (int)'z');
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var str = wr.WriteString(txt, sep);
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(bytes, cacheSize);
|
|||
|
|
var strRes = re.ReadString(str, sep);
|
|||
|
|
Assert.AreEqual(txt, strRes);
|
|||
|
|
}
|
|||
|
|
[Test]
|
|||
|
|
public void TestASCIIStringsDeduplication([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 1, 10, 100, 1000, 5000)]int strLen, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var txt = RandomText(strLen, false, '/');
|
|||
|
|
var sep = (char)UnityEngine.Random.Range((int)'a', (int)'z');
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var str = wr.WriteString(txt, sep);
|
|||
|
|
var size = wr.Length;
|
|||
|
|
var str2 = wr.WriteString(txt, sep);
|
|||
|
|
Assert.AreEqual(size, wr.Length);
|
|||
|
|
Assert.AreEqual(str, str2);
|
|||
|
|
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize);
|
|||
|
|
Assert.AreEqual(txt, re.ReadString(str, sep));
|
|||
|
|
Assert.AreEqual(txt, re.ReadString(str2, sep));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestUnicodeStrings([Values(1024, 1024 * 1024)]int chunkSize, [Values(0, 1, 10, 100, 1000, 5000)]int strLen, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var txt = RandomText(strLen, true, '/');
|
|||
|
|
var sep = (char)UnityEngine.Random.Range((int)'a', (int)'z');
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var str = wr.WriteString(txt, sep);
|
|||
|
|
var bytes = wr.SerializeToByteArray();
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(bytes, cacheSize);
|
|||
|
|
var strRes = re.ReadString(str, sep);
|
|||
|
|
Assert.AreEqual(txt, strRes);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestStringExamples(
|
|||
|
|
[Values(8, 256, 1024)]int chunkSize,
|
|||
|
|
[Values(
|
|||
|
|
null,
|
|||
|
|
"",
|
|||
|
|
"1",
|
|||
|
|
"string",
|
|||
|
|
"a/b/c/d/f/g/h/i/j/k",
|
|||
|
|
"rootfolder1/rootfolder2/rootfolder3/long file name",
|
|||
|
|
"rootfolder1/rootЁfolder2/rootfolder3_withЁ/long file name",
|
|||
|
|
"a/b/wergwegbwethgrwtherth/c/e/ffdsfsrgwetghwthwrh/e/s/wergwethgwrthrewthwer",
|
|||
|
|
"a/b/wergwegbwethgrwtherth/Ёc/e/ffdsfsЁrgwetghwthwrh/e/s/wergwethgwrthrewthweЁr"
|
|||
|
|
)]string str, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize);
|
|||
|
|
var id = wr.WriteString(str, '/');
|
|||
|
|
var r = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize);
|
|||
|
|
var str2 = r.ReadString(id, '/');
|
|||
|
|
Assert.AreEqual(str, str2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void PerfTestStringExamples()
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(1024);
|
|||
|
|
var unicodeStr = "unicode string = Ё";
|
|||
|
|
var asciiStr = "ascii string";
|
|||
|
|
|
|||
|
|
int count = 10000;
|
|||
|
|
var ids = new uint[count];
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
{
|
|||
|
|
var sb = new StringBuilder(1000);
|
|||
|
|
var partCount = UnityEngine.Random.Range(2, 10);
|
|||
|
|
for (int j = 0; j < partCount; j++)
|
|||
|
|
{
|
|||
|
|
var v = UnityEngine.Random.Range(0, 10);
|
|||
|
|
if (v > 4)
|
|||
|
|
sb.Append($"{asciiStr} - {v}");
|
|||
|
|
else
|
|||
|
|
sb.Append($"{unicodeStr} - {v}");
|
|||
|
|
sb.Append('/');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ids[i] = wr.WriteString(sb.ToString(), '/');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var r = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), 1024);
|
|||
|
|
var sw = new Stopwatch();
|
|||
|
|
sw.Start();
|
|||
|
|
for (int i = 0; i < 100000; i++)
|
|||
|
|
r.ReadString(ids[UnityEngine.Random.Range(0, ids.Length)], '/');
|
|||
|
|
sw.Stop();
|
|||
|
|
Debug.Log($"ReadString time: {sw.ElapsedMilliseconds}ms.");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
class ComplexObject : IEquatable<ComplexObject>
|
|||
|
|
{
|
|||
|
|
public class ComplexSubClass : IEquatable<ComplexSubClass>
|
|||
|
|
{
|
|||
|
|
public string stringVal;
|
|||
|
|
public float floatV;
|
|||
|
|
public bool Equals(ComplexSubClass other) => stringVal.Equals(other.stringVal) && floatV.Equals(other.floatV);
|
|||
|
|
}
|
|||
|
|
public int intVal;
|
|||
|
|
public string stringVal;
|
|||
|
|
public ComplexSubClass sub;
|
|||
|
|
public ComplexObject() { }
|
|||
|
|
public ComplexObject(int seed)
|
|||
|
|
{
|
|||
|
|
UnityEngine.Random.InitState(seed);
|
|||
|
|
intVal = UnityEngine.Random.Range(1, 1000);
|
|||
|
|
stringVal = $"string value {UnityEngine.Random.Range(1, 1000)}";
|
|||
|
|
sub = new ComplexSubClass { floatV = UnityEngine.Random.Range(.1f, 10000f), stringVal = $"sub string value {UnityEngine.Random.Range(10000, 100000)}" };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool Equals(ComplexObject other) => intVal.Equals(other.intVal) && stringVal.Equals(other.stringVal) && sub.Equals(other.sub);
|
|||
|
|
|
|||
|
|
public class Serializer : BinaryStorageBuffer.ISerializationAdapter<ComplexObject>
|
|||
|
|
{
|
|||
|
|
public IEnumerable<BinaryStorageBuffer.ISerializationAdapter> Dependencies => null;
|
|||
|
|
|
|||
|
|
struct Data
|
|||
|
|
{
|
|||
|
|
public struct Sub
|
|||
|
|
{
|
|||
|
|
public uint stringId;
|
|||
|
|
public float floatVal;
|
|||
|
|
}
|
|||
|
|
public int intVal;
|
|||
|
|
public uint stringId;
|
|||
|
|
public uint subId;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public object Deserialize(BinaryStorageBuffer.Reader reader, Type type, uint offset)
|
|||
|
|
{
|
|||
|
|
var data = reader.ReadValue<Data>(offset);
|
|||
|
|
var sub = reader.ReadValue<Data.Sub>(data.subId);
|
|||
|
|
return new ComplexObject
|
|||
|
|
{
|
|||
|
|
intVal = data.intVal,
|
|||
|
|
stringVal = reader.ReadString(data.stringId),
|
|||
|
|
sub = new ComplexSubClass
|
|||
|
|
{
|
|||
|
|
floatV = sub.floatVal,
|
|||
|
|
stringVal = reader.ReadString(sub.stringId)
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public uint Serialize(BinaryStorageBuffer.Writer writer, object val)
|
|||
|
|
{
|
|||
|
|
var co = val as ComplexObject;
|
|||
|
|
var id = writer.Reserve<Data>();
|
|||
|
|
var data = new Data
|
|||
|
|
{
|
|||
|
|
intVal = co.intVal,
|
|||
|
|
stringId = writer.WriteString(co.stringVal),
|
|||
|
|
subId = writer.Write(new Data.Sub
|
|||
|
|
{
|
|||
|
|
floatVal = co.sub.floatV,
|
|||
|
|
stringId = writer.WriteString(co.sub.stringVal)
|
|||
|
|
})
|
|||
|
|
};
|
|||
|
|
return writer.Write(id, data);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestStringsAsObjects([Values("ascii string", "unicode string")] string expected, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(1024);
|
|||
|
|
var id = wr.WriteObject(expected, false);
|
|||
|
|
var id2 = wr.WriteObject(expected, true);
|
|||
|
|
var r = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize);
|
|||
|
|
var str = r.ReadObject<string>(id);
|
|||
|
|
Assert.AreEqual(expected, str);
|
|||
|
|
var strObj = r.ReadObject(id2);
|
|||
|
|
Assert.AreEqual(expected, strObj);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestMixedObjectArray([Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(1024, new ComplexObject.Serializer());
|
|||
|
|
var objs = new object[] { "string val", new ComplexObject(1) };
|
|||
|
|
var id = wr.WriteObjects(objs, true);
|
|||
|
|
var r = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize, new ComplexObject.Serializer());
|
|||
|
|
var objs2 = r.ReadObjectArray(id);
|
|||
|
|
for (int i = 0; i < objs.Length; i++)
|
|||
|
|
Assert.AreEqual(objs[i], objs2[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestComplexObjectDeduplication([Values(1024, 1024 * 1024)]int chunkSize, [Values(1, 32, 256, 1024)]int count, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize, new ComplexObject.Serializer());
|
|||
|
|
var ids = new uint[count];
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
ids[i] = wr.WriteObject(new ComplexObject(i), false);
|
|||
|
|
var size = wr.Length;
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
wr.WriteObject(new ComplexObject(i), false);
|
|||
|
|
Assert.Less(wr.Length, size * 2);
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize, new ComplexObject.Serializer());
|
|||
|
|
for (int i = 0; i < ids.Length; i++)
|
|||
|
|
Assert.AreEqual(new ComplexObject(i), re.ReadObject<ComplexObject>(ids[i]));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestComplexObjectArray([Values(1024, 1024 * 1024)]int chunkSize, [Values(1, 32, 256, 1024)]int count, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize, new ComplexObject.Serializer());
|
|||
|
|
var objs = new ComplexObject[count];
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
objs[i] = new ComplexObject(i);
|
|||
|
|
uint objArrayWithoutType = wr.WriteObjects(objs, false);
|
|||
|
|
uint objArrayWithType = wr.WriteObjects(objs, true);
|
|||
|
|
var re = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize, new ComplexObject.Serializer());
|
|||
|
|
var typedObjs = re.ReadObjectArray<ComplexObject>(objArrayWithoutType);
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
Assert.AreEqual(objs[i], typedObjs[i]);
|
|||
|
|
var untypedObjs = re.ReadObjectArray(objArrayWithType);
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
Assert.AreEqual(objs[i], untypedObjs[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestManyComplexObjectsAndStrings([Values(1024, 1024 * 1024)]int chunkSize, [Values(1024, 10 * 1024, 100 * 1024)]int count, [Values(0, 10, 1024)]int cacheSize)
|
|||
|
|
{
|
|||
|
|
var wr = new BinaryStorageBuffer.Writer(chunkSize, new ComplexObject.Serializer());
|
|||
|
|
var ids = new uint[count];
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
{
|
|||
|
|
if (i % 2 == 0)
|
|||
|
|
ids[i] = wr.WriteObject(new ComplexObject(i), true);
|
|||
|
|
else
|
|||
|
|
ids[i] = wr.WriteString($"very long start of string/a middle part that is also somewhat long/almost done.../this part is unique{i}...../this part has unicode characters, see ЁЁЁЁЁЁЁ", '/');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
var r = new BinaryStorageBuffer.Reader(wr.SerializeToByteArray(), cacheSize, new ComplexObject.Serializer());
|
|||
|
|
for (int i = 0; i < count; i++)
|
|||
|
|
{
|
|||
|
|
if (i % 2 == 0)
|
|||
|
|
Assert.AreEqual(new ComplexObject(i), r.ReadObject(ids[i], false));
|
|||
|
|
else
|
|||
|
|
Assert.AreEqual($"very long start of string/a middle part that is also somewhat long/almost done.../this part is unique{i}...../this part has unicode characters, see ЁЁЁЁЁЁЁ", r.ReadString(ids[i], '/'));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endif
|