public void Add_ShouldReturnAdditionOfGivenValues() { // Arrange int expected = 10; // Act var actual = _calculatorService.Add(5, 5); // Assert Assert.Equal(expected, actual); }
public void RelayCompositeMessage() { const string responseXml = "<CalculatorResponse xmlns=\"urn:services.stateless.be:unit:calculator\">" + "<s0:Result xmlns:s0=\"urn:services.stateless.be:unit:calculator\">one</s0:Result>" + "<s0:Result xmlns:s0=\"urn:services.stateless.be:unit:calculator\">two</s0:Result>" + "</CalculatorResponse>"; StubServiceHost.FindDefaultService <ICalculatorService>() .Setup(s => s.Add(It.IsAny <XmlCalculatorRequest>())) .Returns(new StringStream(responseXml)); ICalculatorService client = null; try { client = SimpleServiceClient <CalculatorService, ICalculatorService> .Create(); var calculatorResult = client.Add(new XmlCalculatorRequest(CALCULATOR_REQUEST_XML)); Assert.AreEqual(responseXml, calculatorResult.RawXmlBody); client.Close(); } catch (Exception) { if (client != null) { client.Abort(); } throw; } }
public void CallServiceOperations() { // Call the Add service operation. double value1 = 100.00D; double value2 = 15.99D; double result = _calculatorService.Add(value1, value2); Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result); // Call the Subtract service operation. value1 = 145.00D; value2 = 76.54D; result = _calculatorService.Subtract(value1, value2); Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result); // Call the Multiply service operation. value1 = 9.00D; value2 = 81.25D; result = _calculatorService.Multiply(value1, value2); Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result); // Call the Divide service operation. value1 = 22.00D; value2 = 7.00D; result = _calculatorService.Divide(value1, value2); Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result); }
public async Task <ActionResult <double> > Add([FromQuery(Name = "n")] double[] numbers) { var sw = new Stopwatch(); sw.Start(); using (_logger.BeginScope($"{nameof(Add)} with {numbers})")) { try { var result = await _calculatorService.Add(numbers).ConfigureAwait(false); _logger.LogInformation($"Completed {nameof(Add)} in : {sw.Elapsed.TotalSeconds} seconds."); return(Ok(Math.Round(result, 2))); } catch (ArgumentNullException ex) { _logger.LogError($"Error occurred while processing the {nameof(Add)} request: {ex.Message}", ex.StackTrace); return(BadRequest($"Unable to process the request: {ex.Message}")); } catch (Exception ex) { _logger.LogError($"Error occurred while processing the {nameof(Add)} request: {ex.Message}", ex.StackTrace); return(StatusCode(500, $"Unable to process the request: {ex.Message}")); } } }
static void Main(string[] args) { Uri uri = new Uri(ConfigurationManager.AppSettings["CalculatorServiceAddress"]); BasicHttpBinding binding = new BasicHttpBinding(); EndpointAddress endpoint = new EndpointAddress(uri); ChannelFactory <ICalculatorService> proxy = new ChannelFactory <ICalculatorService>(binding, endpoint); ICalculatorService calculatorService = proxy.CreateChannel(); int result = calculatorService.Add(1, 2); Console.WriteLine(result); try { result = calculatorService.Divide(4, 0); } catch (FaultException <DivideByZeroFault> e) { Console.WriteLine($"{e.Detail.Code} {e.Detail.Error} {e.Detail.Description}"); } Console.WriteLine("Press key to exit."); Console.ReadKey(); }
public void RelaySyncMessage() { StubServiceHost.FindDefaultService <ICalculatorService>() .Setup(s => s.Add(It.IsAny <XmlCalculatorRequest>())) .Returns(new StringStream(string.Format(CALCULATOR_RESPONSE_XML, 3))); ICalculatorService client = null; try { client = SimpleServiceClient <CalculatorService, ICalculatorService> .Create(); var calculatorResult = client.Add(new XmlCalculatorRequest(CALCULATOR_REQUEST_XML)); Assert.AreEqual(string.Format(CALCULATOR_RESPONSE_XML, 3), calculatorResult.RawXmlBody); client.Close(); } catch (Exception) { if (client != null) { client.Abort(); } throw; } }
static void Main(string[] args) { try { Environment.SetEnvironmentVariable("GIGYA_CONFIG_ROOT", Environment.CurrentDirectory); Environment.SetEnvironmentVariable("GIGYA_CONFIG_PATHS_FILE", ""); Environment.SetEnvironmentVariable("GIGYA_ENVVARS_FILE", Environment.CurrentDirectory); Environment.SetEnvironmentVariable("REGION", "us1"); Environment.SetEnvironmentVariable("ZONE", "us1a"); Environment.SetEnvironmentVariable("ENV", "dev"); CurrentApplicationInfo.Init("CalculatorService.Client"); var kernel = new StandardKernel(); kernel.Load <MicrodotModule>(); kernel.Load <NLogModule>(); ICalculatorService calculatorService = kernel.Get <ICalculatorService>(); int sum = calculatorService.Add(2, 3).Result; Console.WriteLine($"Sum: {sum}"); } catch (Exception ex) { Console.Error.WriteLine(ex); } }
public void TestPropertyInjection() { ICalculatorService calc = container.GetService(typeof(ICalculatorService)) as ICalculatorService; Assert.NotNull(calc); Assert.Equal(100, calc.X); Assert.Equal(200, calc.Y); Assert.Equal(2, calc.Add(1, 1)); Assert.Equal(2, calc.Subtract(3, 1)); Assert.Throws(typeof(KeyNotFoundException), () => { container.GetService <ICalculatorService>("KeyNotFoundException"); }); Assert.Throws(typeof(KeyNotFoundException), () => { container.GetService <ICalculatorService>("PropertyKeyNotFound"); }); }
public IActionResult Index(int firstNumber, int secondNumber) { var result = _calculatorService.Add(firstNumber, secondNumber); ViewBag.Result = $"{firstNumber} + {secondNumber} = {result}"; return(View()); }
public void RelayCompositeMessage() { const string responseXml = "<CalculatorResponse xmlns=\"urn:services.stateless.be:unit:calculator\">" + "<s0:Result xmlns:s0=\"urn:services.stateless.be:unit:calculator\">one</s0:Result>" + "<s0:Result xmlns:s0=\"urn:services.stateless.be:unit:calculator\">two</s0:Result>" + "</CalculatorResponse>"; _soapStub.As <ICalculatorService>() .Setup(s => s.Add(It.IsAny <XmlCalculatorRequest>())) .Returns(new StringStream(responseXml)); ICalculatorService client = null; try { client = SoapClient <ICalculatorService> .For(_calculatorServiceHost.Endpoint); var calculatorResult = client.Add(new XmlCalculatorRequest(CALCULATOR_REQUEST_XML)); Assert.That(calculatorResult.RawXmlBody, Is.EqualTo(responseXml)); client.Close(); } catch (Exception) { client?.Abort(); throw; } }
public IActionResult Post([FromBody] Calculate model) { //Store the audit entry _dataRepository.Add(new Audit { IPAddress = _accessor.ActionContext.HttpContext.Connection.RemoteIpAddress.ToString(), Date = DateTime.UtcNow }); double result = 0; switch (model.Operator) { case '+': result = _service.Add(model.FirstNumber, model.SecondNumber); break; case '-': result = _service.Subtract(model.FirstNumber, model.SecondNumber); break; case '*': result = _service.Multiply(model.FirstNumber, model.SecondNumber); break; case '/': result = _service.Divide(model.FirstNumber, model.SecondNumber); break; case '%': result = _service.Remainder(model.FirstNumber, model.SecondNumber); break; default: return(BadRequest($"operator {model.Operator} not supported")); } return(Ok(result)); }
public IActionResult Add([FromQuery] int num1, int num2) { if (_calculatorService.CheckNumber(num1, num2)) { return(Ok(_calculatorService.Add(num1, num2))); } return(BadRequest("InputIsIllegally")); }
public async Task <int> CalcAdd(string input) { Tuple <int, int> nums = Task.Run(() => processNumbers(input)).Result; var result = await _calculatorService.Add(nums.Item1, nums.Item2); return(result); }
private static void Add(ICalculatorService calculator) { Console.WriteLine("Enter a:"); var a = ReadDouble(); Console.WriteLine("Enter b:"); var b = ReadDouble(); var result = calculator.Add(a, b); Console.WriteLine("Result: " + result); }
public async Task <IActionResult> Add(OperationViewModel operation) { _logger.BeginScope("Wow, CalculatorController"); _logger.LogInformation("Such action. Adding time!"); operation.Result = await _calculatorService.Add(operation.FirstNumber, operation.SecondNumber); return(View("Index", operation)); }
static void Main(string[] args) { using (ChannelFactory <ICalculatorService> factory = new ChannelFactory <ICalculatorService>(new WSHttpBinding(), "http://localhost:8888/ICalculatorService")) { ICalculatorService proxy = factory.CreateChannel(); var result = proxy.Add(1.1, 2.2); } Console.Read(); }
static void Main(string[] args) { using (var channelFactory = new ChannelFactory <ICalculatorService>("calculatorservice")) { ICalculatorService proxy = channelFactory.CreateChannel(); Console.WriteLine(proxy.Add(1, 2)); Console.Read(); } Console.Read(); }
public void Add_TwoPositiveIntegers_ResultPositive() { MockConfig mockConfig; int a = 2147483647; int b = 2147483647; ICalculatorService calculatorService = Init(out mockConfig); var result = calculatorService.Add(a, b); Assert.Positive(result); }
static void Main(string[] args) { ICalculatorService calculatorClient = ServiceProxy.Create <ICalculatorService> (new Uri("fabric:/CalculatorApplication1/CalculatorService")); var result = calculatorClient.Add(1, 2).Result.ToString(); Console.WriteLine(result); Console.ReadKey(); }
public void Add_TwoNegativeIntMaxRange_ResultNegative() { MockConfig mockConfig; int a = -2147483647; int b = -2147483647; ICalculatorService calculatorService = Init(out mockConfig); var result = calculatorService.Add(a, b); Assert.True(true); }
public JsonResult Index([FromBody] CalculationRequest calculationRequest) { var calculationResponse = new CalculationResponse(); if (calculationRequest.Operation.Equals("add", StringComparison.OrdinalIgnoreCase)) { calculationResponse.CalculationResult = _calculatorService.Add(calculationRequest.Input).ToString(); } return(Json(calculationResponse)); }
public ActionResult AddMatrix(string mdataA, string mdataB) { try { return(GetJSon(Service.Add(GetMatrixFromData(mdataA), GetMatrixFromData(mdataB)))); } catch { return(Json(new { success = false, responseData = "There are incorrect data in the matrix!" }, JsonRequestBehavior.AllowGet)); }; }
static void Main(string[] args) { using (ChannelFactory <ICalculatorService> factory = new ChannelFactory <ICalculatorService>("CalculatorService")) { ICalculatorService proxy = factory.CreateChannel(); Console.WriteLine(proxy.Add(5.0, 2.0)); Console.WriteLine(proxy.Sub(5.0, 2.0)); Console.WriteLine(proxy.Mul(5.0, 2.0)); Console.WriteLine(proxy.Div(5.0, 2.0)); Console.Read(); }; }
protected void btnAdd_Click(object sender, EventArgs e) { int a = int.Parse(txta.Text); int b = int.Parse(txtb.Text); ChannelFactory <ICalculatorService> factory = new ChannelFactory <ICalculatorService>("SelfhostCalculator"); ICalculatorService client = factory.CreateChannel(); CalculatorData c = client.Add(a, b); lblResult.Text = c.Result.ToString(); }
static void Main(string[] args) { IAliothServiceContainer container = new AliothServiceContainer(null) { Description = "demo1" }.Apply("servicecontainer.json"); ICalculatorService calc = container.GetService <ICalculatorService>(); IXYService xy = container.GetService <IXYService>(); Console.WriteLine("{0} + {1} = {2}", xy.X, xy.Y, calc.Add(xy.X, xy.Y)); Console.WriteLine("{0} - {1} = {2}", xy.X, xy.Y, calc.Sub(xy.X, xy.Y)); }
static void Main(string[] args) { using (ChannelFactory <ICalculatorService> factory = new ChannelFactory <ICalculatorService>(new BasicHttpBinding(), "http://localhost:8888/ICalculatorService/")) { ICalculatorService proxy = factory.CreateChannel(); Console.WriteLine(proxy.Add(5.0, 2.0)); Console.WriteLine(proxy.Sub(5.0, 2.0)); Console.WriteLine(proxy.Mul(5.0, 2.0)); Console.WriteLine(proxy.Div(5.0, 2.0)); Console.Read(); }; }
static void Main(string[] args) { while (true) { ICalculatorService calculatorClient = ServiceProxy.Create <ICalculatorService>( new Uri("fabric:/CalculatorApplication2/CalculatorService")); var result = calculatorClient.Add(1, 2).Result; Console.WriteLine(result); Thread.Sleep(3000); } }
public static void Main(string[] args) { using (ChannelFactory <ICalculatorService> channelFactory = new ChannelFactory <ICalculatorService>("calculatorservice")) { ICalculatorService proxy = channelFactory.CreateChannel(); using (proxy as IDisposable) { Console.WriteLine("x + y = {2} when x = {0} and y ={1}", 3, 5, proxy.Add(3, 5)); } } Console.WriteLine("Hello World!"); Console.ReadKey(); }
public async Task <IActionResult> Add(OperationViewModel operation) { _logger.BeginScope("Wow, CalculatorController"); //var log = CreateAwesomeLog("Such action. Adding time!"); //log.UserName = this.User.Identity.Name; //log.AdditionalInfo.Add("user", this.User.Identity); //_awesomeLogger.WriteUsage(log); _logger.LogInformation("Such action. Adding time!"); operation.Result = await _calculatorService.Add(operation.FirstNumber, operation.SecondNumber); return(View("Index", operation)); }
private void AddValue_Click(object sender, EventArgs e) { using (ChannelFactory <ICalculatorService> facotry = new ChannelFactory <ICalculatorService>(new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/MyServiceAddress"))) { ICalculatorService proxy = facotry.CreateChannel(); // Generate a random number to send to the service Random rand = new Random(); var value = rand.Next(3, 20); // Send the random value to Windows service proxy.Add(value); } }