public XmlReaderValidator(XmlReader subjectReader, XmlReader otherReader, string because, object[] reasonArgs) { assertion = Execute.Assertion.BecauseOf(because, reasonArgs); this.subjectReader = subjectReader; this.otherReader = otherReader; }
public void When_disposed_it_should_throw_any_failures() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var scope = new AssertionScope(); AssertionScope.Current.FailWith("Failure1"); //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = scope.Dispose; //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- try { act(); } catch (Exception exception) { Assert.IsTrue(exception.Message.StartsWith("Failure1")); } }
protected StringValidator(string subject, string expected, string because, object[] reasonArgs) { assertion = Execute.Assertion.BecauseOf(because, reasonArgs); this.subject = subject; this.expected = expected; }
public void AssertEquality(EquivalencyValidationContext context) { using (var scope = new AssertionScope()) { scope.AddReportable("configuration", config.ToString()); scope.AddNonReportable("objects", new ObjectTracker(config.CyclicReferenceHandling)); scope.BecauseOf(context.Reason, context.ReasonArgs); AssertEqualityUsing(context); } }
/// <summary> /// Starts a new assertion context. Always place inside a using block. /// </summary> /// <param name="name">Plain-english description of this context</param> public AssertContext(string name) { this.name = name; this.parent = CallContext.GetData(ContextKey) as AssertContext; CallContext.SetData(ContextKey, this); this.scope = new AssertionScope(name); // TEMPORARY approach for the POC. We may need to request/submit a change on GitHub to get around this. typeof(AssertionScope) .GetField("assertionStrategy", BindingFlags.Instance | BindingFlags.NonPublic) .SetValue(this.scope, new FailWithContextStrategy()); }
public void Validate() { if ((expected != null) || (subject != null)) { if (ValidateAgainstNulls()) { if (IsLongOrMultiline(expected) || IsLongOrMultiline(subject)) { assertion = assertion.UsingLineBreaks; } ValidateAgainstSuperfluousWhitespace(); ValidateAgainstLengthDifferences(); ValidateAgainstMismatch(); } } }
public void When_a_nested_scope_is_discarded_its_failures_should_also_be_discarded() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var scope = new AssertionScope(); AssertionScope.Current.FailWith("Failure1"); using (var nestedScope = new AssertionScope()) { nestedScope.FailWith("Failure2"); using (var deeplyNestedScope = new AssertionScope()) { deeplyNestedScope.FailWith("Failure3"); deeplyNestedScope.Discard(); } } //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = scope.Dispose; //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- try { act(); } catch (Exception exception) { Assert.IsTrue(exception.Message.Contains("Failure1")); Assert.IsTrue(exception.Message.Contains("Failure2")); Assert.IsFalse(exception.Message.Contains("Failure3")); } }
public void When_multiple_scopes_are_nested_it_should_throw_all_failures_from_the_outer_scope() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var scope = new AssertionScope(); AssertionScope.Current.FailWith("Failure1"); using (var nestedScope = new AssertionScope()) { nestedScope.FailWith("Failure2"); using (var deeplyNestedScope = new AssertionScope()) { deeplyNestedScope.FailWith("Failure3"); } } //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = scope.Dispose; ; //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- try { act(); } catch (Exception exception) { Assert.IsTrue(exception.Message.Contains("Failure1")); Assert.IsTrue(exception.Message.Contains("Failure2")); Assert.IsTrue(exception.Message.Contains("Failure3")); } }
public async Task CompileProject_produces_empty_diagnostics_collection_when_it_passes() { var kernel = new CSharpProjectKernel("csharp"); await kernel.SendAsync(new OpenProject(new Project(new[] { new ProjectFile("Program.cs", @" public class Program { public static void Main(string[] args) { #region test-region #endregion } } ") }))); await kernel.SendAsync(new OpenDocument("Program.cs", regionName : "test-region")); await kernel.SendAsync(new SubmitCode("int someInt = 1;")); var result = await kernel.SendAsync(new CompileProject()); var kernelEvents = result.KernelEvents.ToSubscribedList(); using var _ = new AssertionScope(); kernelEvents .Should() .NotContainErrors(); kernelEvents .Should() .ContainSingle <AssemblyProduced>(); kernelEvents .Should() .ContainSingle <DiagnosticsProduced>() .Which .Diagnostics .Should() .BeEmpty(); }
public void Directive_node_indicates_parent_language( string markupCode, string defaultLanguage) { MarkupTestFile.GetNamedSpans(markupCode, out var code, out var spansByName); var parser = CreateSubmissionParser(defaultLanguage); var tree = parser.Parse(code); using var _ = new AssertionScope(); foreach (var pair in spansByName) { var expectedParentLanguage = pair.Key; var spans = pair.Value; foreach (var position in spans.SelectMany(s => Enumerable.Range(s.Start, s.Length))) { var node = tree.GetRoot().FindNode(position); switch (node) { case KernelNameDirectiveNode _: expectedParentLanguage.Should().Be("none"); break; case ActionDirectiveNode adn: adn.ParentKernelName.Should().Be(expectedParentLanguage); break; default: throw new AssertionFailedException($"Expected a {nameof(DirectiveNode)} but found: {node}"); } } } }
public void SelectedTemplate_SetTemplateWithValue_ValueSet() { var windowManager = Substitute.For <IWindowManager>(); var dialogs = Substitute.For <IDialogs>(); var fileSystem = Substitute.For <IFileSystem>(); var processApi = Substitute.For <IProcess>(); var projectData = new ProjectData(new Settings(), windowManager, dialogs, fileSystem, processApi); var sut = new EditBookingViewModel(projectData, YearBegin) { CreditAccount = 1, DebitAccount = 2, BookingText = "default", BookingValue = 42, Date = new DateTime(2020, 6, 20) }; sut.Accounts.Add(new AccountDefinition { ID = 1 }); sut.Accounts.Add(new AccountDefinition { ID = 2 }); sut.Accounts.Add(new AccountDefinition { ID = 3 }); sut.BindingTemplates.Add(new BookingTemplate { Value = 123 }); sut.SelectedTemplate = sut.BindingTemplates.Last(); using var _ = new AssertionScope(); sut.DebitAccount.Should().Be(2); sut.CreditAccount.Should().Be(1); sut.BookingValue.Should().Be(123); sut.BookingText.Should().Be("default"); }
public void Constructor__Copy_ShouldCreate4x4MatrixAndAssignElementsFromTheOtherMatrix() { // arrange var other = new Matrix4( new[, ] { { 1f, 2f, 3f, 4f }, { 5f, 6f, 7f, 8f }, { 9f, 10f, 11f, 12f }, { 13f, 14f, 15f, 16f } } ); // act var result = new Matrix4(other); // assert using var _ = new AssertionScope(); result.Rows.Should().Be(4); result.Columns.Should().Be(4); result[0, 0].Should().Be(1f); result[0, 1].Should().Be(2f); result[0, 2].Should().Be(3f); result[0, 3].Should().Be(4f); result[1, 0].Should().Be(5f); result[1, 1].Should().Be(6f); result[1, 2].Should().Be(7f); result[1, 3].Should().Be(8f); result[2, 0].Should().Be(9f); result[2, 1].Should().Be(10f); result[2, 2].Should().Be(11f); result[2, 3].Should().Be(12f); result[3, 0].Should().Be(13f); result[3, 1].Should().Be(14f); result[3, 2].Should().Be(15f); result[3, 3].Should().Be(16f); }
public async Task CreateUpdatedEvent_ShouldReturnRollbackInvalidRouteNode_OnIntersectingRouteSegment() { var applicationSetting = A.Fake <IOptions <ApplicationSetting> >(); var geoDatabase = A.Fake <IGeoDatabase>(); var beforeNode = A.Fake <RouteNode>(); var afterNode = A.Fake <RouteNode>(); var shadowTableRouteNode = A.Fake <RouteNode>(); A.CallTo(() => afterNode.Mrid).Returns(Guid.NewGuid()); A.CallTo(() => geoDatabase.GetRouteNodeShadowTable(afterNode.Mrid, false)).Returns(shadowTableRouteNode); A.CallTo(() => afterNode.GetGeoJsonCoordinate()) .Returns("[665931.4446905176,7197297.75114815]"); A.CallTo(() => afterNode.MarkAsDeleted).Returns(false); A.CallTo(() => shadowTableRouteNode.GetGeoJsonCoordinate()) .Returns("[565931.4446905176,6197297.75114815]"); A.CallTo(() => shadowTableRouteNode.MarkAsDeleted).Returns(false); A.CallTo(() => geoDatabase.GetIntersectingRouteSegments(afterNode)).Returns(new List <RouteSegment> { A.Fake <RouteSegment>() }); var factory = new RouteNodeCommandFactory(applicationSetting, geoDatabase); var result = await factory.CreateUpdatedEvent(beforeNode, afterNode); var rollbackInvalidRouteNode = (RollbackInvalidRouteNode)result[0]; var expected = new RollbackInvalidRouteNode(beforeNode, "Update to route node is invalid because it is insecting with route-segments."); using (var scope = new AssertionScope()) { result.Should().HaveCount(1); rollbackInvalidRouteNode.Should().BeEquivalentTo(expected); } }
public void ScrollViewer_Margin_Centered() { Run("UITests.Windows_UI_Xaml_Controls.ScrollViewerTests.ScrollViewer_Margin_Centered"); _app.Marked("shapeWidth").SetDependencyPropertyValue("Value", "100"); _app.Marked("shapeHeight").SetDependencyPropertyValue("Value", "340"); _app.WaitForElement("ctl2"); using var screenshot = TakeScreenshot("test", ignoreInSnapshotCompare: true); for (byte i = 1; i <= 2; i++) { using var _ = new AssertionScope(); var logicalRect = _app.GetLogicalRect($"ctl{i}"); logicalRect.Width.Should().Be(100); logicalRect.Height.Should().Be(340); var physicalRect = _app.GetPhysicalRect($"ctl{i}"); // Left / Top ImageAssert.HasColorAt(screenshot, physicalRect.X + LogicalToPhysical(10), physicalRect.Y + LogicalToPhysical(10), Color.Orange); ImageAssert.HasColorAt(screenshot, physicalRect.X + LogicalToPhysical(20), physicalRect.Y + LogicalToPhysical(20), Color.Red); // Right / Top ImageAssert.HasColorAt(screenshot, physicalRect.Right - LogicalToPhysical(11), physicalRect.Y + LogicalToPhysical(10), Color.Orange); ImageAssert.HasColorAt(screenshot, physicalRect.Right - LogicalToPhysical(21), physicalRect.Y + LogicalToPhysical(20), Color.Red); // Middle ImageAssert.HasColorAt(screenshot, physicalRect.CenterX, physicalRect.CenterY, Color.Red); // Left / Bottom ImageAssert.HasColorAt(screenshot, physicalRect.X + LogicalToPhysical(10), physicalRect.Bottom - LogicalToPhysical(11), Color.Orange); ImageAssert.HasColorAt(screenshot, physicalRect.X + LogicalToPhysical(20), physicalRect.Bottom - LogicalToPhysical(21), Color.Red); // Right / Bottom ImageAssert.HasColorAt(screenshot, physicalRect.Right - LogicalToPhysical(11), physicalRect.Bottom - LogicalToPhysical(11), Color.Orange); ImageAssert.HasColorAt(screenshot, physicalRect.Right - LogicalToPhysical(21), physicalRect.Bottom - LogicalToPhysical(21), Color.Red); } }
public async Task when_code_contains_compile_time_warnings_diagnostics_are_produced(Language language, params string[] diagnosticMessageFragments) { var kernel = CreateKernel(language); var source = language switch { Language.FSharp => new[] { "System.AppDomain.GetCurrentThreadId()" }, Language.CSharp => new[] { "System.AppDomain.GetCurrentThreadId()", } }; await SubmitCode(kernel, source); using var _ = new AssertionScope(); KernelEvents .Should() .ContainSingle <ReturnValueProduced>(); KernelEvents .Should() .ContainSingle <DiagnosticsProduced>(d => d.Diagnostics.Count > 0) .Which .Diagnostics .Should() .ContainSingle(diagnostic => true) .Which .Message .Should() .ContainAll(diagnosticMessageFragments); }
public void SerializeToBitmap_ShouldWriteBmpHeaderAtTheStartOfTheOutput() { // arrange const int imageDimension = 4; const int headerSize = 54; const int pixelDataSize = imageDimension * imageDimension * 3; Debug.Assert(pixelDataSize % 4 == 0, nameof(pixelDataSize) + " is a multiple of 4"); using var stream = new MemoryStream(); var sut = new Canvas(imageDimension, imageDimension); // act using (var writer = new BinaryWriter(stream, Encoding.Default, leaveOpen: true)) { sut.SerializeToBitmap(writer); } stream.Position = 0; using var reader = new BinaryReader(stream); // assert using var _ = new AssertionScope(); reader.ReadChars(2) .Should() .ContainInOrder(new[] { 'B', 'M' }, "offset 0x00 must be the BM file type marker"); reader.ReadUInt32() .Should() .Be(headerSize + pixelDataSize, "offset 0x02 must be the 4 byte total file size"); reader.ReadUInt32().Should().Be(0, "offset 0x06 must be 4 bytes zeroed (unused)"); reader.ReadUInt32() .Should() .Be( headerSize, "offset 0x0A must be the 4 byte offset where the pixel data starts (total header size)" ); }
public bool Handle(IEquivalencyValidationContext context, IEquivalencyValidator parent, IEquivalencyAssertionOptions config) { bool success = false; using (var scope = new AssertionScope()) { // Try without conversion if (AppliesTo(context)) { success = ExecuteAssertion(context); } bool converted = false; if (!success && converter.CanHandle(context, config)) { // Convert into a child context context = context.Clone(); converter.Handle(context, parent, config); converted = true; } if (converted && AppliesTo(context)) { // Try again after conversion success = ExecuteAssertion(context); if (success) { // If the assertion succeeded after conversion, discard the failures from // the previous attempt. If it didn't, let the scope throw with those failures. scope.Discard(); } } } return(success); }
public void AssertEqualityUsing(IEquivalencyValidationContext context) { if (ContinueRecursion(context.SelectedMemberPath)) { AssertionScope scope = AssertionScope.Current; scope.Context = (context.SelectedMemberDescription.Length == 0) ? scope.Context : context.SelectedMemberDescription; scope.AddNonReportable("subject", context.Subject); scope.AddNonReportable("expectation", context.Expectation); var objectTracker = scope.Get <CyclicReferenceDetector>("objects"); if (!objectTracker.IsCyclicReference(new ObjectReference(context.Expectation, context.SelectedMemberPath))) { bool wasHandled = false; foreach (var step in AssertionOptions.EquivalencySteps) { if (step.CanHandle(context, config)) { if (step.Handle(context, this, config)) { wasHandled = true; break; } } } if (!wasHandled) { Execute.Assertion.FailWith( "No IEquivalencyStep was found to handle the context. " + "This is likely a bug in Fluent Assertions."); } } } }
public async Task diagnostics_are_produced_on_command_succeeded(Language language, string code, string errorCode, params string[] diagnosticMessageFragments) { var kernel = CreateKernel(language); await kernel.SubmitCodeAsync(code); using var _ = new AssertionScope(); KernelEvents .Should() .ContainSingle <CommandSucceeded>(); KernelEvents .Should() .ContainSingle <DiagnosticsProduced>(d => d.Diagnostics.Count > 0) .Which .Diagnostics .Should() .ContainSingle(diag => diag.Code == errorCode && diagnosticMessageFragments.All( frag => diag.Message.Contains(frag) )); }
public void Refresh_ForReadOnlyDictionaryWithSingleCustomCharacteristics_AddsCharacteristic( ) { _expectedCharacteristics.Add(_characteristic1); _foundCharacteristicsDictionary.Add(Description1, _characteristics1Uuid); var sut = CreateSut( ); sut.Refresh(_customs); using var scope = new AssertionScope( ); sut.Characteristics .Count .Should( ) .Be(1, "Characteristics Count"); sut.Characteristics [Description1] .Should( ) .Be(_characteristic1, "Contains Characteristic1"); }
public void Constructor__Copy_ShouldCreate3x3MatrixAndAssignElementsFromTheOtherMatrix() { // arrange var other = new Matrix3(new[, ] { { 1f, 2f, 3f }, { 4f, 5f, 6f }, { 7f, 8f, 9f } }); // act var result = new Matrix3(other); // assert using var _ = new AssertionScope(); result.Rows.Should().Be(3); result.Columns.Should().Be(3); result[0, 0].Should().Be(1f); result[0, 1].Should().Be(2f); result[0, 2].Should().Be(3f); result[1, 0].Should().Be(4f); result[1, 1].Should().Be(5f); result[1, 2].Should().Be(6f); result[2, 0].Should().Be(7f); result[2, 1].Should().Be(8f); result[2, 2].Should().Be(9f); }
public async Task Create_ShouldReturnRouteNodeInfoUpdated_OnUpdatedNodeInfo() { var geoDatabase = A.Fake <IGeoDatabase>(); var before = new RouteNode(); var after = new RouteNode { RouteNodeInfo = new RouteNodeInfo { Function = RouteNodeFunctionEnum.FlexPoint, Kind = RouteNodeKindEnum.CabinetSmall } }; var factory = new RouteNodeInfoCommandFactory(geoDatabase); var result = await factory.Create(before, after); var infoUpdated = (RouteNodeInfoUpdated)result.First(); using (var scope = new AssertionScope()) { result.Count().Should().Be(1); infoUpdated.RouteNode.Should().BeEquivalentTo(after); } }
public async Task Create_ShouldReturnDoNothing_OnReturnedRouteNodeShadowTableBeingDeleted() { var geoDatabase = A.Fake <IGeoDatabase>(); RouteNode before = new RouteNode(); RouteNode after = new RouteNode(); var shadowTableSegment = new RouteNode { Mrid = Guid.NewGuid(), MarkAsDeleted = true }; A.CallTo(() => geoDatabase.GetRouteNodeShadowTable(after.Mrid, true)).Returns <RouteNode>(shadowTableSegment); var factory = new RouteNodeInfoCommandFactory(geoDatabase); var result = await factory.Create(before, after); var doNothingEvent = (DoNothing)result.First(); using (var scope = new AssertionScope()) { result.Count().Should().Be(1); doNothingEvent.Should().BeOfType(typeof(DoNothing)); } }
public void Inverse_ShouldReturnInvertedMatrix4(Matrix4 sut, Matrix4 expected) { // arrange // act var actual = sut.Inverse(); // assert using var _ = new AssertionScope(); foreach (var row in Enumerable.Range(0, 4)) { foreach (var col in Enumerable.Range(0, 4)) { actual[row, col] .Should() .BeApproximately( expected[row, col], 1e-5f, "[{0}, {1}] should match expected", row, col ); } } }
public async Task GhostShouldNotMoveWhenPacManIsDying() { var x = 1; var y = 1; _gameSettings.InitialGameStatus = GameStatus.Dying; _gameSettings.Ghosts.Add(new Ghost("Ghost1", new CellLocation(x, y), Direction.Left, CellLocation.TopLeft, new DirectToStrategy(new DirectToPacManLocation()))); _gameSettings.PacMan = new PacMan((3, 3), Direction.Down); var game = new Game(_gameClock, _gameSettings); game.StartGame(); await _gameClock.Tick(); using var _ = new AssertionScope(); game.Ghosts.Values.First() .Should().BeEquivalentTo(new { Location = new { X = x, Y = y } }); }
public async Task IgnorePaths(string path, bool shouldIgnore) { var httpContext = new DefaultHttpContext(); var nextCalled = false; var expectedHttpStatusCode = shouldIgnore ? 404 : 200; var expectNextCall = !shouldIgnore; var middleware = new IgnorePathsMiddleware(_ => { nextCalled = true; return(Task.CompletedTask); }, new List <PathString> { "/ignore", "/api" }); httpContext.Request.Path = path; await middleware.Invoke(httpContext); using var _ = new AssertionScope(); nextCalled.Should().Be(expectNextCall); httpContext.Response.StatusCode.Should().Be(expectedHttpStatusCode); }
public void Should_GetSunkShotResult_WhenDestroyerWasSunk() { // Arrange var previousShotResults = new[] { _gameBoard.ShootAt("C4"), _gameBoard.ShootAt("C5"), _gameBoard.ShootAt("C6"), }; // Act var shotResult = _gameBoard.ShootAt("C7"); // Assert using var scope = new AssertionScope(); previousShotResults.Should().HaveCount(3); previousShotResults.All(x => x.ShotResultType == ShotResultType.Hit).Should().BeTrue(); previousShotResults.All(x => x.ShipType == ShipType.Destroyer).Should().BeTrue(); shotResult.Should().NotBeNull(); shotResult.ShotResultType.Should().Be(ShotResultType.Sunk); shotResult.ShipType.Should().Be(ShipType.Destroyer); }
public async Task Create_ShouldReturnDoNothing_OnBeforeBeingMarkedAsDeleted() { var routeSegmentId = Guid.NewGuid(); var geoDatabase = A.Fake <IGeoDatabase>(); var before = new RouteSegment { Mrid = routeSegmentId, MarkAsDeleted = true }; var after = new RouteSegment { Mrid = routeSegmentId, RouteSegmentInfo = new RouteSegmentInfo { Height = "10" } }; var shadowTableSegment = new RouteSegment { Mrid = routeSegmentId, MarkAsDeleted = true }; A.CallTo(() => geoDatabase.GetRouteSegmentShadowTable(after.Mrid, true)).Returns(shadowTableSegment); var factory = new RouteSegmentInfoCommandFactory(geoDatabase); var result = await factory.Create(before, after); var doNothingEvent = (DoNothing)result.First(); using (var scope = new AssertionScope()) { result.Count().Should().Be(1); doNothingEvent.Should().BeOfType(typeof(DoNothing)); } }
public async Task HttpApiTunneling_route_serves_bootstrapper_js() { var tunnelUri = new Uri("http://choosen.one:1000/"); var server = await GetServer(command : "stdio", port : 1000); var response = await server.HttpClient.PostAsync("/apitunnel", new StringContent(new { tunnelUri = tunnelUri.AbsoluteUri, frontendType = "vscode" }.SerializeToJson().ToString())); var responseBody = JObject.Parse(await response.Content.ReadAsStringAsync()); var boostrapperUri = responseBody["bootstrapperUri"].Value <string>(); response = await server.HttpClient.GetAsync(boostrapperUri); var code = await response.Content.ReadAsStringAsync(); using var scope = new AssertionScope(); response.StatusCode.Should().Be(HttpStatusCode.OK); response.Content.Headers.ContentType.MediaType.Should().Be("text/javascript"); code.Should().Contain(tunnelUri.AbsoluteUri); code.Should().Contain("bootstrapper_vscode_"); }
public async Task PacManDoesNotEatPowerPillAndScoreStaysTheSameWhenCollidesWithGhost() { var pillAndGhostLocation = _gameSettings.PacMan.Location + Direction.Right; var ghost = GhostBuilder.New() .WithLocation(pillAndGhostLocation) .Create(); _gameSettings.Ghosts.Add(ghost); _gameSettings.PowerPills.Add(pillAndGhostLocation); var game = new Game(_gameClock, _gameSettings); game.StartGame(); var score = game.Score; await game.ChangeDirection(Direction.Right); await _gameClock.Tick(); using var _ = new AssertionScope(); game.PowerPills.Should().ContainEquivalentOf(pillAndGhostLocation); game.Score.Should().Be(score); }
internal static TResult CheckItemHelper <TResult>(AssertionScope scope, TypeValuePair typeValuePair, UnionMethodInfo methodInfo) { var itemType = typeValuePair.Type; var expectedType = typeof(TResult); var expectedTypePretty = expectedType.PrettyPrint(); var givenTypes = methodInfo.OptionalLast ? methodInfo.CaseTypes.Concat(new[] { typeof(None) }).ToArray() : methodInfo.CaseTypes; var givenTypesPretty = string.Join(", ", givenTypes.Select(ReflectionUtils.PrettyPrint)); scope .ForCondition(givenTypes.Contains(expectedType)) .FailWith("Value should be one of {0} but found {1} instead.", givenTypesPretty, expectedTypePretty); scope .ForCondition(expectedType.IsAssignableFrom(itemType)) .FailWith("Value should be assignable to {0} but found {1} instead", expectedTypePretty, itemType.PrettyPrint()); return((TResult)typeValuePair.Value); }
public async Task PacManDoesNotCollectCoinAndScoreStaysTheSameWhenCollidesWithGhost() { var ghostAndCoinLocation = _gameSettings.PacMan.Location + Direction.Right; var ghost = GhostBuilder.New() .WithLocation(ghostAndCoinLocation) .Create(); _gameSettings.Ghosts.Add(ghost); _gameSettings.Coins.Add(ghostAndCoinLocation); var gameHarness = new GameHarness(_gameSettings); gameHarness.StartGame(); var score = gameHarness.Score; await gameHarness.ChangeDirection(Direction.Right); await gameHarness.GetEatenByGhost(ghost); using var _ = new AssertionScope(); gameHarness.Game.Coins.Should().ContainEquivalentOf(ghostAndCoinLocation); gameHarness.Score.Should().Be(score); }
public async Task quit_command_fails_when_not_configured() { var kernel = CreateKernel(); var quit = new Quit(); await kernel.SendAsync(quit); using var _ = new AssertionScope(); KernelEvents .Should().ContainSingle <CommandFailed>() .Which .Command .Should() .Be(quit); KernelEvents .Should().ContainSingle <CommandFailed>() .Which .Exception .Should() .BeOfType <InvalidOperationException>(); }
protected void AssertSubjectEquality <T>(IEnumerable expectation, Func <T, T, bool> predicate, string because = "", params object[] reasonArgs) { AssertionScope assertion = Execute.Assertion.BecauseOf(because, reasonArgs); bool subjectIsNull = ReferenceEquals(Subject, null); bool expectationIsNull = ReferenceEquals(expectation, null); if (subjectIsNull && expectationIsNull) { return; } if (subjectIsNull) { assertion.FailWith("Expected {context:collection} to be equal{reason}, but found <null>."); } if (expectation == null) { throw new ArgumentNullException("expectation", "Cannot compare collection with <null>."); } T[] expectedItems = expectation.Cast <T>().ToArray(); T[] actualItems = Subject.Cast <T>().ToArray(); AssertCollectionsHaveSameCount(expectedItems, actualItems, assertion); for (int index = 0; index < expectedItems.Length; index++) { assertion .ForCondition((index < actualItems.Length) && predicate(actualItems[index], expectedItems[index])) .FailWith("Expected {context:collection} to be equal to {0}{reason}, but {1} differs at index {2}.", expectation, Subject, index); } }
public Continuation(AssertionScope sourceScope, bool sourceSucceeded) { this.sourceScope = sourceScope; this.sourceSucceeded = sourceSucceeded; }
/// <summary> /// Prints the program syntax with line numbers and diagnostics if a test fails in the given assertion scope. /// </summary> public static AssertionScope WithVisualDiagnostics(this AssertionScope assertionScope, BicepFile bicepFile, IEnumerable <IDiagnostic> diagnostics) => WithAnnotatedSource( assertionScope, bicepFile, "diagnostics", diagnostics.Select(x => new PrintHelper.Annotation(x.Span, $"[{x.Code} ({x.Level})] {x.Message}")));
/// <summary> /// Prints the program syntax with line numbers and a cursor if a test fails in the given assertion scope. /// </summary> public static AssertionScope WithVisualCursor(this AssertionScope assertionScope, BicepFile bicepFile, IPositionable cursorPosition) => WithAnnotatedSource( assertionScope, bicepFile, "cursor info", new PrintHelper.Annotation(cursorPosition.Span, "cursor").AsEnumerable());
private string[] TryToMatch(object subject, object expectation, int expectationIndex) { using (var scope = new AssertionScope()) { parent.AssertEqualityUsing(context.CreateForCollectionItem(expectationIndex, subject, expectation)); return scope.Discard(); } }
public void When_Text_is_Constrained_Then_Clipping_is_Applied() { Run("Uno.UI.Samples.Content.UITests.TextBlockControl.TextBlock_ConstrainedByContainer"); // 1) Take a screenshot of the whole sample // 2) Switch opacity of text to zero // 3) Take new screenshot // 4) Compare Right zone -- must be identical // 5) Compare Bottom zone -- must be identical // 6) Do the same for subsequent text block in sample (1 to 5) // // +-sampleRootPanel------------+--------------+ // | | | // | +-borderX---------------+ | // | | [textX]Lorem ipsum... | | // | +-----------------------+ Right zone | // | | | | // | | Bottom zone | | // | | | | // +----+-----------------------+--------------+ // (1) using var sampleScreenshot = this.TakeScreenshot("fullSample", ignoreInSnapshotCompare: true); var sampleRect = _app.GetPhysicalRect("sampleRootPanel"); using var _ = new AssertionScope(); Test("text1", "border1"); Test("text2", "border2"); Test("text3", "border3"); Test("text4", "border4"); Test("text5", "border5"); void Test(string textControl, string borderControl) { var textRect = _app.GetPhysicalRect(borderControl); // (2) _app.Marked(textControl).SetDependencyPropertyValue("Opacity", "0"); // (3) using var afterScreenshot = this.TakeScreenshot("sample-" + textControl, ignoreInSnapshotCompare: true); // (4) using (var s = new AssertionScope("Right zone")) { var rect1 = new AppRect( x: textRect.Right, y: sampleRect.Y, width: sampleRect.Right - textRect.Right, height: sampleRect.Height) .DeflateBy(1f); ImageAssert.AreEqual(sampleScreenshot, rect1, afterScreenshot, rect1); } // (5) using (var s = new AssertionScope("Bottom zone")) { var rect2 = new AppRect( x: textRect.X, y: textRect.Bottom, width: textRect.Width, height: sampleRect.Height - textRect.Bottom) .DeflateBy(1f); ImageAssert.AreEqual(sampleScreenshot, rect2, afterScreenshot, rect2); } } }
private void AssertCollectionsHaveSameCount <T>(T[] expectedItems, T[] actualItems, AssertionScope assertion) { int delta = Math.Abs(expectedItems.Length - actualItems.Length); if (delta != 0) { var expected = (IEnumerable)expectedItems; if (actualItems.Length == 0) { assertion.FailWith("Expected {context:collection} to be equal to {0}{reason}, but found empty collection.", expected); } else if (actualItems.Length < expectedItems.Length) { assertion.FailWith( "Expected {context:collection} to be equal to {0}{reason}, but {1} contains {2} item(s) less.", expected, Subject, delta); } else if (actualItems.Length > expectedItems.Length) { assertion.FailWith( "Expected {context:collection} to be equal to {0}{reason}, but {1} contains {2} item(s) too many.", expected, Subject, delta); } } }
/// <inheritdoc/> public void Dispose() { if (this.parent != null) CallContext.SetData(ContextKey, this.parent); else CallContext.FreeNamedDataSlot(ContextKey); this.scope.Dispose(); this.scope = null; }
public void When_the_same_failure_is_handled_twice_or_more_it_should_still_report_it_once() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var scope = new AssertionScope(); AssertionScope.Current.FailWith("Failure"); AssertionScope.Current.FailWith("Failure"); using (var nestedScope = new AssertionScope()) { nestedScope.FailWith("Failure"); nestedScope.FailWith("Failure"); } //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = scope.Dispose; //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- try { act(); } catch (Exception exception) { int matches = new Regex(".*Failure.*").Matches(exception.Message).Count; Assert.AreEqual(4, matches); } }