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);
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"
});
}
