public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.OutputSidePacketInfos());
}
}
public void OutputSidePacketInfos_ShouldReturnEdgeInfoList_When_OutputSidePacketsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
var outputSidePacketInfos = config.OutputSidePacketInfos();
Assert.AreEqual(4, outputSidePacketInfos.Count);
var intPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "int_packet");
Assert.AreEqual(-1, intPacket.upstream);
Assert.AreEqual(NodeType.Calculator, intPacket.parentNode.type);
Assert.False(intPacket.backEdge);
var floatPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "float_packet");
Assert.AreEqual(-1, floatPacket.upstream);
Assert.AreEqual(NodeType.Calculator, floatPacket.parentNode.type);
Assert.False(floatPacket.backEdge);
var boolPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "bool_packet");
Assert.AreEqual(-1, boolPacket.upstream);
Assert.AreEqual(NodeType.Calculator, boolPacket.parentNode.type);
Assert.False(boolPacket.backEdge);
var stringPacket = outputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "string_packet");
Assert.AreEqual(-1, stringPacket.upstream);
Assert.AreEqual(NodeType.Calculator, stringPacket.parentNode.type);
Assert.False(stringPacket.backEdge);
}
}
public void OutputStreamInfos_ShouldReturnEdgeInfoList_When_OutputStreamsExist()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
var outputStreamInfos = config.OutputStreamInfos();
Assert.AreEqual(3, outputStreamInfos.Count);
var inStream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "in");
Assert.AreEqual(-1, inStream.upstream);
Assert.AreEqual(NodeType.GraphInputStream, inStream.parentNode.type);
Assert.AreEqual(2, inStream.parentNode.index, 2);
Assert.False(inStream.backEdge);
var out1Stream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "out1");
Assert.AreEqual(-1, out1Stream.upstream);
Assert.AreEqual(NodeType.Calculator, out1Stream.parentNode.type);
Assert.AreEqual(0, out1Stream.parentNode.index);
Assert.False(out1Stream.backEdge);
var outStream = outputStreamInfos.First((edgeInfo) => edgeInfo.name == "out");
Assert.AreEqual(-1, outStream.upstream);
Assert.AreEqual(NodeType.Calculator, outStream.parentNode.type);
Assert.AreEqual(1, outStream.parentNode.index);
Assert.False(outStream.backEdge);
}
}
public void InputStreamInfos_ShouldReturnEmptyList_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsEmpty(config.InputStreamInfos());
}
}
public void OutputStreamToNode_ShouldReturnNegativeValue_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.AreEqual(-1, config.OutputStreamToNode(""));
}
}
public void Package_ShouldReturnNull_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.IsNull(config.Package());
}
}
public void IsExternalSidePacket_ShouldReturnFalse_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
Assert.False(config.IsExternalSidePacket("model_complexity"));
}
}
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var config = new ValidatedGraphConfig())
{
Assert.False(config.isDisposed);
}
}
public void InputStreamInfos_ShouldReturnEmptyList_When_NoInputStreamExists()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.IsEmpty(config.InputStreamInfos());
}
}
public void Config_ShouldReturnAnEmptyConfig_When_NotInitialized()
{
using (var config = new ValidatedGraphConfig())
{
var canonicalizedConfig = config.Config();
Assert.AreEqual(canonicalizedConfig.CalculateSize(), 0);
}
}
public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NoOutputSidePacketExists()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.IsEmpty(config.OutputSidePacketInfos());
}
}
public void OutputSidePacketIndex_ShouldReturnIndex_When_TheNameIsValid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.AreEqual(0, config.OutputSidePacketIndex("int_packet"));
}
}
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var config = new ValidatedGraphConfig();
config.Dispose();
Assert.True(config.isDisposed);
}
public void IsExternalSidePacket_ShouldReturnTrue_When_TheSidePacketIsExternal()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PoseLandmarkConfigText)).AssertOk();
Assert.True(config.IsExternalSidePacket("model_complexity"));
}
}
public void Package_ShouldReturnNull_When_TheNamespaceIsNotSet()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.IsNull(config.Package());
}
}
public void OutputStreamToNode_ShouldReturnIndex_When_TheNameIsValid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(0, config.OutputStreamToNode("out1"));
}
}
public void OutputSidePacketIndex_ShouldReturnNegativeValue_When_TheNameIsInvalid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.AreEqual(-1, config.OutputSidePacketIndex("unknown"));
}
}
public void OutputStreamToNode_ShouldReturnNegativeValue_When_TheNameIsInvalid()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
Assert.AreEqual(-1, config.OutputStreamToNode("unknown"));
}
}
public void Ctor_ShouldInstantiateValidatedGraphConfig()
{
Assert.DoesNotThrow(() =>
{
var config = new ValidatedGraphConfig();
config.Dispose();
});
}
public void IsExternalSidePacket_ShouldReturnFalse_When_TheSidePacketIsInternal()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
Assert.False(config.IsExternalSidePacket("int_packet"));
}
}
public void RegisteredStreamTypeName_ShouldReturnInvalidArgumentError_When_TheStreamDoesNotExist()
{
using (var config = new ValidatedGraphConfig())
{
using (var statusOrString = config.RegisteredStreamTypeName("in"))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, statusOrString.status.Code());
}
}
}
public void RegisteredSidePacketTypeName_ShouldReturnUnknownError_When_TheSidePacketTypeCannotBeDetermined()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PoseLandmarkConfigText)).AssertOk();
using (var statusOrString = config.RegisteredSidePacketTypeName("model_complexity"))
{
Assert.AreEqual(Status.StatusCode.Unknown, statusOrString.status.Code());
}
}
}
public void Initialize_ShouldReturnOk_When_CalledWithValidGraphType()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize("SwitchContainer"))
{
Assert.True(status.Ok());
}
Assert.True(config.Initialized());
}
}
public void RegisteredStreamTypeName_ShouldReturnUnknownError_When_TheStreamTypeCannotBeDetermined()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
using (var statusOrString = config.RegisteredStreamTypeName("in"))
{
Assert.AreEqual(Status.StatusCode.Unknown, statusOrString.status.Code());
}
}
}
public void Initialize_ShouldReturnOk_When_CalledWithConfig()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)))
{
Assert.True(status.Ok());
}
Assert.True(config.Initialized());
}
}
public void Initialize_ShouldReturnInternalError_When_CalledWithInvalidGraphType()
{
using (var config = new ValidatedGraphConfig())
{
using (var status = config.Initialize("InvalidSubgraph"))
{
Assert.AreEqual(Status.StatusCode.NotFound, status.Code());
}
Assert.False(config.Initialized());
}
}
public void Config_ShouldReturnTheCanonicalizedConfig_When_TheConfigIsPoseLandmarkConfig()
{
using (var config = new ValidatedGraphConfig())
{
var originalConfig = CalculatorGraphConfig.Parser.ParseFromTextFormat(_PoseLandmarkConfigText);
config.Initialize(originalConfig).AssertOk();
var canonicalizedConfig = config.Config();
Assert.AreEqual(251, originalConfig.CalculateSize());
Assert.AreEqual(26514, canonicalizedConfig.CalculateSize());
}
}
public void ValidateRequiredSidePackets_ShouldReturnOk_When_AllTheSidePacketsAreOptional_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PoseLandmarkConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheConfigRequiresSidePackets_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ObjectronConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
}
}
}
}
public void ValidateRequiredSidePackets_ShouldReturnOk_When_TheConfigDoesNotRequireSidePackets_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.True(status.Ok());
}
}
}
}
