public override Value Visit(GreaterThan greaterThan)
{
Value left = greaterThan.Left.Accept(this);
Value right = greaterThan.Right.Accept(this);
return(left.IsGreaterThan(right));
}
public Value Visit(GreaterThan node)
{
Value left = node.Left().Accept(this);
Value right = node.Right().Accept(this);
return(left.Greater(right));
}
public void CloneTest()
{
var exp = new GreaterThan(new Number(2), new Number(3));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public void Visit(GreaterThan m)
{
Console.WriteLine("pop stack into a");
Console.WriteLine("pop stack into b");
Console.WriteLine("compare a,b");
Console.WriteLine("push a 1 if carry flag set");
}
public IType Visit(GreaterThan node)
{
var leftHandSideValue = Visit((dynamic)node.Lhs);
var rightHandSideValue = Visit((dynamic)node.Rhs);
return(leftHandSideValue.GreaterThan(rightHandSideValue));
}
public void Visit(GreaterThan op)
{
var left = VisitChild(op.Variable);
var right = VisitChild(op.Literal);
_codeStack.Peek().Expression = new CodeBinaryOperatorExpression(left.Expression, CodeBinaryOperatorType.GreaterThan, right.Expression);
}
public object Visit(GreaterThan expression)
{
object leftValue = expression.Left.Accept <object>(this);
object rightValue = expression.Right.Accept <object>(this);
return((int)leftValue > (int)rightValue);
}
public override Value Visit(GreaterThan node)
{
Value left = node.Left().Accept(this);
Value right = node.Right().Accept(this);
return(left.Greater((dynamic)right));
}
private IExpression RelationalExpression()
{
var expression = AdditiveExpression();
while (lookAhead.Type == ExpressionTokenType.Less ||
lookAhead.Type == ExpressionTokenType.LessEqual ||
lookAhead.Type == ExpressionTokenType.Greater ||
lookAhead.Type == ExpressionTokenType.GreaterEqual)
{
var type = lookAhead.Type;
NextToken();
var rightOperand = AdditiveExpression();
switch (type)
{
case ExpressionTokenType.Less:
expression = new LessThan(expression, rightOperand);
break;
case ExpressionTokenType.LessEqual:
expression = new LessThanOrEquals(expression, rightOperand);
break;
case ExpressionTokenType.Greater:
expression = new GreaterThan(expression, rightOperand);
break;
case ExpressionTokenType.GreaterEqual:
expression = new GreaterThanOrEquals(expression, rightOperand);
break;
}
}
return(expression);
}
private static IExpression InvertBinaryOperation(IBinaryOperation binOp) {
Contract.Requires(binOp != null);
Contract.Ensures(Contract.Result<IExpression>() != null);
BinaryOperation/*?*/ result = null;
if (binOp is IEquality && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float32 && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float64)
result = new NotEquality();
else if (binOp is INotEquality && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float32 && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float64)
result = new Equality();
else if (binOp is ILessThan)
result = new GreaterThanOrEqual() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((ILessThan)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is ILessThanOrEqual)
result = new GreaterThan() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((ILessThanOrEqual)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is IGreaterThan)
result = new LessThanOrEqual() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((IGreaterThan)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is IGreaterThanOrEqual)
result = new LessThan() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((IGreaterThanOrEqual)binOp).IsUnsignedOrUnordered, binOp) };
if (result != null) {
result.LeftOperand = binOp.LeftOperand;
result.RightOperand = binOp.RightOperand;
result.Type = binOp.Type;
result.Locations.AddRange(binOp.Locations);
return result;
}
LogicalNot logicalNot = new LogicalNot();
logicalNot.Operand = binOp;
logicalNot.Type = binOp.Type;
logicalNot.Locations.AddRange(binOp.Locations);
return logicalNot;
}
private ExpressionNode ParseRelationalExpression()
{
var left = ParseAdditiveExpression();
while (IsOperator('<') || IsOperator('>') || IsOperator('L') || IsOperator('G'))
{
var o = (Operator)Token;
NextToken();
switch (o.Value)
{
case '<':
left = new LessThan(left, ParseAdditiveExpression());
break;
case '>':
left = new GreaterThan(left, ParseAdditiveExpression());
break;
case 'L':
left = new LessEqual(left, ParseAdditiveExpression());
break;
case 'G':
left = new GreaterEqual(left, ParseAdditiveExpression());
break;
}
}
return(left);
}
private ComparisonOperator ComparisonOperator()
{
if (this.lexer.Token == null || !this.lexer.Token.Is(TokenType.Name))
{
this.SyntaxError("comparision operator");
}
ComparisonOperator comparisonOperator = null;
switch (this.lexer.Token.Value)
{
case "pr":
comparisonOperator = new Present();
break;
case "eq":
comparisonOperator = new Equal();
break;
case "ne":
comparisonOperator = new NotEqual();
break;
case "co":
comparisonOperator = new Contains();
break;
case "sw":
comparisonOperator = new StartsWith();
break;
case "ew":
comparisonOperator = new EndsWith();
break;
case "gt":
comparisonOperator = new GreaterThan();
break;
case "lt":
comparisonOperator = new LessThan();
break;
case "ge":
comparisonOperator = new GreaterThanOrEqual();
break;
case "le":
comparisonOperator = new LessThanOrEqual();
break;
default:
this.SyntaxError("comparision operator");
break;
}
this.Match(this.lexer.Token.Name);
return(comparisonOperator);
}
public override bool Visit(GreaterThan node)
{
traverse(node.left);
outputCode(" > ", false, false);
traverse(node.right);
//Visit((LogicalBinaryExpression) node);
return(true);
}
public static string GetGreaterThanOperand(GreaterThan expression, VHDLCompilerInterface compiler)
{
string left = GetOperand(expression.Left, compiler);
string right = GetOperand(expression.Right, compiler);
FunctionCallTemplate template = new FunctionCallTemplate(left, "GreaterThan", right);
return(template.TransformText());
}
public void TestGreaterThanHardcoded()
{
var lhs = new ValueOperand(5.0);
var rhs = new ValueOperand(-1.5);
var node = new GreaterThan().SetChildren(lhs, rhs);
Assert.IsTrue((bool)node.Value().Invoke(null));
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The result of analysis.</returns>
public string Analyze(GreaterThan exp)
{
if (exp.Parent is BinaryExpression)
{
return(ToString(exp, "({0} > {1})"));
}
return(ToString(exp, "{0} > {1}"));
}
public void TestGreaterThan()
{
var gt = new GreaterThan(new Constant("23"), new Constant("12"));
Assert.IsTrue((bool) gt.Evaluate(new Reflection(this)));
gt = new GreaterThan(new Constant("12"), new Constant("23"));
Assert.IsFalse((bool) gt.Evaluate(new Reflection(this)));
gt = new GreaterThan(new Constant("12"), new Constant("12"));
Assert.IsFalse((bool) gt.Evaluate(new Reflection(this)));
}
public void CloneTest()
{
var lessThen = new LessThan(Variable.X, new Number(10));
var greaterThen = new GreaterThan(Variable.X, new Number(10));
var exp = new Or(lessThen, greaterThen);
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
/// <summary>
/// Initializes the <see cref="Ops" /> class.
/// </summary>
static Ops()
{
Equal = new Equal();
GreaterThan = new GreaterThan();
GreaterThanOrEqual = new GreaterThanOrEqual();
LessThan = new LessThan();
LessThanOrEqual = new LessThanOrEqual();
NotEqual = new NotEqual();
}
public void Evaluate_LeftIsGreaterThanThanRight_ReturnsTrue()
{
var left = new Integer(5000);
var right = new Integer(3934);
var expr = new GreaterThan(left, right);
var result = expr.EvaluateWithData <bool>();
Assert.True(result);
}
static void Main(string[] args)
{
square myLambdaExpression = x => x * x;
Console.WriteLine("X squared is {0}", myLambdaExpression(5));
GreaterThan gt = (x, y) => x > y;
Console.WriteLine("Is {0} greater than {1}? {2}", 6, 5, gt(6, 5));
}
public void Evaluate_LeftIsEqualToRight_ReturnsFalse()
{
var left = new Integer(3934);
var right = new Integer(3934);
var expr = new GreaterThan(left, right);
var result = expr.EvaluateWithData <bool>();
Assert.False(result);
}
public static ICriteria <T> GreaterThan <T>(this IPredicate <T> predicate, object value)
{
var root = (IRestorableQuery <T>)predicate;
var @operator = new GreaterThan();
var criteria = new SingleCriteria <T>(root.RootQuery, predicate, @operator, value);
root.RootQuery.Criterias.Add(criteria);
return(criteria);
}
public void TestGreaterThan(int number1, int number2, bool expectedResult)
{
GreaterThan gt = new GreaterThan
{
LeftHand = new Number(number1),
RightHand = new Number(number2)
};
Assert.Equal(expectedResult, gt.Execute());
}
public void ThenResolveReturnsTrue()
{
var rightHandSide = new Mock<IValue>();
rightHandSide.Setup(x => x.LessThan("larger")).Returns(true);
var subject = new GreaterThan("Value", rightHandSide.Object);
var result = subject.Resolve(new TestObject { Value = "larger" }, new List<IExpression>());
Assert.That(result, Is.True);
}
public void TestGreaterThan()
{
var gt = new GreaterThan(new Constant("23"), new Constant("12"));
Assert.IsTrue((bool)gt.Evaluate(new Reflection(this)));
gt = new GreaterThan(new Constant("12"), new Constant("23"));
Assert.IsFalse((bool)gt.Evaluate(new Reflection(this)));
gt = new GreaterThan(new Constant("12"), new Constant("12"));
Assert.IsFalse((bool)gt.Evaluate(new Reflection(this)));
}
public void GreaterThan_WithDouble2Integer3_ReturnFalse()
{
var left = new Constant(2.0);
var right = new Constant(3);
var operation = new GreaterThan(left, right);
var actual = (bool)operation.GetExpression(null).Calculate();
Assert.AreEqual(false, actual);
}
public override void Write(TextWriter writer)
{
LessThan.Write(writer);
Name.Write(writer);
foreach (var attribute in Attributes)
{
attribute.Write(writer);
}
GreaterThan.Write(writer);
}
public void CalculateGreaterFalseTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 0)
};
var lessThen = new GreaterThan(Variable.X, new Number(10));
Assert.False((bool)lessThen.Execute(parameters));
}
public void CalculateGreaterTrueTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 463)
};
var greaterThen = new GreaterThan(Variable.X, new Number(10));
Assert.True((bool)greaterThen.Execute(parameters));
}
public void CalculateGreaterFalseTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 0)
};
var lessThen = new GreaterThan(new Variable("x"), new Number(10));
Assert.Equal(false, lessThen.Execute(parameters));
}
public void CalculateGreaterTrueTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 463)
};
var greaterThen = new GreaterThan(new Variable("x"), new Number(10));
Assert.Equal(true, greaterThen.Execute(parameters));
}
public void Conditional_Expression_Arguments_Are_Compatible_Incorrect_Test()
{
List<FormObject> formObjects = new List<FormObject>();
Expression greaterThan = new GreaterThan(
new Int(2, position),
new Bool(true, position),
position);
Conditional conditional = new Conditional(greaterThan, null, position);
formObjects.Add(conditional);
ExpressionContainerChecker expressionContainerChecker = new ExpressionContainerChecker(manager, null);
INotificationManager notificationManager = expressionContainerChecker.AnalyzeAndReport(formObjects);
Assert.IsTrue(notificationManager.GetNotifications().Count == 1);
}
public void Evaluate_GreaterThan_Int_True_Test()
{
Expression left = CreateIntLiteral(2);
Expression right = CreateIntLiteral(1);
Expression greaterThan = new GreaterThan(left, right, pos);
Values.Bool value = ((Values.Bool)greaterThan.Accept(evaluator));
Assert.IsTrue(value.GetValue());
}
private Expression ParseRelationalExpression(TokenSet followers) {
TokenSet followerOrRelational = followers|Parser.RelationalOperators;
Expression result = this.ParseAdditiveExpression(followerOrRelational);
while (Parser.RelationalOperators[this.currentToken]) {
SourceLocationBuilder slb = new SourceLocationBuilder(result.SourceLocation);
Token operatorToken = this.currentToken;
this.GetNextToken();
Expression operand2 = this.ParseAdditiveExpression(followerOrRelational);
slb.UpdateToSpan(operand2.SourceLocation);
switch (operatorToken){
case Token.Equals: result = new Equality(result, operand2, slb); break;
case Token.GreaterThan: result = new GreaterThan(result, operand2, slb); break;
case Token.GreaterThanEqualTo: result = new GreaterThanOrEqual(result, operand2, slb); break;
case Token.LessThan: result = new LessThan(result, operand2, slb); break;
case Token.LessThanEqualTo: result = new LessThanOrEqual(result, operand2, slb); break;
case Token.NotEqualTo: result = new NotEquality(result, operand2, slb); break;
}
}
//^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile;
return result;
}
public void SetUp()
{
testee = new GreaterThan<CustomEntity>(">");
}
void Comparison(out Expression exp)
{
Expression second;
BitOr(out exp);
if (StartOf(3)) {
switch (la.kind) {
case 29: {
Get();
break;
}
case 30: {
Get();
break;
}
case 31: {
Get();
break;
}
case 32: {
Get();
break;
}
case 33: {
Get();
break;
}
case 34: {
Get();
break;
}
}
Token tok = t;
Comparison(out second);
if (!ExpectInt(exp, tok, false)) { return; };
if (!ExpectInt(second, tok, true)) { return; };
if (tok.val == "<") {
exp = new LessThan((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == ">") {
exp = new GreaterThan((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == "<=") {
exp = new LessThanOrEqual((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == ">=") {
exp = new GreaterThanOrEqual((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == "==") {
exp = new Equal((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == "!=") {
exp = new NotEqual((TypedExpression<int>)exp, (TypedExpression<int>)second);
}
}
}
public void GreaterThanCorrectlyConvertsToJson()
{
var gt = new GreaterThan<int>(50);
gt.ToString().ShouldEqual(GreaterThanJson);
}
public virtual void Visit(GreaterThan node)
{
}
