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); }
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(); }
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); }
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); } }
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); }
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); }
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(); }
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); }
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); }
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); }
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); }
public ConsumerAdapter(IUnitTestProvider provider, UnitTestElementConsumer consumer) { this.provider = provider; this.consumer = consumer; messageConsumer = new MessageConsumer() .Handle <TestDiscoveredMessage>(HandleTestDiscoveredMessage) .Handle <AnnotationDiscoveredMessage>(HandleAnnotationDiscoveredMessage); }
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(); }
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)); }
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; }
// 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); } } }
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) { } }
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); }
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); }
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; }
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; }
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); }
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; }