public ThrottlerTests(ITestOutputHelper output)
{
// Fixture Setup
this.container = TestComponentryContainer.Create(output);
this.receiver = new MockComponent(this.container);
this.receiver.RegisterHandler <string>(this.receiver.OnMessage);
}
public void WriteNetworkBehaviorArray()
{
var go = new GameObject("TestWriteNetworkBehaviorNotNull", typeof(NetworkIdentity), typeof(MockComponent));
MockComponent mock = go.GetComponent <MockComponent>();
// init lazy props
_ = mock.Identity.NetworkBehaviours;
mock.Identity.NetId = 1;
// returns found id
reader.ObjectLocator.TryGetIdentity(1, out NetworkIdentity _).Returns(x => { x[1] = mock.Identity; return(true); });
// try/fianlly so go is always destroyed
try
{
var mockArray = new MockComponent[] { mock };
writer.Write(mockArray);
reader.Reset(writer.ToArraySegment());
MockComponent[] readArray = reader.Read <MockComponent[]>();
Assert.That(mockArray.Length == mockArray.Length);
Assert.That(mockArray[0] == mockArray[0]);
Assert.That(writer.ByteLength, Is.EqualTo(reader.BytePosition));
}
finally
{
GameObject.Destroy(go);
}
}
public void WriteNetworkBehaviorDestroyed()
{
// setup
var go = new GameObject("TestWriteNetworkBehaviorNotNull", typeof(NetworkIdentity), typeof(MockComponent));
MockComponent mock = go.GetComponent <MockComponent>();
// init lazy props
_ = mock.Identity.NetworkBehaviours;
mock.Identity.NetId = 1;
// return not found
reader.ObjectLocator.TryGetIdentity(1, out NetworkIdentity _).Returns(x => { x[1] = null; return(false); });
// try/fianlly so go is always destroyed
try
{
writer.WriteNetworkBehaviour(mock);
reader.Reset(writer.ToArraySegment());
MockComponent behaviour = reader.ReadNetworkBehaviour <MockComponent>();
Assert.That(behaviour, Is.Null);
// make sure read same as written (including compIndex for non-0 netid
Assert.That(writer.ByteLength, Is.EqualTo(reader.BytePosition));
}
finally
{
GameObject.Destroy(go);
}
}
public void SortedBySite()
{
MockSite site1 = new MockSite();
site1.Name = "b";
MockSite site2 = new MockSite();
site2.Name = "a";
MockSite site3 = new MockSite();
site3.Name = "z";
MockComponent c1 = new MockComponent();
c1.Site = site1;
MockComponent c2 = new MockComponent();
c2.Site = site2;
MockComponent c3 = new MockComponent();
c3.Site = site3;
object[] unsortedObjects = new object[] { c1, c2, c3 };
object[] expectedSortedObjects = new object[] { c2, c1, c3 };
Assert.AreEqual(expectedSortedObjects, PropertyPad.SortObjectsBySiteName(unsortedObjects));
}
internal void MessagingPerformanceTest()
{
// Arrange
var receiver = new MockComponent(this.container);
receiver.RegisterHandler <int>(receiver.OnMessage);
PerformanceHarness.Test(() =>
{
for (var i = 0; i < 1000000; i++)
{
receiver.Endpoint.SendAsync(i);
receiver.Endpoint.SendAsync(i);
}
while (receiver.ProcessedCount < 2000000)
{
// Wait
}
},
1,
1,
this.Output);
this.Output.WriteLine(receiver.Messages.Count.ToString());
// ~1350 ms for 1000000 messages with Task<bool> being returned by handler
// ~1250 ms for 1000000 messages with bool being returned by handler
// ~850 ms for 1000000 messages (19/7/2020)
// Assert
Assert.Equal(0, receiver.InputCount);
Assert.Equal(2000000, receiver.ProcessedCount);
}
internal void GivenManyMessagesOfDifferentTypes_WhenHandlersRegistered_ThenStoresInReceiver()
{
// Arrange
var receiver = new MockComponent(this.container);
receiver.RegisterHandler <string>(receiver.OnMessage);
receiver.RegisterHandler <int>(receiver.OnMessage);
// Act
receiver.Endpoint.SendAsync("1");
receiver.Endpoint.SendAsync(1);
receiver.Endpoint.SendAsync("2");
receiver.Endpoint.SendAsync(2);
receiver.Endpoint.SendAsync("3");
receiver.Endpoint.SendAsync(3);
receiver.Endpoint.SendAsync("4");
receiver.Endpoint.SendAsync(4).Wait();
receiver.Stop().Wait();
Assert.True(receiver.Messages[0].Equals("1"));
Assert.True(receiver.Messages[1].Equals(1));
Assert.True(receiver.Messages[2].Equals("2"));
Assert.True(receiver.Messages[3].Equals(2));
Assert.True(receiver.Messages[4].Equals("3"));
Assert.True(receiver.Messages[5].Equals(3));
Assert.True(receiver.Messages[6].Equals("4"));
Assert.True(receiver.Messages[7].Equals(4));
Assert.Equal(0, receiver.InputCount);
Assert.Equal(9, receiver.ProcessedCount);
Assert.Equal(8, receiver.Messages.Count);
}
internal void GivenMultipleSubscribeAndUnsubscribe_HandlesCorrectly()
{
// Arrange
var receiver2 = new MockComponent(this.container, "2");
var subscribe1 = new Subscribe <Type>(
typeof(Tick),
this.receiver.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe2 = new Subscribe <Type>(
typeof(Tick),
receiver2.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var unsubscribe = new Unsubscribe <Type>(
typeof(Tick),
receiver2.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.dataBus.Endpoint.SendAsync(subscribe1).Wait();
this.dataBus.Endpoint.SendAsync(subscribe2).Wait();
this.dataBus.Endpoint.SendAsync(unsubscribe).Wait();
this.dataBus.Stop().Wait();
// Assert
Assert.Equal(1, this.dataBus.Subscriptions.Count);
}
public void TestTestableComponentIsUpdated()
{
MockComponent component = kernel.Get <MockComponent>();
Assert.AreEqual(0, component.updateCount);
step(1);
Assert.AreEqual(1, component.updateCount);
}
public void TestDestroyedObjectsNotUpdated()
{
MockComponent component = kernel.Get <MockComponent>();
component.Obj.Destroy();
step();
Assert.AreEqual(0, component.updateCount);
}
public DataBusTests(ITestOutputHelper output)
{
// Fixture Setup
this.container = TestComponentryContainer.Create(output);
this.receiver = new MockComponent(this.container, "1");
this.dataBus = new DataBus <Tick>(this.container);
this.receiver.RegisterHandler <Tick>(this.receiver.OnMessage);
this.dataBus.Start().Wait();
}
internal void GivenMultipleSubscribe_HandlesCorrectly()
{
// Arrange
var receiver2 = new MockComponent(this.container, "2");
var subscribe1 = new Subscribe <Type>(
typeof(Event),
this.receiver.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe2 = new Subscribe <Type>(
typeof(Event),
receiver2.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe3 = new Subscribe <Type>(
typeof(MarketOpened),
this.receiver.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe4 = new Subscribe <Type>(
typeof(SessionConnected),
this.receiver.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe5 = new Subscribe <Type>(
typeof(SessionConnected),
receiver2.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.messageBus.Endpoint.SendAsync(subscribe1).Wait();
this.messageBus.Endpoint.SendAsync(subscribe2).Wait();
this.messageBus.Endpoint.SendAsync(subscribe3).Wait();
this.messageBus.Endpoint.SendAsync(subscribe4).Wait();
this.messageBus.Endpoint.SendAsync(subscribe5).Wait();
this.messageBus.Stop().Wait();
this.receiver.Stop().Wait();
receiver2.Stop().Wait();
Task.Delay(TestAssertionsTaskDelay).Wait(); // Allow sending to complete for assertions
// Assert
Assert.Contains(typeof(Event), this.messageBus.Subscriptions);
Assert.Contains(typeof(MarketOpened), this.messageBus.Subscriptions);
Assert.Contains(typeof(SessionConnected), this.messageBus.Subscriptions);
Assert.Equal(2, this.messageBus.Subscriptions[typeof(Event)].Count);
Assert.Equal(1, this.messageBus.Subscriptions[typeof(MarketOpened)].Count);
Assert.Equal(2, this.messageBus.Subscriptions[typeof(SessionConnected)].Count);
Assert.Equal(1, this.messageBus.Subscriptions[typeof(MarketOpened)].Count);
Assert.Equal(5, this.messageBus.SubscriptionCount);
}
public void OneSiteIsNull()
{
MockSite site1 = new MockSite();
site1.Name = "z";
MockComponent c1 = new MockComponent();
c1.Site = site1;
MockComponent c2 = new MockComponent();
object[] unsortedObjects = new object[] { c1, c2 };
object[] expectedSortedObjects = new object[] { c2, c1 };
Assert.AreEqual(expectedSortedObjects, PropertyPad.SortObjectsBySiteName(unsortedObjects));
}
internal void GivenData_WhenSubscribers_SendsDataToSubscriber()
{
// Arrange
var receiver2 = new MockComponent(this.container, "2");
receiver2.RegisterHandler <Tick>(receiver2.OnMessage);
var subscribe1 = new Subscribe <Type>(
typeof(Tick),
this.receiver.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var subscribe2 = new Subscribe <Type>(
typeof(Tick),
receiver2.Mailbox,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var tick1 = StubQuoteTickProvider.Create(new Symbol("AUD/USD", new Venue("FXCM")));
var tick2 = StubQuoteTickProvider.Create(new Symbol("AUD/USD", new Venue("FXCM")), StubZonedDateTime.UnixEpoch() + Duration.FromSeconds(1));
var tick3 = StubQuoteTickProvider.Create(new Symbol("AUD/USD", new Venue("FXCM")), StubZonedDateTime.UnixEpoch() + Duration.FromSeconds(2));
// Act
this.dataBus.Endpoint.SendAsync(subscribe1).Wait();
this.dataBus.Endpoint.SendAsync(subscribe2).Wait();
Task.Delay(100).Wait(); // Allow subscriptions
this.dataBus.PostData(tick1);
this.dataBus.PostData(tick2);
this.dataBus.PostData(tick3);
this.dataBus.Stop().Wait();
this.dataBus.StopData().Wait();
this.receiver.Stop().Wait();
receiver2.Stop().Wait();
// Assert
Assert.Contains(tick1, this.receiver.Messages);
Assert.Contains(tick2, this.receiver.Messages);
Assert.Contains(tick3, this.receiver.Messages);
Assert.Contains(tick1, receiver2.Messages);
Assert.Contains(tick2, receiver2.Messages);
Assert.Contains(tick3, receiver2.Messages);
Assert.Equal(3, this.receiver.Messages.Count);
Assert.Equal(3, receiver2.Messages.Count);
}
public void Test_GetComponentsGeneric()
{
DictionaryComponent dictionary = new DictionaryComponent();
IComponent component1 = new StubComponent();
IComponent component2 = new MockComponent();
dictionary.Add(component1);
dictionary.Add(component2);
var receivedComponents = dictionary.GetComponents <IComponent>();
IComponent ReceivedComponent1 = receivedComponents[0];
IComponent ReceivedComponent2 = receivedComponents[1];
Assert.AreEqual(2, receivedComponents.Length);
Assert.AreSame(component1, ReceivedComponent1);
Assert.AreSame(component2, ReceivedComponent2);
}
public void WriteNetworkBehaviorNotNull()
{
MockComponent mock = CreateBehaviour <MockComponent>();
// init lazy props
_ = mock.Identity.NetworkBehaviours;
mock.Identity.NetId = 1;
// returns found id
reader.ObjectLocator.TryGetIdentity(1, out var _).Returns(x => { x[1] = mock.Identity; return(true); });
writer.WriteNetworkBehaviour(mock);
reader.Reset(writer.ToArraySegment());
var behaviour = reader.ReadNetworkBehaviour <MockComponent>();
Assert.That(behaviour == mock);
Assert.That(writer.ByteLength, Is.EqualTo(reader.BytePosition));
}
public void WriteNetworkBehaviorDestroyed()
{
// setup
MockComponent mock = CreateBehaviour <MockComponent>();
// init lazy props
_ = mock.Identity.NetworkBehaviours;
mock.Identity.NetId = 1;
// return not found
reader.ObjectLocator.TryGetIdentity(1, out var _).Returns(x => { x[1] = null; return(false); });
writer.WriteNetworkBehaviour(mock);
reader.Reset(writer.ToArraySegment());
var behaviour = reader.ReadNetworkBehaviour <MockComponent>();
Assert.That(behaviour, Is.Null);
// make sure read same as written (including compIndex for non-0 netid
Assert.That(writer.ByteLength, Is.EqualTo(reader.BytePosition));
}
public MessageBusTests(ITestOutputHelper output)
{
// Fixture Setup
this.container = TestComponentryContainer.Create(output);
this.receiver = new MockComponent(this.container, "1");
this.messageBus = new MessageBus <Event>(this.container);
var addresses = new Dictionary <Address, IEndpoint>
{
{ ComponentAddress.DataService, this.receiver.Endpoint },
{ ComponentAddress.Scheduler, this.receiver.Endpoint },
};
this.messageBus.Endpoint.SendAsync(new InitializeSwitchboard(
Switchboard.Create(addresses),
this.container.GuidFactory.Generate(),
this.container.Clock.TimeNow()));
this.receiver.RegisterHandler <IEnvelope>(this.receiver.OnMessage);
}
public void WriteNetworkBehaviorArray()
{
MockComponent mock = CreateBehaviour <MockComponent>();
// init lazy props
_ = mock.Identity.NetworkBehaviours;
mock.Identity.NetId = 1;
// returns found id
reader.ObjectLocator.TryGetIdentity(1, out var _).Returns(x => { x[1] = mock.Identity; return(true); });
var mockArray = new MockComponent[] { mock };
writer.Write(mockArray);
reader.Reset(writer.ToArraySegment());
var readArray = reader.Read <MockComponent[]>();
Assert.That(mockArray.Length == mockArray.Length);
Assert.That(mockArray[0] == mockArray[0]);
Assert.That(writer.ByteLength, Is.EqualTo(reader.BytePosition));
}
public void TestAddMessages()
{
InitializeHttpContext();
var component = new MockComponent();
component.InfoMessage("情報メッセージ1");
component.InfoMessage("情報メッセージ2");
component.SuccessMessage("success");
component.WarnMessage("warn");
component.ErrorMessage("error");
var store = FeedbackMessageStore.Current;
Assert.AreEqual(5, store.Count);
Assert.AreEqual(2, store.GetFeedbackMessages(FeedbackMessageLevel.INFO).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.SUCCESS).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.WARN).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.ERROR).Count);
}
internal void GivenMessagesOfDifferentTypes_WhenHandlersRegistered_ThenStoresInReceiver()
{
// Arrange
var receiver = new MockComponent(this.container);
receiver.RegisterHandler <string>(receiver.OnMessage);
receiver.RegisterHandler <int>(receiver.OnMessage);
// Act
receiver.Endpoint.SendAsync("test");
receiver.Endpoint.SendAsync(2).Wait();
receiver.Stop().Wait();
// Assert
Assert.Contains(typeof(string), receiver.HandlerTypes);
Assert.Contains(typeof(int), receiver.HandlerTypes);
Assert.True(receiver.Messages[0].Equals("test"));
Assert.True(receiver.Messages[1].Equals(2));
Assert.Equal(0, receiver.InputCount);
Assert.Equal(3, receiver.ProcessedCount);
Assert.Equal(2, receiver.Messages.Count);
}
public ExecutionEngineTests(ITestOutputHelper output)
{
// Fixture Setup
var container = TestComponentryContainer.Create(output);
var messagingAdapter = new MockMessageBusProvider(container).Adapter;
this.tradingGateway = new MockTradingGateway(container);
this.receiver = new MockComponent(container);
this.receiver.RegisterHandler <Event>(this.receiver.OnMessage);
this.database = new InMemoryExecutionDatabase(container);
this.engine = new ExecutionEngine(
container,
messagingAdapter,
this.database,
this.tradingGateway,
this.receiver.Endpoint);
this.tradingGateway.Start().Wait();
this.receiver.Start().Wait();
this.engine.Start().Wait();
}
public HasGameObjectBoundaryAsParameter(TestableGameObject obj, MockComponent nested)
: base(obj)
{
this.nested = nested;
}
public HasGameObjectBoundaryAsParameter(TestableGameObject obj, MockComponent nested) : base(obj)
{
this.nested = nested;
this.nested.Obj.transform.Parent = this.Obj.transform;
}
public void SetUp()
{
_base = (MockComponent)Game.Player.GetComponent <MockComponent>();
_base.ProcessTimeUnit();
}
public HasGameObjectBoundaryAsParameter(TestableGameObject obj, MockComponent nested)
: base(obj)
{
this.nested = nested;
this.nested.Obj.transform.Parent = this.Obj.transform;
}
public HasGameObjectBoundaryAsParameter(TestableGameObject obj, MockComponent nested) : base(obj)
{
this.nested = nested;
}
