Пример #1
0
        public void TestCallbackServer()
        {
            var callbackServer  = new CallbackServer(_mockJvm.Object, false);
            var callbackHandler = new TestCallbackHandler();

            callbackHandler.Id = callbackServer.RegisterCallback(callbackHandler);
            Assert.Equal(1, callbackHandler.Id);

            using ISocketWrapper callbackSocket = SocketFactory.CreateSocket();
            callbackServer.Run(callbackSocket);

            int connectionNumber = 2;
            var clientSockets    = new ISocketWrapper[connectionNumber];

            for (int i = 0; i < connectionNumber; ++i)
            {
                var            ipEndpoint   = (IPEndPoint)callbackSocket.LocalEndPoint;
                ISocketWrapper clientSocket = SocketFactory.CreateSocket();
                clientSockets[i] = clientSocket;
                clientSocket.Connect(ipEndpoint.Address, ipEndpoint.Port);

                WriteAndReadTestData(clientSocket, callbackHandler, i);
            }

            Assert.Equal(connectionNumber, callbackServer.CurrentNumConnections);

            IOrderedEnumerable <int> actualValues   = callbackHandler.Inputs.OrderBy(i => i);
            IEnumerable <int>        expectedValues = Enumerable
                                                      .Range(0, connectionNumber)
                                                      .Select(i => callbackHandler.Apply(i))
                                                      .OrderBy(i => i);

            Assert.True(expectedValues.SequenceEqual(actualValues));
        }
Пример #2
0
 public void TestCallbackHandlers()
 {
     var tokenSource          = new CancellationTokenSource();
     var callbackHandlersDict = new ConcurrentDictionary <int, ICallbackHandler>();
     int inputToHandler       = 1;
     {
         // Test CallbackConnection using a ICallbackHandler that runs
         // normally without error.
         var callbackHandler = new TestCallbackHandler
         {
             Id = 1
         };
         callbackHandlersDict[callbackHandler.Id] = callbackHandler;
         TestCallbackConnection(
             callbackHandlersDict,
             callbackHandler,
             inputToHandler,
             tokenSource.Token);
         Assert.Single(callbackHandler.Inputs);
         Assert.Equal(
             callbackHandler.Apply(inputToHandler),
             callbackHandler.Inputs.First());
     }
     {
         // Test CallbackConnection using a ICallbackHandler that
         // throws an exception.
         var callbackHandler = new ThrowsExceptionHandler
         {
             Id = 2
         };
         callbackHandlersDict[callbackHandler.Id] = callbackHandler;
         TestCallbackConnection(
             callbackHandlersDict,
             callbackHandler,
             inputToHandler,
             tokenSource.Token);
         Assert.Empty(callbackHandler.Inputs);
     }
     {
         // Test CallbackConnection when cancellation has been requested for the token.
         tokenSource.Cancel();
         var callbackHandler = new TestCallbackHandler
         {
             Id = 3
         };
         callbackHandlersDict[callbackHandler.Id] = callbackHandler;
         TestCallbackConnection(
             callbackHandlersDict,
             callbackHandler,
             inputToHandler,
             tokenSource.Token);
         Assert.Empty(callbackHandler.Inputs);
     }
 }