public void ConstructorTopLeft()
{
var resolver = new TestResolver();
var block = new Block(resolver.Resolve<BlocksContent>(), new FixedRandom(), new Point(1, 2));
Assert.AreEqual(1, block.Left);
Assert.AreEqual(2, block.Top);
}
public void DoBricksSplitInHalfOnExit()
{
var content = new TestResolver().Resolve<BlocksContent>();
Assert.IsFalse(content.DoBricksSplitInHalfWhenRowFull);
content.DoBricksSplitInHalfWhenRowFull = true;
Assert.IsTrue(content.DoBricksSplitInHalfWhenRowFull);
}
public void CreateZoomingEffect()
{
var resolver = new TestResolver();
var content = resolver.Resolve<Content>();
var effect = new ZoomingEffect(content.Load<Image>("test"), Rectangle.Zero, Rectangle.One);
Assert.AreEqual(Point.Zero, effect.DrawArea.Center);
}
public void AreFiveBrickBlocksAllowed()
{
var content = new TestResolver().Resolve<BlocksContent>();
Assert.IsTrue(content.AreFiveBrickBlocksAllowed);
content.AreFiveBrickBlocksAllowed = false;
Assert.IsFalse(content.AreFiveBrickBlocksAllowed);
}
public void DoBlocksStartInARandomColumn()
{
var content = new TestResolver().Resolve<BlocksContent>();
Assert.IsFalse(content.DoBlocksStartInARandomColumn);
content.DoBlocksStartInARandomColumn = true;
Assert.IsTrue(content.DoBlocksStartInARandomColumn);
}
public TestMultimediaResolver(TestResolver testResolver)
: base(testResolver)
{
SetupSoundDeviceMock();
SetupSoundMock();
SetupMusicMock();
}
public void CreateFallingEffectFromDrawArea()
{
var resolver = new TestResolver();
var content = resolver.Resolve<Content>();
var effect = new FallingEffect(content.Load<Image>("test"), Rectangle.One);
Assert.AreEqual(Rectangle.One, effect.DrawArea);
}
public void KnownCharacterRendersWithoutException()
{
var resolver = new TestResolver();
var renderer = resolver.Resolve<Renderer>();
renderer.Add(new VectorText(CreateVectorTextData(), Point.Zero, 1.0f) { Text = "A" });
resolver.AdvanceTimeAndExecuteRunners(1.0f);
}
public TestRenderingResolver(TestResolver testResolver)
: base(testResolver)
{
Window window = SetupWindow();
Drawing drawing = SetupGraphics();
SetupRenderer(window, drawing);
}
public void ResolveWithCustomParameter()
{
var resolver = new TestResolver();
resolver.RegisterAllUnknownTypesAutomatically();
var runner = resolver.Resolve<CustomRunner>("test");
runner.Run();
}
public TestInputResolver(TestResolver testResolver)
: base(testResolver)
{
AllocateStates();
InitializePositions();
SetupInput();
}
private static WindowsMouse GetMouse()
{
var resolver = new TestResolver();
var window = resolver.Resolve<Window>();
var screen = new QuadraticScreenSpace(window);
var positionTranslater = new CursorPositionTranslater(window, screen);
return new WindowsMouse(positionTranslater);
}
public void RegisterTwice()
{
using (var resolver = new TestResolver())
{
resolver.Start<DummyRunner>();
resolver.Start<DummyRunner>();
}
}
public void UnknownCharacterThrowsException()
{
var resolver = new TestResolver();
var renderer = resolver.Resolve<Renderer>();
renderer.Add(new VectorText(CreateVectorTextData(), Point.Zero, 1.0f) { Text = "B" });
Assert.Throws<VectorText.VectorCharacterNotFoundException>(
() => renderer.Run(resolver.Resolve<Time>()));
}
public void RotateClockwise()
{
var resolver = new TestResolver();
var block = new Block(resolver.Resolve<BlocksContent>(),
new FixedRandom(new[] { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9f }), new Point(8, 1));
Assert.AreEqual("O.../OOO./..../....", block.ToString());
block.RotateClockwise();
Assert.AreEqual("OO../O.../O.../....", block.ToString());
}
public void ConditionMatched(Type resolver)
{
Start(resolver, (InputCommands input) =>
{
var command = new TestResolver().Resolve<Command>();
command.Add(new KeyTrigger(Key.Y, State.Released));
command.Run(input);
});
}
public void CreateFadeoutEffectFromDrawArea()
{
var resolver = new TestResolver();
var content = resolver.Resolve<Content>();
var effect = new FadeoutEffect(content.Load<Image>("test"), Rectangle.One);
Assert.IsTrue(effect.IsVisible);
Assert.AreEqual(Point.Half, effect.DrawArea.Center);
Assert.AreEqual(Color.White, effect.Color);
}
public void RunnersAreExecutedInCorrectOrder()
{
Output.Clear();
using (var resolver = new TestResolver())
resolver.Run();
const string ExpectedOutput = "Window.Run, Device.Run, AppRunnerTests, Device.Present";
Assert.AreEqual(ExpectedOutput, Output.ToText());
}
public void GetButtonState()
{
var mouse = new TestResolver().Resolve<Mouse>();
Assert.AreEqual(State.Released, mouse.GetButtonState(MouseButton.Left));
Assert.AreEqual(State.Released, mouse.GetButtonState(MouseButton.Middle));
Assert.AreEqual(State.Released, mouse.GetButtonState(MouseButton.Right));
Assert.AreEqual(State.Released, mouse.GetButtonState(MouseButton.X1));
Assert.AreEqual(State.Released, mouse.GetButtonState(MouseButton.X2));
}
public void GetFilenameWithoutPrefix()
{
var content = new TestResolver().Resolve<BlocksContent>();
content.Prefix = "ABC";
Assert.AreEqual("DEF", content.GetFilenameWithoutPrefix("ABCDEF"));
Assert.Throws<BlocksContent.FilenameWrongPrefixException>(
() => content.GetFilenameWithoutPrefix("ADEF"));
Assert.Throws<BlocksContent.FilenameWrongPrefixException>(
() => content.GetFilenameWithoutPrefix("AAADEF"));
}
public void RotationSpeed()
{
var resolver = new TestResolver();
var content = resolver.Resolve<Content>();
var effect = new FallingEffect(content.Load<Image>("test"), Rectangle.One)
{
RotationSpeed = 1.0f
};
Assert.AreEqual(1.0f, effect.RotationSpeed);
}
public void ConditionMatched()
{
var resolver = new TestResolver();
var input = resolver.Resolve<InputCommands>();
var trigger = new MouseMovementTrigger();
Assert.False(trigger.ConditionMatched(input));
var mouse = resolver.Resolve<Mouse>();
mouse.SetPosition(Point.Zero);
Assert.True(trigger.ConditionMatched(input));
}
public void AffixingBlockAddsToScore()
{
var resolver = new TestResolver();
resolver.Resolve<Game>();
var userInterface = resolver.Resolve<UserInterface>();
Assert.AreEqual(0, userInterface.Score);
resolver.AdvanceTimeAndExecuteRunners(10.0f);
Assert.AreEqual(1, userInterface.Score);
Assert.AreEqual("Score 1", userInterface.Scoreboard.Text);
}
public void GetDescriptionAddsCoreReferences(string shortFrameworkName, string expectedNames)
{
var resolver = new TestResolver(shortFrameworkName);
var provider = new ProjectReferenceDependencyProvider(resolver);
Assert.Equal(
expectedNames.Split(',').Select(s => "fx/" + s).ToArray(),
provider.GetDescription(new LibraryRange(TestResolver.ProjectName, frameworkReference: false), VersionUtility.ParseFrameworkName(shortFrameworkName))
.Dependencies
.Select(d => d.LibraryRange.Name).ToArray());
}
public void Constructor()
{
var soundbank = new TestResolver().Resolve<Soundbank>();
Assert.IsNotNull(soundbank.BlockAffixed);
Assert.IsNotNull(soundbank.BlockCouldntMove);
Assert.IsNotNull(soundbank.BlockMoved);
Assert.IsNotNull(soundbank.GameLost);
Assert.IsNotNull(soundbank.MultipleRowsRemoved);
Assert.IsNotNull(soundbank.RowRemoved);
}
public void Gravity()
{
var resolver = new TestResolver();
var content = resolver.Resolve<Content>();
var effect = new FallingEffect(content.Load<Image>("test"), Rectangle.One)
{
Gravity = Point.Half
};
Assert.AreEqual(Point.Half, effect.Gravity);
}
public void RegisterAllUnknownClasses()
{
using (var resolver = new TestResolver())
{
resolver.RegisterAllUnknownTypesAutomatically();
resolver.Start<DummyRunner>();
Assert.Throws<AutofacResolver.RegisterCallsMustBeBeforeInit>(
resolver.RegisterAllUnknownTypesAutomatically);
resolver.Resolve<ClassWithInnerClass.UnknownInnerClass>();
}
}
public void CreateEmptyImage()
{
var resolver = new TestResolver();
resolver.RegisterAllUnknownTypesAutomatically();
var content = new Content(resolver);
Rectangle centered = Rectangle.FromCenter(Point.Half, new Size(0.2f));
var newSprite = new Sprite(content.Load<Image>("test"), centered);
Assert.IsTrue(newSprite.IsVisible);
Assert.AreEqual(centered.Center, newSprite.DrawArea.Center);
Assert.AreEqual(Color.White, newSprite.Color);
}
public void FireBall()
{
var resolver = new TestResolver();
var ball = resolver.Resolve<BallInLevel>();
Assert.IsTrue(ball.IsVisible);
resolver.Run();
var initialBallPosition = new Point(0.5f, 0.86f);
Assert.AreEqual(initialBallPosition, ball.Position);
resolver.SetKeyboardState(Key.Space, State.Pressing);
resolver.AdvanceTimeAndExecuteRunners(1.0f);
Assert.AreNotEqual(initialBallPosition, ball.Position);
}
public void CreateEmptyAnimatedSprite()
{
var resolver = new TestResolver();
resolver.RegisterAllUnknownTypesAutomatically();
var content = new Content(resolver);
Rectangle centered = Rectangle.FromCenter(Point.Half, new Size(0.2f));
var redFrames = new[] { new Point(1.0f, 0), new Point(2.0f, 0), new Point(3.0f, 0),
new Point(4.0f, 0) };
var animatedSprite = new AnimatedSprite(content.Load<Image>("test"), centered, Color.Blue,
32, 32, 4, redFrames);
Assert.AreEqual(centered.Center, animatedSprite.DrawArea.Center);
Assert.AreEqual(Color.Blue, animatedSprite.Color);
}
public void Test_Container_Serialize_Work()
{
var c = CreateTestContainerWithTracker();
var data = MessagePackSerializer.Serialize(c, TestResolver.GetMessagePackOption());
var c2 = MessagePackSerializer.Deserialize <TrackableDataContainer>(data, TestResolver.GetMessagePackOption());
Assert.Equal(c.Dictionary.Count, c2.Dictionary.Count);
Assert.Equal(c.List.Count, c2.List.Count);
}
public async Task PickAsync_HedgingWithDrop_ThrowsError()
{
// Arrange
string?authority = null;
var testMessageHandler = TestHttpMessageHandler.Create(async request =>
{
authority = request.RequestUri !.Authority;
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var services = new ServiceCollection();
services.AddNUnitLogger();
var resolver = new TestResolver();
DropLoadBalancer?loadBalancer = null;
services.AddSingleton <ResolverFactory>(new TestResolverFactory(resolver));
services.AddSingleton <LoadBalancerFactory>(new DropLoadBalancerFactory(c =>
{
loadBalancer = new DropLoadBalancer(c);
return(loadBalancer);
}));
services.AddSingleton <ISubchannelTransportFactory>(new TestSubchannelTransportFactory());
var invoker = HttpClientCallInvokerFactory.Create(testMessageHandler, "test:///localhost", configure: o =>
{
o.Credentials = ChannelCredentials.Insecure;
o.ServiceProvider = services.BuildServiceProvider();
o.ServiceConfig = new ServiceConfig
{
MethodConfigs =
{
new MethodConfig
{
Names = { MethodName.Default },
HedgingPolicy = new HedgingPolicy
{
MaxAttempts = 5,
HedgingDelay = TimeSpan.FromMinutes(10),
NonFatalStatusCodes ={ StatusCode.DataLoss }
}
}
},
LoadBalancingConfigs = { new LoadBalancingConfig("drop") }
};
});
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions().WithWaitForReady(), new HelloRequest());
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.DataLoss, ex.StatusCode);
Assert.AreEqual(1, loadBalancer !.PickCount);
}
public void Setup() => Schedule(() => Child = container = new BindingContainer <TestModel> {
Child = resolver = new TestResolver()
});
public void Can_add_custom_resolver_to_composite_resolver_by_subclassing()
{
var tr = new TestResolver();
tr.AssertCustomResolverWasAdded();
}
public void Test_Set_Serialize_Work()
{
var set = CreateTestSetWithTracker();
var serialize = MessagePackSerializer.Serialize(set, TestResolver.GetMessagePackOption());
var set2 = MessagePackSerializer.Deserialize <TrackableSet <int> >(serialize, TestResolver.GetMessagePackOption());
Assert.Equal(set.Count, set2.Count);
}
public async Task UpdateAddresses_ConnectIsInProgress_InProgressConnectIsCanceledAndRestarted()
{
// Arrange
var services = new ServiceCollection();
services.AddNUnitLogger();
var serviceProvider = services.BuildServiceProvider();
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
var testLogger = loggerFactory.CreateLogger(GetType());
var resolver = new TestResolver(loggerFactory);
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 80)
});
var connectAddressesChannel = Channel.CreateUnbounded <DnsEndPoint>();
var syncPoint = new SyncPoint(runContinuationsAsynchronously: true);
var transportFactory = new TestSubchannelTransportFactory(async(s, c) =>
{
c.Register(state => ((SyncPoint)state !).Continue(), syncPoint);
var connectAddress = s.GetAddresses().Single();
testLogger.LogInformation("Writing connect address " + connectAddress);
await connectAddressesChannel.Writer.WriteAsync(connectAddress.EndPoint, c);
await syncPoint.WaitToContinue();
c.ThrowIfCancellationRequested();
return(ConnectivityState.Ready);
});
var clientChannel = CreateConnectionManager(loggerFactory, resolver, transportFactory);
clientChannel.ConfigureBalancer(c => new PickFirstBalancer(c, loggerFactory));
// Act
_ = clientChannel.ConnectAsync(waitForReady: true, CancellationToken.None).ConfigureAwait(false);
var connectAddress1 = await connectAddressesChannel.Reader.ReadAsync().AsTask().DefaultTimeout();
Assert.AreEqual(80, connectAddress1.Port);
// Endpoints are unchanged so continue connecting...
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 80)
});
Assert.IsFalse(syncPoint.WaitToContinue().IsCompleted);
// Endpoints change so cancellation + reconnect triggered
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 81)
});
await syncPoint.WaitToContinue().DefaultTimeout();
var connectAddress2 = await connectAddressesChannel.Reader.ReadAsync().AsTask().DefaultTimeout();
Assert.AreEqual(81, connectAddress2.Port);
}
public async Task PickAsync_ChannelStateChangesWithWaitForReady_WaitsForCorrectEndpoint()
{
// Arrange
var services = new ServiceCollection();
services.AddNUnitLogger();
var serviceProvider = services.BuildServiceProvider();
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
var resolver = new TestResolver(loggerFactory);
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 80)
});
var transportFactory = new TestSubchannelTransportFactory();
var clientChannel = CreateConnectionManager(loggerFactory, resolver, transportFactory);
clientChannel.ConfigureBalancer(c => new RoundRobinBalancer(c, loggerFactory));
// Act
var pickTask1 = clientChannel.PickAsync(
new PickContext {
Request = new HttpRequestMessage()
},
waitForReady: true,
CancellationToken.None).AsTask();
await clientChannel.ConnectAsync(waitForReady : true, CancellationToken.None).DefaultTimeout();
var result1 = await pickTask1.DefaultTimeout();
// Assert
Assert.AreEqual(new DnsEndPoint("localhost", 80), result1.Address !.EndPoint);
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 80),
new BalancerAddress("localhost", 81)
});
for (var i = 0; i < transportFactory.Transports.Count; i++)
{
transportFactory.Transports[i].UpdateState(ConnectivityState.TransientFailure);
}
var pickTask2 = clientChannel.PickAsync(
new PickContext {
Request = new HttpRequestMessage()
},
waitForReady: true,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.IsFalse(pickTask2.IsCompleted);
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 82)
});
var result2 = await pickTask2.DefaultTimeout();
Assert.AreEqual(new DnsEndPoint("localhost", 82), result2.Address !.EndPoint);
}
public void Test_ContainerTracker_Serialize_Work()
{
var c = CreateTestContainerWithTracker();
// Act
c.Person.Name = "Bob";
c.Person.Age = 30;
c.Dictionary[1] = "OneModified";
c.Dictionary.Remove(2);
c.Dictionary[4] = "FourAdded";
c.List[0] = "OneModified";
c.List.RemoveAt(1);
c.List.Insert(1, "TwoInserted");
c.Set.Remove(1);
c.Set.Remove(2);
c.Set.Add(4);
c.Set.Add(5);
// Assert
var data = MessagePackSerializer.Serialize(c.Tracker, TestResolver.GetMessagePackOption());
var tracker2 = MessagePackSerializer.Deserialize <TrackableDataContainerTracker>(data, TestResolver.GetMessagePackOption());
var c2 = CreateTestContainer();
tracker2.ApplyTo(c2);
Assert.Equal(c.Person.Name, c2.Person.Name);
Assert.Equal(c.Person.Age, c2.Person.Age);
Assert.Equal(c.Dictionary.OrderBy(x => x.Key), c2.Dictionary.OrderBy(x => x.Key));
Assert.Equal(c.List, c2.List);
Assert.Equal(c.Set.OrderBy(x => x), c2.Set.OrderBy(x => x));
}
public void Test_SetTracker_Serialize_Work()
{
var set = CreateTestSetWithTracker();
set.Remove(1);
set.Remove(2);
set.Add(4);
set.Add(5);
var serialize = MessagePackSerializer.Serialize(set.Tracker, TestResolver.GetMessagePackOption());
var tracker2 = MessagePackSerializer.Deserialize <TrackableSetTracker <int> >(serialize, TestResolver.GetMessagePackOption());
var set2 = CreateTestSet();
tracker2.ApplyTo(set2);
Assert.Equal(new HashSet <int> {
5, 4, 3
},
set2);
}
