public override Value Visit(NotEqual node) { Value left = node.Left().Accept(this); Value right = node.Right().Accept(this); return(left.BoolNotEqual((dynamic)right)); }
public void NumberEqualTest() { var equal = new NotEqual(new Number(11), new Number(10)); var result = (bool)equal.Execute(); Assert.True(result); }
public bool CompareShouldBeAffectedIgnoreCase(string left, string right, bool ignoreCase) { var expression = Expression.Constant(""); var result = new NotEqual<CustomEntity>("!=", ignoreCase).Compare(expression, OperandBuilder.BuildUp(left), OperandBuilder.BuildUp(right)); return (bool)Expression.Lambda(result.Expression).Compile().DynamicInvoke(); }
public void BoolTrueAndFalseEqualTest() { var equal = new NotEqual(new Bool(true), new Bool(false)); var result = (bool)equal.Execute(); Assert.True(result); }
public Value Visit(NotEqual node) { Value left = node.Left().Accept(this); Value right = node.Right().Accept(this); return(left.NotEqual(right)); }
public void BoolFalseEqualTest() { var equal = new NotEqual(new Bool(false), new Bool(false)); var result = (bool)equal.Execute(); Assert.Equal(false, result); }
public void CloneTest() { var exp = new NotEqual(new Number(2), new Number(2)); var clone = exp.Clone(); Assert.Equal(exp, clone); }
public void Visit(NotEqual op) { var left = VisitChild(op.Variable); var right = VisitChild(op.Literal); _codeStack.Peek().Expression = new CodeBinaryOperatorExpression(left.Expression, CodeBinaryOperatorType.IdentityInequality, right.Expression); }
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 void Visit(NotEqual n) { Helpers.Write("("); n.LeftExpression.Accept(this); Helpers.Write(" != "); n.RightExpression.Accept(this); Helpers.Write(")"); }
public override bool Visit(NotEqual node) { traverse(node.left); outputCode(" != ", false, false); traverse(node.right); //Visit((LogicalBinaryExpression) node); return(true); }
public bool CompareShouldBeAffectedIgnoreCase(string left, string right, bool ignoreCase) { var expression = Expression.Constant(""); var result = new NotEqual <CustomEntity>("!=", ignoreCase).Compare(expression, OperandBuilder.BuildUp(left), OperandBuilder.BuildUp(right)); return((bool)Expression.Lambda(result.Expression).Compile().DynamicInvoke()); }
/// <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(); }
/// <summary> /// Analyzes the specified expression. /// </summary> /// <param name="exp">The expression.</param> /// <returns>The result of analysis.</returns> public string Analyze(NotEqual exp) { if (exp.Parent is BinaryExpression && !(exp.Parent is While)) { return(ToString(exp, "({0} != {1})")); } return(ToString(exp, "{0} != {1}")); }
public void NotEqual_WithString3Double3_ReturnsFalse() { var left = new Constant("3"); var right = new Constant(3.0); var operation = new NotEqual(left, right); var actual = (bool)operation.GetExpression(null).Calculate(); Assert.AreEqual(false, actual); }
//----------------------------------------------------------- public string Visit(NotEqual node, Table table) { return(String.Format( "{0}{1}" + "\t\tceq\n" + "\t\tldc.i4.0\n" + "\t\tceq\n", Visit((dynamic)node[0], table), Visit((dynamic)node[1], table))); }
public static ICriteria <T> NotEqual <T>(this IPredicate <T> predicate, object value) { var root = (IRestorableQuery <T>)predicate; var @operator = new NotEqual(); var criteria = new SingleCriteria <T>(root.RootQuery, predicate, @operator, value); root.RootQuery.Criterias.Add(criteria); return(criteria); }
public void Evaluate_NotEqual_String_False_Test() { Expression left = CreateStringLiteral("notEqual"); Expression right = CreateStringLiteral("notEqual"); Expression notEqual = new NotEqual(left, right, pos); Values.Bool value = ((Values.Bool)notEqual.Accept(evaluator)); Assert.IsFalse(value.GetValue()); }
/// <summary> /// ステータスをチェック:ステータスが存在しない場合は falseを返す /// </summary> /// <param name="stsmgr"></param> /// <returns></returns> public bool CheckStatus(IStatusManager stsmgr) { if (_op == null && Status != null) { _op = new And(); var coa = Status.Split('&', StringSplitOptions.RemoveEmptyEntries); foreach (var a in coa) { var idx = a.IndexOf("!="); if (idx >= 0) { var eq = new NotEqual { StatusName = StrUtil.Left(a, idx).Trim(), StatusValue = StrUtil.Mid(a, idx + 2), }; _op.Commands.Add(eq); continue; } idx = a.IndexOf("="); if (idx >= 0) { var eq = new Equal { StatusName = StrUtil.Left(a, idx).Trim(), StatusValue = StrUtil.Mid(a, idx + 1).Trim(), }; _op.Commands.Add(eq); continue; } else { if (a.Trim().StartsWith('!')) { _op.Commands.Add(new Equal { StatusName = a.Trim().Substring(1), StatusValue = "False", }); } else { _op.Commands.Add(new NotEqual { StatusName = a.Trim(), StatusValue = "False", }); } } } } return(_op?.Check(stsmgr) ?? false); }
protected virtual Expression OnVisit(NotEqual expression) { var left = OnVisit(expression.Left); var right = OnVisit(expression.Right); if (left != expression.Left || right != expression.Right) { return(CopyTrivia(new NotEqual(left, right), expression)); } return(expression); }
public void Evaluate_NotEqual_Int_True_Test() { Expression left = CreateIntLiteral(1); Expression right = CreateIntLiteral(2); Expression notEqual = new NotEqual(left, right, pos); Values.Bool value = ((Values.Bool)notEqual.Accept(evaluator)); Assert.IsTrue(value.GetValue()); }
public void NumberAndBoolVarEqualTest() { var parameters = new ParameterCollection() { new Parameter("x", 10), new Parameter("y", false) }; var equal = new NotEqual(Variable.X, new Variable("y")); Assert.Throws <NotSupportedException>(() => equal.Execute(parameters)); }
public void BoolTrueAndFalseVarEqualTest() { var parameters = new ParameterCollection() { new Parameter("x", true), new Parameter("y", false) }; var equal = new NotEqual(Variable.X, new Variable("y")); var result = (bool)equal.Execute(parameters); Assert.True(result); }
public void BoolFalseVarEqualTest() { var parameters = new ParameterCollection() { new Parameter("x", false), new Parameter("y", false) }; var equal = new NotEqual(new Variable("x"), new Variable("y")); var result = (bool)equal.Execute(parameters); Assert.Equal(false, result); }
public void NumberVarEqualTest() { var parameters = new ParameterCollection() { new Parameter("x", 11), new Parameter("y", 10) }; var equal = new NotEqual(Variable.X, new Variable("y")); var result = (bool)equal.Execute(parameters); Assert.True(result); }
public StringFilter ToUpper() { Equal = Equal?.ToUpper(); NotEqual = NotEqual?.ToUpper(); Contain = Contain?.ToUpper(); NotContain = NotContain?.ToUpper(); StartWith = StartWith?.ToUpper(); NotStartWith = NotStartWith?.ToUpper(); EndWith = EndWith?.ToUpper(); NotEndWith = NotEndWith?.ToUpper(); return(this); }
static RuleSet CreateRuleset(string rulesetName) { // create a simple rule // IF MySampleBusinessObject.MyValue != XMLdocument.ID // THEN MySampleBusinessObject.MySampleMethod1(5) //Creating the XML bindings on the SampleSchema XSD //Document Binding that binds to the schema name and specifies the selector XPathPair xp_root = new XPathPair("/*[local-name()='Root']", "Root"); XMLDocumentBinding xdb = new XMLDocumentBinding("SampleSchema", xp_root); //DocumentField Bindings that bind to the fields in the schema that need to be used in rule defintion XPathPair xp_ID = new XPathPair("/*[local-name()='Root']/*[local-name()='ID']", "ID"); XMLDocumentFieldBinding xfb1 = new XMLDocumentFieldBinding(Type.GetType("System.Int32"), xp_ID, xdb); //Creating .NET class (property and member) bindings // Class Bindings to bind to the class defintions whose properties and memebers will be used in rule defintion ClassBinding cb = new ClassBinding(typeof(Microsoft.Samples.BizTalk.BusinessRulesHelloWorld2.HelloWorld2Library.HelloWorld2LibraryObject)); // Member Bindings to bind to the properties and members in the MySampleBusinessObject class that need to be used in rule definition ClassMemberBinding myValue = new ClassMemberBinding("MyValue", cb); ArgumentCollection argList = new ArgumentCollection(); argList.Add(new Constant(5)); ClassMemberBinding method1 = new ClassMemberBinding("MySampleMethod", cb, argList); // create IF part LogicalExpression condition = new NotEqual(new UserFunction(myValue), new UserFunction(xfb1)); // create then part ActionCollection actions = new ActionCollection(); actions.Add(new UserFunction(method1)); // create the rule Rule rule1 = new Rule("rule1", 0, condition, actions); //create the verion information and ruleset description DateTime time = new DateTime(System.DateTime.Now.Year, System.DateTime.Now.Month, System.DateTime.Now.Day); VersionInfo vinf1 = new VersionInfo("Sample RuleSet to demonstrate the use of the Policy object", time, "BizRules", 1, 0); // create the ruleset RuleSet rs1 = new RuleSet(rulesetName, vinf1); rs1.Rules.Add(rule1); return(rs1); }
public SemanticAtom Visit(NotEqual n) { var left = n.LeftExpression.Accept(this) as SemanticType; var right = n.RightExpression.Accept(this) as SemanticType; if (!left.IsAssignableFrom(right) && !right.IsAssignableFrom(left)) { Globals.Errors.Add($"[{n.LeftExpression.Location.StartLine}, {n.LeftExpression.Location.StartColumn}] The two expressions of (!=) are not comparable types ({left.Name}, {right.Name})."); } n.RealizedType = Primitive.Boolean; return(n.RealizedType); }
public string Visit(NotEqual node) { var result = "\t\tldc.i4 42\n"; result += Visit((dynamic)node[0]); result += Visit((dynamic)node[1]); var labelSuccess = GenerateLabel(); result += "\t\tbne.un " + labelSuccess + "\n"; result += "\t\tpop\n"; result += "\t\tldc.i4 0\n"; result += "\t\t" + labelSuccess + ":\n"; return(result); }
public void Visit(NotEqual n) { Helpers.WriteLine($"{_tab}{n.Text} [{n.Location.StartLine}, {n.Location.StartColumn}]"); Tab(); Helpers.WriteLine($"{_tab}Left"); Tab(); n.LeftExpression.Accept(this); Untab(); Helpers.WriteLine($"{_tab}Right"); Tab(); n.RightExpression.Accept(this); Untab(); Untab(); }
public override void VisitNotEqual(NotEqual n) { SetupOperands(n); if (_lastWalkedType == typeof(String)) { _gen.Emit(OpCodes.Call, typeof(String).GetMethod("Equals", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(string), typeof(string) }, null)); } else { _gen.Emit(OpCodes.Ceq); } //compare it with 0 to negate _gen.Emit(OpCodes.Ldc_I4_0); _gen.Emit(OpCodes.Ceq); _lastWalkedType = typeof(bool); }
public void SetUp() { testee = new NotEqual<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 NotEqualCorrectlyConvertsToJson() { var neq = new NotEqual<string>("foo"); neq.ToString().ShouldEqual(NotEqualJson); }
public virtual void Visit(NotEqual node) { }
public virtual void VisitNotEqual(NotEqual n) { }