744 lines
24 KiB
C#
744 lines
24 KiB
C#
// Copyright (c) 2021 homuler
|
|
//
|
|
// Use of this source code is governed by an MIT-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://opensource.org/licenses/MIT.
|
|
|
|
using NUnit.Framework;
|
|
using System.Linq;
|
|
|
|
namespace Mediapipe.Tests
|
|
{
|
|
public class ValidatedGraphConfigTest
|
|
{
|
|
private const string _PassThroughConfigText = @"
|
|
node {
|
|
calculator: ""PassThroughCalculator""
|
|
input_stream: ""in""
|
|
output_stream: ""out1""
|
|
}
|
|
node {
|
|
calculator: ""PassThroughCalculator""
|
|
input_stream: ""out1""
|
|
output_stream: ""out""
|
|
}
|
|
input_stream: ""in""
|
|
output_stream: ""out""
|
|
";
|
|
|
|
private const string _FlowLimiterConfigText = @"
|
|
input_stream: ""input_video""
|
|
input_stream: ""output""
|
|
|
|
node {
|
|
calculator: ""FlowLimiterCalculator""
|
|
input_stream: ""input_video""
|
|
input_stream: ""FINISHED:output""
|
|
input_stream_info: {
|
|
tag_index: ""FINISHED""
|
|
back_edge: true
|
|
}
|
|
input_side_packet: ""MAX_IN_FLIGHT:max_in_flight""
|
|
input_side_packet: ""OPTIONS:flow_limiter_calculator_options""
|
|
output_stream: ""throttled_input_video""
|
|
}
|
|
";
|
|
|
|
private const string _ImageTransformationConfigText = @"
|
|
input_stream: ""input_video""
|
|
|
|
node: {
|
|
calculator: ""ImageTransformationCalculator""
|
|
input_stream: ""IMAGE:input_video""
|
|
input_side_packet: ""ROTATION_DEGREES:input_rotation""
|
|
input_side_packet: ""FLIP_HORIZONTALLY:input_horizontally_flipped""
|
|
input_side_packet: ""FLIP_VERTICALLY:input_vertically_flipped""
|
|
output_stream: ""IMAGE:transformed_input_video""
|
|
}
|
|
";
|
|
|
|
private const string _ConstantSidePacketConfigText = @"
|
|
node {
|
|
calculator: ""ConstantSidePacketCalculator""
|
|
output_side_packet: ""PACKET:0:int_packet""
|
|
output_side_packet: ""PACKET:1:float_packet""
|
|
output_side_packet: ""PACKET:2:bool_packet""
|
|
output_side_packet: ""PACKET:3:string_packet""
|
|
options: {
|
|
[mediapipe.ConstantSidePacketCalculatorOptions.ext]: {
|
|
packet { int_value: 256 }
|
|
packet { float_value: 0.5f }
|
|
packet { bool_value: false }
|
|
packet { string_value: ""string"" }
|
|
}
|
|
}
|
|
}
|
|
";
|
|
|
|
private const string _FaceDetectionShortRangeConfigText = @"
|
|
input_stream: ""image""
|
|
input_stream: ""roi""
|
|
|
|
node {
|
|
calculator: ""FaceDetectionShortRange""
|
|
input_stream: ""IMAGE:image""
|
|
input_stream: ""ROI:roi""
|
|
output_stream: ""DETECTIONS:detections""
|
|
}
|
|
";
|
|
|
|
#region Constructor
|
|
[Test]
|
|
public void Ctor_ShouldInstantiateValidatedGraphConfig()
|
|
{
|
|
Assert.DoesNotThrow(() =>
|
|
{
|
|
var config = new ValidatedGraphConfig();
|
|
config.Dispose();
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region #isDisposed
|
|
[Test]
|
|
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.False(config.isDisposed);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
|
|
{
|
|
var config = new ValidatedGraphConfig();
|
|
config.Dispose();
|
|
|
|
Assert.True(config.isDisposed);
|
|
}
|
|
#endregion
|
|
|
|
#region #Initialize
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region #ValidateRequiredSidePackets
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnOk_When_TheConfigDoesNotRequireSidePackets_And_SidePacketIsNotEmpty()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
sidePacket.Emplace("in", new IntPacket(0));
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.True(status.Ok());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnOk_When_AllTheSidePacketsAreOptional_And_SidePacketIsEmpty()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.True(status.Ok());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheConfigRequiresSidePackets_And_SidePacketIsEmpty()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_AllTheRequiredSidePacketsAreNotGiven()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
|
|
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheSidePacketValuesAreWrong()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
|
|
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
|
|
sidePacket.Emplace("input_rotation", new StringPacket("0"));
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateRequiredSidePackets_ShouldReturnOk_When_AllTheRequiredSidePacketsAreGiven()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ImageTransformationConfigText)).AssertOk();
|
|
using (var sidePacket = new SidePacket())
|
|
{
|
|
sidePacket.Emplace("input_horizontally_flipped", new BoolPacket(false));
|
|
sidePacket.Emplace("input_vertically_flipped", new BoolPacket(true));
|
|
sidePacket.Emplace("input_rotation", new IntPacket(0));
|
|
using (var status = config.ValidateRequiredSidePackets(sidePacket))
|
|
{
|
|
Assert.True(status.Ok());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Config
|
|
[Test]
|
|
public void Config_ShouldReturnAnEmptyConfig_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
var canonicalizedConfig = config.Config();
|
|
Assert.AreEqual(canonicalizedConfig.CalculateSize(), 0);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Config_ShouldReturnTheCanonicalizedConfig_When_TheConfigIsPassThroughConfig()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
var originalConfig = CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText);
|
|
config.Initialize(originalConfig).AssertOk();
|
|
var canonicalizedConfig = config.Config();
|
|
|
|
Assert.AreEqual(originalConfig.Node, canonicalizedConfig.Node);
|
|
Assert.AreEqual(originalConfig.InputStream, canonicalizedConfig.InputStream);
|
|
Assert.AreEqual(originalConfig.OutputStream, canonicalizedConfig.OutputStream);
|
|
Assert.IsEmpty(originalConfig.Executor);
|
|
Assert.AreEqual(1, canonicalizedConfig.Executor.Count);
|
|
Assert.AreEqual(0, canonicalizedConfig.Executor[0].CalculateSize());
|
|
|
|
Assert.AreEqual(80, originalConfig.CalculateSize());
|
|
Assert.AreEqual(82, canonicalizedConfig.CalculateSize());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Config_ShouldReturnTheCanonicalizedConfig_When_TheConfigIsFaceDetectionShortRangeCommonConfig()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
var originalConfig = CalculatorGraphConfig.Parser.ParseFromTextFormat(_FaceDetectionShortRangeConfigText);
|
|
config.Initialize(originalConfig).AssertOk();
|
|
var canonicalizedConfig = config.Config();
|
|
|
|
Assert.AreEqual(84, originalConfig.CalculateSize());
|
|
// 2167 on CPU, 2166 on GPU
|
|
Assert.AreEqual(2166, canonicalizedConfig.CalculateSize(), 1);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region InputStreamInfos
|
|
[Test]
|
|
public void InputStreamInfos_ShouldReturnEmptyList_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.IsEmpty(config.InputStreamInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void InputStreamInfos_ShouldReturnEmptyList_When_NoInputStreamExists()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
|
|
Assert.IsEmpty(config.InputStreamInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void InputStreamInfos_ShouldReturnEdgeInfoList_When_InputStreamsExist()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
var inputStreamInfos = config.InputStreamInfos();
|
|
|
|
Assert.AreEqual(inputStreamInfos.Count, 2);
|
|
|
|
var inStream = inputStreamInfos.First((edgeInfo) => edgeInfo.name == "in");
|
|
Assert.AreEqual(0, inStream.upstream);
|
|
Assert.AreEqual(NodeType.Calculator, inStream.parentNode.type);
|
|
Assert.AreEqual(0, inStream.parentNode.index);
|
|
Assert.False(inStream.backEdge);
|
|
|
|
var out1Stream = inputStreamInfos.First((edgeInfo) => edgeInfo.name == "out1");
|
|
Assert.AreEqual(1, out1Stream.upstream);
|
|
Assert.AreEqual(NodeType.Calculator, out1Stream.parentNode.type);
|
|
Assert.AreEqual(1, out1Stream.parentNode.index);
|
|
Assert.False(out1Stream.backEdge);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OutputStreamInfos
|
|
[Test]
|
|
public void OutputStreamInfos_ShouldReturnEmptyList_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.IsEmpty(config.OutputStreamInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region InputSidePacketInfos
|
|
[Test]
|
|
public void InputSidePacketInfos_ShouldReturnEmptyList_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.IsEmpty(config.InputSidePacketInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void InputSidePacketInfos_ShouldReturnEmptyList_When_NoInputSidePacketExists()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.IsEmpty(config.InputSidePacketInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void InputSidePacketInfos_ShouldReturnEdgeInfoList_When_InputSidePacketsExist()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
|
|
var inputSidePacketInfos = config.InputSidePacketInfos();
|
|
|
|
Assert.True(inputSidePacketInfos.Count >= 2);
|
|
|
|
var maxInFlightPacket = inputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "max_in_flight");
|
|
Assert.AreEqual(-1, maxInFlightPacket.upstream);
|
|
Assert.AreEqual(NodeType.Calculator, maxInFlightPacket.parentNode.type);
|
|
Assert.False(maxInFlightPacket.backEdge);
|
|
|
|
var flowLimiterCalculatorOptionsPacket = inputSidePacketInfos.First((edgeInfo) => edgeInfo.name == "flow_limiter_calculator_options");
|
|
Assert.AreEqual(-1, flowLimiterCalculatorOptionsPacket.upstream);
|
|
Assert.AreEqual(NodeType.Calculator, flowLimiterCalculatorOptionsPacket.parentNode.type);
|
|
Assert.False(flowLimiterCalculatorOptionsPacket.backEdge);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OutputSidePacketInfos
|
|
[Test]
|
|
public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.IsEmpty(config.OutputSidePacketInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputSidePacketInfos_ShouldReturnEmptyList_When_NoOutputSidePacketExists()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.IsEmpty(config.OutputSidePacketInfos());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OutputStreamIndex
|
|
[Test]
|
|
public void OutputStreamIndex_ShouldReturnNegativeValue_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.AreEqual(-1, config.OutputStreamIndex(""));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputStreamIndex_ShouldReturnNegativeValue_When_TheNameIsInvalid()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.AreEqual(-1, config.OutputStreamIndex("unknown"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputStreamIndex_ShouldReturnIndex_When_TheNameIsValid()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.AreEqual(2, config.OutputStreamIndex("out"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputStreamIndex_ShouldReturnIndex_When_TheStreamIsNotPublic()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.AreEqual(1, config.OutputStreamIndex("out1"));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OutputSidePacketIndex
|
|
[Test]
|
|
public void OutputSidePacketIndex_ShouldReturnNegativeValue_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.AreEqual(-1, config.OutputSidePacketIndex(""));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputSidePacketIndex_ShouldReturnNegativeValue_When_TheNameIsInvalid()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
|
|
Assert.AreEqual(-1, config.OutputSidePacketIndex("unknown"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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"));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region OutputStreamToNode
|
|
[Test]
|
|
public void OutputStreamToNode_ShouldReturnNegativeValue_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.AreEqual(-1, config.OutputStreamToNode(""));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputStreamToNode_ShouldReturnNegativeValue_When_TheNameIsInvalid()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.AreEqual(-1, config.OutputStreamToNode("unknown"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OutputStreamToNode_ShouldReturnIndex_When_TheNameIsValid()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.AreEqual(0, config.OutputStreamToNode("out1"));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region RegisteredSidePacketTypeName
|
|
[Test]
|
|
public void RegisteredSidePacketTypeName_ShouldReturnInvalidArgumentError_When_TheSidePacketDoesNotExist()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
using (var statusOrString = config.RegisteredSidePacketTypeName("max_in_flight"))
|
|
{
|
|
Assert.AreEqual(Status.StatusCode.InvalidArgument, statusOrString.status.Code());
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RegisteredSidePacketTypeName_ShouldReturnUnknownError_When_TheSidePacketTypeCannotBeDetermined()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
|
|
using (var statusOrString = config.RegisteredSidePacketTypeName("max_in_flight"))
|
|
{
|
|
Assert.AreEqual(Status.StatusCode.Unknown, statusOrString.status.Code());
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region RegisteredStreamTypeName
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Package
|
|
[Test]
|
|
public void Package_ShouldReturnNull_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.IsNull(config.Package());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Package_ShouldReturnNull_When_TheNamespaceIsNotSet()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_PassThroughConfigText)).AssertOk();
|
|
Assert.IsNull(config.Package());
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region IsReservedExecutorName
|
|
[Test]
|
|
public void IsReservedExecutorName_ShouldReturnFalse_When_TheNameIsNotReserved()
|
|
{
|
|
Assert.False(ValidatedGraphConfig.IsReservedExecutorName("unknown"));
|
|
}
|
|
|
|
[Test]
|
|
public void IsReservedExecutorName_ShouldReturnFalse_When_TheNameIsReserved()
|
|
{
|
|
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("default"));
|
|
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("gpu"));
|
|
Assert.True(ValidatedGraphConfig.IsReservedExecutorName("__gpu"));
|
|
}
|
|
#endregion
|
|
|
|
#region IsExternalSidePacket
|
|
[Test]
|
|
public void IsExternalSidePacket_ShouldReturnFalse_When_NotInitialized()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
Assert.False(config.IsExternalSidePacket("max_in_flight"));
|
|
}
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void IsExternalSidePacket_ShouldReturnFalse_When_TheSidePacketIsInternal()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ConstantSidePacketConfigText)).AssertOk();
|
|
Assert.False(config.IsExternalSidePacket("int_packet"));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void IsExternalSidePacket_ShouldReturnTrue_When_TheSidePacketIsExternal()
|
|
{
|
|
using (var config = new ValidatedGraphConfig())
|
|
{
|
|
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_FlowLimiterConfigText)).AssertOk();
|
|
Assert.True(config.IsExternalSidePacket("max_in_flight"));
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|