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