public void Serialization_Complex()
{
var date = DateTime.UtcNow;
var arg = new ProgressiveVolumeResponseItem
{
Date = date,
Volume = new SimpleVolumesResponse
{
Cut = 10.0,
Fill = 20.0,
BoundingExtentGrid = new TRex.Geometry.BoundingWorldExtent3D(1.0, 2.0, 3.0, 4.0, 5.0, 6.0),
CutArea = 30.0,
FillArea = 40.0,
TotalCoverageArea = 100.0
}
};
var writer = new TestBinaryWriter();
arg.ToBinary(writer);
var cp2 = new ProgressiveVolumeResponseItem();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
arg.Should().BeEquivalentTo(cp2);
}
private static void WriteArrayOneDimension(int rank)
{
byte[] _EncodedValue = null;
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Int32[] _value = new Int32[] { 0, 1, 2, 3, 4 };
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.Int32, rank, new int[] { _value.Length }), Value = _value
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
_EncodedValue = _stream.ToArray();
}
Assert.IsNotNull(_EncodedValue);
string _EncodedValueString = String.Join(", ", _EncodedValue);
string _expectedString = "134, 5, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0";
Assert.AreEqual <string>(_expectedString, _EncodedValueString);
Assert.AreEqual <int>(25, _EncodedValue.Length);
Assert.AreEqual <int>(0, _EncodedValue[5]);
Assert.AreEqual <int>(1, _EncodedValue[9]);
Assert.AreEqual <int>(2, _EncodedValue[13]);
Assert.AreEqual <int>(3, _EncodedValue[17]);
Assert.AreEqual <int>(4, _EncodedValue[21]);
}
public void ArrayMultiDimensionTest()
{
byte[] _EncodedValue = null;
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Int32[] _dimensions = new Int32[] { 2, 2 };
Int32[,] _array = new Int32[, ] {
{ 0, 1 }, { 2, 3 }
};
Assert.AreEqual <int>(2, _array.Rank);
Assert.AreEqual <int>(4, _array.Length);
Assert.AreEqual <int>(_dimensions.Length, _array.Rank);
UATypeInfo _uaTypeInfo = new UATypeInfo(BuiltInType.Int32, _dimensions.Length, _dimensions);
Variant _variant = new Variant {
UATypeInfo = _uaTypeInfo, Value = _array
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
_EncodedValue = _stream.ToArray();
}
Assert.IsNotNull(_EncodedValue);
Assert.AreEqual <int>(33, _EncodedValue.Length);
string _content = String.Join(", ", _EncodedValue);
Assert.AreEqual <string>("198, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0", _content);
}
public void Serialization_Complex()
{
var arg = new ProgressiveVolumesSubGridsRequestArgument
{
Interval = new TimeSpan(1, 0, 0, 0),
StartDate = new DateTime(2020, 1, 1, 1, 1, 1),
EndDate = new DateTime(2020, 1, 1, 1, 1, 1),
ExternalDescriptor = Guid.NewGuid(),
Filters = new FilterSet(new CombinedFilter()),
LiftParams = new LiftParameters(),
OriginatingIgniteNodeId = Guid.NewGuid(),
Overrides = new OverrideParameters(),
ProjectID = Guid.NewGuid()
};
var writer = new TestBinaryWriter();
arg.ToBinary(writer);
var cp2 = new ProgressiveVolumesSubGridsRequestArgument();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
arg.Should().BeEquivalentTo(cp2);
}
public void Serialization_Complex()
{
var arg = new SimpleVolumesRequestArgument
{
CutTolerance = 0.05,
FillTolerance = 0.01,
AdditionalSpatialFilter = new CombinedFilter(),
ExternalDescriptor = Guid.NewGuid(),
Filters = new FilterSet(new CombinedFilter()),
LiftParams = new LiftParameters(),
OriginatingIgniteNodeId = Guid.NewGuid(),
Overrides = new OverrideParameters(),
ProjectID = Guid.NewGuid(),
BaseDesign = new DesignOffset(Guid.NewGuid(), 1.23),
TopDesign = new DesignOffset(Guid.NewGuid(), 1.33),
VolumeType = VolumeComputationType.BetweenDesignAndFilter
};
var writer = new TestBinaryWriter();
arg.ToBinary(writer);
var cp2 = new SimpleVolumesRequestArgument();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
arg.Should().BeEquivalentTo(cp2);
}
static byte[] Write(EntityManager manager, Mode mode)
{
if (mode == Mode.Binary)
{
using (var writer = new TestBinaryWriter())
{
SerializeUtility.SerializeWorld(manager, writer);
return(writer.content.ToArray());
}
}
else
{
// Save the World to a memory buffer via a a Stream Writer
using (var memStream = new MemoryStream())
using (var sw = new StreamWriter(memStream))
{
sw.NewLine = "\n";
if (mode == Mode.Yaml)
{
SerializeUtility.SerializeWorldIntoYAML(manager, sw, false);
}
else if (mode == Mode.YamlDumpChunk)
{
SerializeUtility.SerializeWorldIntoYAML(manager, sw, true);
}
sw.Flush();
memStream.Seek(0, SeekOrigin.Begin);
return(memStream.ToArray());
}
}
}
public void UnsupportedClass_Write()
{
var bs = new BinarizableSerializer();
var writer = new TestBinaryWriter();
Action act = () => bs.WriteBinary(new object(), writer);
act.Should().Throw <TRexNonBinarizableException>().WithMessage("Not IBinarizable on WriteBinary: System.Object");
}
public void Exception_Write()
{
var bs = new BinarizableSerializer();
var writer = new TestBinaryWriter();
Action act = () => bs.WriteBinary(new Exception("An Exception"), writer);
act.Should().Throw <NotImplementedException>();
}
public void WriteByteStringTest()
{
using (var _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
_buffer.Write(_buffer, new byte[10]);
_buffer.Close();
byte[] _Encoded = _stream.ToArray();
Assert.AreEqual <int>(14, _Encoded.Length);
}
}
public void FromToBinary()
{
var cp1 = new BoundingWorldExtent3D(1, 2, 3, 4, 5, 6);
var writer = new TestBinaryWriter();
cp1.ToBinary(writer);
var cp2 = new BoundingWorldExtent3D();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
cp1.Should().BeEquivalentTo(cp2);
}
public void ArrayLengthOutOfRangeTest()
{
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Int32[] _value = new Int32[byte.MaxValue + 1];
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.Int32, 1), Value = _value
};
_buffer.Write(_buffer, _variant);
}
}
public void Test_CellPass_FromToBinary()
{
var cp1 = ATestCellPass();
var writer = new TestBinaryWriter();
cp1.ToBinary(writer);
var cp2 = new CellPass();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
cp1.Should().BeEquivalentTo(cp2);
}
public void EmitVersionByte_Binarizable()
{
const byte TEST_VERSION = 99;
var writer = new TestBinaryWriter();
VersionSerializationHelper.EmitVersionByte(writer, TEST_VERSION);
var ms = writer._stream.BaseStream as MemoryStream;
ms.Position = 0;
ms.ReadByte().Should().Be(TEST_VERSION);
}
public void FromToBinary()
{
var data = DummyFilteredPassData();
var writer = new TestBinaryWriter();
data.ToBinary(writer);
var data2 = new FilteredPassData();
data2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
data2.Should().BeEquivalentTo(data2);
}
public void Serialization_Null()
{
var arg = new ProgressiveVolumeResponseItem();
var writer = new TestBinaryWriter();
arg.ToBinary(writer);
var cp2 = new ProgressiveVolumeResponseItem();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
arg.Should().BeEquivalentTo(cp2);
}
public void Serialization_Null()
{
var arg = new SimpleVolumesRequestArgument();
var writer = new TestBinaryWriter();
arg.ToBinary(writer);
var cp2 = new SimpleVolumesRequestArgument();
cp2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
arg.Should().BeEquivalentTo(cp2);
}
private void TestIBinarizableSerializationForItem(object item)
{
if (item is IBinarizable)
{
// exercise serialize/deserialize of func and argument before invoking function
var serializer = new BinarizableSerializer();
var writer = new TestBinaryWriter();
serializer.WriteBinary(item, writer);
var newInstance = Activator.CreateInstance(item.GetType());
serializer.ReadBinary(newInstance, new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
}
}
public void CheckVersionByte_Binarizable_Success()
{
const byte TEST_VERSION = 99;
var writer = new TestBinaryWriter();
VersionSerializationHelper.EmitVersionByte(writer, TEST_VERSION);
var ms = writer._stream.BaseStream as MemoryStream;
ms.Position = 0;
var reader = new TestBinaryReader(ms);
VersionSerializationHelper.CheckVersionByte(reader, TEST_VERSION);
}
public void GuidTestMethod()
{
byte[] _EncodedGuid = null;
Guid _Guid = Guid.NewGuid();
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
_buffer.Write(_Guid);
_buffer.Close();
_EncodedGuid = _stream.ToArray();
}
Assert.IsNotNull(_EncodedGuid);
Assert.AreEqual <int>(16, _EncodedGuid.Length);
Guid _recoveredGuid = new Guid(_EncodedGuid);
Assert.AreEqual <Guid>(_Guid, _recoveredGuid);
}
public void CheckVersionByte_Binarizable_Failure()
{
const byte TEST_VERSION = 99;
const byte BAD_TEST_VERSION = 100;
var writer = new TestBinaryWriter();
VersionSerializationHelper.EmitVersionByte(writer, BAD_TEST_VERSION);
var ms = writer._stream.BaseStream as MemoryStream;
ms.Position = 0;
var reader = new TestBinaryReader(ms);
Action act = () => VersionSerializationHelper.CheckVersionByte(reader, TEST_VERSION);
act.Should().Throw <TRexSerializationVersionException>().WithMessage($"Invalid version read during deserialization: {BAD_TEST_VERSION}, expected version in [{TEST_VERSION}]");
}
public void VariantDateTimeTestMethod()
{
foreach (CommonDefinitions.DateTimeVariantEncoding _dtx in CommonDefinitions.DateTimeTestingValues)
{
MemoryStream _stream = new MemoryStream();
TestBinaryWriter _buffer = new TestBinaryWriter(_stream);
Assert.IsNotNull(_buffer);
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.DateTime), Value = _dtx.dateTime
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
byte[] _EncodedVariant = _stream.ToArray();
Assert.IsNotNull(_EncodedVariant);
Assert.AreEqual <int>(9, _EncodedVariant.Length);
Assert.AreEqual <byte>((byte)BuiltInType.DateTime, _EncodedVariant[0]);
CollectionAssert.AreEqual(_dtx.encoding, _EncodedVariant.ToList <byte>());
}
}
public void VariantGuidTestMethod()
{
byte[] _EncodedVGuid = null;
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.Guid), Value = CommonDefinitions.TestGuid
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
_EncodedVGuid = _stream.ToArray();
}
Assert.IsNotNull(_EncodedVGuid);
Assert.AreEqual <int>(17, _EncodedVGuid.Length);
ArraySegment <byte> _segment = new ArraySegment <byte>(_EncodedVGuid, 1, 16);
Assert.AreEqual <byte>((byte)BuiltInType.Guid, _EncodedVGuid[0]);
CollectionAssert.AreEqual(CommonDefinitions.TestGuid.ToByteArray(), _segment.ToList <byte>());
}
public void VariantArrayOfByteStringsTestMethod()
{
byte[] _EncodedValue = null;
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.ByteString, 1), Value = new byte[][] { new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 5, 6, 7, 8, 9 } }
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
_EncodedValue = _stream.ToArray();
}
Assert.IsNotNull(_EncodedValue);
Assert.AreEqual <int>(23, _EncodedValue.Length);
Assert.AreEqual <byte>((byte)((byte)BuiltInType.ByteString | (byte)VariantEncodingMask.IsArray), _EncodedValue[0]);
string _content = String.Join(", ", _EncodedValue);
Assert.AreEqual <string>("143, 2, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 5, 0, 0, 0, 5, 6, 7, 8, 9", _content);
}
public void VariantByteStringTestMethod()
{
byte[] _EncodedValue = null;
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
{
Assert.IsNotNull(_buffer);
Variant _variant = new Variant {
UATypeInfo = new UATypeInfo(BuiltInType.ByteString), Value = new byte[] { 0, 1, 2, 3, 4 }
};
_buffer.Write(_buffer, _variant);
_buffer.Close();
_EncodedValue = _stream.ToArray();
}
Assert.IsNotNull(_EncodedValue);
Assert.AreEqual <int>(10, _EncodedValue.Length);
Assert.AreEqual <byte>((byte)BuiltInType.ByteString, _EncodedValue[0]);
string _content = String.Join(", ", _EncodedValue);
Assert.AreEqual <string>("15, 5, 0, 0, 0, 0, 1, 2, 3, 4", _content);
}
public void WriteDataValueTestMethod()
{
using (MemoryStream _stream = new MemoryStream())
using (TestBinaryWriter _buffer = new TestBinaryWriter(_stream))
_buffer.Write(_buffer, (IDataValue)null);
}
