public static TestObjectInterceptor InterfaceInterceptor(TestProcessor Processor) { return new InterfaceInterceptor { Processor = Processor, Log = Log }; }
public void EntityProcessorsFiresOnEnumerationOfTEntity() { EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel)); var connection = TestConfiguration.GetConnection(); var context = new MongoDbContext(connection); var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); provider.EntityProcessors.Add(processor); context.ChangeTracker.SetEntityState(new MongoFrameworkQueryableModel { Title = "EntityProcessorFireTest" }, EntityEntryState.Added); context.SaveChanges(); foreach (var dbEntity in queryable) { //Do nothing } Assert.IsTrue(processor.EntityProcessed); }
public void Should_not_call_processor_when_queue_is_empty() { var worker = new TestProcessor(); var target = new WorkerThread <int>("test", TimeSpan.FromMilliseconds(10), worker.Process); worker.Go.WaitOne(TimeSpan.FromSeconds(1)).Should().Be.False(); }
public void Should_not_call_processor_when_queue_is_empty() { var worker = new TestProcessor(); var target = new WorkerThread<int>("test", TimeSpan.FromMilliseconds(10), worker.Process); worker.Go.WaitOne(TimeSpan.FromSeconds(1)).Should().Be.False(); }
public void EntityProcessorsNotFiredWhenNotTEntity_Select() { EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel)); var connection = TestConfiguration.GetConnection(); var context = new MongoDbContext(connection); var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); provider.EntityProcessors.Add(processor); context.ChangeTracker.SetEntityState(new MongoFrameworkQueryableModel { Title = "EntityProcessorsNotFiredWhenNotTEntity_Select" }, EntityEntryState.Added); context.SaveChanges(); foreach (var titles in queryable.Select(e => e.Title)) { //Do nothing } Assert.IsFalse(processor.EntityProcessed); }
public ActionResult NoSQL(CosmosTestData data) { var test = new TestProcessor(); NoSQLTestResult result = new NoSQLTestResult() { Ignore = false }; if (TestType.TestCosmosDB && TestType.TestSearch) { var cosmosDBResult = test.TestCosmos(data); var searchResult = test.TestSearch(data); result = new NoSQLTestResult(cosmosDBResult, searchResult); } else if (TestType.TestCosmosDB) { result = test.TestCosmos(data); } else { result = test.TestSearch(data); } result.Ignore = false; ViewBag.Result = result; return(View(data)); }
public void EntityProcessorsRunWhenToDictionaryIsUsed() { EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel)); var connection = TestConfiguration.GetConnection(); var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); provider.EntityProcessors.Add(processor); var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>(); var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection); writerPipeline.AddCollection(entityCollection); entityCollection.Update(new MongoFrameworkQueryableModel { Title = "EntityProcessorsRunWithToDictionaryTest" }, EntityEntryState.Added); writerPipeline.Write(); var result = queryable.ToDictionary(m => m.Id); Assert.AreEqual("EntityProcessorsRunWithToDictionaryTest", result.FirstOrDefault().Value.Title); Assert.IsTrue(processor.EntityProcessed); }
public void Persistence_of_simple_put_transaction_with_one_object() { var transaction1 = MakeTransaction(new Trade(1, 5465, "TATA", DateTime.Now.Date, 150)); var engine = new PersistenceEngine(); engine.Start(); engine.NewTransaction(transaction1); // wait for the transaction log to be processed engine.WaitForPendingTransactions(); engine.Stop(); var processor = new TestProcessor(); //reload data from persistent storage var unused = new ReliableStorage(processor); unused.LoadPersistentData(); unused.Dispose(); Assert.AreEqual(1, processor.LoadedObjects.Count); var reloaded = CachedObject.Unpack <Trade>(processor.LoadedObjects[0]); Assert.AreEqual("TATA", reloaded.Folder); }
public void EntityProcessorsNotFiredWhenNotTEntity() { EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel)); var connection = TestConfiguration.GetConnection(); var collection = connection.GetDatabase().GetCollection <MongoFrameworkQueryableModel>(nameof(MongoFrameworkQueryableModel)); var underlyingQueryable = collection.AsQueryable(); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel, MongoFrameworkQueryableModel>(connection, underlyingQueryable); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); queryable.EntityProcessors.Add(processor); var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>(); var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection); writerPipeline.AddCollection(entityCollection); entityCollection.Update(new MongoFrameworkQueryableModel { Title = "EntityProcessorNoFireTest" }, EntityEntryState.Added); writerPipeline.Write(); foreach (var titles in queryable.Select(e => e.Title)) { //Do nothing } Assert.IsFalse(processor.EntityProcessed); }
public void TextOptions() { var options = new ZLoggerOptions() { PrefixFormatter = (writer, info) => ZString.Utf8Format(writer, "[Pre:{0}]", info.LogLevel), SuffixFormatter = (writer, info) => ZString.Utf8Format(writer, "[Suf:{0}]", info.CategoryName), ExceptionFormatter = (writer, ex) => ZString.Utf8Format(writer, "{0}", ex.Message) }; var processsor = new TestProcessor(options); var loggerFactory = LoggerFactory.Create(x => { x.SetMinimumLevel(LogLevel.Debug); x.AddZLoggerLogProcessor(processsor); }); var logger = loggerFactory.CreateLogger("test"); logger.ZLogDebug("FooBar{0}-NanoNano{1}", 100, 200); processsor.Dequeue().Should().Be("[Pre:Debug]FooBar100-NanoNano200[Suf:test]"); logger.ZLogInformation("FooBar{0}-NanoNano{1}", 100, 300); processsor.Dequeue().Should().Be("[Pre:Information]FooBar100-NanoNano300[Suf:test]"); // fallback case logger.LogDebug("FooBar{0}-NanoNano{1}", 100, 200); processsor.Dequeue().Should().Be("[Pre:Debug]FooBar100-NanoNano200[Suf:test]"); logger.LogInformation("FooBar{0}-NanoNano{1}", 100, 300); processsor.Dequeue().Should().Be("[Pre:Information]FooBar100-NanoNano300[Suf:test]"); }
public void AsyncProcessorShouldProcess() { // Arrange var waitHandle = new ManualResetEvent(false); bool result = false; var sut = new TestProcessor(); sut.Complete += (o, e) => { waitHandle.Set(); result = e.Result; }; // Act Assert.IsFalse(sut.Processed); sut.ProcessAsync(123); // Assert bool handleSet = waitHandle.WaitOne(); Assert.IsTrue(handleSet); ////Assert.IsTrue(result); // This fails when run within Suite-Run Assert.IsTrue(sut.Processed); }
public void ShouldCreateAndProcessTwoStepsPipeline() { PipelineProcessor processor = new PipelineProcessor(); TestProcessor testProcessor1 = new TestProcessor(); TestProcessor testProcessor2 = new TestProcessor(); TestProcessor receiverProcessor = new TestProcessor(); ICollection <IProcessor> processors = new List <IProcessor>(); processors.Add(testProcessor1); processors.Add(testProcessor2); processor.RegisterProcessor(receiverProcessor); processor.Processors = processors; processor.ProcessMessage(new Message("foo")); testProcessor1.AutoEvent.WaitOne(); testProcessor2.AutoEvent.WaitOne(); receiverProcessor.AutoEvent.WaitOne(); Assert.IsNotNull(testProcessor1.ProcessedMessage); Assert.AreEqual("foo", testProcessor1.ProcessedMessage.Payload); Assert.IsNotNull(testProcessor2.ProcessedMessage); Assert.AreEqual("foo", testProcessor2.ProcessedMessage.Payload); Assert.IsNotNull(receiverProcessor.ProcessedMessage); Assert.AreEqual("foo", receiverProcessor.ProcessedMessage.Payload); }
public void Nuller_can_process_object_by_reference() { var someClass = new SomeClass{FakeProp1="Test"}; var processor = new TestProcessor(); processor.Process(someClass); Assert.IsNull(someClass.FakeProp1); }
public void EntityProcessorsFiresOnEnumerationOfTEntity() { EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel)); var connection = TestConfiguration.GetConnection(); var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); provider.EntityProcessors.Add(processor); var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>(); var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection); writerPipeline.AddCollection(entityCollection); entityCollection.Update(new MongoFrameworkQueryableModel { Title = "EntityProcessorFireTest" }, EntityEntryState.Added); writerPipeline.Write(); foreach (var entity in queryable) { //Do nothing } Assert.IsTrue(processor.EntityProcessed); }
public static TestObjectInterceptor ClassInterceptor(TestProcessor Processor) { return new ClassInterceptor { Processor = Processor, Log = Log }; }
public void EntityProcessorsNotFiredWhenNotTEntity() { var database = TestConfiguration.GetDatabase(); new EntityMapper <MongoFrameworkQueryableModel>(); var collection = database.GetCollection <MongoFrameworkQueryableModel>("MongoFrameworkQueryableModel"); var underlyingQueryable = collection.AsQueryable(); var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel, MongoFrameworkQueryableModel>(underlyingQueryable); var processor = new TestProcessor <MongoFrameworkQueryableModel>(); queryable.EntityProcessors.Add(processor); var entityContainer = new DbEntityCollection <MongoFrameworkQueryableModel>(); var writer = new DbEntityWriter <MongoFrameworkQueryableModel>(database); entityContainer.Update(new MongoFrameworkQueryableModel { Title = "EntityProcessorNoFireTest" }, DbEntityEntryState.Added); writer.Write(entityContainer); foreach (var titles in queryable.Select(e => e.Title)) { //Do nothing } Assert.IsFalse(processor.EntityProcessed); }
public void BroadcastProcessor_ShutsDownAll() { var processor1 = new TestProcessor(null, null); var processor2 = new TestProcessor(null, null); var broadcastProcessor = new BroadcastProcessor(new[] { processor1, processor2 }); broadcastProcessor.ShutdownAsync(default);
public void Can_provide_time_and_rest_of_the_line_to_processor() { var processor = new TestProcessor(); var parser = new OutputLogParser("4:21:21 PM: Skill Lumberjacking increased by 0.1 %, currently it is 88.6 %", processor); parser.Parse(); processor.Result.Should().Be("04:21:21 - Skill Lumberjacking increased by 0.1 %, currently it is 88.6 %"); }
public void Skips_lines_wihtout_valid_time_before_colon() { var processor = new TestProcessor(); var parser = new OutputLogParser("some random text with colon: but without valid time", processor); parser.Parse(); processor.Result.Should().Be(string.Empty); }
public ProcessorTests() { _testProcessor = new TestProcessor(); var nowish = DateTimeOffset.UtcNow; _mockClock = new Mock <IClock>(); _mockClock.Setup(x => x.UtcNow()).Returns(nowish); _simpleWorfklowState = new SimpleWorkflowState(); }
public void Skips_lines_without_colon() { var processor = new TestProcessor(); var parser = new OutputLogParser("some random text withotu colon", processor); parser.Parse(); processor.Result.Should().Be(string.Empty); }
public void Can_parse_multiple_lines_with_dos_eol() { var processor = new TestProcessor(); var parser = new OutputLogParser("4:21:21 PM: x\r\n4:21:21 PM: y", processor); parser.Parse(); processor.Result.Should().Be($"04:21:21 - x{Environment.NewLine}04:21:21 - y"); }
public void When_RegisterProcessor_Should_Add_Enabled_Processor() { var manager = new MessagingManager(_builderMock.Object, _loggerFactoryMock.Object); var processor = new TestProcessor(); manager.RegisterProcessor(processor); manager.EnabledProcessors.Count.Should().Be(1); manager.EnabledProcessors[0].Should().Be(processor); }
public void When_RegisterProcessor_Should_Add_MessageQueueMap_Item() { _builderMock.SetupGet(b => b.MessageQueueMap).Returns(new Dictionary <string, Type>()); var manager = new MessagingManager(_builderMock.Object, _loggerFactoryMock.Object); var processor = new TestProcessor(); manager.RegisterProcessor(processor); _builderMock.Object.MessageQueueMap[processor.GetQueueName()].Should().Be(processor.GetMessageType()); }
public void Test_Test() { TestProcessor test = new TestProcessor(); Processors proc = new Processors {test}; Assert.AreEqual("test", proc.Process("something")); Assert.AreEqual(1, test.Count); Assert.AreEqual("test", proc.Process("something")); Assert.AreEqual(2, test.Count); }
public void BroadcastProcessor_OneProcessorThrows() { bool start1Called = false; bool start2Called = false; bool end1Called = false; bool end2Called = false; var processor1 = new TestProcessor( ss => { start1Called = true; Assert.False(start2Called); Assert.False(end1Called); Assert.False(end2Called); throw new Exception("Start exception"); }, se => { end1Called = true; Assert.True(start1Called); Assert.True(start2Called); Assert.False(end2Called); throw new Exception("End exception"); }); var processor2 = new TestProcessor( ss => { start2Called = true; Assert.True(start1Called); Assert.False(end1Called); Assert.False(end2Called); }, se => { end2Called = true; Assert.True(start1Called); Assert.True(start2Called); Assert.True(end1Called); }); var broadcastProcessor = new BroadcastProcessor(new[] { processor1, processor2 }); var tracer = TracerFactory.Create(_ => { }).GetTracer(null); var span = (SpanSdk)tracer.StartSpan("foo"); var spanData = new SpanData(span); broadcastProcessor.OnStart(spanData); Assert.True(start1Called); Assert.True(start2Called); broadcastProcessor.OnEnd(spanData); Assert.True(end1Called); Assert.True(end2Called); }
public void SetsDeveloperOnProcessor() { var developer1 = GivenDeveloperExists("session1"); var developer2 = GivenDeveloperExists("session2"); var testProcessor = new TestProcessor(); _uut.Register(testProcessor); _uut.ProcessFeedback(); CollectionAssert.AreEqual(new[] { developer1, developer2 }, testProcessor.ProcessedDevelopers); }
/// <summary> /// The main entry point for the application. /// </summary> static void Main(string[] args) { if (args.Length != 0 && args[0] == "VisualUnitTests") { TestProcessor TestProcessor = new TestProcessor(); TestProcessor.EvaluateTestes("AdvancedDemos.exe"); } else { Demos game = new Demos(); } }
public void SyncProcessorShouldProcess() { // Arrange var sut = new TestProcessor(); // Act Assert.IsFalse(sut.Processed); sut.Process(); // Assert Assert.IsTrue(sut.Processed); }
public void SyncProcessorShouldProcess() { // Arrange var sut = new TestProcessor(); // Act Assert.IsFalse(sut.Processed); bool result = sut.Process(123); // Assert Assert.IsTrue(result); Assert.IsTrue(sut.Processed); }
public void Should_be_able_to_dispose_failing_worker() { var worker = new TestProcessor(); var target = new WorkerThread<int>("test", TimeSpan.FromDays(1), worker.Process); target.Enqueue(1); target.Dispose(); worker.Logs.Should().Have.SameSequenceAs(new[] { "1" }); }
public void Should_be_able_to_dispose_failing_worker() { var worker = new TestProcessor(); var target = new WorkerThread <int>("test", TimeSpan.FromDays(1), worker.Process); target.Enqueue(1); target.Dispose(); worker.Logs.Should().Have.SameSequenceAs(new[] { "1" }); }
public void InformsProcessorsWhenStreamForCurrentDeveloperEnds() { GivenDeveloperExists("sessionX"); GivenEventExists("sessionX", "A"); GivenEventExists("sessionX", "B"); var testProcessor = new TestProcessor(); _uut.Register(testProcessor); _uut.ProcessFeedback(); Assert.IsTrue(testProcessor.IsFinilized); }
private void TestProcessor_UsersArgs() { Compilation compilation = TestUtil.GetCompilation(); HlslBackend backend = new HlslBackend(compilation); TestProcessor processor = new TestProcessor(); ShaderGenerator sg = new ShaderGenerator( compilation, backend, "TestShaders.ProcessorTestShaders.VS", "TestShaders.ProcessorTestShaders.FS", null, processor); sg.GenerateShaders(); Assert.Equal("This Sentence Should Be Printed By_Enumerating All Resources In Order", processor.Result); }
public void Test_Test() { TestProcessor test = new TestProcessor(); Processors proc = new Processors { test }; Assert.AreEqual("test", proc.Process("something")); Assert.AreEqual(1, test.Count); Assert.AreEqual("test", proc.Process("something")); Assert.AreEqual(2, test.Count); }
public void BroadcastProcessor_OneProcessorThrows() { bool start1Called = false; bool start2Called = false; bool end1Called = false; bool end2Called = false; var processor1 = new TestProcessor( ss => { start1Called = true; Assert.False(start2Called); Assert.False(end1Called); Assert.False(end2Called); throw new Exception("Start exception"); }, se => { end1Called = true; Assert.True(start1Called); Assert.True(start2Called); Assert.False(end2Called); throw new Exception("End exception"); }); var processor2 = new TestProcessor( ss => { start2Called = true; Assert.True(start1Called); Assert.False(end1Called); Assert.False(end2Called); }, se => { end2Called = true; Assert.True(start1Called); Assert.True(start2Called); Assert.True(end1Called); }); var broadcastProcessor = new BroadcastActivityProcessor(new[] { processor1, processor2 }); var activity = new Activity("somename"); broadcastProcessor.OnStart(activity); Assert.True(start1Called); Assert.True(start2Called); broadcastProcessor.OnEnd(activity); Assert.True(end1Called); Assert.True(end2Called); }
public void Should_dequeue_all_when_disposing() { var worker = new TestProcessor(); var target = new WorkerThread<int>("test", TimeSpan.FromDays(1), worker.Process); target.Enqueue(1); target.Enqueue(2); target.Enqueue(3); target.Dispose(); worker.Logs.Should().Have.SameSequenceAs(new[] { "1, 2, 3" }); }
// Use this for initialization void Awake() { world = new EntityWorld(); for(int i = 0; i< 5; ++i){ Entity e = world.CreateEntity(); TestComp1 te = new TestComp1(); e.AddComponent(te); } EntitySystem.BlackBoard.SetEntry<TestProcessor>("test1", new TestProcessor()); //world.RefreshEntity(); TestProcessor processor = new TestProcessor(); TestProcessor2 processor2 = new TestProcessor2(); world.SystemManager.SetSystem<TestProcessor>(processor,Artemis.Manager.GameLoopType.Update); // world.SystemManager.SetSystem<TestProcessor2>(processor2,Artemis.Manager.GameLoopType.Update); }
public void AsyncProcessorShouldProcess() { // Arrange var waitHandle = new ManualResetEvent(false); var sut = new TestProcessor(); sut.Complete += delegate { waitHandle.Set(); }; // Act Assert.IsFalse(sut.Processed); sut.ProcessAsync(); // Assert bool handleSet = waitHandle.WaitOne(); Assert.IsTrue(handleSet); Assert.IsTrue(sut.Processed); }
public void Should_dequeue_in_batch() { var worker = new TestProcessor(); var target = new WorkerThread<int>("test", TimeSpan.FromSeconds(.75), worker.Process); target.Enqueue(1); target.Enqueue(2); target.Enqueue(3); worker.Go.WaitOne(); target.Enqueue(4); target.Enqueue(5); target.Enqueue(6); worker.Go.WaitOne(); worker.Logs.Should().Have.SameSequenceAs(new[] { "1, 2, 3", "4, 5, 6" }); }