public void TryingToGetHigherOperator() { OperatorFactory factory = GetOperatorFactory(); Operator op = factory.GetOperator(OperatorKeys.HigherKey); Assert.IsTrue(op.IsSameOperator(Operator.higher)); }
public void TryingToGetLessOperator() { OperatorFactory factory = GetOperatorFactory(); Operator op = factory.GetOperator(OperatorKeys.LessKey); Assert.IsTrue(op.IsSameOperator(Operator.less)); }
static OnesComplement() { OperatorFactory.TryBind(ref Invoke, (byte val) => ~val); OperatorFactory.TryBind(ref Invoke, (byte val) => (byte)~val); OperatorFactory.TryBind(ref Invoke, (sbyte val) => ~val); OperatorFactory.TryBind(ref Invoke, (sbyte val) => (sbyte)~val); OperatorFactory.TryBind(ref Invoke, (short val) => ~val); OperatorFactory.TryBind(ref Invoke, (short val) => (short)~val); OperatorFactory.TryBind(ref Invoke, (ushort val) => ~val); OperatorFactory.TryBind(ref Invoke, (ushort val) => (ushort)~val); OperatorFactory.TryBind(ref Invoke, (int val) => ~val); OperatorFactory.TryBind(ref Invoke, (uint val) => ~val); OperatorFactory.TryBind(ref Invoke, (long val) => ~val); OperatorFactory.TryBind(ref Invoke, (ulong val) => ~val); OperatorFactory.TryBind(ref Invoke, (char val) => ~val); OperatorFactory.TryBind(ref Invoke, (char val) => (char)~val); OperatorFactory.TryBind(ref Invoke, (bool val) => !val); Invoke = Invoke ?? OperatorFactory.CreateDelegate <Func <T, R> >("op_OnesComplement") ?? Throw.Func <T, R>; }
public EntityQueryStrategy(string key, string value, IEntityQueryMapper <T> queryMapper) { this.Key = key; this.value = value; this.entityPropertySelector = queryMapper.GetSelector(key); this.operation = OperatorFactory.Default(); }
public override InterpreterState MoveToNextState(Symbol symbol, ILexemesStack stack, ExecutorContext context) { switch (symbol.Type) { case SymbolType.Number: case SymbolType.Identifier: return(new ErrorState(symbol)); case SymbolType.Operator: var @operator = OperatorFactory.CreateOperator(symbol); stack.Push(@operator); switch (@operator) { case ClosingBracket _: return(new ClosingBracketOperatorState()); case CommaOperator _: case OpeningBracket _: case AssignmentOperator _: return(new ErrorState(symbol)); default: return(new BinaryOperatorState()); } default: return(new ErrorState(symbol)); } }
public void TryingToGetEqualOperator() { OperatorFactory factory = GetOperatorFactory(); Operator op = factory.GetOperator(OperatorKeys.EqualKey); Assert.IsTrue(op.IsSameOperator(Operator.equal)); }
public OperatorCreateHandler(GlobalSolusindoDb db, tblM_User user, OperatorValidator _operatorValidator, OperatorFactory _operatorFactory, OperatorQuery _operatorQuery, AccessControl accessControl) : base(db, user) { this._operatorValidator = _operatorValidator; this._operatorFactory = _operatorFactory; this._operatorQuery = _operatorQuery; this._operatorEntryDataProvider = new OperatorEntryDataProvider(db, user, accessControl, _operatorQuery); }
public override InterpreterState MoveToNextState(Symbol symbol, ILexemesStack stack, ExecutorContext context) { switch (symbol.Type) { case SymbolType.Number: case SymbolType.Identifier: return(new FunctionArgumentReadingState(_functionSignature, symbol)); case SymbolType.Operator: var @operator = OperatorFactory.CreateOperator(symbol, false); switch (@operator) { case OpeningBracket _: case PlusOperator _: case MinusOperator _: return(new FunctionArgumentReadingState(_functionSignature, symbol)); default: return(new ErrorState(symbol)); } default: return(new ErrorState(symbol)); } }
static Increment() { try { OperatorFactory.TryBind(ref Invoke, (byte val) => ++ val); OperatorFactory.TryBind(ref Invoke, (sbyte val) => ++ val); OperatorFactory.TryBind(ref Invoke, (short val) => ++ val); OperatorFactory.TryBind(ref Invoke, (ushort val) => ++ val); OperatorFactory.TryBind(ref Invoke, (int val) => ++ val); OperatorFactory.TryBind(ref Invoke, (uint val) => ++ val); OperatorFactory.TryBind(ref Invoke, (long val) => ++ val); OperatorFactory.TryBind(ref Invoke, (ulong val) => ++ val); OperatorFactory.TryBind(ref Invoke, (float val) => ++ val); OperatorFactory.TryBind(ref Invoke, (double val) => ++ val); OperatorFactory.TryBind(ref Invoke, (bool val) => true); OperatorFactory.TryBind(ref Invoke, (char val) => ++ val); Invoke = Invoke ?? OperatorFactory.CreateDelegate <Func <T, R> >("op_Increment"); } finally { Supported = Invoke != null; Invoke = Invoke ?? Throw.Func <T, R>; } }
private static QueryCondition BuildQueryCondition <T>(string postFilter) { var postFilterParts = postFilter.Split(new[] { "=", "==", "!=", "<>", ">", "<", ">=", "<=" }, 2, StringSplitOptions.RemoveEmptyEntries); if (postFilterParts.Length != 2) { return(null); } var propertyName = postFilterParts[0]; var constraintValue = postFilterParts[1]; var stringOperator = postFilter.Substring(propertyName.Length, postFilter.Length - propertyName.Length - constraintValue.Length); Operator binaryOperator; try { binaryOperator = OperatorFactory.FromString(stringOperator); } catch (ArgumentException) { // unsupported operators are ignored return(null); } var type = typeof(T); var property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance); if (property == null) { return(null); } var queryCondition = new QueryCondition() { Term = new OperatorTerm() { Operator = binaryOperator }, ConstraintValue = constraintValue, Property = new PropertyModel() { Alias = propertyName, Name = propertyName, Type = property.PropertyType.Name } }; return(queryCondition); }
void Start() { operatorFactory = new OperatorFactory(); operators = new List<GameObject>(); level = DifficultyMode.SelectedDifficulty; minNumOperators = 1; if (level == Difficulty.Easy) { maxNumOperators =1; } else if (level == Difficulty.Medium) { maxNumOperators = 2; } else if (level == Difficulty.Hard) { maxNumOperators = 3; } else if(level == Difficulty.Expert) { minNumOperators = 2; maxNumOperators = 4; } Debug.Log ("Difficutly = " + level); GetRandomEquation(); }
public int CalculatePostfixString(string[] values) { int result = 0; var stack = new Stack <int>(); foreach (string value in values) { // if value == number // then push to the stack if (IsNumeric(value)) { stack.Push(int.Parse(value)); } else if (IsOperator(value)) { // if value == operator // then pop first two values // then $result = operator(second popped value, first popped value) // then push $result to the stack var rightValue = stack.Pop(); var leftValue = stack.Pop(); var @operator = OperatorFactory.CreateOperator(value); result = @operator.Operate(leftValue, rightValue); stack.Push(result); } } return(result); }
private IMethodReturnMessage HandleObservableReturnType(IMethodCallMessage call, System.Reflection.MethodInfo method, OperatorInfo operatorInfo) { var actualObservable = ProduceActualObservable(call, method, operatorInfo); var ret = OperatorFactory.CreateOperatorObservable(actualObservable, method.ReturnType.GetGenericArguments()[0], operatorInfo); return(new ReturnMessage(ret, null, 0, null, call)); }
public void GetMaxPrecedence() { List <MathToken> tokens = _lexer.GetTokens("3 + 3 * 2"); MathToken token = _precedence.GetMaxPrecedence(tokens); MathOperator op = OperatorFactory.Create(token.Token); Assert.AreEqual(op.Token, "*"); }
public void TestEqualOperator_WithTwoEqualInt_EvaluationReturnTrue() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); int i = 1; int j = 1; Assert.AreEqual(i, j); Assert.IsTrue(op.evaluate(i, j)); }
public void TestLessOperatorWithDouble_SecondDoubleIsLesserThanFirstDouble_EvaluationReturnTrue() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.LessKey); double d1 = 2.2; double d2 = 1.2; Assert.IsTrue(!(d1 < d2)); Assert.IsFalse(op.evaluate(d1, d2)); }
public void TestHigherOperatorWithInt_SecondIntIsHigherThanFirstInt_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.HigherKey); int i = 1; int j = 2; Assert.IsTrue(!(i > j)); //Tactical ! (are ! are tactical) Assert.IsFalse(op.evaluate(i, j)); }
public void TestHigherOperatorWithInt_FirstIntIsHigherThanSecondInt_EvaluationReturnTrue() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.HigherKey); int i = 2; int j = 1; Assert.IsTrue(i > j); Assert.IsTrue(op.evaluate(i, j)); }
public void TestHigherOperatorWithDouble_SecondDoubleIsHigherThanFirstDouble_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.HigherKey); double d1 = 1.1; double d2 = 2.2; Assert.IsTrue(!(d1 > d2)); Assert.IsFalse(op.evaluate(d1, d2)); }
public void TestEqualOperator_WithTwoDiferentDouble_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); double d1 = 1.3; double d2 = d1 + 1.3; Assert.AreNotEqual(d1, d2); Assert.IsFalse(op.evaluate(d1, d2)); }
public void TestLessOperatorWithInt_SecondIntIsLesserThanFirstInt_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.LessKey); int i = 2; int j = 1; Assert.IsTrue(!(i < j)); Assert.IsFalse(op.evaluate(i, j)); }
public void TestEqualOperator_WithTwoEqualDouble_EvaluationReturnTrue() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); double d1 = 1.3; double d2 = 1.3; Assert.AreEqual(d1, d2); Assert.IsTrue(op.evaluate(d1, d2)); }
public void TestEqualOperator_WithTwoDiferentString_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); string st1 = "a"; string st2 = st1 + "a"; Assert.AreNotEqual(st1, st2); Assert.IsFalse(op.evaluate(st1, st2)); }
public void TestEqualOperator_WithTwoEqualString_EvaluationReturnTrue() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); string st1 = "a"; string st2 = "a"; Assert.AreEqual(st1, st2); Assert.IsTrue(op.evaluate(st1, st2)); }
public void TestEqualOperator_WithTwoDiferentInt_EvaluationReturnFalse() { Operator op = OperatorFactory.GetOperatorFactory().GetOperator(OperatorKeys.EqualKey); int i = 1; int j = i + 1; Assert.AreNotEqual(i, j); Assert.IsFalse(op.evaluate(i, j)); }
private void Calculate() { char operatorChar = operatorsStack.Pop(); double number1 = numbersStack.Pop(); double number2 = numbersStack.Pop(); double result = OperatorFactory.GetResult(operatorChar, number1, number2); numbersStack.Push(result); }
public void ThrowExceptionGivenNoOperator() { // Arrange OperatorFactory SystemUnderTest = new OperatorFactory(); string InvalidOperation = "1242&213124"; // Act + Assert Should.Throw <ArgumentException>(() => SystemUnderTest.Create(InvalidOperation)); }
/// <summary> /// 是否異常 /// </summary> /// <param name="monitor">監控訊息</param> /// <param name="target">監控項目資訊</param> /// <returns></returns> public string IsException(Monitor monitor, Target target) { var type = (AlarmOperatorType)Enum.Parse(typeof(AlarmOperatorType), target.OPERATOR_TYPE); var alarmOperator = OperatorFactory.CreateInstance(type); var conditions = target.ALARM_CONDITIONS.Select(x => x.TARGET_VALUE).ToList(); var falseResult = target.IS_EXCEPTION == "Y" ? "N" : "Y"; return(alarmOperator.Check(monitor.TARGET_VALUE, conditions) ? target.IS_EXCEPTION : falseResult); }
static UnaryPlus() { Invoke = OperatorFactory.CreateDelegate <Func <T, R> >("op_UnaryPlus"); if (Invoke != null) { return; } OperatorFactory.TryBind <T, R, T, T>(ref Invoke, val => val); Invoke = Invoke ?? Throw.Func <T, R>; }
public void SetUp() { var expressionValidator = new MathRegex(); var expressionFixer = new ExpressionFixer(expressionValidator); this.lexer = new MathLexer(expressionValidator, expressionFixer); var limitsValidator = new LimitsValidator(-100, 100); var proxy = new CalculatorProxy(limitsValidator); var calculator = new Calculator(); var operatorFactory = new OperatorFactory(proxy, calculator); this.parser = new MathParser(this.lexer, operatorFactory); }
public void CreateCorrectType(string operationText, Type createdType) { // Arrange OperatorFactory SystemUnderTest = new OperatorFactory(); // Act IOperator createdOperator = SystemUnderTest.Create(operationText); // Assert createdOperator.ShouldBeOfType(createdType); }
public override InterpreterState MoveToNextState(Symbol symbol, ILexemesStack stack, ExecutorContext context) { switch (symbol.Type) { case SymbolType.Number: case SymbolType.Identifier: _argumentBuilder.Append(symbol); return(this); case SymbolType.Operator: var @operator = OperatorFactory.CreateOperator(symbol); switch (@operator) { case OpeningBracket _: _bracketsBalance++; _argumentBuilder.Append(symbol); return(this); case ClosingBracket _: _bracketsBalance--; if (_bracketsBalance == 0) { _functionSignature.AppendArgument(_argumentBuilder); return(new FunctionSignatureEndState(_functionSignature)); } _argumentBuilder.Append(symbol); return(this); case CommaOperator _: if (_bracketsBalance != 1) { return(new ErrorState(symbol)); } if (_argumentBuilder.IsEmpty) { return(new ErrorState(symbol)); } _functionSignature.AppendArgument(_argumentBuilder); return(new FunctionArgumentReadingState(_functionSignature, null)); default: _argumentBuilder.Append(symbol); return(this); } default: return(new ErrorState(symbol)); } }