public void TestUnaryOpException()
{
var m = new Module(null);
var e = Assert.Throws <ArgumentException>(() => BinaryExpression.Create(OberonGrammarLexer.PLUS,
ConstantExpression.Create(false), null, m.Block));
Assert.Equal("Cannot find operation '+' (Bool, Any)", e.Message);
}
public void ExpressionRelGe1()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.GE,
ConstantExpression.Create(4),
ConstantExpression.Create(4),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantBoolExpression;
Assert.NotNull(result);
Assert.True(result.ToBool());
}
public void ExpressionDiv1()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.DIV,
ConstantExpression.Create(10),
ConstantExpression.Create(2),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantIntExpression;
Assert.NotNull(result);
Assert.Equal(5, result.ToInt32());
}
public void ExpressionDiv0()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.DIV,
ConstantExpression.Create("10.0"),
ConstantIntExpression.Zero,
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantDoubleExpression;
Assert.NotNull(result);
Assert.True(double.IsInfinity(result.ToDouble()));
}
public void ExpressionAnd()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.AND,
ConstantExpression.Create(false),
ConstantExpression.Create("true"),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantBoolExpression;
Assert.NotNull(result);
Assert.False(result.ToBool());
}
public void ExpressionAdd2()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.PLUS,
ConstantExpression.Create(1),
ConstantExpression.Create(1.42),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantDoubleExpression;
Assert.NotNull(result);
Assert.Equal(2.42, result.ToDouble());
}
public void ExpressionMult2()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.STAR,
ConstantExpression.Create(6.1),
ConstantExpression.Create(7),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantDoubleExpression;
Assert.NotNull(result);
Assert.True(result.ToDouble() - 42.7 < double.Epsilon);
}
public void ExpressionDiv3()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.DIV,
ConstantExpression.Create("10.0"),
ConstantExpression.Create(4),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantDoubleExpression;
Assert.NotNull(result);
Assert.Equal(2.5, result.ToDouble());
}
public void BinaryOperatorCheckParametersNull()
{
var b = new Module(null).Block;
var e = Assert.Throws <ArgumentNullException>(
() => new OpRelOp().Operate(null, b, null));
Assert.Equal("e", e.ParamName);
var e1 = Assert.Throws <ArgumentNullException>(
() => new OpRelOp().Operate(
BinaryExpression.Create(OberonGrammarLexer.PLUS, ConstantExpression.Create(0),
ConstantExpression.Create(1), b), null, null));
Assert.Equal("block", e1.ParamName);
}
public void ExpressionRelVar()
{
var m = new Module(null);
m.Block.Declarations.Add(new Declaration("a", m.Block.LookupType("INTEGER")));
var e = BinaryExpression.Create(
OberonGrammarLexer.NOTEQUAL,
VariableReferenceExpression.Create(m.Block.LookupVar("a"), null),
ConstantExpression.Create(10),
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as BinaryExpression;
Assert.NotNull(result);
Assert.False(result.IsConst);
}
public void ExpressionAddRes0()
{
var m = new Module(null);
var e = BinaryExpression.Create(
OberonGrammarLexer.PLUS,
ConstantExpression.Create(1),
ConstantDoubleExpression.Zero,
m.Block);
var result = ConstantSolver.Solve(e, m.Block) as ConstantDoubleExpression;
Assert.NotNull(result);
Assert.Equal(1, result.ToInt32());
Assert.Equal(1.0, result.ToDouble());
Assert.True(result.ToBool());
Assert.False(result.IsUnary);
Assert.True(result.IsConst);
}
/* expressions */
public override void ExitExprConstant(OberonGrammarParser.ExprConstantContext context)
{
context.expReturn = ConstantExpression.Create(context.c.Text);
}
public void ExpressionInvalidConst()
{
var ex = Assert.Throws <InvalidOperationException>(() => ConstantExpression.Create("Test"));
Assert.Equal("Unknown constant 'Test'", ex.Message);
}
