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