public void TestStringValue1Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
StringUnit lexemValue = null;
//-----------------------------------------------------------------
sequence.DecodeLineIgnoreCaseSymbols = true;
sequence.Error(x => error = x);
//-----------------------------------------------------------------
sequence.Add(new StringUnit("lexem").Action(unit => lexemValue = unit));
//-----------------------------------------------------------------
var result = sequence.DecodeLine(" Lexem ");
Assert.IsTrue(result);
Assert.IsTrue(error == null);
Assert.IsTrue(lexemValue.Value == "Lexem");
Assert.IsTrue(lexemValue.StartPosition == 5);
}
public void TestValue3Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
ValueUnit value = null;
//-----------------------------------------------------------------
sequence
.Add(new ValueUnit().Action(x => value = x))
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("value");
Assert.IsTrue(result);
Assert.IsTrue(error == null);
Assert.IsTrue(value.Available);
Assert.IsTrue(value.StartPosition == 0);
Assert.IsTrue(string.Equals(value.Value, "value", StringComparison.OrdinalIgnoreCase));
}
public void TestAddAndIgnoreCaseSymbols1Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
//-----------------------------------------------------------------
sequence
.Add(
new StringUnit("lexem").DecodeLineIgnoreCaseSymbols(true),
new StringUnit("xxx").DecodeLineIgnoreCaseSymbols(false)
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexem XXX");
Assert.IsFalse(result);
Assert.IsTrue(error.PositionInLine == 6);
Assert.IsTrue(string.Equals(((StringUnit)error.Unit).OriginalValue, "xxx", StringComparison.OrdinalIgnoreCase));
}
public void Tes2BoardSuccess()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var isSlavingAvailable = false;
var isUserAvailable = false;
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var slavingAction = new Action(() => isSlavingAvailable = true);
var userAction = new Action(() => isUserAvailable = true);
//-----------------------------------------------------------------
sequence
.If(
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction)
);
sequence
.Else(
new ValueUnit().Action(slotValueAction)
);
sequence.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_SlavingLexemName).Action(slavingAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_UserLexemName).Action(userAction))
);
sequence
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine($"8,12 {_SlavingLexemName}");
Assert.IsTrue(result);
Assert.IsTrue(string.Equals(shelfValue, "8", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(slotValue, "12", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(isSlavingAvailable);
Assert.IsFalse(isUserAvailable);
Assert.IsTrue(error == null);
}
public void TestIfAndActionFailed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isIfAvailable = false;
//-----------------------------------------------------------------
sequence.Error(x => error = x);
//-----------------------------------------------------------------
sequence
.If(new StringUnit("lexem").Action(() => isIfAvailable = true));
//-----------------------------------------------------------------
var result = sequence.DecodeLine("leaem");
Assert.IsFalse(result);
Assert.IsFalse(isIfAvailable);
Assert.IsTrue(error.PositionInLine == 2);
Assert.IsTrue(error.PositionInUnit == 2);
Assert.IsTrue(string.Equals(((StringUnit)error.Unit).OriginalValue, "lexem", StringComparison.OrdinalIgnoreCase));
}
public void TestActionsFailed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var action1Raised = false;
var action2Raised = false;
var action3Raised = false;
//-----------------------------------------------------------------
var action1 = new Action(() =>
{
if (!action2Raised && !action3Raised)
{
action1Raised = true;
}
});
var action2 = new Action(() =>
{
action2Raised = true;
});
var action3 = new Action(() =>
{
action3Raised = true;
});
//-----------------------------------------------------------------
sequence
.Add(new StringUnit("lexem")
.Action(action1)
.Action(action2)
.Action(action3)
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexem");
Assert.IsTrue(result);
Assert.IsTrue(action1Raised);
Assert.IsTrue(action2Raised);
Assert.IsTrue(action3Raised);
Assert.IsTrue(error == null);
}
public void TestIfAndAddAndElse1Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isIfAvailable = false;
//-----------------------------------------------------------------
sequence.Error(x => error = x);
//-----------------------------------------------------------------
sequence
.If(new StringUnit("lexem"))
.Add(new StringUnit("ddd").Action(() => isIfAvailable = true));
sequence
.Else(new StringUnit("aaa"));
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexem ddd");
Assert.IsTrue(result);
Assert.IsTrue(isIfAvailable);
Assert.IsTrue(error == null);
}
public void TestAny4Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isLexem1Available = false;
var isLexem2Available = false;
//-----------------------------------------------------------------
sequence
.Any(
new StringUnit("lexem").Action(() => isLexem1Available = true),
new StringUnit("pop").Action(() => isLexem2Available = true)
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("pop lexem");
Assert.IsTrue(result);
Assert.IsTrue(isLexem1Available);
Assert.IsTrue(isLexem2Available);
Assert.IsTrue(error == null);
}
public void TestComplexAdd1Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
//-----------------------------------------------------------------
sequence
.Add(
new StringUnit("lexem"),
new SymbolUnit(' '),
new StringUnit("x"),
new SymbolUnit('('),
new ValueUnit(),
new SymbolUnit(')')
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexemx(222 )");
Assert.IsFalse(result);
Assert.IsTrue(error.PositionInLine == 5);
Assert.IsTrue(error.Unit is SymbolUnit);
}
public void TestIfAndElseMore2Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
//-----------------------------------------------------------------
sequence.Error(x => error = x);
//-----------------------------------------------------------------
var sequenceIf = new Sequence();
sequenceIf
.If(new StringUnit("ll"));
sequenceIf
.Else(new StringUnit("xxx"));
//-----------------------------------------------------------------
sequence
.If(new StringUnit("lexem"))
.Add(sequenceIf);
//-----------------------------------------------------------------
var result = sequence.DecodeLine(" lexem ll ");
Assert.IsTrue(result);
Assert.IsTrue(error == null);
}
public void TestAnyContainer2Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var lexemCount = 0;
var xxxCount = 0;
//-----------------------------------------------------------------
var anyContainerUnit = sequence.CreateAnyContainer();
anyContainerUnit
.Add(2, new StringUnit("lexem").Action(() => ++ lexemCount))
.Add(2, new StringUnit("xxx").Action(() => ++ xxxCount));
sequence
.Add(anyContainerUnit)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("xxx ");
Assert.IsTrue(result);
Assert.IsTrue(lexemCount == 0);
Assert.IsTrue(xxxCount == 1);
Assert.IsTrue(error == null);
}
public void TestComplexAdd1Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var value = "";
//-----------------------------------------------------------------
sequence
.Add(
new StringUnit("lexem"),
new SymbolUnit(' '),
new StringUnit("x"),
new SymbolUnit('('),
new ValueUnit().Action(x => value = x.Value),
new SymbolUnit(')')
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexem x( 222 )");
Assert.IsTrue(result);
Assert.IsTrue(string.Equals(value, "222", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(error == null);
}
private static Exception CreateParseException(UnitError unitError, Lexeme lexeme, IError innerError = null)
{
return new UnitExpressionParseException(Error.From(unitError, lexeme, innerError));
}
public void Test2Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var channelValue = "";
var numberValue = "";
var raniValue = false;
var aniValue = "";
var ani2Value = "";
var arouteDelayValue = "";
var arouteNumValue = "";
var prioValue = "";
var infoValue = "";
var attribValue = "";
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var channelValueAction = new Action <ValueUnit>(x => channelValue = x.Value);
var numberValueAction = new Action <ValueUnit>(x => numberValue = x.Value);
var raniValueAction = new Action(() => raniValue = true);
var aniValueAction = new Action <ValueUnit>(x => aniValue = x.Value);
var ani2ValueAction = new Action <ValueUnit>(x => ani2Value = x.Value);
var arouteDelayValueAction = new Action <ValueUnit>(x => arouteDelayValue = x.Value);
var arouteNumValueAction = new Action <ValueUnit>(x => arouteNumValue = x.Value);
var prioValueAction = new Action <ValueUnit>(x => prioValue = x.Value);
var infoValueAction = new Action <ValueUnit>(x => infoValue = x.Value);
var attribValueAction = new Action <ValueUnit>(x => attribValue = x.Value);
//-----------------------------------------------------------------
sequence
.If(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Else(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("rani").Action(raniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani-"), new ValueUnit().Action(aniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani2-"), new ValueUnit().Action(ani2ValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("aroute"),
new SymbolUnit('('),
new ValueUnit().Action(arouteDelayValueAction),
new SymbolUnit(','),
new ValueUnit().Action(arouteNumValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("prio-"), new ValueUnit().Action(prioValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("info"),
new SymbolUnit('('),
new ValueUnit().Action(infoValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("attr-"), new ValueUnit().Action(attribValueAction))
)
.Error(x => error = x);
//-----------------------------------------------------------------
//-----------------------------------------------------------------
var result = sequence.DecodeLine("loc(6,1,2,3) attr-111 rani aki-23 prio-dd ani2-33");
Assert.IsFalse(result);
Assert.IsTrue(string.IsNullOrEmpty(shelfValue));
Assert.IsTrue(string.IsNullOrEmpty(slotValue));
Assert.IsTrue(string.IsNullOrEmpty(channelValue));
Assert.IsTrue(string.IsNullOrEmpty(numberValue));
Assert.IsFalse(raniValue);
Assert.IsTrue(string.IsNullOrEmpty(aniValue));
Assert.IsTrue(string.IsNullOrEmpty(ani2Value));
Assert.IsTrue(string.IsNullOrEmpty(arouteDelayValue));
Assert.IsTrue(string.IsNullOrEmpty(arouteNumValue));
Assert.IsTrue(string.IsNullOrEmpty(prioValue));
Assert.IsTrue(string.IsNullOrEmpty(infoValue));
Assert.IsTrue(string.IsNullOrEmpty(attribValue));
Assert.IsTrue(error.PositionInLine == 28);
Assert.IsTrue(error.Unit == null);
}
public void Test4Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var channelValue = "";
var numberValue = "";
var raniValue = false;
var aniValue = "";
var ani2Value = "";
var arouteDelayValue = "";
var arouteNumValue = "";
var prioValue = "";
var infoValue = "";
var attribValue = "";
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var channelValueAction = new Action <ValueUnit>(x => channelValue = x.Value);
var numberValueAction = new Action <ValueUnit>(x => numberValue = x.Value);
var raniValueAction = new Action(() => raniValue = true);
var aniValueAction = new Action <ValueUnit>(x => aniValue = x.Value);
var ani2ValueAction = new Action <ValueUnit>(x => ani2Value = x.Value);
var arouteDelayValueAction = new Action <ValueUnit>(x => arouteDelayValue = x.Value);
var arouteNumValueAction = new Action <ValueUnit>(x => arouteNumValue = x.Value);
var prioValueAction = new Action <ValueUnit>(x => prioValue = x.Value);
var infoValueAction = new Action <ValueUnit>(x => infoValue = x.Value);
var attribValueAction = new Action <ValueUnit>(x => attribValue = x.Value);
//-----------------------------------------------------------------
sequence
.If(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Else(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("rani").Action(raniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani-"), new ValueUnit().Action(aniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani2-"), new ValueUnit().Action(ani2ValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("aroute"),
new SymbolUnit('('),
new ValueUnit().Action(arouteDelayValueAction),
new SymbolUnit(','),
new ValueUnit().Action(arouteNumValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("prio-"), new ValueUnit().Action(prioValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("info"),
new SymbolUnit('('),
new ValueUnit().Action(infoValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("attr-"), new ValueUnit().Action(attribValueAction))
)
.Error(x => error = x);
//-----------------------------------------------------------------
//-----------------------------------------------------------------
var result = sequence.DecodeLine("loc(6,1,2,3)");
Assert.IsTrue(result);
Assert.IsTrue(string.Equals(shelfValue, "6", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(slotValue, "1", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(channelValue, "2", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(numberValue, "3", StringComparison.OrdinalIgnoreCase));
Assert.IsFalse(raniValue);
Assert.IsTrue(string.IsNullOrEmpty(aniValue));
Assert.IsTrue(string.IsNullOrEmpty(ani2Value));
Assert.IsTrue(string.IsNullOrEmpty(arouteDelayValue));
Assert.IsTrue(string.IsNullOrEmpty(arouteNumValue));
Assert.IsTrue(string.IsNullOrEmpty(prioValue));
Assert.IsTrue(string.IsNullOrEmpty(infoValue));
Assert.IsTrue(string.IsNullOrEmpty(attribValue));
Assert.IsTrue(error == null);
}
private static Exception CreateParseException(UnitError unitError, Lexeme lexeme, IError innerError = null)
{
return(new UnitExpressionParseException(Error.From(unitError, lexeme, innerError)));
}
