public void ValueTest()
{
var item = new TestSwitch();
item.SwitchValue = "1";
item.SwitchValue = "0";
item.SwitchValue = "-1";
}
public void DescriptionTest()
{
var item = new TestSwitch("Desc");
Assert.Equal("Desc", item.Description);
item = new TestSwitch();
Assert.Equal("", item.Description);
}
public void SwitchStandAlone()
{
// SwitchNoDefaultSimple switch case scenario
// Test case description:
// Simple switch case scenario
TestSwitch <int> switchAct = new TestSwitch <int>
{
DisplayName = "standAloneSwitch",
Expression = 23
};
switchAct.AddCase(12, new TestProductWriteline {
Text = "in case 12"
});
switchAct.AddCase(23, new TestProductWriteline {
Text = "in case 23"
});
switchAct.AddCase(123, new TestProductWriteline {
Text = "in case 123"
});
switchAct.AddCase(234, new TestProductWriteline {
Text = "in case 234"
});
switchAct.Hints.Add(1);
TestRuntime.RunAndValidateWorkflow(switchAct);
}
public void SwitchDefault()
{
// SwitchDefaultSimple switch case default
// Test case description:
// Simple switch case default
TestSwitch <int> switchAct = new TestSwitch <int>();
Variable <int> switchExpression = new Variable <int>("switchExpression", 444);
TestSequence seq = new TestSequence();
seq.Variables.Add(switchExpression);
switchAct.ExpressionVariable = switchExpression;
switchAct.AddCase(12, new TestProductWriteline {
Text = "in case 12"
});
switchAct.AddCase(23, new TestProductWriteline {
Text = "in case 23"
});
switchAct.AddCase(123, new TestProductWriteline {
Text = "in case 123"
});
switchAct.AddCase(234, new TestProductWriteline {
Text = "in case 234"
});
switchAct.Default = new TestProductWriteline {
Text = "in default"
};
switchAct.Hints.Add(-1);
seq.Activities.Add(switchAct);
TestRuntime.RunAndValidateWorkflow(seq);
}
public void DescriptionTest()
{
var item = new TestSwitch("Desc");
Assert.Equal("Desc", item.Description);
item = new TestSwitch();
Assert.Equal("", item.Description);
}
public void ValueTest()
{
var item = new TestSwitch();
item.SwitchValue = "1";
item.SwitchValue = "0";
item.SwitchValue = "-1";
}
public void EmptySwitch()
{
TestSwitch <string> switchAct = new TestSwitch <string>();
switchAct.Hints.Add(-1);
switchAct.Expression = "";
TestRuntime.RunAndValidateWorkflow(switchAct);
}
private static void Main()
{
TestSwitch test = new TestSwitch();
test.SelectLanguage();
Console.ReadKey();
}
public void PruneTest()
{
var strongSwitch = new TestSwitch();
var weakSwitch = new WeakReference(new TestSwitch());
Assert.True(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
Assert.False(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
}
public void PruneTest()
{
var strongSwitch = new TestSwitch();
var weakSwitch = PruneMakeRef();
GC.Collect(2);
Trace.Refresh();
Assert.False(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
}
public void PruneTest()
{
var strongSwitch = new TestSwitch();
var weakSwitch = new WeakReference(new TestSwitch());
Assert.True(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
Assert.False(weakSwitch.IsAlive);
GC.Collect(2);
Trace.Refresh();
}
public void Return_No_Consumption_If_Switch_Does_Not_Match()
{
// arrange
var switch0 = new TestSwitch(new Parser("a"), 't', "test", (o, strings) => { });
var info = new IterationInfo("-x a b c d e d f g".Split(' '));
// act
var result = switch0.CanConsume("", info);
// assert
result.NumConsumed.Should().Be(0);
}
public void Return_A_Human_Friendly_ToString()
{
// arrange
var switch0 = new TestSwitch(new Parser("a"), 't', "test", (o, strings) => { });
var switch1 = new TestSwitch(new Parser("a"), null, "test", (o, strings) => { });
var switch2 = new TestSwitch(new Parser("a"), 't', null, (o, strings) => { });
// act
// assert
switch0.ToString().Should().Be($"-t, --test");
switch1.ToString().Should().Be($"--test");
switch2.ToString().Should().Be($"-t");
}
public void SwitchEvaluatingNullCase()
{
TestSwitch <string> sw = new TestSwitch <string>();
string s = null;
sw.AddCase(null, new TestWriteLine()
{
Message = "Hi"
});
sw.Hints.Add(0);
sw.Expression = s;
TestRuntime.RunAndValidateWorkflow(sw);
}
public void SwitchWithEmptyCase()
{
TestSwitch <string> switchAct = new TestSwitch <string>();
switchAct.AddCase("12", new TestProductWriteline {
Text = "in case 12"
});
switchAct.AddCase("", new TestProductWriteline {
Text = "in case 12"
});
switchAct.Hints.Add(1);
switchAct.Expression = "";
TestRuntime.RunAndValidateWorkflow(switchAct);
}
public void ThrowExceptionInCase()
{
TestSwitch <float> switchAct = new TestSwitch <float>();
switchAct.DisplayName = "Switch Act";
switchAct.AddCase(123, new TestThrow <InvalidCastException>("THrow invalid cast")
{
ExpectedOutcome = Outcome.UncaughtException(typeof(InvalidCastException))
});
switchAct.Expression = 123;
switchAct.Hints.Add(0);
TestRuntime.RunAndValidateAbortedException(switchAct, typeof(InvalidCastException), new Dictionary <string, string>());
}
public void SwitchWithNoExpressionSet()
{
TestSwitch <string> switchAct = new TestSwitch <string>();
switchAct.Hints.Add(-1);
switchAct.AddCase("1", new TestProductWriteline {
Text = "in case 1"
});
((CoreWf.Statements.Switch <string>)switchAct.ProductActivity).Expression = null;
string exceptionMessage = string.Format(ErrorStrings.RequiredArgumentValueNotSupplied, "Expression");
TestRuntime.ValidateWorkflowErrors(switchAct, new List <TestConstraintViolation>(), typeof(ArgumentException), exceptionMessage);
}
public void ThrowExcInCaseWhichWontExecute()
{
TestSwitch <float> switchAct = new TestSwitch <float>();
switchAct.AddCase(345678, new TestWriteLine("Writeline")
{
Message = "345678"
});
switchAct.AddCase(123, new TestThrow <InvalidCastException>("Throw invalid cast"));
switchAct.Expression = 345678;
switchAct.Hints.Add(0);
TestRuntime.RunAndValidateWorkflow(switchAct);
}
public void Return_No_Consumption_If_Minimum_Number_Of_Values_Are_Not_Met()
{
// arrange
var switch0 = new TestSwitch(new Parser("a"), 't', "test", (o, strings) => { })
{
MinRequired = 50
};
var info = new IterationInfo("-t a b c d e d f g".Split(' '));
// act
var result = switch0.CanConsume("", info);
// assert
result.NumConsumed.Should().Be(0);
}
public void CompositeProcedurals()
{
Variable <bool> cond = new Variable <bool> {
Default = true
};
Variable <string> value = new Variable <string> {
Default = "Apple"
};
DelegateInArgument <string> arg = new DelegateInArgument <string> {
Name = "Apple"
};
string[] values = { "a", "b" };
TestSwitch <string> switchAct = new TestSwitch <string>
{
ExpressionVariable = value
};
switchAct.AddCase("Apple", new TestWriteLine("Apple", "this is an apple"));
switchAct.AddCase("Orange", new TestWriteLine("Orange", "this is an orange"));
switchAct.Hints.Add(0);
TestIf ifAct = new TestIf(HintThenOrElse.Then)
{
ConditionVariable = cond,
ThenActivity = new TestWriteLine("W", "Yes thats true"),
ElseActivity = new TestWriteLine("W", "No thats not true")
};
TestForEach <string> forEachAct = new TestForEach <string>
{
Values = values,
CurrentVariable = arg,
HintIterationCount = 2,
Body = new TestWriteLine {
DisplayName = "w1", MessageExpression = context => arg.Get(context), HintMessageList = { "a", "b" }
}
};
TestSequence seq = new TestSequence
{
Variables = { cond, value },
Activities = { switchAct, ifAct, forEachAct }
};
TestRuntime.RunAndValidateWorkflow(seq);
}
public void ThrowExceptionInExpression()
{
TestSwitch <int> switchAct = new TestSwitch <int>();
Variable <int> temp = VariableHelper.CreateInitialized <int>("temp", 3);
TestSequence seq = new TestSequence();
seq.Activities.Add(switchAct);
seq.Variables.Add(temp);
switchAct.AddCase(123, new TestSequence("Seq"));
switchAct.ExpressionExpression = (env) => (int)(1 / (temp.Get(env) - 3));
switchAct.Hints.Add(-1);
switchAct.ExpectedOutcome = Outcome.UncaughtException(typeof(DivideByZeroException));
TestRuntime.RunAndValidateAbortedException(seq, typeof(DivideByZeroException), new Dictionary <string, string>());
}
public void Indicate_It_Can_Consume_The_Max_Allowed_When_Current_Arg_Is_A_Match()
{
// arrange
var switch0 = new TestSwitch(new Parser("a"), 't', "test", (o, strings) => { })
{
MaxAllowed = 3
};
var info = new IterationInfo("-t a b c d e d f g".Split(' '));
// act
// assert
var result = switch0.CanConsume("", info);
result.NumConsumed.Should().Be(3);
result.Info.Current.Should().Be("c");
}
public void SwitchThrowInDefault()
{
TestSwitch <float> switchAct = new TestSwitch <float>();
switchAct.AddCase(123, new TestThrow <InvalidCastException>("Throw invalid cast")
{
ExpectedOutcome = Outcome.None
});
switchAct.Default = new TestThrow <TestCaseException>("Op cancelled")
{
ExpectedOutcome = Outcome.UncaughtException(typeof(TestCaseException))
};
switchAct.Expression = 456;
switchAct.Hints.Add(-1);
TestRuntime.RunAndValidateAbortedException(switchAct, typeof(TestCaseException), new Dictionary <string, string>());
}
public void SwitchWithEnums()
{
TestSwitch <OrderStatus> order = new TestSwitch <OrderStatus>();
order.AddCase(OrderStatus.NewOrder, new TestWriteLine("We have received a new order")
{
Message = "New Order"
});
order.AddCase(OrderStatus.Processing, new TestWriteLine("Order is in processing state")
{
Message = "Processing"
});
order.AddCase(OrderStatus.Shipped, new TestSequence {
Activities = { new TestWriteLine("Order is shipped to you")
{
Message = "Order shipped"
} }
});
order.Hints.Add(0);
order.Hints.Add(1);
order.Hints.Add(2);
List <OrderStatus> values = new List <OrderStatus>()
{
OrderStatus.NewOrder, OrderStatus.Processing, OrderStatus.Shipped
};
DelegateInArgument <OrderStatus> var = new DelegateInArgument <OrderStatus> {
Name = "var"
};
TestForEach <OrderStatus> forEachAct = new TestForEach <OrderStatus>("ForEachAct")
{
Values = values,
CurrentVariable = var
};
TestSequence seq = new TestSequence("Seq in For Each");
seq.Activities.Add(order);
forEachAct.Body = seq;
order.ExpressionExpression = (env) => (OrderStatus)var.Get(env);
forEachAct.HintIterationCount = 3;
TestRuntime.RunAndValidateWorkflow(forEachAct);
}
public void Return_True_When_Current_Arg_Matches()
{
// arrange
var switch0 = new TestSwitch(new Parser("a"), 't', "test", (o, strings) => { });
var switch1 = new TestSwitch(new Parser("a"), null, "test", (o, strings) => { });
var switch2 = new TestSwitch(new Parser("a"), 't', null, (o, strings) => { });
// act
// assert
switch0.IsLetterMatch(new IterationInfo("-t".Split(' '), 0)).Should().BeTrue();
switch0.IsWordMatch(new IterationInfo("--test".Split(' '), 0)).Should().BeTrue();
switch1.IsLetterMatch(new IterationInfo("-t".Split(' '), 0)).Should().BeFalse();
switch1.IsWordMatch(new IterationInfo("--test".Split(' '), 0)).Should().BeTrue();
switch2.IsLetterMatch(new IterationInfo("-t".Split(' '), 0)).Should().BeTrue();
switch2.IsWordMatch(new IterationInfo("--test".Split(' '), 0)).Should().BeFalse();
}
public Switch(FlightControlSystem fcs, XmlElement element)
: base(fcs, element)
{
string value;
TestSwitch current_test;
Bind(element); // Bind() this component here in case it is used in its own
// definition for a sample-and-hold
XmlElement test_element = element.FindElement("default");
if (test_element != null)
{
current_test = new TestSwitch();
value = test_element.GetAttribute("value");
current_test.SetTestValue(value, name, propertyManager);
current_test.Default = true;
double tmp;
if (delay > 0 && double.TryParse(value, out tmp))
{ // If there is a delay, initialize the
for (int i = 0; i < delay - 1; i++)
{ // delay buffer to the default value
output_array[i] = tmp; // for the switch if that value is a number.
}
}
tests.Add(current_test);
}
var nodeList = element.GetElementsByTagName("test");
foreach (var elem in nodeList)
{
if (elem is XmlElement)
{
test_element = elem as XmlElement;
current_test = new TestSwitch();
current_test.condition = new Condition(test_element, propertyManager);
value = test_element.GetAttribute("value");
current_test.SetTestValue(value, name, propertyManager);
tests.Add(current_test);
}
}
Debug(0);
}
public void SwitchWithWorkflowInvoker()
{
TestSwitch <int> switchAct = new TestSwitch <int>();
switchAct.AddCase(12, new TestProductWriteline {
Text = "in case 12"
});
switchAct.AddCase(23, new TestProductWriteline {
Text = "in case 23"
});
switchAct.AddCase(123, new TestProductWriteline {
Text = "in case 123"
});
switchAct.AddCase(234, new TestProductWriteline {
Text = "in case 234"
});
switchAct.Hints.Add(2);
Dictionary <string, object> dic = new Dictionary <string, object>();
dic.Add("Expression", 123);
TestRuntime.RunAndValidateUsingWorkflowInvoker(switchAct, dic, null, null);
}
public void ThrowWithCaseInfinity()
{
TestSwitch <float> switchAct = new TestSwitch <float>();
Variable <float> temp = VariableHelper.CreateInitialized <float>("temp", 3);
float temp1 = 1;
float temp2 = 0;
TestSequence seq = new TestSequence();
seq.Activities.Add(switchAct);
seq.Variables.Add(temp);
switchAct.AddCase(123, new TestWriteLine("Seq")
{
Message = ""
});
switchAct.AddCase(temp1 / temp2, new TestWriteLine()
{
Message = "Infinity is the value"
});
switchAct.ExpressionExpression = (env) => (float)(1 / (temp.Get(env) - 3));
switchAct.Hints.Add(1);
TestRuntime.RunAndValidateWorkflow(seq);
}
public void DifferentArguments()
{
//Testing Different argument types for Switch.Expression
// DelegateInArgument
// DelegateOutArgument
// Activity<T>
// Variable<T> , Activity<T> and Expression is already implemented.
DelegateInArgument <string> delegateInArgument = new DelegateInArgument <string>("Input");
DelegateOutArgument <string> delegateOutArgument = new DelegateOutArgument <string>("Output");
TestCustomActivity <InvokeFunc <string, string> > invokeFunc = TestCustomActivity <InvokeFunc <string, string> > .CreateFromProduct(
new InvokeFunc <string, string>
{
Argument = "PassedInValue",
Func = new ActivityFunc <string, string>
{
Argument = delegateInArgument,
Result = delegateOutArgument,
Handler = new CoreWf.Statements.Sequence
{
DisplayName = "Sequence1",
Activities =
{
new CoreWf.Statements.Switch <string>
{
DisplayName = "Switch1",
Expression = delegateInArgument,
Cases =
{
{
"PassedInValue",
new CoreWf.Statements.Assign <string>
{
DisplayName = "Assign1",
To = delegateOutArgument,
Value = "OutValue",
}
},
},
Default = new Test.Common.TestObjects.CustomActivities.WriteLine{
DisplayName = "W1", Message = "This should not be printed"
},
},
new CoreWf.Statements.Switch <string>
{
DisplayName = "Switch2",
Expression = delegateOutArgument,
Cases =
{
{
"OutValue",
new Test.Common.TestObjects.CustomActivities.WriteLine {
DisplayName = "W2", Message = delegateOutArgument
}
}
},
Default = new Test.Common.TestObjects.CustomActivities.WriteLine{
DisplayName = "W3", Message = "This should not be printed"
},
}
}
}
}
}
);
TestSwitch <string> switch1 = new TestSwitch <string>
{
DisplayName = "Switch1",
Hints = { 0 }
};
switch1.AddCase("PassedInValue", new TestAssign <string> {
DisplayName = "Assign1"
});
switch1.Default = new TestWriteLine {
DisplayName = "W1"
};
TestSwitch <string> switch2 = new TestSwitch <string>
{
DisplayName = "Switch2",
Hints = { 0 }
};
switch2.AddCase("OutValue", new TestWriteLine {
DisplayName = "W2", HintMessage = "OutValue"
});
switch2.Default = new TestWriteLine {
DisplayName = "W3"
};
TestSequence sequenceForTracing = new TestSequence
{
DisplayName = "Sequence1",
Activities =
{
switch1,
switch2,
}
};
invokeFunc.CustomActivityTraces.Add(sequenceForTracing.GetExpectedTrace().Trace);
TestRuntime.RunAndValidateWorkflow(invokeFunc);
}
public Switch(FlightControlSystem fcs, XmlElement element)
: base(fcs, element)
{
string value, logic;
TestSwitch current_test;
foreach (XmlNode currentNode in element.ChildNodes)
{
if (currentNode.NodeType == XmlNodeType.Element)
{
XmlElement currentElement = (XmlElement)currentNode;
current_test = new TestSwitch();
if (currentElement.LocalName.Equals("default"))
{
tests.Add(current_test);
current_test.Logic = eLogic.eDefault;
}
else if (currentElement.LocalName.Equals("test"))
{
tests.Add(current_test);
logic = currentElement.GetAttribute("logic");
if (logic.Equals("OR"))
{
current_test.Logic = eLogic.eOR;
}
else if (logic.Equals("AND"))
{
current_test.Logic = eLogic.eAND;
}
else if (logic.Length == 0)
{
current_test.Logic = eLogic.eAND; // default
}
else
{ // error
if (log.IsErrorEnabled)
{
log.Error("Unrecognized LOGIC token " + logic + " in switch component: " + name);
}
}
ReaderText rtxt = new ReaderText(new StringReader(currentElement.InnerText));
while (rtxt.Done)
{
string tmp = rtxt.ReadLine().Trim();
if (tmp.Length != 0)
{
current_test.conditions.Add(new Condition(tmp, propertyManager));
}
}
foreach (XmlNode currentNode2 in currentElement.ChildNodes)
{
if (currentNode2.NodeType == XmlNodeType.Element)
{
current_test.conditions.Add(new Condition(currentNode2 as XmlElement, propertyManager));
}
}
}
if (!currentElement.LocalName.Equals("output"))
{
value = currentElement.GetAttribute("value");
if (value.Length == 0)
{
if (log.IsErrorEnabled)
{
log.Error("No VALUE supplied for switch component: " + name);
}
}
else
{
Match match = testRegex.Match(value);
if (match.Success)
{
if (match.Groups["prop"].Value == "") // if true (and execution falls into this block), "value" is a number.
{
current_test.OutputVal = double.Parse(value, FormatHelper.numberFormatInfo);
}
else
{
// "value" must be a property if execution passes to here.
if (value[0] == '-')
{
current_test.sign = -1.0;
value = value.Remove(0, 1);
}
else
{
current_test.sign = 1.0;
}
current_test.OutputProp = propertyManager.GetPropertyNode(value);
}
}
}
}
}
}
base.Bind();
}
