public void Calculate_MoreThanOneNumberZeroDivision_CannotDivideByZero()
{
string[] args = null;
string userInput = "";
calculatorInputHandler.InterpretCalculatorInput(Arg.Any <string>()).Returns(
new CalculatorInput {
Numbers = new List <int>()
{
24, 0
}
}
);
programArgumentsHandler.InterpretProgramArguments(Arg.Any <string[]>())
.Returns(new ProgramArguments {
CalculatorType = Calculator.CalculatorTypes.Division
});
CalculatorHandler calculatorHandler = new CalculatorHandler(calculatorInputHandler, programArgumentsHandler);
CalculatorResult calculatorResult = calculatorHandler.Calculate(userInput, args);
Assert.IsTrue(calculatorResult.Total == 0);
Assert.IsTrue(calculatorResult.Formula.Equals("0 = 0"));
Assert.IsTrue(calculatorResult.ErrorMessage.ToUpper().Contains("CANNOT DIVIDE BY ZERO"));
}
private CalculatorResult Triangle2D_Worker(int precision)
{
Stopwatch watch = Stopwatch.StartNew();
double radius = 500.0d;
double radius_squared = radius * radius;
double area = 0.0d;
double degrees_to_radians = (Math.PI / 180.0d);
double angle = (360.0d / (double)precision) * degrees_to_radians;
for (int i = 0; i < precision; i++)
{
//AREA OF AN ISOSCELES TRIANGLE
area += 0.5 * radius_squared * Math.Sin(angle);
}
// AREA OF CIRCLE = PI * R ^ 2
// PI = AREA / ( R ^2 )
CalculatorResult rc = new CalculatorResult();
double pi_calculated = area / (radius * radius);
double elapsed_time = watch.ElapsedMilliseconds;
return(new CalculatorResult(pi_calculated, elapsed_time));
}
private void PublishMessages(QueueName requestQueueName, QueueName replyQueueName, ref int processedMessages, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
processedMessages = 0;
Random random = new Random();
while (true)
{
long x = random.Next();
long y = random.Next();
Message <CalculatorOperation> message = new Message <CalculatorOperation>(TimeSpan.FromMinutes(5), new CalculatorOperation(replyQueueName, "+", x, y));
queueingService.PostMessages(requestQueueName, message);
bool handled = false;
while (true)
{
// process reply messages
using (Claim claim = queueingService.ClaimMessage(replyQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)))
{
foreach (QueuedMessage queuedMessage in claim.Messages)
{
CalculatorResult result = queuedMessage.Body.ToObject <CalculatorResult>();
if (result._id == message.Body._id)
{
// this is the reply to this thread's operation
Assert.AreEqual(message.Body._operand1 + message.Body._operand2, result._result);
Assert.AreEqual(x + y, result._result);
queueingService.DeleteMessage(replyQueueName, queuedMessage.Id, claim);
processedMessages++;
handled = true;
}
else if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
if (handled)
{
break;
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
public void Calculate_CalculatorNegativeNumbersDisallowed_NegativeNumberException()
{
string[] args = null;
string userInput = "";
programArgumentsHandler.InterpretProgramArguments(Arg.Any <string[]>())
.Returns(new ProgramArguments {
CalculatorType = Calculator.CalculatorTypes.Addition, AllowNegativeNumbers = false
});
calculatorInputHandler.InterpretCalculatorInput(Arg.Any <string>()).Returns(
new CalculatorInput {
Numbers = new List <int>()
{
24, -5, -3
}
}
);
CalculatorHandler calculatorHandler = new CalculatorHandler(calculatorInputHandler, programArgumentsHandler);
CalculatorResult calculatorResult = calculatorHandler.Calculate(userInput, args);
Assert.IsTrue(calculatorResult.Total == 0);
Assert.IsTrue(calculatorResult.Formula.Equals("0 = 0"));
Assert.IsTrue(calculatorResult.ErrorMessage.ToUpper().Contains("NEGATIVE NUMBERS ARE NOT ALLOWED: -5,-3"));
}
public CalculatorPage()
{
InitializeComponent();
resultLabel.Text = "0";
testEntry = new Entry()
{
Text = "Test"
};
testEntryCell = new EntryCell {
Text = "new"
};
formats = new FormatList();
var items = Enumerable.Range(0, 2);
ListView listView = new ListView();
listView.HasUnevenRows = true;
listView.RowHeight = 5;
listView.ItemTemplate = new DataTemplate(typeof(FormatCell));
listView.ItemsSource = formats;
CalculatorResult result = new CalculatorResult()
{
IsValid = true,
Result = 25
};
resultLabel.Text = new IntResult().GetFormatted(result.Result);
mainLayout.Children.Add(listView);
}
/// <summary>
/// Calculate the total of a list of numbers using polymorphism
/// </summary>
/// <param name="numbers"></param>
/// <param name="calculator"></param>
/// <returns></returns>
public CalculatorResult Calculate(List <int> numbers, Calculator calculator)
{
//Handle the first number
CalculatorResult calculatorResult = new CalculatorResult()
{
};
if (numbers.Count > 0 && calculator.IsValidNumbersSet(numbers))
{
string FORMULA_DELIMITER = calculator.GetFormulaDelimiter();
StringBuilder formula = new StringBuilder();
//Handle the first number without any airithmetic operation
calculatorResult.Total = numbers[0];
formula.Append((numbers[0]).ToString());
//Handle the subsequent numbers, operating between each one and the previous result
foreach (int number in numbers.GetRange(1, numbers.Count - 1))
{
calculatorResult.Total = calculator.ExecuteAirithmeticOperation(calculatorResult.Total, number);
formula.Append($"{FORMULA_DELIMITER}{number}");
}
//Attach the total to the formula concatenation
calculatorResult.Formula = $"{formula.ToString()} = {calculatorResult.Total}";
}
return(calculatorResult);
}
public void NoDiscountApplied(string dependentName)
{
//Arrange
int dependentCost = 500;
decimal discount = .1m;
var rule = new DependentRule(
dependentCost: dependentCost,
discount: discount
);
DependentModel dependentModel = new DependentModel()
{
Name = dependentName
};
CalculatorResult result = new CalculatorResult();
//Act
rule.Calculate(dependentModel, result);
//Assert
decimal expectedTotalCost = dependentCost;
Assert.AreEqual(dependentCost, result.Total);
Assert.AreEqual(1, result.Results.Count);
Assert.AreEqual(CostCodeEnum.DependentBaseCost, result.Results[0].CostCode);
Assert.AreEqual(dependentCost, result.Results[0].Value);
Assert.AreEqual(0, result.SubResults.Count);
}
public CalculatorResult Multiple(double first, double second)
{
CalculatorResult result = new CalculatorResult {
type = "Multiple", result = first * second
};
return(result);
}
public CalculatorResult Sub(double first, double second)
{
CalculatorResult result = new CalculatorResult {
type = "Sub", result = first - second
};
return(result);
}
internal MeasurementResult(IPerfConfiguration configuration, string name)
{
CalculatorResult calcResult = Calculate(StorageCollection.GetOrCreate(name), configuration.ForTime);
Name = name;
Count = calcResult.Count;
AverageCallTime = calcResult.AverageTime;
}
public CalculatorResult Add(double first, double second)
{
CalculatorResult result = new CalculatorResult {
type = "Add", result = first + second
};
return(result);
}
public override float Get_K(CalculatorResult h, float d, int e, int f)
{
if (h == CalculatorResult.P)
{
return(2 * d + (d * e / 100));
}
return(base.Get_K(h, d, e, f));
}
public void Calculate_DivisionInvalidNumber_DivideByZerioException()
{
List <int> numbers = new List <int> {
20, 0
};
calculator = Calculator.CreateCalculator(Calculator.CalculatorTypes.Division);
CalculatorResult calculatorResult = calculator.Calculate(numbers, calculator);
}
public void SmartStandardPattern_Calculates_Correctly_With_24_By_24_Room()
{
IPattern standardPattern = new SmartStandardPattern();
CalculatorResult result = standardPattern.Calculate(new Room(24, 24), new Tile(12, 12), .25);
Assert.AreEqual(4, result.WholeTilesUsed);
Assert.AreEqual(4, result.TotalCuts);
Assert.AreEqual(.02, result.WastePercentage);
}
public async Task <CalculatorResult> CalculateBtK1Async(double K, double S, double r, double t, double sigma, int n, double T)
{
CalculatorResult result = new CalculatorResult();
result.ResultNumber = 1;
result.BtResult = _btCalculator.CalculateBtK1(r, sigma, t, K, S, n, T);
result.PutResult = await _putCalculator.CalculateAsync(K, S, r, t, sigma, n, T, result.BtResult);
return(result);
}
public void StandardPattern_Calculates_Correctly_With_36_By_36_Room()
{
IPattern standardPattern = new StandardPattern();
CalculatorResult result = standardPattern.Calculate(new Room(36, 36), new Tile(12, 12), .25);
Assert.AreEqual(9, result.WholeTilesUsed);
Assert.AreEqual(6, result.TotalCuts);
Assert.AreEqual(.03, result.WastePercentage);
}
public void Calculate_NoNumbers_DefaultResult()
{
List <int> numbers = new List <int>();
calculator = Calculator.CreateCalculator(Calculator.CalculatorTypes.Addition);
CalculatorResult calculatorResult = calculator.Calculate(numbers, calculator);
Assert.IsTrue(calculatorResult.Total == 0);
Assert.IsTrue(calculatorResult.Formula.Equals("0 = 0"));
}
public void SmartStandardPattern_Calculates_Correctly_Using_Offcuts()
{
IPattern standardPattern = new SmartStandardPattern();
CalculatorResult result = standardPattern.Calculate(new Room(16.25, 36.5), new Tile(12, 12), .25);
Assert.AreEqual(4, result.WholeTilesUsed);
Assert.AreEqual(2, result.TotalCuts);
Assert.AreEqual(0, result.WastePercentage);
}
public void TestMethod_EgyptianPyramid()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.EgyptianPyramidEngine);
CalculatorResult rc = null;
rc = engine.Calculate();
Assert.AreEqual(rc.PI, 3.14, 0.05, "INVALID EGYPT CALCULATION");
}
public void TestMethod_MonteCarlo3D_100()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.MonteCarlo3DEngine);
CalculatorResult rc = null;
rc = engine.Calculate(100);
Assert.AreEqual(rc.PI, 3.141, 0.005, "INVALID MONTECARLO 3D CALCULATION");
}
public void TestMethod_Nilakantha()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.NilakanthaEngine);
CalculatorResult rc = null;
rc = engine.Calculate(10000);
Assert.AreEqual(rc.PI, 3.14, 0.05, "INVALID NILAKANTHA CALCULATION");
}
public void TestMethod_GregoryLeibniz_HundredMillionCalc()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.GregoryLeibnizEngine);
CalculatorResult rc = null;
rc = engine.Calculate(1000000 * 10);
Assert.AreEqual(rc.PI, 3.14, 0.005, "INVALID GREGORY-LEIBNIZ CALCULATION");
}
public void Four_Band_Register_Test()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new OhmValueCalculator();
//Act
CalculatorResult result = ohmValueCalculator.CalculateOhmValue("yellow", "violet", "red", "gold");
//Assert
Assert.AreEqual("4935", result.MaxResistance);
}
public void Large_Resistance_Tests()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new OhmValueCalculator();
//Act
CalculatorResult result = ohmValueCalculator.CalculateOhmValue("white", "white", "white", "silver");
//Assert
Assert.AreEqual("108,900M", result.MaxResistance);
}
public void CalculateResult_FindMatchingOffcut_Returns_Null_When_No_Suitable_Offcuts()
{
var result = new CalculatorResult(new Tile(12, 12));
result.Offcuts.Add(new Tile(2, 10));
result.Offcuts.Add(new Tile(6, 1));
var offcut = result.FindMatchingOffcut(new Area(3, 5));
Assert.IsNull(offcut);
}
public void TestMethod_ArcTangent()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.ArcTangentEngine);
CalculatorResult rc = null;
rc = engine.Calculate();
Assert.AreEqual(rc.PI, 3.14, 0.05, "INVALID ARCTANGENT CALCULATION");
}
public CalculatorResult Calculate()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine();
CalculatorResult rc = null;
rc = engine.Calculate();
return(new CalculatorResult(rc.PI, rc.CalculationTime));
}
public void Small_Resistance_Test()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new OhmValueCalculator();
//Act
CalculatorResult result = ohmValueCalculator.CalculateOhmValue("brown", "black", "black", "brown");
//Assert
Assert.AreEqual("10.1", result.MaxResistance);
}
// WEBAPI2 HAS METHOD SIGNATURE ROUTING
public CalculatorResult Get()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.Triangle2DEngine);
CalculatorResult rc = null;
rc = engine.Calculate();
return(new CalculatorResult(rc.PI, rc.CalculationTime));
}
public void TestMethod_Pyramid2DEngine()
{
ConstantModel model = new ConstantModel();
IconstantEngine engine = null;
engine = model.GetconstantEngine(PI_ENGINE_TYPE.Triangle2DEngine);
//engine = model.GetconstantEngine(PI_ENGINE_TYPE.GregoryLeibnizEngine);
CalculatorResult rc = null;
rc = engine.Calculate(1000);
Assert.AreEqual(rc.PI, 3.14, 0.10, "INVALID PYRAMID2D CALCULATION");
}
private void SubscribeMessages(QueueName requestQueueName, ref int processedMessages, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
processedMessages = 0;
while (true)
{
// process request messages
using (Claim claim = queueingService.ClaimMessage(requestQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)))
{
List<QueuedMessage> messagesToDelete = new List<QueuedMessage>();
foreach (QueuedMessage queuedMessage in claim.Messages)
{
if (token.IsCancellationRequested)
{
return;
}
CalculatorOperation operation = queuedMessage.Body.ToObject<CalculatorOperation>();
CalculatorResult result;
switch (operation._command)
{
case "+":
result = new CalculatorResult(operation, operation._operand1 + operation._operand2);
break;
case "-":
result = new CalculatorResult(operation, operation._operand1 - operation._operand2);
break;
case "*":
result = new CalculatorResult(operation, operation._operand1 * operation._operand2);
break;
case "/":
result = new CalculatorResult(operation, operation._operand1 / operation._operand2);
break;
default:
throw new InvalidOperationException();
}
messagesToDelete.Add(queuedMessage);
queueingService.PostMessages(operation._replyQueueName, new Message<CalculatorResult>(TimeSpan.FromMinutes(5), result));
processedMessages++;
}
if (messagesToDelete.Count > 0)
queueingService.DeleteMessages(requestQueueName, messagesToDelete.Select(i => i.Id));
}
if (token.IsCancellationRequested)
{
return;
}
}
}
private async Task<int> SubscribeMessages(QueueName requestQueueName, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
int processedMessages = 0;
try
{
while (true)
{
// process request messages
using (Claim claim = await queueingService.ClaimMessageAsync(requestQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), token))
{
List<QueuedMessage> messagesToDelete = new List<QueuedMessage>();
foreach (QueuedMessage queuedMessage in claim.Messages)
{
CalculatorOperation operation = queuedMessage.Body.ToObject<CalculatorOperation>();
CalculatorResult result;
switch (operation._command)
{
case "+":
result = new CalculatorResult(operation, operation._operand1 + operation._operand2);
break;
case "-":
result = new CalculatorResult(operation, operation._operand1 - operation._operand2);
break;
case "*":
result = new CalculatorResult(operation, operation._operand1 * operation._operand2);
break;
case "/":
result = new CalculatorResult(operation, operation._operand1 / operation._operand2);
break;
default:
throw new InvalidOperationException();
}
messagesToDelete.Add(queuedMessage);
// Assigning result to a local suppresses a warning about calling an asynchronous operation.
// In this case, we do not need to wait for the task to finish.
Task postTask = queueingService.PostMessagesAsync(operation._replyQueueName, token, new Message<CalculatorResult>(TimeSpan.FromMinutes(5), result));
processedMessages++;
}
if (messagesToDelete.Count > 0)
await queueingService.DeleteMessagesAsync(requestQueueName, messagesToDelete.Select(i => i.Id), token);
// start the dispose process using DisposeAsync so the CancellationToken is honored
Task disposeTask = claim.DisposeAsync(token);
}
if (token.IsCancellationRequested)
{
return processedMessages;
}
}
}
catch (AggregateException ex)
{
ex.Flatten().Handle(
e =>
{
if (e is TaskCanceledException)
return true;
WebException webException = e as WebException;
if (webException != null)
{
if (webException.Status == WebExceptionStatus.RequestCanceled)
return true;
}
return false;
});
return processedMessages;
}
catch (TaskCanceledException)
{
return processedMessages;
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.RequestCanceled)
throw;
return processedMessages;
}
}
