private void TestParseBinaryExp(Func <string, NativeXBinaryExpression> parser)
{
NativeXBinaryExpression a = parser("a=(1<<2)+3*4");
Assert.AreEqual("=", a.Operator);
{
Assert.AreEqual("a", ((NativeXReferenceExpression)a.LeftOperand).ReferencedName);
}
{
NativeXBinaryExpression b = (NativeXBinaryExpression)a.RightOperand;
Assert.AreEqual("+", b.Operator);
{
NativeXBinaryExpression c = (NativeXBinaryExpression)b.LeftOperand;
Assert.AreEqual("<<", c.Operator);
Assert.AreEqual("1", ((NativeXPrimitiveExpression)c.LeftOperand).Code);
Assert.AreEqual("2", ((NativeXPrimitiveExpression)c.RightOperand).Code);
}
{
NativeXBinaryExpression c = (NativeXBinaryExpression)b.RightOperand;
Assert.AreEqual("*", c.Operator);
Assert.AreEqual("3", ((NativeXPrimitiveExpression)c.LeftOperand).Code);
Assert.AreEqual("4", ((NativeXPrimitiveExpression)c.RightOperand).Code);
}
}
}
private void TestParseExpressionStatementInternal(Func <string, NativeXExpressionStatement> parser)
{
NativeXExpressionStatement s = parser("1+2;");
NativeXBinaryExpression a = (NativeXBinaryExpression)s.Expression;
Assert.AreEqual("1", ((NativeXPrimitiveExpression)a.LeftOperand).Code);
Assert.AreEqual("2", ((NativeXPrimitiveExpression)a.RightOperand).Code);
}
private void TestParseForStatementInternal(Func <string, NativeXForStatement> parser)
{
NativeXForStatement s = parser("for (variable int i = 0; variable int j = 0; when (i - j > 5) with i+=2; j+=1;) do x();");
Assert.AreEqual(2, s.Initializer.Count);
{
NativeXVariableStatement s1 = (NativeXVariableStatement)s.Initializer[0];
Assert.AreEqual("i", s1.Name);
Assert.AreEqual("int", ((NativeXReferenceType)s1.Type).ReferencedName);
Assert.AreEqual("0", ((NativeXPrimitiveExpression)s1.Initializer).Code);
}
{
NativeXVariableStatement s2 = (NativeXVariableStatement)s.Initializer[1];
Assert.AreEqual("j", s2.Name);
Assert.AreEqual("int", ((NativeXReferenceType)s2.Type).ReferencedName);
Assert.AreEqual("0", ((NativeXPrimitiveExpression)s2.Initializer).Code);
}
Assert.AreEqual(2, s.SideEffect.Count);
{
NativeXBinaryExpression e1 = (NativeXBinaryExpression)((NativeXExpressionStatement)s.SideEffect[0]).Expression;
Assert.AreEqual("+=", e1.Operator);
Assert.AreEqual("i", ((NativeXReferenceExpression)e1.LeftOperand).ReferencedName);
Assert.AreEqual("2", ((NativeXPrimitiveExpression)e1.RightOperand).Code);
}
{
NativeXBinaryExpression e2 = (NativeXBinaryExpression)((NativeXExpressionStatement)s.SideEffect[1]).Expression;
Assert.AreEqual("+=", e2.Operator);
Assert.AreEqual("j", ((NativeXReferenceExpression)e2.LeftOperand).ReferencedName);
Assert.AreEqual("1", ((NativeXPrimitiveExpression)e2.RightOperand).Code);
}
{
NativeXInvokeExpression a = (NativeXInvokeExpression)((NativeXExpressionStatement)s.Statement).Expression;
Assert.AreEqual("x", ((NativeXReferenceExpression)a.Function).ReferencedName);
Assert.AreEqual(0, a.Arguments.Count);
}
{
NativeXBinaryExpression e1 = (NativeXBinaryExpression)s.Condition;
Assert.AreEqual(">", e1.Operator);
Assert.AreEqual("5", ((NativeXPrimitiveExpression)e1.RightOperand).Code);
NativeXBinaryExpression e2 = (NativeXBinaryExpression)e1.LeftOperand;
Assert.AreEqual("-", e2.Operator);
Assert.AreEqual("i", ((NativeXReferenceExpression)e2.LeftOperand).ReferencedName);
Assert.AreEqual("j", ((NativeXReferenceExpression)e2.RightOperand).ReferencedName);
}
}
private void TestParseVariableDeclarationInternal(Func <string, NativeXVariableDeclaration> parser)
{
Action <NativeXVariableDeclaration> vd_common = d =>
{
Assert.AreEqual("a", d.Name);
NativeXInstanciatedType t = (NativeXInstanciatedType)d.Type;
Assert.AreEqual("List", t.ElementType.ReferencedName);
Assert.AreEqual(1, t.GenericArguments.Count);
Assert.AreEqual("int", ((NativeXReferenceType)t.GenericArguments[0]).ReferencedName);
};
Action <NativeXVariableDeclaration> vd1 = d =>
{
Assert.IsNull(d.Initializer);
Assert.IsNull(d.Linking);
};
Action <NativeXVariableDeclaration> vd2 = d =>
{
Assert.IsNull(d.Initializer);
Assert.AreEqual("Utility", d.Linking.LinkingAssembly);
Assert.AreEqual("Sum", d.Linking.LinkingSymbol);
};
Action <NativeXVariableDeclaration> vd3 = d =>
{
Assert.IsNull(d.Linking);
NativeXBinaryExpression e = (NativeXBinaryExpression)d.Initializer;
Assert.AreEqual("1", ((NativeXPrimitiveExpression)e.LeftOperand).Code);
Assert.AreEqual("2", ((NativeXPrimitiveExpression)e.RightOperand).Code);
};
string d1 = "variable List<int> a;";
string d2 = "variable List<int> a alias Utility.Sum;";
string d3 = "variable List<int> a = 1+2;";
{
NativeXVariableDeclaration d = parser(d1);
vd_common(d);
vd1(d);
}
{
NativeXVariableDeclaration d = parser(d2);
vd_common(d);
vd2(d);
}
{
NativeXVariableDeclaration d = parser(d3);
vd_common(d);
vd3(d);
}
{
NativeXVariableDeclaration d = parser(g1 + d1);
vg1(d);
vd_common(d);
vd1(d);
}
{
NativeXVariableDeclaration d = parser(g2 + d2);
vg2(d);
vd_common(d);
vd2(d);
}
{
NativeXVariableDeclaration d = parser(g3 + d3);
vg3(d);
vd_common(d);
vd3(d);
}
}
private void TestParseFunctionDeclarationInternal(Func <string, NativeXFunctionDeclaration> parser)
{
Action <NativeXFunctionDeclaration> vd_common = d =>
{
Assert.AreEqual("Sum", d.Name);
Assert.AreEqual("int", ((NativeXReferenceType)d.ReturnType).ReferencedName);
Assert.AreEqual(2, d.Parameters.Count);
Assert.AreEqual("int", ((NativeXReferenceType)((NativeXPointerType)d.Parameters[0].Type).ElementType).ReferencedName);
Assert.AreEqual("numbers", d.Parameters[0].Name);
Assert.AreEqual("int", ((NativeXReferenceType)d.Parameters[1].Type).ReferencedName);
Assert.AreEqual("count", d.Parameters[1].Name);
};
Action <NativeXFunctionDeclaration> vd1 = d =>
{
Assert.IsFalse(d.Foreign);
Assert.IsNull(d.Linking);
NativeXCompositeStatement s = (NativeXCompositeStatement)d.Statement;
Assert.AreEqual(1, s.Statements.Count);
NativeXBinaryExpression e = (NativeXBinaryExpression)((NativeXExpressionStatement)s.Statements[0]).Expression;
Assert.IsNotNull((NativeXFunctionResultExpression)e.LeftOperand);
Assert.AreEqual("0", ((NativeXPrimitiveExpression)e.RightOperand).Code);
};
Action <NativeXFunctionDeclaration> vd2 = d =>
{
Assert.IsFalse(d.Foreign);
Assert.IsNull(d.Statement);
Assert.AreEqual("Utility", d.Linking.LinkingAssembly);
Assert.AreEqual("Sum", d.Linking.LinkingSymbol);
};
Action <NativeXFunctionDeclaration> vd3 = d =>
{
Assert.IsTrue(d.Foreign);
Assert.IsNull(d.Linking);
Assert.IsNull(d.Statement);
};
string d1 = "function int Sum(int* numbers, int count){result = 0;}";
string d2 = "function int Sum(int* numbers, int count) alias Utility.Sum;";
string d3 = "foreign function int Sum(int* numbers, int count);";
{
NativeXFunctionDeclaration d = parser(d1);
vd_common(d);
vd1(d);
}
{
NativeXFunctionDeclaration d = parser(d2);
vd_common(d);
vd2(d);
}
{
NativeXFunctionDeclaration d = parser(d3);
vd_common(d);
vd3(d);
}
{
NativeXFunctionDeclaration d = parser(g1 + d1);
vg1(d);
vd_common(d);
vd1(d);
}
{
NativeXFunctionDeclaration d = parser(g2 + d2);
vg2(d);
vd_common(d);
vd2(d);
}
{
NativeXFunctionDeclaration d = parser(g3 + d3);
vg3(d);
vd_common(d);
vd3(d);
}
}
