public void CanAddIntegers()
{
var scalar1 = ScalarValue.Create(1);
var scalar2 = ScalarValue.Create(1);
var op = new OperandPair(scalar1, scalar2);
var result = calc.Add(op);
Assert.IsInstanceOf<ScalarValue>(result);
var expected = scalar1 + scalar2;
Assert.AreEqual(expected, result);
}
public void CanEqualsPIDLoop()
{
var pidLoop1 = new PIDLoop();
var pidLoop2 = new PIDLoop();
var op = new OperandPair(pidLoop1, pidLoop2);
var result = calc.Equal(op);
Assert.IsFalse((bool)result);
op = new OperandPair(pidLoop1, pidLoop1);
result = calc.Equal(op);
Assert.IsTrue((bool)result);
}
public void CanEqualsPIDLoop()
{
var pidLoop1 = new PIDLoop();
var pidLoop2 = new PIDLoop();
var op = new OperandPair(pidLoop1, pidLoop2);
var result = calc.Equal(op);
Assert.IsFalse((bool)result);
op = new OperandPair(pidLoop1, pidLoop1);
result = calc.Equal(op);
Assert.IsTrue((bool)result);
}
public void CanAddIntegers()
{
var scalar1 = ScalarValue.Create(1);
var scalar2 = ScalarValue.Create(1);
var op = new OperandPair(scalar1, scalar2);
var result = calc.Add(op);
Assert.IsInstanceOf <ScalarValue>(result);
var expected = scalar1 + scalar2;
Assert.AreEqual(expected, result);
}
public override object Divide(OperandPair pair)
{
CheckPairForNull(pair, "Divide");
object result;
if (TryInvokeExplicit(pair, "op_Division", out result))
{
return result;
}
OperandPair resultPair;
if (TryCoerceImplicit(pair, out resultPair))
{
return Divide(resultPair);
}
throw new KOSException(GetMessage("/", pair));
}
public override object Add(OperandPair pair)
{
CheckPairForNull(pair, "Add");
object result;
if (TryInvokeExplicit(pair, "op_Addition", out result))
{
return result;
}
OperandPair resultPair;
if (TryCoerceImplicit(pair, out resultPair))
{
return Add(resultPair);
}
throw new KOSException(GetMessage("+", pair));
}
public override object GreaterThan(OperandPair pair)
{
CheckPairForNull(pair, "GreaterThan");
object result;
if (TryInvokeExplicit(pair, "op_GreaterThan", out result))
{
return result;
}
OperandPair resultPair;
if (TryCoerceImplicit(pair, out resultPair))
{
return GreaterThan(resultPair);
}
throw new KOSException(GetMessage(">", pair));
}
public override object Equal(OperandPair pair)
{
CheckPairForNull(pair, "Equal");
object result;
if (TryInvokeExplicit(pair, "op_Equality", out result))
{
return result;
}
OperandPair resultPair;
if (TryCoerceImplicit(pair, out resultPair))
{
return Equal(pair);
}
return pair.Left.Equals(pair.Right);
}
public static Calculator GetCalculator(OperandPair operandPair)
{
var scalarCount = 0;
var stringCount = 0;
var specialCount = 0;
var boolCount = 0;
if (operandPair.Left is ScalarValue) scalarCount++;
if (operandPair.Left is StringValue) stringCount++;
if (operandPair.Left is ISuffixed) specialCount++;
if (operandPair.Left is BooleanValue) boolCount++;
if (operandPair.Right is ScalarValue) scalarCount++;
if (operandPair.Right is StringValue) stringCount++;
if (operandPair.Right is ISuffixed) specialCount++;
if (operandPair.Right is BooleanValue) boolCount++;
if (scalarCount == 2) return new CalculatorScalar();
if (stringCount > 0) return new CalculatorString();
if (boolCount > 0) return new CalculatorBool();
if (specialCount > 0) return new CalculatorStructure();
throw new NotImplementedException(string.Format("Can't operate types {0} and {1}", operandPair.Left.GetType(), operandPair.Right.GetType()));
}
/// <summary>
/// Describe the error in terms of the two operands and the verb/preposition
/// being done with them. For example:
/// </summary>
/// <param name="pair">the left and right objects of the preposition</param>
/// <param name="verb">present-tense singular conjugation of the operation's verb, i.e "add"</param>
/// <param name="preposition">preposition usually used with the verb, i.e you add "to", but divide "by".</param>
public KOSBinaryOperandTypeException(OperandPair pair, string verb, string preposition) :
base(String.Format(TERSE_MSG_FMT, verb, pair.Left.GetType().Name, preposition, pair.Right.GetType().Name))
{
}
public abstract object Subtract(OperandPair pair);
public abstract object NotEqual(OperandPair pair);
public abstract object LessThanEqual(OperandPair pair);
public abstract object Divide(OperandPair pair);
public override object NotEqual(OperandPair pair)
{
return !string.Equals(pair.Left.ToString(), pair.Right.ToString(), StringComparison.OrdinalIgnoreCase);
}
public override object LessThanEqual(OperandPair pair)
{
int compareNum = string.Compare(pair.Left.ToString(), pair.Right.ToString(), StringComparison.OrdinalIgnoreCase);
return compareNum <= 0;
}
public override object GreaterThan(OperandPair pair)
{
int compareNum = string.Compare(pair.Left.ToString(), pair.Right.ToString(), StringComparison.OrdinalIgnoreCase);
return compareNum > 0;
}
public override object Add(OperandPair pair)
{
return new StringValue(string.Concat(pair.Left, pair.Right));
}
public override object Power(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "exponentiate", "by");
}
public override object Subtract(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "subtract", "from");
}
/// <summary>
/// Describe the error in terms of the two operands and the verb/preposition
/// being done with them. For example:
/// </summary>
/// <param name="pair">the left and right objects of the preposition</param>
/// <param name="verb">present-tense singular conjugation of the operation's verb, i.e "add"</param>
/// <param name="preposition">preposition usually used with the verb, i.e you add "to", but divide "by".</param>
public KOSBinaryOperandTypeException(OperandPair pair, string verb, string preposition)
: base(String.Format(TERSE_MSG_FMT, verb, pair.Left.GetType().Name, preposition, pair.Right.GetType().Name))
{
}
public abstract object Add(OperandPair pair);
public override object Add(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "add", "to");
}
public abstract object GreaterThanEqual(OperandPair pair);
public override object Divide(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "divide", "by");
}
public abstract object Multiply(OperandPair pair);
public override object GreaterThan(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "ordinate", ">");
}
public abstract object Power(OperandPair pair);
public override object Multiply(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "multiply", "by");
}
public override void Execute(ICpu cpu)
{
object right = cpu.PopValue();
object left = cpu.PopValue();
var operands = new OperandPair(left, right);
Calculator calc = Calculator.GetCalculator(operands);
Operands = operands;
object result = ExecuteCalculation(calc);
cpu.PushStack(result);
}
public override object NotEqual(OperandPair pair)
{
return new BooleanValue(Convert.ToBoolean(pair.Left) != Convert.ToBoolean(pair.Right));
}
public override object LessThanEqual(OperandPair pair)
{
throw new KOSBinaryOperandTypeException(pair, "ordinate", "<=");
}
private bool TryInvokeExplicit(OperandPair pair, string methodName, out object result)
{
MethodInfo method1 = pair.LeftType.GetMethod(methodName, FLAGS, null, new[] { pair.LeftType, pair.RightType }, null);
if (method1 != null)
{
result = method1.Invoke(null, new[] {pair.Left, pair.Right});
return true;
}
MethodInfo method2 = pair.RightType.GetMethod(methodName, FLAGS, null, new[] { pair.LeftType, pair.RightType }, null);
if (method2 != null)
{
result = method2.Invoke(null, new[] {pair.Left, pair.Right});
return true;
}
result = null;
return false;
}
