int ICalculator.Add(int x, int y, int z)
{
var method = this.GetInterfaceMethod <Func <int, int, int, int>, ICalculator>(((ICalculator)this).Add);
var invocation = new MethodInvocation(this, method, x, y, z);
var returns = pipeline.Invoke(
invocation,
(input, next) => {
try
{
var returnValue = calculator != null ?
calculator.Add(x, y, z) :
default(int);
return(input.CreateValueReturn(returnValue, x, y, z));
}
catch (Exception ex)
{
return(input.CreateExceptionReturn(ex));
}
}
);
var exception = returns.Exception;
if (exception != null)
{
throw exception;
}
return(((int?)returns.ReturnValue).GetValueOrDefault());
}
public void Test()
{
_calculator.Add(1, 3).Returns(4);
_calculatorService.Add(1, 3).Should().Be(4);
_calculator.Received(1).Add(1, 3);
}
public static Point <T> AddPoints <T>(this ICalculator <T> calc, Point <T> p1, Point <T> p2)
{
var x = calc.Add(p1.X, p2.X);
var y = calc.Add(p1.Y, p2.Y);
return(new Point <T>(x, y));
}
public void ShouldAddTwoPositiveNumbers()
{
var result = c.Add(num1, num2);
Assert.AreEqual(addresult, result);
}
static void Main(string[] args)
{
//基于地址和绑定对象创建一个ChannelFactory<ICalculator> 通过代码
//using (ChannelFactory<ICalculator> channelFactory = new ChannelFactory<ICalculator>(new WSHttpBinding(), "http://127.0.0.1:3721/CalculatorService"))
//{
// //创建服务代理对象
// ICalculator proxy = channelFactory.CreateChannel();
// //调用计算器方法
// Console.WriteLine("x+y={2} when x={0} and y={1}",1,2,proxy.Add(1,2));
// Console.WriteLine("x-y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
// Console.WriteLine("x*y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
// Console.WriteLine("x/y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
// Console.ReadLine();
//}
//基于地址和绑定对象创建一个ChannelFactory<ICalculator> 通过配置文件
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>("calculatorService"))
{
//创建服务代理对象
ICalculator proxy = channelFactory.CreateChannel();
//调用计算器方法
Console.WriteLine("x+y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
Console.WriteLine("x-y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
Console.WriteLine("x*y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
Console.WriteLine("x/y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
Console.ReadLine();
}
}
/// <summary>
/// Calculates the overlap of the cubes on single axis having one of the center coordinates and size.
/// </summary>
private T CalculateOverlapOnSingleAxis(T centerCoord1, T size1, T centerCoord2, T size2)
{
// basically there are two cases, when on a single axis one cube overlap entirelly the second one and when not :)
// not really a rocket science :)
T sDiff = _calc.Div2(_calc.Add(size1, size2));
T xLeft1 = _calc.Sub(centerCoord1, _calc.Div2(size1));
T xRight1 = _calc.Add(centerCoord1, _calc.Div2(size1));
T xLeft2 = _calc.Sub(centerCoord2, _calc.Div2(size2));
T xRight2 = _calc.Add(centerCoord2, _calc.Div2(size2));
// first one overlap second
if (_calc.Contains(xLeft1, xRight1, xLeft2, xRight2))
{
return(size2);
}
// second overlap first
else if (_calc.Contains(xLeft2, xRight2, xLeft1, xRight1))
{
return(size1);
}
// they overlap partially or not at all
else
{
T xDist = _calc.Abs(_calc.Sub(centerCoord1, centerCoord2));
return(_calc.Sub(sDiff, xDist));
}
}
/// <summary>
/// 普通方法处理异常（此时服务端接口必须用Try catch,否则通道死亡）
/// </summary>
private static void TestNormalError()
{
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>("Tcp1_CalculatorService"))
{
ICalculator proxy = null;
try
{
proxy = channelFactory.CreateChannel();
(proxy as ICommunicationObject).Closed += delegate
{
Console.WriteLine("服务代理关闭成功！");
};
Console.WriteLine("x+y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
Console.WriteLine("x/y={2} when x={0} and y={1}", 1, 0, proxy.DivideInt(1, 0));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
try
{
Console.WriteLine("x+y={2} when x={0} and y={1}", 1, 2, proxy.Add(1, 2));
}
catch (Exception ee)
{
Console.WriteLine(channelFactory.State.ToString() + " " + ((ICommunicationObject)proxy).State.ToString());
Console.WriteLine(ee.ToString());
}
}
}
}
public void TestCalculatorSuccessfully()
{
Assert.AreEqual(12, calc.Add(5, 7));
Assert.AreEqual(7, calc.Add(3, 4));
Assert.AreEqual(0, calc.Add(4, 1)); // Returns 0 rather than 5 because that behavior was not defined for Add
Assert.AreEqual(9, calc.Mul(3, 3));
}
public void TestCalculatorSuccessfully()
{
Assert.AreEqual(calc.Add(5, 7), 12);
Assert.AreEqual(calc.Add(3, 4), 7);
Assert.AreEqual(calc.Add(4, 1), 0); // Returns 0 rather than 5 because that behavior was not defined for Add
Assert.AreEqual(calc.Mul(3, 3), 9);
}
static void Main(string[] args)
{
EndpointAddress address = new EndpointAddress("net.tcp://127.0.0.1:3721/calculatorservice");
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>(new SimpleSessionBinding(), address))
{
//创建第一个服务代理
ICalculator proxy = channelFactory.CreateChannel();
proxy.Add(1, 2);
Console.WriteLine("Done");
proxy.Add(1, 2);
Console.WriteLine("Done");
(proxy as ICommunicationObject).Close();
//创建第二个服务代理
proxy = channelFactory.CreateChannel();
proxy.Add(1, 2);
Console.WriteLine("Done");
proxy.Add(1, 2);
Console.WriteLine("Done");
(proxy as ICommunicationObject).Close();
channelFactory.Close();
}
Console.Read();
}
public void Add_TwoPositive()
{
//Act
var actual = _calculator.Add(5, 6);
//Assert
Assert.AreEqual(11, actual);
}
public void Test_GetStarted_ReturnSpecifiedValue()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(1, 2).Returns(3);
Assert.AreEqual(3, calculator.Add(1, 2));
}
public void Run()
{
_logger.WriteInfo($"{nameof(Application)} starting!");
_calculator.Add(1, 2);
_calculator.Add(2, 3);
_calculator.Add(3, 5);
_logger.WriteInfo($"{nameof(Application)} ending!");
}
public void Should_return_value()
{
const int value = 33;
_channel.OnSend += msg => _messageDispatcher.Dispatch(new ResponseMessage(msg.CorrelationId, value));
Assert.That(_calculator.Add(30, 3), Is.EqualTo(value));
}
public void Add_Given5And6_ShouldReturn11()
{
//Act
int result = _calculator.Add(5, 6);
//Assert
Assert.AreEqual(11, result);
}
public void Add_TwoPositive()
{
//Act
var actual = _calculator.Add(5.2, 6.33);
var expected = (double)5.2 + 6.33;
//Assert
Assert.AreEqual(expected, actual);
}
public static void Main(string[] args)
{
ProxyGenerator proxyGenerator = new ProxyGenerator();
ICalculator calculator = new Calculator();
ICalculator proxy = proxyGenerator.CreateInterfaceProxyWithTarget(
calculator,
ProxyGenerationOptions.Default,
new ValidationInterceptor()
);
Console.WriteLine("Validando con 1er parametro invalido");
try
{
Console.WriteLine(proxy.Add(-1, 10, 25));
}
catch (NotValidParametersException ex)
{
foreach (var validationResult in ex.Errors)
{
Console.WriteLine(validationResult.ErrorMessage);
}
}
Console.WriteLine("\nValidando con 2do parametro invalido");
try
{
Console.WriteLine(proxy.Add(10, -1, 25));
}
catch (NotValidParametersException ex)
{
foreach (var validationResult in ex.Errors)
{
Console.WriteLine(validationResult.ErrorMessage);
}
}
Console.WriteLine("\nValidando con 3er parametro invalido");
Console.WriteLine(proxy.Add(10, 25, -1));
Console.WriteLine("\nValidando con 1er y 2do parametro invalido");
try
{
Console.WriteLine(proxy.Add(-1, -5, 100));
}
catch (NotValidParametersException ex)
{
foreach (var validationResult in ex.Errors)
{
Console.WriteLine(validationResult.ErrorMessage);
}
}
Console.WriteLine("\nTodos validos");
Console.WriteLine(proxy.Add(5, 10, 100));
}
public TKey GetKey(TKey point)
{
var key = _config.StartPoint;
var count = _calculator.Divide(_calculator.Subtract(point, _config.StartPoint), _config.PerLoadSize);
count = _calculator.Floor(count);
key = _calculator.Add(_config.StartPoint, _calculator.Multiply(count, _config.PerLoadSize));
return(key);
}
public void Test_GetStarted_ReturnAddedValue()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(2, 3).Returns(5);
int actual = calculator.Add(2, 3);
Assert.AreEqual(5, actual);
}
public void Test_ReturnSpecifiedValue()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(1, 2).Returns(3);
int actual = calculator.Add(1, 2);
Assert.AreEqual(3, actual);
}
public void ICalculator_AddWithTwoInteger_ReturnSpecifiedValue()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(1, 2).Returns(3);
int actual = calculator.Add(1, 2);
Assert.AreEqual <int>(3, actual);
}
public void TestMethod1()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(3, 6).Returns(9);
var expected = 9;
var actual = calculator.Add(3, 6);
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>("calculatorservice"))
{
ICalculator serviceProxy = channelFactory.CreateChannel();
serviceProxy.Add(1, 2);
serviceProxy.Add(1, 2);
}
Console.Read();
}
static void Main(string[] args)
{
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>("WSHttpBinding_CalculatorService"))
{
ICalculator proxy = channelFactory.CreateChannel();
proxy.Add(1, 2);
proxy.Add(1, 2);
}
Console.ReadLine();
}
public void Test_GetStarted_PassFuncToReturns()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(Arg.Any <int>(), Arg.Any <int>())
.Returns(x => (int)x[0] + (int)x[1]);
int actual = calculator.Add(5, 10);
Assert.AreEqual(15, actual);
}
public void ICalculator_AddWithTwoInteger_PassFuncToReturns()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator.Add(Arg.Any <int>(), Arg.Any <int>())
.Returns(x => (int)x[0] + (int)x[1]);
int actual = calculator.Add(5, 10);
Assert.AreEqual <int>(15, actual);
}
public void NSubstitute_ArgsCheck_Test()
{
//Arrange
ICalculator calculator = Substitute.For <ICalculator>();
//Act
calculator.Add(Arg.Is <int>((x) => x > 0), Arg.Is <int>((x) => x > 0))
.Returns(x => (int)x[0] + (int)x[1]);
//Assert
Assert.That(calculator.Add(5, 10) == 15);
}
public void test_calculator_add()
{
var result = _calculator.Add(new int[] { 1, 5000 });
Assert.AreEqual(result, 5001);
result = _calculator.Add(new int[] { 4, -3 });
Assert.AreEqual(result, 1);
result = _calculator.Add(new int[] { -4, -3 });
Assert.AreEqual(result, -7);
}
public ActionResult <CalculatorValue> Add([FromBody] CalculatorPayload payload)
{
if (_validator.ValidateNull(payload, out var result))
{
return(result);
}
var calculatioResult = _calculator.Add(payload.ValueX, payload.ValueY);
calculatioResult.CorrelationId = payload.CorrelationId;
return(Ok(calculatioResult));
}
public void Test_PassFuncToReturns()
{
ICalculator calculator = Substitute.For <ICalculator>();
calculator
.Add(Arg.Any <int>(), Arg.Any <int>())
.Returns(x => (int)x[0] + (int)x[1]);
var actual = calculator.Add(5, 10);
actual.Should().Be(15);
}
static void DoCalculations(ICalculator client)
{
// Call the Add service operation.
double value1 = 100.00D;
double value2 = 15.99D;
double result = client.Add(value1, value2);
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
// Call the Subtract service operation.
value1 = 145.00D;
value2 = 76.54D;
result = client.Subtract(value1, value2);
Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);
// Call the Multiply service operation.
value1 = 9.00D;
value2 = 81.25D;
result = client.Multiply(value1, value2);
Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);
// Call the Divide service operation.
value1 = 22.00D;
value2 = 7.00D;
result = client.Divide(value1, value2);
Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);
}
public void AddTest()
{
calculator = new ComplexNumbers.Calculator();
Complex<double> actual = calculator.Add(new Complex<double>(4, 5), new Complex<double>(6, 7));
Complex<double> expected = new Complex<double>(4 + 6, 5 + 7);
Assert.True(actual.Equals(expected));
}
static void Invoke(ICalculator calculator)
{
try
{
calculator.Add(1, 2);
Console.WriteLine("服务调用成功...");
}
catch
{
Console.WriteLine("服务调用失败...");
}
}
static void DoCalculations(ICalculator proxy)
{
MyChannelExtension extension = ((IContextChannel)proxy).Extensions.Find<MyChannelExtension>();
if (extension != null)
{
if (extension.Binding != null)
{
Console.WriteLine("Sending requests over {0}", extension.Binding.Scheme);
}
if (extension.IntroduceErrors)
{
Console.WriteLine("Errors will be introduced in the request");
}
}
// Call the Add service operation.
double value1 = 100.00D;
double value2 = 15.99D;
double result = proxy.Add(value1, value2);
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
// Call the Subtract service operation.
value1 = 145.00D;
value2 = 76.54D;
result = proxy.Subtract(value1, value2);
Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);
// Call the Multiply service operation.
value1 = 9.00D;
value2 = 81.25D;
result = proxy.Multiply(value1, value2);
Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);
// Call the Divide service operation.
value1 = 22.00D;
value2 = 7.00D;
result = proxy.Divide(value1, value2);
Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);
Console.WriteLine();
}
private static void ParseLine(string line, ICalculator calculatorModule)
{
var strings = line.Split(' ');
if(strings.Length == 0) { return;}
switch (strings[0])
{
case "1":
Console.WriteLine("1 + 2 = {0}",calculatorModule.Add(1, 2));
break;
case "2":
Console.WriteLine("1 + 2 = {0}", calculatorModule.Subtract(2, 1));
break;
case "3":
Console.WriteLine("1 + 2 = {0}", calculatorModule.Multiply(2, 3));
break;
case "4":
Console.WriteLine("1 + 2 = {0}", calculatorModule.Divide(4, 2));
break;
}
}
private static void RunCalculator(ICalculator calc)
{
if (calc == null)
{
//No calculators were found; read a line and exit.
Console.ReadLine();
}
Console.WriteLine("Available operations: +, -, *, /");
Console.WriteLine("Request a calculation , such as: 2 + 2");
Console.WriteLine("Type \"exit\" to exit");
String line = Console.ReadLine();
while (!line.Equals("exit"))
{
// The Parser class parses the user's input.
try
{
Parser c = new Parser(line);
switch (c.Action)
{
case "+":
Console.WriteLine(calc.Add(c.A, c.B));
break;
case "-":
Console.WriteLine(calc.Subtract(c.A, c.B));
break;
case "*":
Console.WriteLine(calc.Multiply(c.A, c.B));
break;
case "/":
Console.WriteLine(calc.Divide(c.A, c.B));
break;
default:
Console.WriteLine("{0} is an invalid command. Valid commands are +,-,*,/", c.Action);
break;
}
}
catch
{
Console.WriteLine("Invalid command: {0}. Commands must be formated: [number] [operation] [number]", line);
}
line = Console.ReadLine();
}
}
public void Set_a_return_value_for_a_method()
{
//{CODE:set_return_values.for_a_method}
_calculator = Substitute.For<ICalculator>();
_calculator.Add(1, 2).Returns(3); //Make this call return 3.
}
public void ShouldAddNumbers(ICalculator calculator, int first, int second, int expected)
{
int result = calculator.Add(first, second);
Assert.Equal(expected, result);
}