Example #1
0
        private IDisposable subscribe(Destination destination, Action <Message> callback, string messageType)
        {
            IDisposable subscription = null;

            string[] selectors = new[]
            {
                messageType != null ? "JMSType = '" + messageType + "'" : null,
                m_JailedTag != null ? JailedSelector : null
            }.Where(x => x != null).ToArray();

            MessageConsumer consumer = selectors.Length == 0
                ? m_Session.createConsumer(destination)
                : m_Session.createConsumer(destination, string.Join(" AND ", selectors));

            consumer.setMessageListener(new GenericMessageListener(callback));

            subscription = Disposable.Create(() =>
            {
                lock (this)
                {
                    consumer.close();
                    // ReSharper disable AccessToModifiedClosure
                    m_Subscriptions.Remove(subscription);
                    // ReSharper restore AccessToModifiedClosure
                    if (m_Subscriptions.Count == 0)
                    {
                        m_Session.close();
                        m_Session = null;
                    }
                }
            });
            m_Subscriptions.Add(subscription);

            return(subscription);
        }
Example #2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Receiver is starting...");
            var consumer1 = new MessageConsumer(ConfigurationManager.AppSettings["q1.Path"], ConfigurationManager.AppSettings["q1.connectionString"]);

            consumer1.MessageReceived += consumer1_MessageReceived;
            Console.WriteLine("Consumer1 started.");
            var consumer2 = new MessageConsumer(ConfigurationManager.AppSettings["q2.Path"], ConfigurationManager.AppSettings["q2.connectionString"]);

            consumer2.MessageReceived += consumer2_MessageReceived;
            Console.WriteLine("Consumer2 started.");

            Console.WriteLine("Waiting for messages...");
            consumer1.StartReceiving();
            consumer2.StartReceiving();

            Console.WriteLine("Press Enter to stop receiving.");
            var input = Console.ReadLine();

            consumer1.StopReceiving();
            Console.WriteLine("Consumer 1 stopped receiving.");
            consumer2.StopReceiving();
            Console.WriteLine("Consumer 2 stopped receiving.");

            Console.WriteLine("Press Enter to exit.");
            Console.ReadLine();
        }
Example #3
0
 private static Action GetOnStopped(ConnectionFactory factory, MessageConsumer processors)
 {
     return(() =>
     {
         processors.DeRegister(factory);
     });
 }
        private void Consume_Message(MessageCommand command)
        {
            var cat     = TestData.Cats.FirstOrDefault();
            var message = new Message <Cat>(command, cat);

            MessageConsumer.Consume(message);
        }
Example #5
0
    public void Run(string[] args)
    {
        try
        {
            Console.WriteLine("Server " + ((serverUrl != null) ? serverUrl : "localhost"));
            Console.WriteLine("User " + ((userName != null) ? userName : "******"));
            Console.WriteLine("Queue " + queueName);

            ConnectionFactory factory    = new TIBCO.EMS.ConnectionFactory(serverUrl);
            Connection        connection = factory.CreateConnection(userName, password);
            Session           session    = connection.CreateSession(false, Session.AUTO_ACKNOWLEDGE); //read up more on AUTO_ACK
            Destination       queue      = session.CreateQueue(queueName);
            MessageConsumer   consumer   = session.CreateConsumer(queue);

            // Start the Connection
            // Don't I need a connection.Close some where?
            connection.Start();

            Console.WriteLine("Waiting for messsages in queue " + queueName);
            consumer.MessageHandler += new EMSMessageHandler(event_MessageHandler);
        }
        catch (EMSException e)
        {
            Console.Error.WriteLine("Exception in ReceiveHelloWorld: " + e.Message);
            Console.Error.WriteLine(e.StackTrace);
            Environment.Exit(0);
        }
        catch (ThreadInterruptedException e)
        {
            Console.Error.WriteLine("Exception in ReceiveHelloWorld: " + e.Message);
            Console.Error.WriteLine(e.StackTrace);
            Environment.Exit(0);
        }
    }
        private static IList<TestData> Explore(IEnumerable<string> sources, ILogger frameworkLogger)
        {
            try
            {
                var testDriver = GetTestDriver(frameworkLogger);

                var tests = new List<TestData>();
                var messageConsumer = new MessageConsumer()
                    .Handle<TestDiscoveredMessage>(message =>
                    {
                        if (message.Test.IsTestCase)
                            tests.Add(message.Test);
                    })
                    .Handle<AnnotationDiscoveredMessage>(message => message.Annotation.Log(frameworkLogger, true));

                var loader = new ReflectionOnlyAssemblyLoader();
                var assemblyInfos = sources.Select(source => LoadAssembly(source, loader)).Where(assembly => assembly != null).ToList();
                var testExplorationOptions = new TestExplorationOptions();

                testDriver.Describe(loader.ReflectionPolicy, assemblyInfos, testExplorationOptions, messageConsumer, NullProgressMonitor.CreateInstance());

                return ResetCollectionForExposedTests(tests) ? null : tests;
            }
            catch (Exception ex)
            {
                frameworkLogger.Log(LogSeverity.Error, "Gallio failed to load tests", ex);
                return null;
            }
        }
        public new void OneTimeSetUp()
        {
            var databaseName      = "Test";
            var collectionName    = "Objects";
            var hostName          = "localHost";
            var exchangeName      = "";
            var requestQueueName  = "ReadNotes";
            var responseQueueName = "NoteAPI";

            Reader  = new MongoClient.EntryReader(databaseName, collectionName);
            Creator = new MongoClient.EntryCreator(Reader, databaseName, collectionName);
            Broker  = new MongoClient.EntryBroker(Creator, Reader, null, null);
            Broker.Initialize(databaseName);
            Broker.DeleteEverything();

            Publisher = new MessagePublisher(hostName, exchangeName, requestQueueName);

            var autoConsumer     = new AutoMessageConsumer(hostName, requestQueueName);
            var objectReader     = new MongoClient.EntryReader(databaseName, collectionName);
            var messagePublisher = new MessagePublisher(hostName, exchangeName, responseQueueName);

            ConsumerReader = new AutoConsumerReader(autoConsumer, objectReader, messagePublisher);

            Consumer = new MessageConsumer(hostName, responseQueueName);

            // Subscribe
            ConsumerReader.ResultsPublished += ConsumerReader_ResultsPublished;
            AutoResetEvent = new AutoResetEvent(false);
        }
        private static IList <TestData> Explore(IEnumerable <string> sources, ILogger frameworkLogger)
        {
            try
            {
                var testDriver = GetTestDriver(frameworkLogger);

                var tests           = new List <TestData>();
                var messageConsumer = new MessageConsumer()
                                      .Handle <TestDiscoveredMessage>(message =>
                {
                    if (message.Test.IsTestCase)
                    {
                        tests.Add(message.Test);
                    }
                })
                                      .Handle <AnnotationDiscoveredMessage>(message => message.Annotation.Log(frameworkLogger, true));

                var loader                 = new ReflectionOnlyAssemblyLoader();
                var assemblyInfos          = sources.Select(source => LoadAssembly(source, loader)).Where(assembly => assembly != null).ToList();
                var testExplorationOptions = new TestExplorationOptions();

                testDriver.Describe(loader.ReflectionPolicy, assemblyInfos, testExplorationOptions, messageConsumer, NullProgressMonitor.CreateInstance());

                return(ResetCollectionForExposedTests(tests) ? null : tests);
            }
            catch (Exception ex)
            {
                frameworkLogger.Log(LogSeverity.Error, "Gallio failed to load tests", ex);
                return(null);
            }
        }
Example #9
0
        public static void Main()
        {
            Console.Write("Enter Exchange: ");
            var exchange = Console.ReadLine();

            Console.Write("Enter Queue: ");
            var queue = Console.ReadLine();

            Console.Write("Enter Route Key: ");
            var routeKey = Console.ReadLine();

            Console.WriteLine($"Listening for messages on {queue}");

            var messageConsumer = new MessageConsumer();
            var connection      = messageConsumer.GetConnection(ConfigurationManager.AppSettings["RabbitMQHost"],
                                                                Convert.ToInt32(ConfigurationManager.AppSettings["RabbitMQPort"]),
                                                                ConfigurationManager.AppSettings["HostUsername"],
                                                                ConfigurationManager.AppSettings["HostPassword"]);

            foreach (var message in messageConsumer.ListenForMessages(connection, "Dexter Printing", queue, "Test"))
            {
                Console.WriteLine(" [x] Received {0}", message.ToString());
            }

            connection.Close();
        }
 private bool IsConsumerConfiguredQueue(MessageConsumer consumer)
 {
     return(!consumer.QueueSettings.IsBrokerAssignedName &&
            !consumer.QueueSettings.IsAutoDelete &&
            !consumer.QueueSettings.IsExclusive &&
            consumer.BindingType == QueueBindingTypes.Create);
 }
Example #11
0
            public Listener(TestRunnerEventDispatcher eventDispatcher, TappedLogger tappedLogger, LockBox <Report> reportBox)
            {
                this.eventDispatcher = eventDispatcher;
                this.tappedLogger    = tappedLogger;
                this.reportBox       = reportBox;

                states = new Dictionary <string, TestStepState>();

                rootTestStepIds       = new List <string>();
                rootTestStepStopwatch = Stopwatch.StartNew();
                rootTestStepResult    = new TestResult()
                {
                    Outcome = TestOutcome.Passed
                };

                consumer = new MessageConsumer()
                           .Handle <TestDiscoveredMessage>(HandleTestDiscoveredMessage)
                           .Handle <AnnotationDiscoveredMessage>(HandleAnnotationDiscoveredMessage)
                           .Handle <TestStepStartedMessage>(HandleTestStepStartedMessage)
                           .Handle <TestStepLifecyclePhaseChangedMessage>(HandleTestStepLifecyclePhaseChangedMessage)
                           .Handle <TestStepMetadataAddedMessage>(HandleTestStepMetadataAddedMessage)
                           .Handle <TestStepFinishedMessage>(HandleTestStepFinishedMessage)
                           .Handle <TestStepLogAttachMessage>(HandleTestStepLogAttachMessage)
                           .Handle <TestStepLogStreamWriteMessage>(HandleTestStepLogStreamWriteMessage)
                           .Handle <TestStepLogStreamEmbedMessage>(HandleTestStepLogStreamEmbedMessage)
                           .Handle <TestStepLogStreamBeginSectionBlockMessage>(HandleTestStepLogStreamBeginSectionBlockMessage)
                           .Handle <TestStepLogStreamBeginMarkerBlockMessage>(HandleTestStepLogStreamBeginMarkerBlockMessage)
                           .Handle <TestStepLogStreamEndBlockMessage>(HandleTestStepLogStreamEndBlockMessage)
                           .Handle <LogEntrySubmittedMessage>(HandleLogEntrySubmittedMessage);

                tappedLogger.SetListener(this);
            }
Example #12
0
        static void Main(string[] args)
        {
            const int partitionId = 0;

            if (args.Length < 2)
            {
                Usage();
                return;
            }

            var  serverAddress = args[0].Split(':')[0];
            var  serverPort    = Convert.ToInt32(args[0].Split(':')[1]);
            var  topicName     = args[1];
            long startOffset   = 5;

            if (args.Length > 2)
            {
                startOffset = Convert.ToInt64(args[2]);
            }

            var busConnector = new KafkaBusConnector(serverAddress, serverPort, "c# KafkaConsume util");

            IKafkaMessageConsumer consumer = new MessageConsumer();

            consumer.Start(busConnector, topicName, partitionId, startOffset, DumpMessage);

            while (Console.KeyAvailable == false)
            {
                Thread.Sleep(100);
            }
            consumer.Stop();
        }
Example #13
0
        public MpServer()
        {
            MessageConsumer serverConsumer = new MessageConsumer();

            serverConsumer.AddHandle(new HandleLogin());
            _server = new AsyncEventServer(IPAddress.Any, 2345, serverConsumer);
        }
        public MatchHistoryService(Session session) : base("/profile/matches")
        {
            this.session = session;

            var messages = new MessageConsumer(session);

            messages.Consume <EndOfGameStats>(OnEndOfGameStats);
        }
Example #15
0
 internal AMQPMessageCloak(MessageConsumer c, Amqp.Message msg)
 {
     message    = msg;
     consumer   = c;
     connection = c.Session.Connection;
     InitMessage();
     InitDeliveryAnnotations();
 }
 public TestQueue(ILogger <MessagePublisher> publisherLogger, ILogger <MessageConsumer> consumerLogger)
 {
     _sqs             = TestConfig.Config.GetAWSOptions("AWS_SQS").CreateServiceClient <IAmazonSQS>();
     _sns             = TestConfig.Config.GetAWSOptions("AWS_SNS").CreateServiceClient <IAmazonSimpleNotificationService>();
     _messageOptions  = TestConfig.Config.Get <MessageServiceOptions>();
     MessagePublisher = new MessagePublisher(Options.Create(_messageOptions), publisherLogger, _sns);
     MessageConsumer  = new MessageConsumer(Options.Create(_messageOptions), consumerLogger, _sqs, new NLogContext(), new List <ITypedHandler>(), _messageHistory);
 }
Example #17
0
        public HextechService(Session session) : base("/collection/hextech")
        {
            this.session = session;

            var messages = new MessageConsumer(session);

            messages.Consume <SimpleDialogMessage>(OnSimpleDialogMessage);
        }
        public void OneTimeSetUp()
        {
            var hostName     = "localhost";
            var exchangeName = "";
            var queueName    = "hello";

            Consumer  = new MessageConsumer(hostName, queueName);
            Publisher = new MessagePublisher(hostName, exchangeName, queueName);
        }
Example #19
0
        public InviteService(Session session, PlayLoopService game) : base("/invite")
        {
            this.session    = session;
            this.loop       = game;
            session.Authed += Session_Authed;
            var messages = new MessageConsumer(session);

            messages.Consume <InvitationRequest>(OnInvitationRequest);
        }
Example #20
0
                public ConsumerAdapter(IUnitTestProvider provider, UnitTestElementConsumer consumer)
                {
                    this.provider = provider;
                    this.consumer = consumer;

                    messageConsumer = new MessageConsumer()
                                      .Handle <TestDiscoveredMessage>(HandleTestDiscoveredMessage)
                                      .Handle <AnnotationDiscoveredMessage>(HandleAnnotationDiscoveredMessage);
                }
Example #21
0
        public SummonerService(Session session) : base("/summoner")
        {
            this.session  = session;
            this.settings = GetSettings <SummonerSettings>();

            var messages = new MessageConsumer(session);

            messages.Consume <StoreAccountBalanceNotification>(OnStoreAccountBalanceNotification);
        }
        public static void ConfigureListener(ref MessageConsumer consumer, TextMessageHandler handler)
        {
            consumer.Stop();

            consumer.ConsumerInfo.Retroactive = false;
            consumer.Listener += (message) => Consumer_Listener(message, handler);

            consumer.Start();
        }
Example #23
0
        public ActiveGameService(PlayLoopService loop, Session session) : base("/playloop/ingame")
        {
            this.session = session;
            this.loop    = loop;

            var messages = new MessageConsumer(session);

            messages.Consume <GameDTO>(OnGameDTO);
        }
        public void Consume_UnknownMessage_Fails()
        {
            var loggerFactory = IocWrapper.Instance.GetService <ILoggerFactory>();
            var consumer      = new MessageConsumer <Cat>(ApiClientMock.Instance, loggerFactory);

            var cat     = TestData.Cats.FirstOrDefault();
            var message = new Message <Cat>(MessageCommand.Unknown, cat);

            Assert.Throws <ArgumentOutOfRangeException>(() => consumer.Consume(message));
        }
Example #25
0
        public AuthService(Session session) : base("/login")
        {
            this.session         = session;
            this.session.Authed += Session_Authed;
            settings             = GetSettings <LoginSettings>();

            var messages = new MessageConsumer(session);

            messages.Consume <ClientLoginKickNotification>(OnClientLoginKickNotification);
        }
        public void IsValidMessageTest(string message, bool expected)
        {
            var consumer = new MessageConsumer(mockLogger.Object);

            consumer.SettingsDictionary = new Dictionary <string, string>();
            consumer.SettingsDictionary["ProducerMessagePrefix"] = producerMessagePrefix;
            bool actual = consumer.IsValidMessage(message.ToString(), out string userInput);

            Assert.Equal(expected, actual);
        }
        public MpClient()
        {
            MessageConsumer clientConsumer = new MessageConsumer();

            clientConsumer.AddHandle(new HandleLogin());
            _serializer = clientConsumer;

            _client = new SyncReceiveTcpClient(clientConsumer);
            _client.ConnectError += ClientConsumerOnConnectError;
        }
Example #28
0
 // Consuming applications can create queues specifically for them based on the
 // application needs.
 private void CreateConsumerQueue(MessageConsumer eventConsumer)
 {
     if (eventConsumer.BindingType == QueueBindingTypes.Create)
     {
         using (IModel channel = _connMgr.CreateChannel(eventConsumer.BrokerName))
         {
             channel.QueueDeclare(eventConsumer);
         }
     }
 }
Example #29
0
 private void subscribe(string messageType, MessageListener msgListener)
 {
     try
     {
         IDestination    destination = session.GetTopic(messageType);
         MessageConsumer consumer    = (MessageConsumer)session.CreateConsumer(destination);
         consumer.Listener += new MessageListener(OnMessage);
     }
     catch (Exception e) { }
 }
Example #30
0
        public void Subscribe <T>(TimeSpan interval, MessageConsumer <IList <T> > consumer)
            where T : class
        {
            Pipe segment = PipeSegment.IntervalConsumer(interval, consumer);

            var binder = new SubscriberBinder(segment);

            binder.Bind(_pipe);

            _disposables.Add(segment);
        }
Example #31
0
        public void Subscribe <T>(MessageConsumer <T> consumer)
            where T : class
        {
            Pipe segment = PipeSegment.Consumer(consumer);

            var binder = new SubscriberBinder(segment);

            binder.Bind(_pipe);

            _disposables.Add(segment);
        }
        public void ConsumeSendsMessageToLogicLayer()
        {
            var logger = new Mock<ILogger>();
            var logicLayer = new Mock<IMessageRouter>();

            var consumer = new MessageConsumer(logger.Object, logicLayer.Object);
            var serializer = new JavaScriptSerializer();

            consumer.Consume(new Message<SampleMessage>(new SampleMessage { Message = serializer.Serialize(TestMessages.GetTestNeedUserMessage()) }));

            logicLayer.Verify(v => v.RouteSampleMessage(It.IsAny<object>()));
        }
 public void Queued_And_Then_Left_Over_A_Period_Of_Time_With_Queue_Per_Worker()
 {
     MessageConsumer consumer = new MessageConsumer();
       ThreadPool pool = new ThreadPool(ThreadPoolConfiguration.FiveAndTen, new QueuePerWorkerStrategy());
       pool.Start();
       foreach (Message message in MessageBuilder.MakeMessages(30))
       {
     pool.Queue(consumer, message);
       }
       Thread.Sleep(TimeSpan.FromSeconds(10.0));
       pool.Stop();
       Assert.AreEqual(30, consumer.NumberOfMessagesProcessed);
 }
        public void PublishLogsExecutionTime()
        {
            var logger = new Mock<ILogger>();
            var logicLayer = new Mock<IMessageRouter>();
            var consumer = new MessageConsumer(logger.Object, logicLayer.Object);
            var serializer = new JavaScriptSerializer();
            var invocations = new List<string>();
            logger.Setup(loggerObj => loggerObj.Trace(It.IsAny<string>(), It.IsAny<object>(), It.IsAny<TimeSpan>()))
                .Callback<string, object[]>((text, message) => invocations.Add(text));

            consumer.Consume(new Message<SampleMessage>(new SampleMessage { Message = serializer.Serialize(TestMessages.GetTestNeedUserMessage()) }));

            Assert.IsTrue(invocations[0].Contains("TimeElapsed"));
        }
        public void PublishLogsMessageProccessingBegun()
        {
            var logger = new Mock<ILogger>();
            var logicLayer = new Mock<IMessageRouter>();
            var consumer = new MessageConsumer(logger.Object, logicLayer.Object);
            var serializer = new JavaScriptSerializer();
            var invocations = new List<string>();
            logger.Setup(loggerObj => loggerObj.Info(It.IsAny<string>(), It.IsAny<object[]>()))
                .Callback<string, object[]>((message, obj) => invocations.Add(message));

            consumer.Consume(new Message<SampleMessage>(new SampleMessage { Message = serializer.Serialize(TestMessages.GetTestNeedUserMessage()) }));

            Assert.IsTrue(invocations[0].Contains("Begun Consuming Message"));
        }
        /// <summary>
        /// Creates a test isolation server.
        /// </summary>
        /// <param name="ipcPortName">The IPC port name.</param>
        /// <param name="linkId">The unique id of the client/server pair.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="ipcPortName"/> is null.</exception>
        public TestIsolationServer(string ipcPortName, Guid linkId)
        {
            if (ipcPortName == null)
                throw new ArgumentNullException("ipcPortName");

            serverChannel = new BinaryIpcServerChannel(ipcPortName);
            clientChannel = new BinaryIpcClientChannel(ipcPortName + ".ServerCallback");
            activeTasks = new Dictionary<Guid, IsolatedTaskState>();

            MessageConsumer messageConsumer = new MessageConsumer()
                .Handle<IsolatedTaskFinishedMessage>(HandleIsolatedTaskFinished);

            messageExchange = new MessageExchange(messageConsumer);
            serverChannel.RegisterService(GetMessageExchangeLinkServiceName(linkId), messageExchange);
        }
        public void PublishLogsMessageProccessingFailed()
        {
            var logger = new Mock<ILogger>();
            var logicLayer = new Mock<IMessageRouter>();
            var consumer = new MessageConsumer(logger.Object, logicLayer.Object);
            var serializer = new JavaScriptSerializer();
            var invocations = new List<string>();
            logger.Setup(loggerObj => loggerObj.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()))
                .Callback<Exception, string, object[]>((ex, message, obj) => invocations.Add(message));
            logicLayer.Setup(c => c.RouteSampleMessage(It.IsAny<object>())).Throws(new Exception("test exception"));

            consumer.Consume(new Message<SampleMessage>(new SampleMessage { Message = serializer.Serialize(TestMessages.GetTestNeedUserMessage()) }));

            Assert.IsTrue(invocations[0].Contains("Error Consuming Message"));
        }
                public ConsumerAdapter(IUnitTestProvider provider, UnitTestElementConsumer consumer)
                {
                    this.provider = provider;
                    this.consumer = consumer;

                    messageConsumer = new MessageConsumer()
                        .Handle<TestDiscoveredMessage>(HandleTestDiscoveredMessage)
                        .Handle<AnnotationDiscoveredMessage>(HandleAnnotationDiscoveredMessage);
                }
Example #39
0
        public override ICollection Load(string location, ProjectData projectData, IWarningHandler warningHandler)
        {
            // Skip loading if the extension is not fully initalized unless we are not
            // running in Visual Studio (because we are running in MSTest instead).
            if (!TipShellExtension.IsInitialized && ShellEnvironment.IsRunningInVisualStudio)
                return EmptyArray<TestElement>.Instance;

            // Explore the tests.
            ITestFrameworkManager testFrameworkManager = RuntimeAccessor.ServiceLocator.Resolve<ITestFrameworkManager>();
            WarningLogger logger = new WarningLogger(warningHandler);

            ReflectionOnlyAssemblyLoader loader = new ReflectionOnlyAssemblyLoader();
            loader.AddHintDirectory(Path.GetDirectoryName(location));

            IAssemblyInfo assembly = loader.ReflectionPolicy.LoadAssemblyFrom(location);

            var testFrameworkSelector = new TestFrameworkSelector()
            {
                Filter = testFrameworkHandle => testFrameworkHandle.Id != "MSTestAdapter.TestFramework",
                FallbackMode = TestFrameworkFallbackMode.Approximate
            };

            ITestDriver driver = testFrameworkManager.GetTestDriver(testFrameworkSelector, logger);
            TestExplorationOptions testExplorationOptions = new TestExplorationOptions();

            ArrayList tests = new ArrayList();
            MessageConsumer messageConsumer = new MessageConsumer()
                .Handle<TestDiscoveredMessage>(message =>
                {
                    if (message.Test.IsTestCase)
                        tests.Add(GallioTestElementFactory.CreateTestElement(message.Test, location, projectData));
                })
                .Handle<AnnotationDiscoveredMessage>(message =>
                {
                    message.Annotation.Log(logger, true);
                });

            driver.Describe(loader.ReflectionPolicy, new ICodeElementInfo[] { assembly },
                testExplorationOptions, messageConsumer, NullProgressMonitor.CreateInstance());

            return tests;
        }
Example #40
0
        public virtual IMessageProvider Register(MessageKind[] kinds)
        {
            if (kinds == null || kinds.Length < 1) throw new ArgumentNullException("kinds");
            kinds = kinds.Distinct().OrderBy(e => e).ToArray();
            if (kinds == null || kinds.Length < 1) throw new ArgumentNullException("kinds");

            // 检查注册范围是否有效
            var ks = Kinds;
            if (ks != null)
            {
                foreach (var item in kinds)
                {
                    if (Array.IndexOf<MessageKind>(ks, item) < 0) throw new ArgumentOutOfRangeException("kinds", "当前消息提供者不支持Kind=" + item + "的消息!");
                }
            }

            var mc = new MessageConsumer() { Parent = this, Kinds = kinds };
            lock (Consumers)
            {
                Consumers.Add(mc);
            }
            mc.OnDisposed += (s, e) => Consumers.Remove(s as MessageConsumer);
            return mc;
        }
Example #41
0
		public unsafe void r_PlaceOrder(MessageConsumer q, int count)
		{
			object target;
			int done = 0;
			Message msg = default(Message);
			Address nextFun = default(Address);
			Address fun = _r_PlaceOrder;
#if IL
			ldftn instance void Snail.Tests.Threading/Security::r_PlaceOrder(class Snail.Threading.MessageConsumer,valuetype Snail.Threading.Message&,int32)
            public Listener(TestRunnerEventDispatcher eventDispatcher, TappedLogger tappedLogger, LockBox<Report> reportBox)
            {
                this.eventDispatcher = eventDispatcher;
                this.tappedLogger = tappedLogger;
                this.reportBox = reportBox;

                states = new Dictionary<string, TestStepState>();

                rootTestStepIds = new List<string>();
                rootTestStepStopwatch = Stopwatch.StartNew();
                rootTestStepResult = new TestResult()
                {
                    Outcome = TestOutcome.Passed
                };

                consumer = new MessageConsumer()
                    .Handle<TestDiscoveredMessage>(HandleTestDiscoveredMessage)
                    .Handle<AnnotationDiscoveredMessage>(HandleAnnotationDiscoveredMessage)
                    .Handle<TestStepStartedMessage>(HandleTestStepStartedMessage)
                    .Handle<TestStepLifecyclePhaseChangedMessage>(HandleTestStepLifecyclePhaseChangedMessage)
                    .Handle<TestStepMetadataAddedMessage>(HandleTestStepMetadataAddedMessage)
                    .Handle<TestStepFinishedMessage>(HandleTestStepFinishedMessage)
                    .Handle<TestStepLogAttachMessage>(HandleTestStepLogAttachMessage)
                    .Handle<TestStepLogStreamWriteMessage>(HandleTestStepLogStreamWriteMessage)
                    .Handle<TestStepLogStreamEmbedMessage>(HandleTestStepLogStreamEmbedMessage)
                    .Handle<TestStepLogStreamBeginSectionBlockMessage>(HandleTestStepLogStreamBeginSectionBlockMessage)
                    .Handle<TestStepLogStreamBeginMarkerBlockMessage>(HandleTestStepLogStreamBeginMarkerBlockMessage)
                    .Handle<TestStepLogStreamEndBlockMessage>(HandleTestStepLogStreamEndBlockMessage)
                    .Handle<LogEntrySubmittedMessage>(HandleLogEntrySubmittedMessage);

                tappedLogger.SetListener(this);
            }
Example #43
0
        public IEnumerable<AutoTest.TestRunners.Shared.Results.TestResult> Run(RunSettings settings)
        {
            if (!_isInitialized)
                return new AutoTest.TestRunners.Shared.Results.TestResult[] { getNotInitializedResult(settings) };
            var tests = settings.Assembly.Tests.ToList();
            var members = settings.Assembly.Members.ToList();
            var namespaces = settings.Assembly.Namespaces.ToList();

            var runAll = namespaces.Count == 0 && members.Count == 0 && tests.Count == 0;
            var steps = new List<TestStepData>();
            var testResults = new List<AutoTest.TestRunners.Shared.Results.TestResult>();

            // Get a test isolation context.  Here we want to run tests in the same AppDomain.
            var testIsolationProvider = (ITestIsolationProvider)RuntimeAccessor.ServiceLocator.ResolveByComponentId("Gallio.LocalTestIsolationProvider");
            var testIsolationOptions = new TestIsolationOptions();
            ITestIsolationContext testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, _logger);

            var testPackage = new TestPackage();
            testPackage.AddFile(new FileInfo(settings.Assembly.Assembly));
            testPackage.TestFrameworkFallbackMode = TestFrameworkFallbackMode.Strict;

            // Create some test exploration options.  Nothing interesting for you here, probably.
            var testExplorationOptions = new TestExplorationOptions();
            var messageSink = new MessageConsumer()
                .Handle<TestStepStartedMessage>((message) =>
                {
                    steps.Add(message.Step);
                })
                .Handle<TestStepFinishedMessage>(message =>
                {
                    var test = steps.FirstOrDefault(x => x.Id.Equals(message.StepId) && x.IsTestCase);
                    if (test == null)
                        return;
                    var fixture = string.Format("{0}.{1}", test.CodeReference.NamespaceName, steps.First(x => x.Id.Equals(test.ParentId)).Name);
                    testResults.Add(new AutoTest.TestRunners.Shared.Results.TestResult(
                        "MbUnit",
                        settings.Assembly.Assembly,
                        fixture,
                        message.Result.Duration.TotalMilliseconds,
                        string.Format("{0}.{1}", fixture, test.Name),
                        convertState(message.Result.Outcome.Status),
                        message.Result.Outcome.DisplayName));
                });

            // Provide a progress monitor.
            var logProgressMonitorProvider = new LogProgressMonitorProvider(_logger);
            var options = new TestExecutionOptions();
            options.FilterSet = new Gallio.Model.Filters.FilterSet<ITestDescriptor>(new OrFilter<ITestDescriptor>(getTestFilter(namespaces, members, tests)));

            // Run the tests.
            logProgressMonitorProvider.Run((progressMonitor) =>
            {
                _testDriver.Run(testIsolationContext, testPackage, testExplorationOptions, options, messageSink, progressMonitor);
            });

            return testResults;
        }