public void RadicalIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Radical(25, 2);
Assert.AreEqual(5, calc.Result);
}
public void BasicControllerGeneration()
{
var calculator = new BasicCalculator(new Addition(), new Subtraction());
Assert.Equal(3, calculator.Add(2, 1));
Assert.Equal(1, calculator.Subtract(2, 1));
}
public void MultiplyDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Multiplication(5.5M, 2.5M);
Assert.AreEqual(13.75M, calc.Result);
}
public void MultiplyIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Multiplication(10, 3);
Assert.AreEqual(30, calc.Result);
}
public void RadicalDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Radical(5.8M, 2M);
Assert.AreEqual(2.40831891575846M, calc.Result);
}
public void DivideDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Divide(10.5M, 2M);
Assert.AreEqual(5.25M, calc.Result);
}
public void DivideIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Divide(10, 2);
Assert.AreEqual(5, calc.Result);
}
public void SubtractIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Subtract(10, 5);
Assert.AreEqual(5, calc.Result);
}
public void SubtractDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Subtract(10.5M, 5.5M);
Assert.AreEqual(5, calc.Result);
}
public void AddIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Add(4, 5);
Assert.AreEqual(9, calc.Result);
}
public void AddDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Add(5.5M, 4.5M);
Assert.AreEqual(10M, calc.Result);
}
static void Main(string[] args)
{
IBasicCalculator ibc = new BasicCalculator();
for (int i = 0; ; i++)
{
Console.WriteLine("Enter Your Choice:");
Console.WriteLine("1.Press '+' for Addition.");
Console.WriteLine("2.Press '-' for Addition.");
Console.WriteLine("3.Press '*' for Addition.");
Console.WriteLine("4.Press '/' for Addition.");
string choice;
choice = Console.ReadLine();
switch (choice)
{
case "+":
ibc.Addition();
break;
case "-":
ibc.Subtraction();
break;
case "*":
ibc.Multiplication();
break;
case "/":
ibc.Division();
break;
}
}
}
public void PowerDecimalTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Exponentiation(7.5M, 2M);
Assert.AreEqual(56.25M, calc.Result);
}
public void PowerIntTest()
{
BasicCalculator calc = new BasicCalculator();
calc.Exponentiation(5, 2);
Assert.AreEqual(25, calc.Result);
}
public void DivideDecimalArrayTest()
{
decimal[] test = { 40.8M, 5M, 2M };
BasicCalculator calc = new BasicCalculator();
calc.Divide(test);
Assert.AreEqual(4.08M, calc.Result);
}
public void SubtractDecimalArrayTest()
{
decimal[] test = { 10M, 2.5M, 1M };
BasicCalculator calc = new BasicCalculator();
calc.Subtract(test);
Assert.AreEqual(6.5M, calc.Result);
}
public void DivideIntArrayTest()
{
int[] test = { 20, 5, 2 };
BasicCalculator calc = new BasicCalculator();
calc.Divide(test);
Assert.AreEqual(2, calc.Result);
}
public void AddDecimalArrayTest()
{
decimal[] testArr = { 1.5M, 2.5M, 3.5M };
BasicCalculator calc = new BasicCalculator();
calc.Add(testArr);
Assert.AreEqual(7.5M, calc.Result);
}
public void AddIntArrayTest()
{
int[] testArr = { 1, 2, 3 };
BasicCalculator calc = new BasicCalculator();
calc.Add(testArr);
Assert.AreEqual(6, calc.Result);
}
public void MultiplyDecimalArrayTest()
{
decimal[] test = { 2.5M, 7.5M, 5M };
BasicCalculator calc = new BasicCalculator();
calc.Multiplication(test);
Assert.AreEqual(93.75M, calc.Result);
}
public void MultiplyIntArrayTest()
{
int[] test = { 5, 2, 3 };
BasicCalculator calc = new BasicCalculator();
calc.Multiplication(test);
Assert.AreEqual(30, calc.Result);
}
public void SubtractIntArrayTest()
{
int[] test = { 5, 1, 2 };
BasicCalculator calc = new BasicCalculator();
calc.Subtract(test);
Assert.AreEqual(2, calc.Result);
}
public void Divide_ByZero_ThrowsDivideByZeroException()
{
var calc = new BasicCalculator();
calc.Add(10);
Assert.Throws <DivideByZeroException>(() => calc.Divide(0));
}
private void CalculatorGUI_Load(object sender, EventArgs e)
{
SetUpToolTips();
this.newExpression = true;
this.returnResult = false;
this.timeToShow = VisibleTime;
this.arguments = new string[3];
this.calculator = new BasicCalculator();
}
public void Add_WithValue_ShouldBeAddedToTotal(decimal value, decimal result)
{
// Arrange
var calc = new BasicCalculator();
// Act
calc.Add(value);
// Assert
Assert.Equal(result, calc.CurrentResult);
}
public void Subtract_WithValue_ShouldBeSubtractedFromTotal()
{
// Arrange
var calc = new BasicCalculator();
decimal value = 5.0M;
// Act
calc.Subtract(value);
// Assert
Assert.Equal(-5M, calc.CurrentResult);
}
public void Subtract_WithValue_ShouldAddExpressionToHistory()
{
// Arrange
var calc = new BasicCalculator();
decimal value = 5.0M;
// Act
calc.Subtract(value);
// Assert
Assert.Contains("0 - 5.0", calc.History);
}
public void realModularFrame()
{
var ironOreForIronInglotForIronPlateTree = new ConstructionTree(Database.get(ItemType.ironOre));
var ironOreForIronInglotForIronRodForScrewTree = new ConstructionTree(Database.get(ItemType.ironOre));
var ironOreForIronInglotForIronRodForModularFrameTree = new ConstructionTree(Database.get(ItemType.ironOre));
var ironInglotForIronPlateTree = new ConstructionTree(Database.get(ItemType.ironInglot));
var ironInglotForIronRodForScrewTree = new ConstructionTree(Database.get(ItemType.ironInglot));
var ironInglotForIronRodForModularFrameTree = new ConstructionTree(Database.get(ItemType.ironInglot));
var ironPlateForReinforcedIronPlateTree = new ConstructionTree(Database.get(ItemType.ironPlate));
var ironRodForScrewTree = new ConstructionTree(Database.get(ItemType.ironRod));
var ironRodForModularFrameTree = new ConstructionTree(Database.get(ItemType.ironRod));
var screwForReinforcedIronPlateTree = new ConstructionTree(Database.get(ItemType.screw));
var modularFrameTree = new ConstructionTree(Database.get(ItemType.modularFrame));
var reinforcedIronPlateForModularFrameTree = new ConstructionTree(Database.get(ItemType.reinforcedIronPlate));
ironInglotForIronPlateTree.addIngredient(ironOreForIronInglotForIronPlateTree);
ironPlateForReinforcedIronPlateTree.addIngredient(ironInglotForIronPlateTree);
reinforcedIronPlateForModularFrameTree.addIngredient(ironPlateForReinforcedIronPlateTree);
modularFrameTree.addIngredient(reinforcedIronPlateForModularFrameTree);
ironInglotForIronRodForScrewTree.addIngredient(ironOreForIronInglotForIronRodForScrewTree);
ironRodForScrewTree.addIngredient(ironInglotForIronRodForScrewTree);
screwForReinforcedIronPlateTree.addIngredient(ironRodForScrewTree);
reinforcedIronPlateForModularFrameTree.addIngredient(screwForReinforcedIronPlateTree);
ironInglotForIronRodForModularFrameTree.addIngredient(ironOreForIronInglotForIronRodForModularFrameTree);
ironRodForModularFrameTree.addIngredient(ironInglotForIronRodForModularFrameTree);
modularFrameTree.addIngredient(ironRodForModularFrameTree);
var wantedProductionPerMinute = 2;
var basicCalculator = new BasicCalculator();
basicCalculator.adjustComponentTreeToWantedProduction(modularFrameTree, wantedProductionPerMinute);
Assert.AreEqual(reinforcedIronPlateForModularFrameTree.root.buildingDevices.Count, 2);
Assert.AreEqual(reinforcedIronPlateForModularFrameTree.root.buildingDevices[0].getClockSpeed(), 60.0);
Assert.AreEqual(ironRodForModularFrameTree.root.buildingDevices.Count, 2);
Assert.AreEqual(ironRodForModularFrameTree.root.buildingDevices[0].getClockSpeed(), 80.0);
Assert.AreEqual(ironInglotForIronPlateTree.root.buildingDevices.Count, 4);
Assert.AreEqual(ironInglotForIronPlateTree.root.buildingDevices[0].getClockSpeed(), 90.0);
Assert.AreEqual(screwForReinforcedIronPlateTree.root.buildingDevices.Count, 2);
Assert.AreEqual(screwForReinforcedIronPlateTree.root.buildingDevices[0].getClockSpeed(), 90.0);
Assert.AreEqual(ironOreForIronInglotForIronRodForScrewTree.root.buildingDevices.Count, 3);
Assert.AreEqual(ironOreForIronInglotForIronRodForScrewTree.root.buildingDevices[0].getClockSpeed(), 80.0);
}
public void GivenIHaveANewBasicCalculator(string calculatorName)
{
if (calculatorName == "Basic Calculator")
{
var instance = new BasicCalculator(); //we let this to IoC container
ScenarioContext.Current.ScenarioContainer.RegisterInstanceAs(instance, typeof(ICalculator), calculatorName);
}
if (calculatorName == "Advanced Calculator")
{
var instance = new AdvancedCalculator(); //we let this to IoC container
ScenarioContext.Current.ScenarioContainer.RegisterInstanceAs(instance, typeof(ICalculator), calculatorName);
}
}
public void Multiply_WithValue_ShouldAddExpressionToHistory()
{
// Arrange
var calc = new BasicCalculator();
decimal starterValue = 5.0M;
decimal value = 5.0M;
// Act
calc.Add(starterValue);
calc.Multiply(value);
// Assert
Assert.Contains("5.0 * 5.0", calc.History);
}
public CalcProxy(LimitsValidator validator,
BasicCalculator calculator)
{
_calculator = calculator;
_validator = validator;
}
public void SetUp()
{
_expressionValidator = new MathRegex();
_fixer = new ExpressionFixer();
_lexer = new MathLexer(_fixer);
_calculator = new Calculator();
_validator = new Validator(-20, 20);
_calcProxy = new CalcProxy(_validator, _calculator);
}
public void SetUp()
{
_calculator = new Calculator();
_validator = new Validator(-20, 20);
_calcProxy = new CalcProxy(_validator, _calculator);
_expressionValidator = new MathRegex();
_fixer = new ExpressionFixer();
_lexer = new MathLexer(_fixer);
_precedence = new Precedence();
_resolver = new Resolver(_lexer, _calcProxy, _precedence);
_parser = new MathParser(_lexer, _expressionValidator, _resolver);
}
public CalcProxy(Validator validator, BasicCalculator calculator)
{
// TODO: Complete member initialization
_validator = validator;
_calculator = calculator;
}
