public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var packet = new FloatPacket())
{
Assert.False(packet.isDisposed);
}
}
public void DebugTypeName_ShouldReturnFloat_When_ValueIsSet()
{
using (var packet = new FloatPacket(0.01f))
{
Assert.AreEqual("float", packet.DebugTypeName());
}
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithValue()
{
var packet = new FloatPacket(0.01f);
Assert.True(packet.ValidateAsType().ok);
Assert.AreEqual(packet.Get(), 0.01f);
Assert.AreEqual(packet.Timestamp(), Timestamp.Unset());
}
public void isDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var packet = new FloatPacket();
packet.Dispose();
Assert.True(packet.isDisposed);
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
var packet = new FloatPacket();
Assert.AreEqual(packet.ValidateAsType().code, Status.StatusCode.Internal);
Assert.Throws <MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(packet.Timestamp(), Timestamp.Unset());
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithValue()
{
using (var packet = new FloatPacket(0.01f))
{
Assert.True(packet.ValidateAsType().Ok());
Assert.AreEqual(0.01f, packet.Get());
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
}
}
public void Consume_ShouldThrowNotSupportedException()
{
using (var packet = new FloatPacket())
{
#pragma warning disable IDE0058
Assert.Throws <NotSupportedException>(() => { packet.Consume(); });
#pragma warning restore IDE0058
}
}
public void size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
var sidePacket = new SidePacket();
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(sidePacket.size, 2);
}
public void Ctor_ShouldInstantiatePacket_When_CalledWithNoArguments()
{
using (var packet = new FloatPacket())
{
#pragma warning disable IDE0058
Assert.AreEqual(Status.StatusCode.Internal, packet.ValidateAsType().Code());
Assert.Throws <MediaPipeException>(() => { packet.Get(); });
Assert.AreEqual(Timestamp.Unset(), packet.Timestamp());
#pragma warning restore IDE0058
}
}
public void Emplace_ShouldIgnoreValue_When_KeyExists()
{
using (var sidePacket = new SidePacket())
{
var oldValuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", oldValuePacket);
Assert.AreEqual(1.0f, sidePacket.At <FloatPacket, float>("value").Get());
var newValuePacket = new FloatPacket(2.0f);
sidePacket.Emplace("value", newValuePacket);
Assert.AreEqual(1.0f, sidePacket.At <FloatPacket, float>("value").Get());
}
}
public void Size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
using (var sidePacket = new SidePacket())
{
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(2, sidePacket.size);
Assert.True(flagPacket.isDisposed);
Assert.True(valuePacket.isDisposed);
}
}
public void Emplace_ShouldInsertAndDisposePacket()
{
var sidePacket = new SidePacket();
Assert.AreEqual(sidePacket.size, 0);
Assert.IsNull(sidePacket.At <FloatPacket>("value"));
var flagPacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", flagPacket);
Assert.AreEqual(sidePacket.size, 1);
Assert.AreEqual(sidePacket.At <FloatPacket>("value").Get(), 1.0f);
Assert.True(flagPacket.isDisposed);
}
public void Emplace_ShouldInsertAndDisposePacket()
{
using (var sidePacket = new SidePacket())
{
Assert.AreEqual(0, sidePacket.size);
Assert.IsNull(sidePacket.At <FloatPacket, float>("value"));
var flagPacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", flagPacket);
Assert.AreEqual(1, sidePacket.size);
Assert.AreEqual(1.0f, sidePacket.At <FloatPacket, float>("value").Get());
Assert.True(flagPacket.isDisposed);
}
}
public void At_ShouldReturnNewPacketWithTimestamp()
{
using (var timestamp = new Timestamp(1))
{
var packet = new FloatPacket(0).At(timestamp);
Assert.AreEqual(0.0f, packet.Get());
Assert.AreEqual(timestamp, packet.Timestamp());
using (var newTimestamp = new Timestamp(2))
{
var newPacket = packet.At(newTimestamp);
Assert.AreEqual(0.0f, newPacket.Get());
Assert.AreEqual(newTimestamp, newPacket.Timestamp());
}
Assert.AreEqual(timestamp, packet.Timestamp());
}
}
public void DebugTypeName_ShouldReturnFloat_When_ValueIsSet()
{
var packet = new FloatPacket(0.01f);
Assert.AreEqual(packet.DebugTypeName(), "float");
}
public void Consume_ShouldThrowNotSupportedException()
{
var packet = new FloatPacket();
Assert.Throws <NotSupportedException>(() => { packet.Consume(); });
}
public void isDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
var packet = new FloatPacket();
Assert.False(packet.isDisposed);
}
