public void AllowStringEqualityAndInequalityComparison(string op)
{
var left = new StringLiteral ("foobar");
var right = new StringLiteral ("baz");
var compared = new BinaryOperation (op, left, right);
var type = compared.Walk (new TypeChecker ());
Assert.AreEqual (SpecType.Boolean, type.Type);
}
public void AllowBooleanEqualityComparison(string op)
{
var left = new BooleanLiteral (true);
var right = new BooleanLiteral (false);
var compared = new BinaryOperation (op, left, right);
var type = compared.Walk (new TypeChecker ());
Assert.AreEqual (SpecType.Boolean, type.Type);
}
public void SerializeBinaryOperation(string op)
{
var binaryNode = new BinaryOperation (op,
new NumberLiteral (1),
new NumberLiteral (2)
);
var binarySql = binaryNode.Walk (new Sqlizer (foobarTable()));
var expected = String.Format ("(1 {0} 2)", op);
Assert.AreEqual (expected, binarySql);
}
public void AllowNullEqualityComparison(string op)
{
var nullVal = new NullLiteral ();
var numberVal = new NumberLiteral (42);
var left = new BinaryOperation (op, nullVal, numberVal);
var right = new BinaryOperation (op, numberVal, nullVal);
var leftType = left.Walk (new TypeChecker ());
var rightType = right.Walk (new TypeChecker ());
Assert.AreEqual (SpecType.Boolean, leftType.Type);
Assert.AreEqual (SpecType.Boolean, rightType.Type);
}
public void CheckOperatorDoesNothing()
{
var str = new StringLiteral ("baz");
var nullNode = new NullLiteral ();
var operation = new BinaryOperation ("=", str, nullNode);
var result = operation.Walk (new RefChecker (), new [] { "Foobar" });
Assert.AreEqual (1, result.Length);
Assert.Contains ("Foobar", result);
}
public void CheckBinaryOperations(string op, SpecType expected)
{
var binary = new BinaryOperation (op, new NumberLiteral (1), new NumberLiteral (2));
var type = binary.Walk (new TypeChecker ());
Assert.AreEqual (expected, type.Type);
}
public void ErrorOnTypeMismatch()
{
var differentTypes = new BinaryOperation ("=", new NumberLiteral (1), new StringLiteral ("foobar"));
var ex = Assert.Throws<TypeCheckException> (() => differentTypes.Walk (new TypeChecker ()));
Assert.That (INCOMPATIBLE_RE.IsMatch (ex.Message));
}
public void ErrorOnStringArithmetric(string op)
{
var numberVal = new NumberLiteral (42);
var stringVal = new StringLiteral ("qux");
var left = new BinaryOperation (op, stringVal, numberVal);
var right = new BinaryOperation (op, numberVal, stringVal);
var leftEx = Assert.Throws<TypeCheckException> (() => left.Walk (new TypeChecker ()));
var rightEx = Assert.Throws<TypeCheckException> (() => right.Walk (new TypeChecker ()));
Assert.That (INVALID_RE.IsMatch (leftEx.Message));
Assert.That (INVALID_RE.IsMatch (rightEx.Message));
}
public void ErrorOnNullInequalityComparison(string op)
{
var nullVal = new NullLiteral ();
var numberVal = new NumberLiteral (42);
var left = new BinaryOperation (op, nullVal, numberVal);
var right = new BinaryOperation (op, numberVal, nullVal);
var leftEx = Assert.Throws<TypeCheckException> (() => left.Walk (new TypeChecker ()));
var rightEx = Assert.Throws<TypeCheckException> (() => right.Walk (new TypeChecker ()));
Assert.That (INVALID_RE.IsMatch (leftEx.Message));
Assert.That (INVALID_RE.IsMatch (rightEx.Message));
}
public void ErrorOnBooleanInequalityComparison(string op)
{
var left = new BooleanLiteral (true);
var right = new BooleanLiteral (false);
var compared = new BinaryOperation (op, left, right);
var ex = Assert.Throws<TypeCheckException> (() => compared.Walk (new TypeChecker ()));
Assert.That (INVALID_RE.IsMatch (ex.Message));
}
public void ErrorOnBooleanArithmetic(string op)
{
var numberVal = new NumberLiteral (42);
var boolVal = new BooleanLiteral (false);
var left = new BinaryOperation (op, boolVal, numberVal);
var right = new BinaryOperation (op, numberVal, boolVal);
var leftEx = Assert.Throws<TypeCheckException> (() => left.Walk (new TypeChecker ()));
var rightEx = Assert.Throws<TypeCheckException> (() => right.Walk (new TypeChecker ()));
Assert.That (INVALID_RE.IsMatch (leftEx.Message));
Assert.That (INVALID_RE.IsMatch (rightEx.Message));
}
