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));
}
}
