public void detectArgumentTest2()
{
IPM pm = new PM(" solution (1.5, -1.5, 1.5f, -1.5f, 1.5d, -1.5d) ");
Assert.AreEqual(pm.Is(LevelType.Method, "solution"), true);
Assert.AreEqual(pm.Levels[0].Args.Length, 6);
Argument[] args = pm.Levels[0].Args;
Assert.AreEqual(args[0].type, ArgumentType.Double);
Assert.AreEqual(args[0].data, 1.5d);
Assert.AreEqual(args[1].type, ArgumentType.Double);
Assert.AreEqual(args[1].data, -1.5d);
Assert.AreEqual(args[2].type, ArgumentType.Float);
Assert.AreEqual(args[2].data, 1.5f);
Assert.AreEqual(args[3].type, ArgumentType.Float);
Assert.AreEqual(args[3].data, -1.5f);
Assert.AreEqual(args[4].type, ArgumentType.Double);
Assert.AreEqual(args[4].data, 1.5d);
Assert.AreEqual(args[5].type, ArgumentType.Double);
Assert.AreEqual(args[5].data, -1.5d);
}
/// <summary>
/// Handler for current data
/// </summary>
/// <param name="data">mixed data</param>
/// <returns>prepared and evaluated data</returns>
public override string parse(string data)
{
var point = entryPoint(data);
string subtype = point.Key;
string request = point.Value;
Log.Trace("`{0}`: subtype - `{1}`, request - `{2}`", ToString(), subtype, request);
IPM pm = new PM(request, msbuild);
switch(subtype) {
case "gnt": {
return stGNT(pm);
}
}
throw new SubtypeNotFoundException("Subtype `{0}` is not found", subtype);
}
/// <summary>
/// To pack string argument in object.
/// </summary>
/// <param name="arg">Argument for packing.</param>
/// <returns></returns>
public static object packArgument(object arg)
{
if (arg == null)
{
return(null);
}
if (!(arg is string) || String.IsNullOrWhiteSpace((string)arg))
{
return(arg);
}
SNode.IPM pm = new SNode.PM(String.Format("_({0})", arg));
SNode.Argument first = pm.FirstLevel.Args[0];
if (first.type != SNode.ArgumentType.Object)
{
return(arg);
}
return(extract((SNode.Argument[])first.data));
}
public void detectArgumentTest1()
{
IPM pm = new PM("solution(\"str data\", 'str data2', 12, -12, 1.5, -1.5, STDOUT, TestEnum.SpecialType, mixed * data, true)");
Assert.AreEqual(pm.Is(LevelType.Method, "solution"), true);
Assert.AreEqual(pm.Levels[0].Args.Length, 10);
Argument[] args = pm.Levels[0].Args;
Assert.AreEqual(args[0].type, ArgumentType.StringDouble);
Assert.AreEqual(args[0].data, "str data");
Assert.AreEqual(args[1].type, ArgumentType.StringSingle);
Assert.AreEqual(args[1].data, "str data2");
Assert.AreEqual(args[2].type, ArgumentType.Integer);
Assert.AreEqual(args[2].data, 12);
Assert.AreEqual(args[3].type, ArgumentType.Integer);
Assert.AreEqual(args[3].data, -12);
Assert.AreEqual(args[4].type, ArgumentType.Double);
Assert.AreEqual(args[4].data, 1.5);
Assert.AreEqual(args[5].type, ArgumentType.Double);
Assert.AreEqual(args[5].data, -1.5);
Assert.AreEqual(args[6].type, ArgumentType.EnumOrConst);
Assert.AreEqual(args[6].data, "STDOUT");
Assert.AreEqual(args[7].type, ArgumentType.EnumOrConst);
Assert.AreEqual(args[7].data, "TestEnum.SpecialType");
Assert.AreEqual(args[8].type, ArgumentType.Mixed);
Assert.AreEqual(args[8].data, "mixed * data");
Assert.AreEqual(args[9].type, ArgumentType.Boolean);
Assert.AreEqual(args[9].data, true);
}
/// <summary>
/// To pack string argument in object.
/// </summary>
/// <param name="arg">Argument for packing.</param>
/// <returns></returns>
public static object packArgument(object arg)
{
if(arg == null) {
return null;
}
if(!(arg is string) || String.IsNullOrWhiteSpace((string)arg)) {
return arg;
}
SNode.IPM pm = new SNode.PM(String.Format("_({0})", arg));
SNode.Argument first = pm.FirstLevel.Args[0];
if(first.type != SNode.ArgumentType.Object) {
return arg;
}
return extract((SNode.Argument[])first.data);
}
public void pinToTest1()
{
IPM pm = new PM("left.solution.right");
Assert.AreEqual(4, pm.Levels.Count);
pm.pinTo(1);
Assert.AreEqual(3, pm.Levels.Count);
Assert.AreEqual(pm.Is(0, LevelType.Property, "solution"), true);
Assert.AreEqual(pm.Is(1, LevelType.Property, "right"), true);
Assert.AreEqual(pm.Is(2, LevelType.RightOperandEmpty, null), true);
pm.pinTo(2);
Assert.AreEqual(pm.Is(0, LevelType.RightOperandEmpty, null), true);
}
public void ItTest2()
{
IPM pm = new PM("solution.m1().Prop1.right");
Assert.AreEqual(true, pm.It(LevelType.Property, "solution"));
Assert.AreEqual(true, pm.Is(LevelType.Method, "m1"));
Assert.AreEqual(false, pm.It(LevelType.Property, "Prop1"));
Assert.AreEqual(true, pm.It(1, LevelType.Property, "Prop1"));
Assert.AreEqual(true, pm.It(LevelType.Property, "right"));
}
public void IsTest3()
{
IPM pm = new PM("solution.m1(')', '(', \"(\").m2(123, \" -> )\").right");
Assert.AreEqual(pm.Is(0, LevelType.Property, "solution"), true);
Assert.AreEqual(pm.Is(1, LevelType.Method, "m1"), true);
Assert.AreEqual(pm.Is(2, LevelType.Method, "m2"), true);
Assert.AreEqual(pm.Is(3, LevelType.Property, "right"), true);
Assert.AreEqual(pm.Is(4, LevelType.RightOperandEmpty), true);
}
public void IsRightTest2()
{
IPM pm = new PM("pname.m1(): mixed data");
Assert.AreEqual(true, pm.It(LevelType.Property, "pname"));
Assert.AreEqual(true, pm.It(LevelType.Method, "m1"));
Assert.AreEqual(false, pm.IsRight(LevelType.RightOperandEmpty));
Assert.AreEqual(true, pm.IsRight(LevelType.RightOperandColon));
Assert.AreEqual(false, pm.IsRight(LevelType.RightOperandStd));
}
public void IsMethodWithArgsTest1()
{
IPM pm = new PM("solution(\"str data\", 12, true).data.right(false, 1).end()");
Assert.AreEqual(true, pm.IsMethodWithArgs("solution", ArgumentType.StringDouble, ArgumentType.Integer, ArgumentType.Boolean));
Assert.AreEqual(false, pm.IsMethodWithArgs(1, "data"));
Assert.AreEqual(true, pm.IsMethodWithArgs(2, "right", ArgumentType.Boolean, ArgumentType.Integer));
Assert.AreEqual(true, pm.IsMethodWithArgs(3, "end"));
}
public void IsDataTest1()
{
IPM pm = new PM("pname . m1(true, 123).right = true");
Assert.AreEqual(true, pm.IsData("pname"));
Assert.AreEqual(false, pm.IsData("pname "));
pm.pinTo(1);
Assert.AreEqual(true, pm.IsData("m1"));
pm.pinTo(1);
Assert.AreEqual(true, pm.IsData("right"));
pm.pinTo(1);
Assert.AreEqual(true, pm.IsData(" true"));
}
public void FinalEmptyIsTest5()
{
IPM pm = new PM("left.solution(\"m(1)\", \"m()\", ')', \")\", \"(\")");
Assert.AreEqual(pm.Is(0, LevelType.Property, "left"), true);
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Method, "solution"), true);
}
public void FinalEmptyIsTest2()
{
try {
IPM pm = new PM("solution.right = ");
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Property, "right"), true);
Assert.Fail("1");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
try {
IPM pm = new PM("solution.right : ");
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Property, "right"), true);
Assert.Fail("2");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
try {
IPM pm = new PM("solution.right . prop");
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Property, "right"), true);
Assert.Fail("3");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
try {
IPM pm = new PM("solution.right mixed data");
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Property, "right"), true);
Assert.Fail("4");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
}
public void FinalEmptyIsTest1()
{
IPM pm = new PM("solution.right ");
Assert.AreEqual(pm.FinalEmptyIs(1, LevelType.Property, "right"), true);
Assert.AreEqual(pm.FinalEmptyIs(2, LevelType.RightOperandEmpty), true);
}
public void detectTest9()
{
IPM pm = new PM("left.solution(\" test , args\", 123, true, ' n1 , n2 ').right");
Assert.AreEqual(pm.Levels[0].Type, LevelType.Property);
Assert.AreEqual(pm.Levels[0].Data, "left");
Assert.AreEqual(pm.Levels[1].Type, LevelType.Method);
Assert.AreEqual(pm.Levels[1].Args.Length, 4);
Assert.AreEqual(pm.Levels[1].Args[0].type, ArgumentType.StringDouble);
Assert.AreEqual(pm.Levels[1].Args[0].data, " test , args");
Assert.AreEqual(pm.Levels[1].Args[1].type, ArgumentType.Integer);
Assert.AreEqual(pm.Levels[1].Args[1].data, 123);
Assert.AreEqual(pm.Levels[1].Args[2].type, ArgumentType.Boolean);
Assert.AreEqual(pm.Levels[1].Args[2].data, true);
Assert.AreEqual(pm.Levels[1].Args[3].type, ArgumentType.StringSingle);
Assert.AreEqual(pm.Levels[1].Args[3].data, " n1 , n2 ");
Assert.AreEqual(pm.Levels[1].Data, "solution");
Assert.AreEqual(pm.Levels[2].Type, LevelType.Property);
Assert.AreEqual(pm.Levels[2].Data, "right");
Assert.AreEqual(pm.Levels[3].Type, LevelType.RightOperandEmpty);
}
public void getRightOperandTest2()
{
IPM pm = new PM("pname = true ");
Assert.AreEqual(true, pm.It(LevelType.Property, "pname"));
Assert.AreEqual(true, pm.IsRight(LevelType.RightOperandStd));
Assert.AreEqual(" true ", pm.Levels[0].Data);
pm = new PM("m(): mixed\ndata ");
Assert.AreEqual(true, pm.It(LevelType.Method, "m"));
Assert.AreEqual(true, pm.IsRight(LevelType.RightOperandColon));
Assert.AreEqual(" mixed\ndata ", pm.Levels[0].Data);
}
public void FinalIsTest1()
{
IPM pm = new PM("left.solution.right");
Assert.AreEqual(pm.Levels.Count, 4);
Assert.AreEqual(pm.FinalIs(2, LevelType.Property, "right"), true);
Assert.AreEqual(pm.FinalIs(3, LevelType.RightOperandEmpty), true);
}
public void IsDataTest2()
{
IPM pm = new PM("pname = true");
Assert.AreEqual(false, pm.IsData("property1", "property2", "property2", "property3"));
Assert.AreEqual(true, pm.IsData("property1", "property2", "pname", "property3"));
}
public void FinalIsTest2()
{
try {
IPM pm = new PM("left.solution.right");
Assert.AreEqual(pm.FinalIs(1, LevelType.Property, "solution"), true);
Assert.Fail("1");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
try {
IPM pm = new PM("left.solution.right");
Assert.AreEqual(pm.FinalIs(LevelType.Property, "left"), true);
Assert.Fail("2");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(NotSupportedOperationException), ex.GetType().ToString()); }
}
public void IsRightTest1()
{
IPM pm = new PM("pname = true");
Assert.AreEqual(true, pm.It(LevelType.Property, "pname"));
Assert.AreEqual(false, pm.IsRight(LevelType.RightOperandEmpty));
Assert.AreEqual(false, pm.IsRight(LevelType.RightOperandColon));
Assert.AreEqual(true, pm.IsRight(LevelType.RightOperandStd));
}
public void FinalIsTest3()
{
IPM pm = new PM("left.solution.right");
Assert.AreEqual(pm.Is(0, LevelType.Property, "right"), false);
Assert.AreEqual(pm.FinalIs(1, LevelType.Property, "right"), false);
Assert.AreEqual(pm.Is(2, LevelType.Property, "right"), true);
}
public void IsTest1()
{
IPM pm = new PM("solution=left.right");
Assert.AreEqual(pm.Is(100, LevelType.Property, "solution"), false);
Assert.AreEqual(pm.Is(-1, LevelType.Property, "solution"), false);
Assert.AreEqual(pm.Is(0, LevelType.Property, "solution"), true);
Assert.AreEqual(pm.Is(1, LevelType.RightOperandStd, "left.right"), true);
}
public void FinalIsTest5()
{
IPM pm = new PM("left.solution(\" (a, b) \").right");
Assert.AreEqual(pm.Is(0, LevelType.Property, "left"), true);
Assert.AreEqual(pm.Is(1, LevelType.Method, "solution"), true);
Assert.AreEqual(pm.FinalIs(2, LevelType.Property, "right"), true);
}
public void ItTest1()
{
IPM pm = new PM("solution.m1().right");
Assert.AreEqual(true, pm.It(LevelType.Property, "solution"));
Assert.AreEqual(true, pm.It(LevelType.Method, "m1"));
Assert.AreEqual(false, pm.It(LevelType.Property, "notRealProperty"));
Assert.AreEqual(true, pm.It(LevelType.Property, "right"));
Assert.AreEqual(true, pm.It(LevelType.RightOperandEmpty));
Assert.AreEqual(0, pm.Levels.Count);
Assert.AreEqual(false, pm.It(LevelType.RightOperandEmpty));
Assert.AreEqual(false, pm.Is(0, LevelType.RightOperandEmpty));
}
public void FirstLevelTest1()
{
IPM pm = new PM("left.solution.right");
Assert.AreEqual(pm.FirstLevel.Data, pm.Levels[0].Data);
Assert.AreEqual(pm.FirstLevel.Type, pm.Levels[0].Type);
pm.pinTo(2);
Assert.AreEqual(pm.FirstLevel.Data, pm.Levels[0].Data);
Assert.AreEqual(pm.FirstLevel.Type, pm.Levels[0].Type);
}
public void detectArgumentTest3()
{
IPM pm = new PM(" m77(\"guid\", 12, {\"p1\", {4, \"test\", 8, 'y'}, true}, {false, 'p2'}) ");
Assert.AreEqual(pm.Is(LevelType.Method, "m77"), true);
Argument[] args = pm.Levels[0].Args;
Assert.AreEqual(args.Length, 4);
Assert.AreEqual(args[0].type, ArgumentType.StringDouble);
Assert.AreEqual(args[0].data, "guid");
Assert.AreEqual(args[1].type, ArgumentType.Integer);
Assert.AreEqual(args[1].data, 12);
Assert.AreEqual(args[2].type, ArgumentType.Object);
{
Argument[] args2 = (Argument[])args[2].data;
Assert.AreEqual(args2.Length, 3);
Assert.AreEqual(args2[0].type, ArgumentType.StringDouble);
Assert.AreEqual(args2[0].data, "p1");
Assert.AreEqual(args2[1].type, ArgumentType.Object);
{
Argument[] args21 = (Argument[])args2[1].data;
Assert.AreEqual(args21.Length, 4);
Assert.AreEqual(args21[0].type, ArgumentType.Integer);
Assert.AreEqual(args21[0].data, 4);
Assert.AreEqual(args21[1].type, ArgumentType.StringDouble);
Assert.AreEqual(args21[1].data, "test");
Assert.AreEqual(args21[2].type, ArgumentType.Integer);
Assert.AreEqual(args21[2].data, 8);
Assert.AreEqual(args21[3].type, ArgumentType.Char);
Assert.AreEqual(args21[3].data, 'y');
}
Assert.AreEqual(args2[2].type, ArgumentType.Boolean);
Assert.AreEqual(args2[2].data, true);
}
Assert.AreEqual(args[3].type, ArgumentType.Object);
{
Argument[] args3 = (Argument[])args[3].data;
Assert.AreEqual(args3.Length, 2);
Assert.AreEqual(args3[0].type, ArgumentType.Boolean);
Assert.AreEqual(args3[0].data, false);
Assert.AreEqual(args3[1].type, ArgumentType.StringSingle);
Assert.AreEqual(args3[1].data, "p2");
}
}
public void FirstLevelTest2()
{
IPM pm = new PM(new List<ILevel>());
Assert.AreEqual(0, pm.Levels.Count);
var lvl = pm.FirstLevel;
}
public void pinToTest2()
{
try {
IPM pm = new PM("left.solution.right");
pm.pinTo(100);
Assert.Fail("1");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(InvalidArgumentException), ex.GetType().ToString()); }
try {
IPM pm = new PM("left.solution.right");
pm.pinTo(-1);
Assert.Fail("2");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(InvalidArgumentException), ex.GetType().ToString()); }
try {
IPM pm = new PM("left.solution.right"); //4
pm.pinTo(4);
Assert.Fail("4");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(InvalidArgumentException), ex.GetType().ToString()); }
try {
IPM pm = new PM("left.solution.right"); //4
pm.pinTo(1);
pm.pinTo(2);
pm.pinTo(1);
Assert.Fail("5");
}
catch(Exception ex) { Assert.IsTrue(ex.GetType() == typeof(InvalidArgumentException), ex.GetType().ToString()); }
}
public void FirstLevelTest3()
{
IPM pm = new PM("left.solution.right");
Assert.AreEqual("left", pm.Levels[0].Data);
string newData = "Test";
pm.Levels[0] = new Level() {
Data = newData
};
Assert.AreEqual(newData, pm.Levels[0].Data);
}
protected string stSolution(string data)
{
Log.Trace("stSolution: started with '{0}'", data);
IPM pm = new PM(data);
if(!pm.Is(0, LevelType.Property, "solution")) {
throw new SyntaxIncorrectException("Failed stSolution - '{0}'", data);
}
// solution.current.
if(pm.Is(1, LevelType.Property, "current"))
{
if(!env.IsOpenedSolution) {
throw new NotSupportedOperationException("Property 'current' is not available. Open the Solution or use 'path()' method instead.");
}
return stSlnPMap(env.SolutionFile, pm.pinTo(2));
}
// solution.path("file").
if(pm.Is(1, LevelType.Method, "path"))
{
Argument[] args = pm.Levels[1].Args;
if(args.Length != 1 || args[0].type != ArgumentType.StringDouble) {
throw new InvalidArgumentException("stSolution: incorrect arguments to `solution.path(string sln)`");
}
return stSlnPMap((string)args[0].data, pm.pinTo(2));
}
throw new OperationNotFoundException("stSolution: not found - '{0}' /'{1}'", pm.Levels[1].Data, pm.Levels[1].Type);
}
public void FirstLevelTest4()
{
IPM pm = new PM(new List<ILevel>());
Assert.AreEqual(0, pm.Levels.Count);
pm.FirstLevel = new Level() { };
}