public void AnonymousFunctionDefinition()
{
Expression expression = parseExpression("(a -> int, b-> Banana) -> Platypus { a + 5; }");
AnonymousFunctionExpression a = assertTypeAndCast <AnonymousFunctionExpression>(expression);
Assert.AreEqual("Platypus", a.returnType.name);
Assert.IsNotInstanceOfType(a.returnType, typeof(GenericTypeName));
Assert.AreEqual(2, a.arguments.members.Count);
Assert.AreEqual(1, a.body.innerExpressions.Count);
Assert.AreEqual("a", a.arguments.members[0].name);
Assert.AreEqual("int", a.arguments.members[0].typeName.name);
Assert.IsNotInstanceOfType(a.arguments.members[0].typeName, typeof(GenericTypeName));
Assert.AreEqual("b", a.arguments.members[1].name);
Assert.AreEqual("Banana", a.arguments.members[1].typeName.name);
Assert.IsNotInstanceOfType(a.arguments.members[1].typeName, typeof(GenericTypeName));
AdditionExpression d = assertTypeAndCast <AdditionExpression>(a.body.innerExpressions[0]);
VariableReferenceExpression e = assertTypeAndCast <VariableReferenceExpression>(d.left);
IntegralLiteralExpression f = assertTypeAndCast <IntegralLiteralExpression>(d.right);
Assert.AreEqual("a", e.name);
Assert.AreEqual(5, f.value);
}
public void TupleAssignment()
{
Expression expression = parseStatement("(a -> int, b -> FakeClass) = (4, p);");
TupleDeclarationAssignmentExpression a = assertTypeAndCast <TupleDeclarationAssignmentExpression>(expression);
Assert.AreEqual(2, a.names.members.Count);
Assert.AreEqual("a", a.names.members[0].name);
Assert.AreEqual("int", a.names.members[0].typeName.name);
Assert.IsNotInstanceOfType(a.names.members[0].typeName, typeof(GenericTypeName));
Assert.AreEqual("b", a.names.members[1].name);
Assert.AreEqual("FakeClass", a.names.members[1].typeName.name);
Assert.IsNotInstanceOfType(a.names.members[1].typeName, typeof(GenericTypeName));
TupleDefinitionExpression d = assertTypeAndCast <TupleDefinitionExpression>(a.values);
Assert.AreEqual(2, d.members.Count);
IntegralLiteralExpression e = assertTypeAndCast <IntegralLiteralExpression>(d.members[0]);
VariableReferenceExpression f = assertTypeAndCast <VariableReferenceExpression>(d.members[1]);
Assert.AreEqual(4, e.value);
Assert.AreEqual("p", f.name);
}
public void VariableAssignment()
{
Expression expression = parseStatement("a = 4;");
VariableAssignmentExpression a = assertTypeAndCast <VariableAssignmentExpression>(expression);
Assert.AreEqual("a", a.name);
IntegralLiteralExpression b = assertTypeAndCast <IntegralLiteralExpression>(a.value);
Assert.AreEqual(4, b.value);
}
public void VariableDeclarationAssignment()
{
Expression expression = parseStatement("a -> int = 4 + p;");
VariableDeclarationAssignmentExpression a = assertTypeAndCast <VariableDeclarationAssignmentExpression>(expression);
Assert.AreEqual("a", a.declaration.name);
Assert.AreEqual("int", a.declaration.typeName.name);
AdditionExpression b = assertTypeAndCast <AdditionExpression>(a.value);
IntegralLiteralExpression c = assertTypeAndCast <IntegralLiteralExpression>(b.left);
VariableReferenceExpression d = assertTypeAndCast <VariableReferenceExpression>(b.right);
Assert.AreEqual(4, c.value);
Assert.AreEqual("p", d.name);
}
public void AdditionAndSubtractionWithBrackets()
{
Expression expression = parseExpression("a + b + (1 - g)");
AdditionExpression a = assertTypeAndCast <AdditionExpression>(expression);
AdditionExpression b = assertTypeAndCast <AdditionExpression>(a.left);
SubtractionExpression c = assertTypeAndCast <SubtractionExpression>(a.right);
VariableReferenceExpression d = assertTypeAndCast <VariableReferenceExpression>(b.left);
VariableReferenceExpression e = assertTypeAndCast <VariableReferenceExpression>(b.right);
IntegralLiteralExpression f = assertTypeAndCast <IntegralLiteralExpression>(c.left);
VariableReferenceExpression g = assertTypeAndCast <VariableReferenceExpression>(c.right);
Assert.AreEqual(d.name, "a");
Assert.AreEqual(e.name, "b");
Assert.AreEqual(f.value, 1);
Assert.AreEqual(g.name, "g");
}
public void TupleDefinition()
{
Expression expression = parseExpression("(a, b, 4+6,\"dsas\\\"dasd\", a - g + p * t)");
TupleDefinitionExpression a = assertTypeAndCast <TupleDefinitionExpression>(expression);
Assert.AreEqual(a.members.Count, 5);
VariableReferenceExpression b = assertTypeAndCast <VariableReferenceExpression>(a.members[0]);
VariableReferenceExpression c = assertTypeAndCast <VariableReferenceExpression>(a.members[1]);
AdditionExpression z = assertTypeAndCast <AdditionExpression>(a.members[2]);
StringLiteralExpression d = assertTypeAndCast <StringLiteralExpression>(a.members[3]);
AdditionExpression e = assertTypeAndCast <AdditionExpression>(a.members[4]);
Assert.AreEqual(b.name, "a");
Assert.AreEqual(c.name, "b");
IntegralLiteralExpression y = assertTypeAndCast <IntegralLiteralExpression>(z.left);
IntegralLiteralExpression x = assertTypeAndCast <IntegralLiteralExpression>(z.right);
Assert.AreEqual(4, y.value);
Assert.AreEqual(6, x.value);
Assert.AreEqual(d.value, "dsas\"dasd");
SubtractionExpression f = assertTypeAndCast <SubtractionExpression>(e.left);
MultiplicationExpression g = assertTypeAndCast <MultiplicationExpression>(e.right);
VariableReferenceExpression h = assertTypeAndCast <VariableReferenceExpression>(f.left);
VariableReferenceExpression i = assertTypeAndCast <VariableReferenceExpression>(f.right);
VariableReferenceExpression j = assertTypeAndCast <VariableReferenceExpression>(g.left);
VariableReferenceExpression k = assertTypeAndCast <VariableReferenceExpression>(g.right);
Assert.AreEqual(h.name, "a");
Assert.AreEqual(i.name, "g");
Assert.AreEqual(j.name, "p");
Assert.AreEqual(k.name, "t");
}
public void ClassTest()
{
Expression expression = parseExpression(@"class Test {
jelly -> int;
public belly -> Banana<int,int>;
p -> String = ""haha"";
foopy(a -> int, b -> Banana) -> String {
a = 5;
}
}");
ClassDefinitionExpression a = assertTypeAndCast <ClassDefinitionExpression>(expression);
Assert.AreEqual("Test", a.name);
Assert.AreEqual(4, a.members.Count);
Assert.AreEqual(Visibility.None, a.visibility);
VariableDeclarationExpression b = assertTypeAndCast <VariableDeclarationExpression>(a.members[0]);
VariableDeclarationExpression c = assertTypeAndCast <VariableDeclarationExpression>(a.members[1]);
VariableDeclarationAssignmentExpression d = assertTypeAndCast <VariableDeclarationAssignmentExpression>(a.members[2]);
FunctionExpression e = assertTypeAndCast <FunctionExpression>(a.members[3]);
Assert.AreEqual("jelly", b.name);
Assert.AreEqual("int", b.typeName.name);
Assert.IsNotInstanceOfType(b.typeName, typeof(GenericTypeName));
Assert.AreEqual(Visibility.None, b.visibility);
Assert.AreEqual("belly", c.name);
Assert.AreEqual("Banana", c.typeName.name);
Assert.AreEqual(Visibility.Public, c.visibility);
GenericTypeName f = assertTypeAndCast <GenericTypeName>(c.typeName);
Assert.AreEqual(2, f.genericTypes.Count);
Assert.AreEqual("int", f.genericTypes[0].name);
Assert.IsNotInstanceOfType(f.genericTypes[0], typeof(GenericTypeName));
Assert.AreEqual("int", f.genericTypes[1].name);
Assert.IsNotInstanceOfType(f.genericTypes[1], typeof(GenericTypeName));
Assert.AreEqual("p", d.declaration.name);
Assert.AreEqual("String", d.declaration.typeName.name);
Assert.IsNotInstanceOfType(d.declaration.typeName, typeof(GenericTypeName));
StringLiteralExpression g = assertTypeAndCast <StringLiteralExpression>(d.value);
Assert.AreEqual("haha", g.value);
Assert.AreEqual("foopy", e.name);
Assert.AreEqual(Visibility.None, e.visibility);
Assert.AreEqual("String", e.returnType.name);
Assert.IsNotInstanceOfType(e.returnType, typeof(GenericTypeName));
Assert.AreEqual(2, e.arguments.members.Count);
Assert.AreEqual(1, e.body.innerExpressions.Count);
Assert.AreEqual("a", e.arguments.members[0].name);
Assert.AreEqual("int", e.arguments.members[0].typeName.name);
Assert.IsNotInstanceOfType(e.arguments.members[0].typeName, typeof(GenericTypeName));
Assert.AreEqual("b", e.arguments.members[1].name);
Assert.AreEqual("Banana", e.arguments.members[1].typeName.name);
Assert.IsNotInstanceOfType(e.arguments.members[1].typeName, typeof(GenericTypeName));
VariableAssignmentExpression h = assertTypeAndCast <VariableAssignmentExpression>(e.body.innerExpressions[0]);
Assert.AreEqual("a", h.name);
IntegralLiteralExpression i = assertTypeAndCast <IntegralLiteralExpression>(h.value);
Assert.AreEqual(5, i.value);
}
