public void ThrowException_WhenValidatorThrowsException(string input, ArgumentException argumentException)
{
A.CallTo(() => _inputValidator.Validate(A <decimal[]> .Ignored, A <bool> .Ignored, A <decimal?> .Ignored)).Throws(argumentException);
var calculatorInput = new CalculatorInput(input, Operation.Add);
var exception = Should.Throw <ArgumentException>(() => _calculatorClient.Calculate(calculatorInput));
exception.ShouldBe(argumentException);
}
public ActionResult GetInput(CalculatorInput input)
{
if (ModelState.IsValid)
{
var output = new CalculatorOutput(input);
return(View("Results", output));
}
else
{
return(View(input));
}
}
public void InterpretCustomDelimiters_ComboSingleMultiCharacterDelimitersProvided_TreatedLikeNoDelimitersProvided()
{
string userInput = @"//;[***][26]\n11***22***33";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInputHandler.AcceptableDelimiters.Count == 2);
Assert.IsTrue(!calculatorInputHandler.AcceptableDelimiters.Contains("***"));
Assert.IsTrue(calculatorInput.Numbers.Count == 2);
Assert.IsTrue(calculatorInput.Numbers[0] == 0);
Assert.IsTrue(calculatorInput.Numbers[1] == 0);
}
public void InterpretCustomDelimiters_MoreThanSingleCharacterDelimiterProvided_ReturnSuccessful()
{
string userInput = @"//;;\n2;5";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInputHandler.AcceptableDelimiters.Count == 2);
Assert.IsTrue(!calculatorInputHandler.AcceptableDelimiters.Contains(";"));
Assert.IsTrue(calculatorInput.Numbers.Count == 2);
Assert.IsTrue(calculatorInput.Numbers[0] == 0);
Assert.IsTrue(calculatorInput.Numbers[1] == 0);
}
public string Calculate(CalculatorInput alculatorInput)
{
var values = _parser.Parse(alculatorInput.Input, alculatorInput.AlternateDelimiter);
var validNumbers = _validator.Validate(values, alculatorInput.AllowNegative, alculatorInput.MaxNumber);
var response = _calculator.Run(
_operatorProvider.GetByOperation(alculatorInput.Operation),
validNumbers,
_operatorProvider.GetSymbolByOperation(alculatorInput.Operation));
return(response.ToString());
}
public void InterpretCalculatorInput_NumbersOver1000Excluded_ReturnSuccessful()
{
string userInput = @"2,1001,6";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
calculatorInputHandler.ReplaceAlternativeDelimiterWithArgumentDelimiter("|");
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInput.Numbers.Count == 2);
Assert.IsTrue(calculatorInput.Numbers[0] == 2);
Assert.IsTrue(calculatorInput.Numbers[1] == 6);
}
public void CallCalculatorWithValidNumber_WhenValidatorReturnsValidNumbers(string input)
{
var numbers = new decimal[] { 1, 0, 5 };
A.CallTo(() => _inputValidator.Validate(A <decimal[]> .Ignored, false, A <decimal?> .Ignored)).Returns(numbers);
var calculatorInput = new CalculatorInput(input, Operation.Add);
_calculatorClient.Calculate(calculatorInput);
A.CallTo(() => _calculator.Run(A <Func <decimal, decimal, decimal> > .Ignored, numbers,
A <string> .Ignored))
.MustHaveHappenedOnceExactly();
}
public void InterpretCustomDelimiters_SingleMultiCharacterDelimiterProvided_ReturnSuccessful()
{
string userInput = @"//[***]\n11***22***33";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInputHandler.AcceptableDelimiters.Count == 3);
Assert.IsTrue(calculatorInputHandler.AcceptableDelimiters.Contains("***"));
Assert.IsTrue(calculatorInput.Numbers.Count == 3);
Assert.IsTrue(calculatorInput.Numbers[0] == 11);
Assert.IsTrue(calculatorInput.Numbers[1] == 22);
Assert.IsTrue(calculatorInput.Numbers[2] == 33);
}
public void InterpretCalculatorInput_MultipleValidNumbersWithCommaAndArgumentDelimiters_ReturnSuccessful()
{
string userInput = @"1|2,3";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
calculatorInputHandler.ReplaceAlternativeDelimiterWithArgumentDelimiter("|");
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInput.Numbers.Count == 3);
Assert.IsTrue(calculatorInput.Numbers[0] == 1);
Assert.IsTrue(calculatorInput.Numbers[1] == 2);
Assert.IsTrue(calculatorInput.Numbers[2] == 3);
}
public IActionResult Calculate(int calculatorId, [FromBody] CalculatorInput calculatorInput)
{
var calculator = this.calculatorService.GetById(calculatorId);
var valueInputs = calculator.Module.Function.GetInputs();
for (var i = 0; i < valueInputs.Length; i++)
{
var input = calculatorInput.Inputs.FirstOrDefault(j => j.Key.Replace("_", " ") == valueInputs[i].Info.Name);
if (input.Key != null && input.Value != null)
{
try
{
valueInputs[i].Value = TypeConverter.ToObject <double>(input.Value);
}
catch (Exception ex)
{
return(this.BadRequest(new CalculateResult($"Bad value for input \"{valueInputs[i].Info.Name}\": {ex.Message}")));
}
continue;
}
var arrayInput = calculatorInput.ArrayInputs.FirstOrDefault(j => j.Key.Replace("_", " ") == valueInputs[i].Info.Name);
if (arrayInput.Key != null && arrayInput.Value != null)
{
try
{
valueInputs[i].Value = TypeConverter.ToArray <double[]>(arrayInput.Value);
}
catch (Exception ex)
{
return(this.BadRequest(new CalculateResult($"Bad value for input \"{valueInputs[i].Info.Name}\": {ex.Message}")));
}
}
}
try
{
var result = calculator.Module.Function.Calculate(valueInputs);
return(Json(new CalculateResult(result)));
}
catch (Exception ex)
{
return(this.BadRequest(new CalculateResult($"An error occurred during calculation: {ex.Message}.")));
}
}
/// <summary>
/// Calculate the aggregation of numbers in a delimited string based on console arguments and input
/// </summary>
/// <param name="userInput">numbers and delimiters in a delimited format</param>
/// <param name="args">applpication arguments</param>
/// <returns>A result of the calculation based on the configuration</returns>
public CalculatorResult Calculate(string userInput, string[] args)
{
CalculatorResult calculatorResult = new CalculatorResult();
try
{
ProgramArguments programArguments = programArgumentsHandler.InterpretProgramArguments(args);
if (programArguments.AlternateDelimiter.Length > 0)
{
calculatorInputHandler.ReplaceAlternativeDelimiterWithArgumentDelimiter(programArguments.AlternateDelimiter);
}
if (programArguments.UpperBoundExists)
{
calculatorInputHandler.UpperBound = programArguments.UpperBound;
}
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
if (!programArguments.AllowNegativeNumbers && calculatorInput.Numbers.Any(x => x < 0))
{
throw new NegativeNumberException("Negative numbers are not allowed: " + string.Join(",", calculatorInput.Numbers.Where(x => x < 0)));
}
try
{
calculatorResult = calculator.Calculate(calculatorInput.Numbers, Calculator.CreateCalculator(programArguments.CalculatorType));
}
catch (DivideByZeroException ex)
{
calculatorResult.ErrorMessage = $"{ex.Message}";
}
catch (Exception ex)
{
calculatorResult.ErrorMessage = $"Encountered an Error Attempting to Run Calculation: {ex.ToString()}";
}
}
catch (MaxNumbersExceededException ex)
{
calculatorResult.ErrorMessage = $"{ex.Message}";
}
catch (NegativeNumberException ex)
{
calculatorResult.ErrorMessage = $"{ex.Message}";
}
catch (Exception ex)
{
calculatorResult.ErrorMessage = $"Encountered an Error Attempting to Intepret the Calculator Input: {ex.ToString()}";
}
return(calculatorResult);
}
public void InterpretCalculatorInput_ArgumentProvidedUpperBoundExcluded_ReturnSuccessful()
{
const int UPPER_BOUND = 2000;
string userInput = @"2,1001,2001,6";
CalculatorInputHandler calculatorInputHandler = new CalculatorInputHandler();
calculatorInputHandler.UpperBound = UPPER_BOUND;
CalculatorInput calculatorInput = calculatorInputHandler.InterpretCalculatorInput(userInput);
Assert.IsTrue(calculatorInput.Numbers.Count == 3);
Assert.IsTrue(calculatorInput.Numbers[0] == 2);
Assert.IsTrue(calculatorInput.Numbers[1] == 1001);
Assert.IsTrue(calculatorInput.Numbers[2] == 6);
}
public void TestFileRead()
{
//to run tests find where the spreadsheet is located on your system couldn't figure out relative paths
string path = @"C:\Users\andel\GUI_Calculator\TestSpreadsheet.xlsx";
Assert.IsTrue(File.Exists(path));
List <CalculatorInput> calcInputs = fileHandler.ReadFromExcel(path).ToList();
CalculatorInput correctInput = new CalculatorInput(
new System.DateTime(2020, 1, 1),
new System.DateTime(2020, 1, 2),
"Days");
Assert.AreEqual(calcInputs[0].firstDateTime, correctInput.firstDateTime);
Assert.AreEqual(calcInputs[0].secondDateTime, correctInput.secondDateTime);
Assert.AreEqual(calcInputs[0].units, correctInput.units);
}
/// <summary>
/// Interprets a formatted delimited string with config data into an object for use by the calculator
/// </summary>
/// <param name="userInput">a formatted delimited string</param>
/// <returns>An object representing the data in the userInput</returns>
public CalculatorInput InterpretCalculatorInput(string userInput)
{
CalculatorInput calculatorInput = new CalculatorInput()
{
};
//Interpret the possible delimiters in the input string
userInput = InterpretCustomDelimiters(userInput);
//Split the string by all of the acceptable delimiters
List <string> splitUserInput = userInput.Split(AcceptableDelimiters.ToArray(), StringSplitOptions.None).ToList();
//Replace invalid entries with 0
calculatorInput.Numbers = splitUserInput.Select(x => int.TryParse(x, out int num) ? num : 0).Where(x => x <= UpperBound).ToList();
return(calculatorInput);
}
public CalculatorResult Calculate(CalculatorInput input)
{
int result = 0;
switch (input.Operation)
{
case "Add":
result = Add(input.Number1, input.Number2);
break;
case "Subtract":
result = Subtract(input.Number1, input.Number2);
break;
case "Multiply":
result = Multiply(input.Number1, input.Number2);
break;
case "Divide":
if (input.Number2 == 0)
{
throw new FaultException <DivideOperationFailure>(new DivideOperationFailure()
{
Number1 = input.Number1,
Number2 = input.Number2,
Message = "Only a dumbo will try to divide by zero"
});
}
if (input.Number2 % 2 == 0)
{
throw new FaultException <DivideByEvenNumberFailure>(new DivideByEvenNumberFailure()
{
Message = "This is juz for fun"
});
}
result = Divide(input.Number1, input.Number2);
break;
}
return(new CalculatorResult()
{
Number1 = input.Number1,
Number2 = input.Number2,
Operation = input.Operation,
Result = result
});
}
void IAdvancedCalculatorProcessor.Calculate(CalculatorInput input)
{
int result = 0;
switch (input.Operation)
{
case "Add":
result = Add(input.Number1, input.Number2);
break;
case "Subtract":
result = Subtract(input.Number1, input.Number2);
break;
case "Multiply":
result = Multiply(input.Number1, input.Number2);
break;
case "Divide":
if (input.Number2 == 0)
{
throw new FaultException <DivideOperationFailure>(new DivideOperationFailure()
{
Number1 = input.Number1,
Number2 = input.Number2,
Message = "Only a dumbo will try to divide by zero"
});
}
result = Divide(input.Number1, input.Number2);
break;
}
Console.WriteLine(new CalculatorResult()
{
Number1 = input.Number1,
Number2 = input.Number2,
Operation = input.Operation,
Result = result
});
}
private void AC_Click(object sender, EventArgs e)
{
CalculatorInput.Clear();
}
//GET: /Home/GetInput
public ActionResult GetInput()
{
var input = new CalculatorInput();
return(View(input));
}
public void GivenTheCostOfMyMealIs(decimal mealCost)
{
TestInput = new CalculatorInput();
TestInput.Amount = mealCost;
}
private void substraction_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText("-");
}
private void sum_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText("+");
}
private void divition_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText("/");
}
private void multiplication_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText("x");
}
private void Decimal_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText(",");
}
private void button0_Click(object sender, EventArgs e)
{
CalculatorInput.AppendText("0");
}
