Exemplo n.º 1
0
 protected MathOperator(MathToken token, int precedence, ICalculatorProxy proxy, CalculatorProxy.SingleBinaryOperation operation)
     : base(token.Token, token.Index)
 {
     this.Precedence = precedence;
     this.proxy = proxy;
     this.operation = operation;
 }
Exemplo n.º 2
0
        public static void Main()
        {
            // Bond has an abstraction for network protocols called a Transport. Epoxy is a custom protocol that is
            // lightweight and built into Bond.Comm. If it doesn't meet your needs, you can write your own Transport.
            var transport  = new EpoxyTransportBuilder().Construct();
            var connection = transport.ConnectToAsync(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultPort)).Result;

            // For each service, Bond will generate a proxy with methods corresponding to the service methods you defined.
            var proxy = new CalculatorProxy <EpoxyConnection>(connection);

            var addArgs = new BinaryOpArgs
            {
                left  = 2,
                right = 2
            };
            // The result of a Bond call is a IMessage, which is either a payload or an error.
            // Display() shows how to handle both cases.
            var addResult = proxy.AddAsync(addArgs).Result;

            Display("Add", addArgs, addResult);

            var divArgs = new BinaryOpArgs
            {
                left  = 1,
                right = 0
            };
            var divResult = proxy.DivideAsync(divArgs).Result;

            Display("Divide", divArgs, divResult);

            Console.ReadLine();
        }
        public async Task MethodCall()
        {
            await DefaultSetup(new CalculatorService(), 1);

            const int first     = 91;
            const int second    = 23;
            int       addResult = first + second;
            int       subResult = first - second;

            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First  = first,
                Second = second
            };
            var request = new Message <PairedInput>(input);
            IMessage <Output> addResponse = await calculatorProxy.AddAsync(request, System.Threading.CancellationToken.None);

            IMessage <Output> subResponse = await calculatorProxy.SubtractAsync(request, System.Threading.CancellationToken.None);

            Output addOutput = addResponse.Payload.Deserialize();
            Output subOutput = subResponse.Payload.Deserialize();

            Assert.AreEqual(addResult, addOutput.Result);
            Assert.AreEqual(subResult, subOutput.Result);
        }
Exemplo n.º 4
0
    static void Main(string[] args)
    {
        CalculatorProxy calc = new CalculatorProxy();

        Console.WriteLine(calc.Add(5, 6));
        Console.ReadKey();
    }
        public async Task MethodCall_ReqRsp_WithStatefulLayers()
        {
            var layerProvider      = new TestLayerProvider_StatefulAppend("Layer");
            var layerStackProvider = new LayerStackProvider <Dummy>(layerProvider);

            transportBuilder.SetLayerStackProvider(layerStackProvider);
            await DefaultSetup(new CalculatorService(), 1);

            layerProvider.Layers.Clear();

            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);

            var request = new Message <PairedInput>(new PairedInput {
                First = 1, Second = 2
            });
            IMessage <Output> response = await calculatorProxy.AddAsync(request, CancellationToken.None);

            Assert.IsFalse(response.IsError);

            Assert.AreEqual(2, layerProvider.Layers.Count);
            Assert.AreEqual("Layer0SendLayer0Receive", layerProvider.Layers[0].State);
            Assert.AreEqual("Layer1ReceiveLayer1Send", layerProvider.Layers[1].State);

            request = new Message <PairedInput>(new PairedInput {
                First = 1, Second = 2
            });
            response = await calculatorProxy.AddAsync(request, CancellationToken.None);

            Assert.IsFalse(response.IsError);

            Assert.AreEqual(4, layerProvider.Layers.Count);
            Assert.AreEqual("Layer2SendLayer2Receive", layerProvider.Layers[2].State);
            Assert.AreEqual("Layer3ReceiveLayer3Send", layerProvider.Layers[3].State);
        }
        public async Task MultipleClientConnectionsEventCalls()
        {
            await DefaultSetup(new CalculatorService(), 10);

            Task[]    connectionTasks = new Task[connections.Length];
            const int taskCount       = 25;

            for (int connectionIndex = 0; connectionIndex < connections.Length; connectionIndex++)
            {
                SimpleInMemConnection conn = connections[connectionIndex];
                connectionTasks[connectionIndex] = Task.Run(() =>
                {
                    Task[] tasks = new Task[taskCount];

                    for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
                    {
                        tasks[taskIndex] = Task.Run(() =>
                        {
                            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(conn);
                            calculatorProxy.IncrementCountAsync();
                        });
                    }

                    Task.WaitAll(tasks);
                });
            }

            Task.WaitAll(connectionTasks);

            int       totalWaitTime = 0;
            const int maxWait       = 5000;
            // Intentionally avoiding exponential back-off due to simple nature of this test
            const int incrementalWait = 500;

            while (totalWaitTime < maxWait)
            {
                await Task.Delay(incrementalWait);

                totalWaitTime += incrementalWait;

                try
                {
                    Assert.AreEqual(CalculatorService.Count, connections.Length * taskCount);
                    break;
                }
                catch (AssertionException)
                {
                    // The implementation of SimpleInMem can guarantee delivery of events just be virtue of staying with in the process boundary.
                    // SimpleInMem event failing after 5 seconds needs to raise alarm and investigation.
                    if (totalWaitTime > maxWait)
                    {
                        throw;
                    }
                }
            }

            Console.WriteLine($"{nameof(MultipleClientConnectionsEventCalls)} - Count: {CalculatorService.Count}");
        }
Exemplo n.º 7
0
 public void SetUp()
 {
     _lexer      = new MathLexer(new ExpressionFixer());
     _calculator = new Calculator();
     _calcProxy  = new CalcProxy(new Validator(-100, 100), _calculator);
     _precedence = new Precedence();
     _resolver   = new Resolver(_lexer, _calcProxy, _precedence);
     _parser     = new MathParser(_lexer, _resolver);
 }
Exemplo n.º 8
0
        public void SubstractIntegracion()
        {
            var validator = new LimitsValidator(-100, 100);
            var calculator = new Calculator();
            var proxy = new CalculatorProxy(validator);

            var result = proxy.BinaryOperation(calculator.Substract, 5, 3);
            Assert.AreEqual(2, result);
        }
Exemplo n.º 9
0
        public void SubstractIntegracion()
        {
            var validator  = new LimitsValidator(-100, 100);
            var calculator = new Calculator();
            var proxy      = new CalculatorProxy(validator);

            var result = proxy.BinaryOperation(calculator.Substract, 5, 3);

            Assert.AreEqual(2, result);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Runs this instance.
        /// </summary>
        private void Run()
        {
            Console.WriteLine("Run a ServiceHost via programmatic configuration...");

            using (ServiceHost serviceHost = new ServiceHost(typeof(Calculator), new Uri("soap.amqp:///")))
            {
                var serviceEndpoint = serviceHost.AddServiceEndpoint(
                    typeof(ICalculator),
                    new RabbitMQBinding(
                        "localhost",
                        5672,
                        "guest",
                        "guest",
                        "/",
                        8192,
                        Protocols.AMQP_0_9_1)
                {
                    OneWayOnly = false
                },
                    "Calculator");

                ////serviceEndpoint.Behaviors.Add(new RabbitMqEndpointBehavior(null));
                Console.WriteLine("Num. behaviors: {0}", serviceEndpoint.Behaviors.Count);

                serviceHost.Open();
                Console.WriteLine("The service is opened, press ENTER to follow next instructions...");
                ////Console.ReadLine();

                var proxyBinding = new RabbitMQBinding(
                    "localhost",
                    5672,
                    "guest",
                    "guest",
                    "/",
                    8192,
                    Protocols.AMQP_0_9_1)
                {
                    OneWayOnly = false
                }
                ;
                var endpoint = new EndpointAddress("soap.amqp:///Calculator");

                using (var proxy = new CalculatorProxy(proxyBinding, endpoint))
                {
                    ////proxy.Endpoint.Behaviors.Add(new RabbitMqEndpointBehavior(null));
                    var res = proxy.Add(4, 5);
                    Console.WriteLine(res);

                    Console.WriteLine("Type name: {0}", proxy.PrintTypeName(new Person()));
                    Console.WriteLine("Type name: {0}", proxy.PrintTypeName(new Student()));
                }
                Console.ReadLine();
            }
        }
Exemplo n.º 11
0
 public void SetUp()
 {
     _mathRegex = new MathRegex();
     _fixer = new ExpressionFixer();
     _lexer = new MathLexer(_fixer);
     _calculator = new Calculator();
     _calcProxy = new CalcProxy(new Validator(-100, 100),
                                    _calculator);
     _resolver = new Resolver(_lexer, new Precedence());
     _parser = new MathParser(_lexer, _resolver);
 }
Exemplo n.º 12
0
 public void SetUp()
 {
     var expressionValidator = new MathRegex();
     var expressionFixer = new ExpressionFixer(expressionValidator);
     this.lexer = new MathLexer(expressionValidator, expressionFixer);
     var limitsValidator = new LimitsValidator(-100, 100);
     var proxy = new CalculatorProxy(limitsValidator);
     var calculator = new Calculator();
     var operatorFactory = new OperatorFactory(proxy, calculator);
     this.parser = new MathParser(this.lexer, operatorFactory);
 }
        public async void EventCall()
        {
            await DefaultSetup(new CalculatorService(), 1);

            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);

            calculatorProxy.ClearAsync();

            bool wasSignaled = CalculatorService.ClearCalledEvent.WaitOne(30000);

            Assert.IsTrue(wasSignaled, "Timed out waiting for event");
        }
        public async void TestWithServerAndClientConnections()
        {
            await DefaultSetup(new CalculatorService(), 1);

            IEnumerator <Guid> pairIds = listener.GetPairIds().GetEnumerator();

            pairIds.MoveNext();
            Guid firstPair = pairIds.Current;
            SimpleInMemConnection serverConnection = listener.GetConnection(firstPair, ConnectionType.Server);
            SimpleInMemConnection clientConnection = listener.GetConnection(firstPair, ConnectionType.Client);

            const int first     = 91;
            const int second    = 23;
            int       addResult = first + second;
            int       subResult = first - second;

            var serverProxy = new CalculatorProxy <SimpleInMemConnection>(serverConnection);
            var clientProxy = new CalculatorProxy <SimpleInMemConnection>(clientConnection);


            var input = new PairedInput
            {
                First  = first,
                Second = second
            };
            var request = new Message <PairedInput>(input);
            IMessage <Output> addResponse = await clientProxy.AddAsync(request, System.Threading.CancellationToken.None);

            IMessage <Output> subResponse = await clientProxy.SubtractAsync(request, System.Threading.CancellationToken.None);

            Assert.IsFalse(addResponse.IsError);
            Assert.IsFalse(subResponse.IsError);
            Output addOutput = addResponse.Payload.Deserialize();
            Output subOutput = subResponse.Payload.Deserialize();

            Assert.AreEqual(addResult, addOutput.Result);
            Assert.AreEqual(subResult, subOutput.Result);

            addResponse = await serverProxy.AddAsync(request, System.Threading.CancellationToken.None);

            subResponse = await serverProxy.SubtractAsync(request, System.Threading.CancellationToken.None);

            Assert.IsTrue(addResponse.IsError);
            Assert.IsTrue(subResponse.IsError);
            Error addError = addResponse.Error.Deserialize();
            Error subError = subResponse.Error.Deserialize();

            Assert.AreEqual((int)ErrorCode.METHOD_NOT_FOUND, (int)addError.error_code);
            Assert.AreEqual("Got request for unknown method [unittest.simpleinmem.Calculator.Add].", addError.message);
            Assert.AreEqual((int)ErrorCode.METHOD_NOT_FOUND, (int)subError.error_code);
            Assert.AreEqual("Got request for unknown method [unittest.simpleinmem.Calculator.Subtract].", subError.message);
        }
Exemplo n.º 15
0
        public void SetUp()
        {
            var expressionValidator = new MathRegex();
            var expressionFixer     = new ExpressionFixer(expressionValidator);

            this.lexer = new MathLexer(expressionValidator, expressionFixer);
            var limitsValidator = new LimitsValidator(-100, 100);
            var proxy           = new CalculatorProxy(limitsValidator);
            var calculator      = new Calculator();
            var operatorFactory = new OperatorFactory(proxy, calculator);

            this.parser = new MathParser(this.lexer, operatorFactory);
        }
Exemplo n.º 16
0
        public void CoordinateValidation()
        {
            const int n1 = 10;
            const int n2 = -20;
            const int result = 1000;

            var validatorMock = new Mock<ILimitsValidator>();
            var calculatorMock = new Mock<ICalculator>();

            calculatorMock.Setup(x => x.Add(n1,n2)).Returns(result);

            var calcProxy = new CalculatorProxy(validatorMock.Object);
            calcProxy.BinaryOperation(calculatorMock.Object.Add, n1, n2);

            validatorMock.Verify(x => x.ValidateArgs(n1, n2));
            validatorMock.Verify(x => x.ValidateResult(result));
        }
Exemplo n.º 17
0
        public void CoordinateValidation()
        {
            const int n1     = 10;
            const int n2     = -20;
            const int result = 1000;

            var validatorMock  = new Mock <ILimitsValidator>();
            var calculatorMock = new Mock <ICalculator>();

            calculatorMock.Setup(x => x.Add(n1, n2)).Returns(result);

            var calcProxy = new CalculatorProxy(validatorMock.Object);

            calcProxy.BinaryOperation(calculatorMock.Object.Add, n1, n2);

            validatorMock.Verify(x => x.ValidateArgs(n1, n2));
            validatorMock.Verify(x => x.ValidateResult(result));
        }
Exemplo n.º 18
0
        public async void TestWithServerAndClientConnections()
        {
            await DefaultSetup(new CalculatorService(), 1);
            IEnumerator<Guid> pairIds = listener.GetPairIds().GetEnumerator();
            pairIds.MoveNext();
            Guid firstPair = pairIds.Current;
            SimpleInMemConnection serverConnection = listener.GetConnection(firstPair, ConnectionType.Server);
            SimpleInMemConnection clientConnection = listener.GetConnection(firstPair, ConnectionType.Client);

            const int first = 91;
            const int second = 23;
            int addResult = first + second;
            int subResult = first - second;

            var serverProxy = new CalculatorProxy<SimpleInMemConnection>(serverConnection);
            var clientProxy = new CalculatorProxy<SimpleInMemConnection>(clientConnection);


            var input = new PairedInput
            {
                First = first,
                Second = second
            };
            var request = new Message<PairedInput>(input);
            IMessage<Output> addResponse = await clientProxy.AddAsync(request, System.Threading.CancellationToken.None);
            IMessage<Output> subResponse = await clientProxy.SubtractAsync(request, System.Threading.CancellationToken.None);
            Assert.IsFalse(addResponse.IsError);
            Assert.IsFalse(subResponse.IsError);
            Output addOutput = addResponse.Payload.Deserialize();
            Output subOutput = subResponse.Payload.Deserialize();
            Assert.AreEqual(addResult, addOutput.Result);
            Assert.AreEqual(subResult, subOutput.Result);

            addResponse = await serverProxy.AddAsync(request, System.Threading.CancellationToken.None);
            subResponse = await serverProxy.SubtractAsync(request, System.Threading.CancellationToken.None);
            Assert.IsTrue(addResponse.IsError);
            Assert.IsTrue(subResponse.IsError);
            Error addError = addResponse.Error.Deserialize();
            Error subError = subResponse.Error.Deserialize();
            Assert.AreEqual((int)ErrorCode.MethodNotFound, (int)addError.error_code);
            Assert.AreEqual("Got request for unknown method [unittest.simpleinmem.Calculator.Add].", addError.message);
            Assert.AreEqual((int)ErrorCode.MethodNotFound, (int)subError.error_code);
            Assert.AreEqual("Got request for unknown method [unittest.simpleinmem.Calculator.Subtract].", subError.message);
        }
        public async Task MethodCall_WithServiceError()
        {
            await DefaultSetup(new CalculatorService(), 1);

            const int first  = 91;
            const int second = 23;

            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First  = first,
                Second = second
            };
            var request = new Message <PairedInput>(input);
            IMessage <Output> multiplyResponse = await calculatorProxy.MultiplyAsync(request, System.Threading.CancellationToken.None);

            Assert.IsTrue(multiplyResponse.IsError);
            InternalServerError error = multiplyResponse.Error.Deserialize <InternalServerError>();

            Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
            Assert.That(error.message, Is.StringContaining(Errors.InternalErrorMessage));
        }
        public async Task MethodCall_WithLayerStack()
        {
            var testList = new List <string>();
            var layer1   = new TestLayer_Append("foo", testList);
            var layer2   = new TestLayer_Append("bar", testList);

            transportBuilder.SetLayerStackProvider(new LayerStackProvider <Dummy>(layer1, layer2));
            await DefaultSetup(new CalculatorService(), 1);

            const int first     = 91;
            const int second    = 23;
            int       addResult = first + second;

            var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First  = first,
                Second = second
            };
            var request = new Message <PairedInput>(input);
            IMessage <Output> addResponse = await calculatorProxy.AddAsync(request, System.Threading.CancellationToken.None);

            Output addOutput = addResponse.Payload.Deserialize();

            Assert.AreEqual(addResult, addOutput.Result);

            Assert.AreEqual(8, testList.Count);
            Assert.AreEqual(layer1.value, testList[0]);
            Assert.AreEqual(testList[0] + layer2.value, testList[1]);
            Assert.AreEqual(testList[1] + layer2.value, testList[2]);
            Assert.AreEqual(testList[2] + layer1.value, testList[3]);
            Assert.AreEqual(layer1.value, testList[4]);
            Assert.AreEqual(testList[4] + layer2.value, testList[5]);
            Assert.AreEqual(testList[5] + layer2.value, testList[6]);
            Assert.AreEqual(testList[6] + layer1.value, testList[7]);
        }
Exemplo n.º 21
0
        public async Task MethodCall()
        {
            await DefaultSetup(new CalculatorService(), 1);

            const int first = 91;
            const int second = 23;
            int addResult = first + second;
            int subResult = first - second;

            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First = first,
                Second = second
            };
            var request = new Message<PairedInput>(input);
            IMessage<Output> addResponse = await calculatorProxy.AddAsync(request, System.Threading.CancellationToken.None);
            IMessage<Output> subResponse = await calculatorProxy.SubtractAsync(request, System.Threading.CancellationToken.None);
            Output addOutput = addResponse.Payload.Deserialize();
            Output subOutput = subResponse.Payload.Deserialize();
            Assert.AreEqual(addResult, addOutput.Result);
            Assert.AreEqual(subResult, subOutput.Result);
        }
        public async Task MultipleClientConnectionsMethodCalls()
        {
            Stopwatch sw = Stopwatch.StartNew();

            await DefaultSetup(new CalculatorService(), 10);

            Task[] connectionTasks = new Task[connections.Length];

            for (int connectionIndex = 0; connectionIndex < connections.Length; connectionIndex++)
            {
                SimpleInMemConnection conn = connections[connectionIndex];
                connectionTasks[connectionIndex] = Task.Run(() =>
                {
                    int taskCount = 25;
                    Task[] tasks  = new Task[taskCount];

                    for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
                    {
                        tasks[taskIndex] = Task.Run(async() =>
                        {
                            Random rand           = new Random(DateTime.UtcNow.Millisecond);
                            int first             = rand.Next(1, 100);
                            int second            = rand.Next(1, 50);
                            int expectedAddResult = first + second;
                            int expectedSubResult = first - second;
                            var addTraceId        = Guid.NewGuid().ToString();
                            var subTraceId        = Guid.NewGuid().ToString();
                            var calculatorProxy   = new CalculatorProxy <SimpleInMemConnection>(conn);

                            var addInput = new PairedInput
                            {
                                First   = first,
                                Second  = second,
                                TraceId = addTraceId
                            };

                            var subInput = new PairedInput
                            {
                                First   = first,
                                Second  = second,
                                TraceId = subTraceId
                            };

                            Message <PairedInput> addRequest = new Message <PairedInput>(addInput);
                            Message <PairedInput> subRequest = new Message <PairedInput>(subInput);
                            IMessage <Output> addResponse    = await calculatorProxy.AddAsync(addRequest, System.Threading.CancellationToken.None);
                            IMessage <Output> subResponse    = await calculatorProxy.SubtractAsync(subRequest, System.Threading.CancellationToken.None);
                            Output addOutput = addResponse.Payload.Deserialize();
                            Output subOutput = subResponse.Payload.Deserialize();

                            Assert.AreEqual(expectedAddResult, addOutput.Result);
                            Assert.AreEqual(addInput.TraceId, addOutput.TraceId);
                            Assert.AreEqual(expectedSubResult, subOutput.Result);
                            Assert.AreEqual(subInput.TraceId, subOutput.TraceId);
                        });
                    }

                    Task.WaitAll(tasks);
                });
            }

            Task.WaitAll(connectionTasks);
            sw.Stop();
            Console.WriteLine($"{nameof(MultipleClientConnectionsMethodCalls)} - test time: {sw.Elapsed.TotalSeconds}");
        }
Exemplo n.º 23
0
 public Resolver( Lexer lexer, CalculatorProxy calcProxy, TokenProcedence precedence)
 {
     _lexer = lexer;
     _calcProxy = calcProxy;
     _precedence = precedence;
 }
Exemplo n.º 24
0
        static void Main()
        {
            TraceSource ts = new TraceSource("ClientCalculatorTraceSource");

            // Start the calculator activity
            Guid newGuid = Guid.NewGuid();
            Trace.CorrelationManager.ActivityId = newGuid;
            ts.TraceEvent(TraceEventType.Start, 0, "Calculator Activity");

            // Create a proxy with given client endpoint configuration
            using (CalculatorProxy proxy = new CalculatorProxy())
            {
                // Save the calculator activity id to transfer back and forth from/to it
                Guid originalGuid = Trace.CorrelationManager.ActivityId;

                // Create and start the Add activity                
                // Generate a new activity id
                newGuid = Guid.NewGuid();
                // Transfer from the calculator activity to the new (Add) activity
                // The value for the "from" in the transfer is implicit; it is the activity id 
                // previously set in Trace.CorrelationManager.ActivityId
                // The value for the "to" is explicitly passed as the newGuid parameter
                ts.TraceTransfer(0, "Transferring...", newGuid);
                // Set the new activity id in Trace.CorrelationManager.ActivityId; it is now in scope
                // for subsequently emitted traces
                Trace.CorrelationManager.ActivityId = newGuid;
                // Emit the Start trace for the new activity
                ts.TraceEvent(TraceEventType.Start, 0, "Add Activity");

                // Now make the Add request
                double value1 = 100.00D;
                double value2 = 15.99D;
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client sends Add request message.");
                double result = proxy.Add(value1, value2);

                // Trace that you have received the response
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client receives Add response message.");
                Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);

                // Transfer back to the Calculator activity and stop the current activity
                ts.TraceTransfer(667, "Transferring...", originalGuid);
                ts.TraceEvent(TraceEventType.Stop, 0, "Add Activity");

                // Set the calculator activity back in scope
                Trace.CorrelationManager.ActivityId = originalGuid;


                // Call the Subtract service operation
                newGuid = Guid.NewGuid();
                ts.TraceTransfer(0, "Transferring...", newGuid);
                Trace.CorrelationManager.ActivityId = newGuid;
                ts.TraceEvent(TraceEventType.Start, 0, "Subtract Activity");

                value1 = 100.00D;
                value2 = 15.99D;
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client sends Subtract request message.");
                result = proxy.Subtract(value1, value2);
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client receives Subtract response message.");
                Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);

                ts.TraceTransfer(667, "Transferring...", originalGuid);
                ts.TraceEvent(TraceEventType.Stop, 0, "Subtract Activity");
                Trace.CorrelationManager.ActivityId = originalGuid;


                // Call the Multiply service operation
                newGuid = Guid.NewGuid();
                ts.TraceTransfer(0, "Transferring...", newGuid);
                Trace.CorrelationManager.ActivityId = newGuid;
                ts.TraceEvent(TraceEventType.Start, 0, "Multiply Activity");

                value1 = 100.00D;
                value2 = 15.99D;
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client sends Multiply request message.");
                result = proxy.Multiply(value1, value2);
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client receives Multiply response message.");
                Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);

                ts.TraceTransfer(667, "Transferring...", originalGuid);
                ts.TraceEvent(TraceEventType.Stop, 0, "Multiply Activity");
                Trace.CorrelationManager.ActivityId = originalGuid;


                // Call the Divide service operation
                newGuid = Guid.NewGuid();
                ts.TraceTransfer(0, "Transferring...", newGuid);
                Trace.CorrelationManager.ActivityId = newGuid;
                ts.TraceEvent(TraceEventType.Start, 0, "Divide Activity");

                value1 = 100.00D;
                value2 = 15.99D;
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client sends Divide request message.");
                result = proxy.Divide(value1, value2);
                ts.TraceEvent(TraceEventType.Information, 0,
                    "Client receives Divide response message.");
                Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);

                ts.TraceTransfer(667, "Transferring...", originalGuid);
                ts.TraceEvent(TraceEventType.Stop, 0, "Divide Activity");
                Trace.CorrelationManager.ActivityId = originalGuid;
            }

            ts.TraceEvent(TraceEventType.Stop, 0, "Calculator Activity");

            Console.WriteLine();
            Console.WriteLine("Press <ENTER> to terminate client.");
            Console.ReadLine();

        }
Exemplo n.º 25
0
 public Resolver(Lexer lexer, CalculatorProxy calcProxy, TokenPrecedence precedence)
 {
     _lexer      = lexer;
     _calcProxy  = calcProxy;
     _precedence = precedence;
 }
Exemplo n.º 26
0
 public void SetUp()
 {
     _expressionValidator = new MathRegex();
     _fixer = new ExpressionFixer();
     _lexer = new MathLexer(_fixer);
     _calculator = new Calculator();
     _validator = new Validator(-20, 20);
     _calcProxy = new CalcProxy(_validator, _calculator);
 }
Exemplo n.º 27
0
        static void Main()
        {
            // Get the username and password
            Console.WriteLine("Username authentication required.");
            Console.WriteLine("Provide a username.");
            Console.WriteLine("   Enter username: (test1)");
            string username = Console.ReadLine();
            Console.WriteLine("   Enter password:"******"";
            ConsoleKeyInfo info = Console.ReadKey(true);
            while (info.Key != ConsoleKey.Enter)
            {
                if (info.Key != ConsoleKey.Backspace)
                {
                    if (info.KeyChar != '\0')
                    {
                        password += info.KeyChar;
                    }
                    info = Console.ReadKey(true);
                }
                else if (info.Key == ConsoleKey.Backspace)
                {
                    if (password != "")
                    {
                        password = password.Substring(0, password.Length - 1);

                    }
                    info = Console.ReadKey(true);
                }
            }

            for (int i = 0; i < password.Length; i++)
            {
                Console.Write("*");
            }
            Console.WriteLine();

            // Create a proxy with Username endpoint configuration
            CalculatorProxy proxy = new CalculatorProxy("Username");

            try
            {
                proxy.ClientCredentials.UserName.UserName = username;
                proxy.ClientCredentials.UserName.Password = password;

                // 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);
                proxy.Close();
            }
            catch (TimeoutException e)
            {
                Console.WriteLine("Call timed out : {0}", e.Message);
                proxy.Abort();
            }
            catch (Exception e)
            {
                Console.WriteLine("Call failed:");
                while (e != null)
                {
                    Console.WriteLine("\t{0}", e.Message);
                    e = e.InnerException;
                }
                proxy.Abort();
            }

            Console.WriteLine();
            Console.WriteLine("Press <ENTER> to terminate client.");
            Console.ReadLine();
        }
Exemplo n.º 28
0
 public void SetUp()
 {
     _calculator = new Calculator();
     _validator = new Validator(-20, 20);
     _calcProxy = new CalcProxy(_validator, _calculator);
     _expressionValidator = new MathRegex();
     _fixer = new ExpressionFixer();
     _lexer = new MathLexer(_fixer);
     _precedence = new Precedence();
     _resolver = new Resolver(_lexer, _calcProxy, _precedence);
     _parser = new MathParser(_lexer, _expressionValidator, _resolver);
 }
Exemplo n.º 29
0
 public MathOperator(int precedence)
     : base(precedence)
 {
     _calcProxy = new CalcProxy(new Validator(-100, 100), new Calculator());
 }
Exemplo n.º 30
0
        public async Task MultipleClientConnectionsEventCalls()
        {
            await DefaultSetup(new CalculatorService(), 10);

            Task[] connectionTasks = new Task[connections.Length];
            const int taskCount = 25;

            for (int connectionIndex = 0; connectionIndex < connections.Length; connectionIndex++)
            {
                SimpleInMemConnection conn = connections[connectionIndex];
                connectionTasks[connectionIndex] = Task.Run(() =>
                {
                    Task[] tasks = new Task[taskCount];

                    for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
                    {
                        tasks[taskIndex] = Task.Run(() =>
                        {
                            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(conn);
                            calculatorProxy.IncrementCountAsync();
                        });
                    }

                    Task.WaitAll(tasks);
                });
            }

            Task.WaitAll(connectionTasks);

            int totalWaitTime = 0;
            const int maxWait = 5000;
            // Intentionally avoiding exponential back-off due to simple nature of this test
            const int incrementalWait = 500;

            while (totalWaitTime < maxWait)
            {
                await Task.Delay(incrementalWait);
                totalWaitTime += incrementalWait;

                try
                {
                    Assert.AreEqual(CalculatorService.Count, connections.Length * taskCount);
                    break;
                }
                catch (AssertionException)
                {
                    // The implementation of SimpleInMem can guarantee delivery of events just be virtue of staying with in the process boundary.
                    // SimpleInMem event failing after 5 seconds needs to raise alarm and investigation.
                    if (totalWaitTime > maxWait)
                    {
                        throw;
                    }
                }
            }

            Console.WriteLine($"{nameof(MultipleClientConnectionsEventCalls)} - Count: {CalculatorService.Count}");
        }
Exemplo n.º 31
0
        public async Task MethodCall_ReqRsp_WithStatefulLayers()
        {
            var layerProvider = new TestLayerProvider_StatefulAppend("Layer");
            var layerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, layerProvider);
            transportBuilder.SetLayerStackProvider(layerStackProvider);
            await DefaultSetup(new CalculatorService(), 1);

            layerProvider.Layers.Clear();

            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);

            var request = new Message<PairedInput>(new PairedInput { First = 1, Second = 2 });
            IMessage<Output> response = await calculatorProxy.AddAsync(request, CancellationToken.None);
            Assert.IsFalse(response.IsError);

            Assert.AreEqual(2, layerProvider.Layers.Count);
            Assert.AreEqual("Layer0SendLayer0Receive", layerProvider.Layers[0].State);
            Assert.AreEqual("Layer1ReceiveLayer1Send", layerProvider.Layers[1].State);

            request = new Message<PairedInput>(new PairedInput { First = 1, Second = 2 });
            response = await calculatorProxy.AddAsync(request, CancellationToken.None);
            Assert.IsFalse(response.IsError);

            Assert.AreEqual(4, layerProvider.Layers.Count);
            Assert.AreEqual("Layer2SendLayer2Receive", layerProvider.Layers[2].State);
            Assert.AreEqual("Layer3ReceiveLayer3Send", layerProvider.Layers[3].State);
        }
Exemplo n.º 32
0
        public async Task MethodCall_WithLayerStack()
        {
            var testList = new List<string>();
            var layer1 = new TestLayer_Append("foo", testList);
            var layer2 = new TestLayer_Append("bar", testList);

            transportBuilder.SetLayerStackProvider(new LayerStackProvider<Dummy>(LoggerTests.BlackHole, layer1, layer2));
            await DefaultSetup(new CalculatorService(), 1);

            const int first = 91;
            const int second = 23;
            int addResult = first + second;

            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First = first,
                Second = second
            };
            var request = new Message<PairedInput>(input);
            IMessage<Output> addResponse = await calculatorProxy.AddAsync(request, System.Threading.CancellationToken.None);
            Output addOutput = addResponse.Payload.Deserialize();
            Assert.AreEqual(addResult, addOutput.Result);

            Assert.AreEqual(8, testList.Count);
            Assert.AreEqual(layer1.value, testList[0]);
            Assert.AreEqual(testList[0] + layer2.value, testList[1]);
            Assert.AreEqual(testList[1] + layer2.value, testList[2]);
            Assert.AreEqual(testList[2] + layer1.value, testList[3]);
            Assert.AreEqual(layer1.value, testList[4]);
            Assert.AreEqual(testList[4] + layer2.value, testList[5]);
            Assert.AreEqual(testList[5] + layer2.value, testList[6]);
            Assert.AreEqual(testList[6] + layer1.value, testList[7]);
        }
Exemplo n.º 33
0
        public async Task MethodCall_WithServiceError()
        {
            await DefaultSetup(new CalculatorService(), 1);

            const int first = 91;
            const int second = 23;

            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);

            var input = new PairedInput
            {
                First = first,
                Second = second
            };
            var request = new Message<PairedInput>(input);
            IMessage<Output> multiplyResponse = await calculatorProxy.MultiplyAsync(request, System.Threading.CancellationToken.None);
            Assert.IsTrue(multiplyResponse.IsError);
            InternalServerError error = multiplyResponse.Error.Deserialize<InternalServerError>();
            Assert.AreEqual((int)ErrorCode.InternalServerError, error.error_code);
            Assert.That(error.message, Is.StringContaining(Errors.InternalErrorMessage));
        }
Exemplo n.º 34
0
        public async Task MultipleClientConnectionsMethodCalls()
        {
            Stopwatch sw = Stopwatch.StartNew();

            await DefaultSetup(new CalculatorService(), 10);

            Task[] connectionTasks = new Task[connections.Length];

            for (int connectionIndex = 0; connectionIndex < connections.Length; connectionIndex++)
            {
                SimpleInMemConnection conn = connections[connectionIndex];
                connectionTasks[connectionIndex] = Task.Run(() =>
                {
                    int taskCount = 25;
                    Task[] tasks = new Task[taskCount];

                    for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
                    {
                        tasks[taskIndex] = Task.Run(async () =>
                        {
                            Random rand = new Random(DateTime.UtcNow.Millisecond);
                            int first = rand.Next(1, 100);
                            int second = rand.Next(1, 50);
                            int expectedAddResult = first + second;
                            int expectedSubResult = first - second;
                            var addTraceId = Guid.NewGuid().ToString();
                            var subTraceId = Guid.NewGuid().ToString();
                            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(conn);

                            var addInput = new PairedInput
                            {
                                First = first,
                                Second = second,
                                TraceId = addTraceId
                            };

                            var subInput = new PairedInput
                            {
                                First = first,
                                Second = second,
                                TraceId = subTraceId
                            };

                            Message<PairedInput> addRequest = new Message<PairedInput>(addInput);
                            Message<PairedInput> subRequest = new Message<PairedInput>(subInput);
                            IMessage<Output> addResponse = await calculatorProxy.AddAsync(addRequest, System.Threading.CancellationToken.None);
                            IMessage<Output> subResponse = await calculatorProxy.SubtractAsync(subRequest, System.Threading.CancellationToken.None);
                            Output addOutput = addResponse.Payload.Deserialize();
                            Output subOutput = subResponse.Payload.Deserialize();

                            Assert.AreEqual(expectedAddResult, addOutput.Result);
                            Assert.AreEqual(addInput.TraceId, addOutput.TraceId);
                            Assert.AreEqual(expectedSubResult, subOutput.Result);
                            Assert.AreEqual(subInput.TraceId, subOutput.TraceId);
                        });
                    }

                    Task.WaitAll(tasks);
                });
            }

            Task.WaitAll(connectionTasks);
            sw.Stop();
            Console.WriteLine($"{nameof(MultipleClientConnectionsMethodCalls)} - test time: {sw.Elapsed.TotalSeconds}");
        }
Exemplo n.º 35
0
        public async void EventCall()
        {
            await DefaultSetup(new CalculatorService(), 1);
            var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);

            calculatorProxy.ClearAsync();

            bool wasSignaled = CalculatorService.ClearCalledEvent.WaitOne(30000);
            Assert.IsTrue(wasSignaled, "Timed out waiting for event");
        }
Exemplo n.º 36
0
 public MathOperator(int precedence)
     : base(precedence)
 {
     _calcProxy = new CalcProxy(
         new Validator(-100, 100), new Calculator());
 }