public static void GetHashCode___Should_be_equal_for_two_objects___When_objects_have_the_same_property_values() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act var expected = scenario.ReferenceObject.GetHashCode(); var actuals = scenario.ObjectsThatAreEqualToButNotTheSameAsReferenceObject.Select(_ => _.GetHashCode()).ToList(); // Assert actuals.AsTest().Must().Each().BeEqualTo(expected, because: scenario.Id); } }
public static void EqualsOperator___Should_return_false___When_objects_being_compared_derive_from_the_same_type_but_are_not_of_the_same_type() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act var actuals1 = scenario.ObjectsThatDeriveFromScenarioTypeButAreNotOfTheSameTypeAsReferenceObject.Select(_ => scenario.ReferenceObject == _).ToList(); var actuals2 = scenario.ObjectsThatDeriveFromScenarioTypeButAreNotOfTheSameTypeAsReferenceObject.Select(_ => _ == scenario.ReferenceObject).ToList(); // Assert actuals1.AsTest().Must().Each().BeFalse(because: scenario.Id); actuals2.AsTest().Must().Each().BeFalse(because: scenario.Id); } }
public static void EqualsOperator___Should_return_true___When_objects_being_compared_have_same_property_values() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act var actuals1 = scenario.ObjectsThatAreEqualToButNotTheSameAsReferenceObject.Select(_ => scenario.ReferenceObject == _).ToList(); var actuals2 = scenario.ObjectsThatAreEqualToButNotTheSameAsReferenceObject.Select(_ => _ == scenario.ReferenceObject).ToList(); // Assert actuals1.AsTest().Must().Each().BeTrue(because: scenario.Id); actuals2.AsTest().Must().Each().BeTrue(because: scenario.Id); } }
public static void NotEqualsOperator___Should_return_false___When_same_object_is_on_both_sides_of_operator() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act #pragma warning disable CS1718 // Comparison made to same variable var actual = scenario.ReferenceObject != scenario.ReferenceObject; #pragma warning restore CS1718 // Comparison made to same variable // Assert actual.AsTest().Must().BeFalse(because: scenario.Id); } }
public static void Equals_with_Object___Should_return_false___When_parameter_other_is_not_of_the_same_type() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act var actuals1 = scenario.ObjectsThatDeriveFromScenarioTypeButAreNotOfTheSameTypeAsReferenceObject.Select(_ => scenario.ReferenceObject.Equals((object)_)).ToList(); var actuals2 = scenario.ObjectsThatAreNotOfTheSameTypeAsReferenceObject.Select(_ => scenario.ReferenceObject.Equals((object)_)).ToList(); // Assert actuals1.AsTest().Must().Each().BeFalse(because: scenario.Id); actuals2.AsTest().Must().Each().BeFalse(because: scenario.Id); } }
public static void GetHashCode___Should_not_be_equal_for_two_objects___When_objects_have_different_property_values() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange, Act var unexpected = scenario.ReferenceObject.GetHashCode(); var actuals = scenario.ObjectsThatAreNotEqualToReferenceObject.Select(_ => _.GetHashCode()).ToList(); // Assert actuals.AsTest().Must().NotContainElement(unexpected, because: scenario.Id); } }
public static void Equals_with_ModelEqualityPrivateSetReadOnlyDictionaryOfNullable___Should_return_false___When_parameter_other_is_null() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange ModelEqualityPrivateSetReadOnlyDictionaryOfNullable systemUnderTest = null; // Act var actual = scenario.ReferenceObject.Equals(systemUnderTest); // Assert actual.AsTest().Must().BeFalse(because: scenario.Id); } }
public static void EqualsOperator___Should_return_false___When_one_side_of_operator_is_null_and_the_other_side_is_not_null() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange ModelEqualityPublicSetArray systemUnderTest = null; // Act var actual1 = systemUnderTest == scenario.ReferenceObject; var actual2 = scenario.ReferenceObject == systemUnderTest; // Assert actual1.AsTest().Must().BeFalse(because: scenario.Id); actual2.AsTest().Must().BeFalse(because: scenario.Id); } }
public static void NotEqualsOperator___Should_return_true___When_one_side_of_operator_is_null_and_the_other_side_is_not_null() { var scenarios = EquatableTestScenarios.ValidateAndPrepareForTesting(); foreach (var scenario in scenarios) { // Arrange ModelEqualityPrivateSetReadOnlyDictionaryOfNullable systemUnderTest = null; // Act var actual1 = systemUnderTest != scenario.ReferenceObject; var actual2 = scenario.ReferenceObject != systemUnderTest; // Assert actual1.AsTest().Must().BeTrue(because: scenario.Id); actual2.AsTest().Must().BeTrue(because: scenario.Id); } }
static ModelEqualityPrivateSetNullableChild1Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPrivateSetReadOnlyCollectionOfNullableChild1Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static SendEmailResponseTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <SendEmailResponse> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'sendEmailResult' is SendEmailResult.Unknown scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SendEmailResponse>(); var result = new SendEmailResponse( SendEmailResult.Unknown, referenceObject.ExceptionToString, referenceObject.CommunicationLog); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "sendEmailResult", "Unknown" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SendEmailResponse> { Name = "constructor should throw ArgumentException when parameter 'sendEmailResult' is SendEmailResult.Success and 'exceptionToString' is not null", ConstructionFunc = () => { var referenceObject = A.Dummy <SendEmailResponse>(); var result = new SendEmailResponse( SendEmailResult.Success, " \r\n ", referenceObject.CommunicationLog); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "When sendEmailResult indicates success, exceptionToString must be null", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SendEmailResponse> { Name = "constructor should throw ArgumentNullException when parameter 'sendEmailResult' is not SendEmailResult.Success and 'exceptionToString' is null", ConstructionFunc = () => { var referenceObject = A.Dummy <SendEmailResponse>(); var result = new SendEmailResponse( A.Dummy <SendEmailResult>().ThatIsNot(SendEmailResult.Success), null, referenceObject.CommunicationLog); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "When sendEmailResult indicates a failure, exceptionToString must not be null nor white space.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SendEmailResponse> { Name = "constructor should throw ArgumentException when parameter 'sendEmailResult' is not SendEmailResult.Success and 'exceptionToString' is white space", ConstructionFunc = () => { var referenceObject = A.Dummy <SendEmailResponse>(); var result = new SendEmailResponse( A.Dummy <SendEmailResult>().ThatIsNot(SendEmailResult.Success), Invariant($" {Environment.NewLine} "), referenceObject.CommunicationLog); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "When sendEmailResult indicates a failure, exceptionToString must not be null nor white space.", }, }); DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <SendEmailResponse> { Name = "DeepCloneWithSendEmailResult should deep clone object and replace SendEmailResult with the provided sendEmailResult", WithPropertyName = "SendEmailResult", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SendEmailResponse>(); var sendEmailResult = systemUnderTest.SendEmailResult == SendEmailResult.Success ? SendEmailResult.Success : A.Dummy <SendEmailResult>().ThatIs(_ => (_ != SendEmailResult.Success) && (_ != systemUnderTest.SendEmailResult)); var result = new SystemUnderTestDeepCloneWithValue <SendEmailResponse> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = sendEmailResult, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SendEmailResponse> { Name = "DeepCloneWithExceptionToString should deep clone object and replace ExceptionToString with the provided exceptionToString", WithPropertyName = "ExceptionToString", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SendEmailResponse>(); var exceptionToString = systemUnderTest.SendEmailResult == SendEmailResult.Success ? null : A.Dummy <string>().ThatIsNot(systemUnderTest.ExceptionToString); var result = new SystemUnderTestDeepCloneWithValue <SendEmailResponse> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = exceptionToString, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SendEmailResponse> { Name = "DeepCloneWithCommunicationLog should deep clone object and replace CommunicationLog with the provided communicationLog", WithPropertyName = "CommunicationLog", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SendEmailResponse>(); var referenceObject = A.Dummy <SendEmailResponse>().ThatIs(_ => !systemUnderTest.CommunicationLog.IsEqualTo(_.CommunicationLog)); var result = new SystemUnderTestDeepCloneWithValue <SendEmailResponse> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.CommunicationLog, }; return(result); }, }); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => new EquatableTestScenario <SendEmailResponse> { Name = "Equatable Scenario", ReferenceObject = ReferenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new SendEmailResponse[] { new SendEmailResponse( ReferenceObjectForEquatableTestScenarios.SendEmailResult, ReferenceObjectForEquatableTestScenarios.ExceptionToString, ReferenceObjectForEquatableTestScenarios.CommunicationLog), }, ObjectsThatAreNotEqualToReferenceObject = new SendEmailResponse[] { // If SendEmailResult == Success, we can just tweak that parameter // because the constructor will throw when it finds a null ExceptionToString, // so we'll just tweak CommunicationLog. Setting to null breaks the test. ReferenceObjectForEquatableTestScenarios.SendEmailResult == SendEmailResult.Success ? new SendEmailResponse(SendEmailResult.Success, null, A.Dummy <string>()) : new SendEmailResponse( A.Dummy <SendEmailResponse>().Whose(_ => !_.SendEmailResult.IsEqualTo(ReferenceObjectForEquatableTestScenarios.SendEmailResult) && (_.SendEmailResult != SendEmailResult.Success)).SendEmailResult, ReferenceObjectForEquatableTestScenarios.ExceptionToString, ReferenceObjectForEquatableTestScenarios.CommunicationLog), // If SendEmailResult == Success, we can just tweak that parameter // because the constructor will throw when it finds a null ExceptionToString // so we'll just tweak CommunicationLog. Setting to null breaks the test. ReferenceObjectForEquatableTestScenarios.SendEmailResult == SendEmailResult.Success ? new SendEmailResponse(SendEmailResult.Success, null, A.Dummy <string>()) : new SendEmailResponse( ReferenceObjectForEquatableTestScenarios.SendEmailResult, A.Dummy <SendEmailResponse>().Whose(_ => !_.ExceptionToString.IsEqualTo(ReferenceObjectForEquatableTestScenarios.ExceptionToString) && (_.SendEmailResult != SendEmailResult.Success)).ExceptionToString, ReferenceObjectForEquatableTestScenarios.CommunicationLog), new SendEmailResponse( ReferenceObjectForEquatableTestScenarios.SendEmailResult, ReferenceObjectForEquatableTestScenarios.ExceptionToString, A.Dummy <SendEmailResponse>().Whose(_ => !_.CommunicationLog.IsEqualTo(ReferenceObjectForEquatableTestScenarios.CommunicationLog)).CommunicationLog), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), }, }); }
static ModelHashingPrivateSetNoneChild1Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static TreeTableTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentNullException when parameter 'tableColumns' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <TreeTable>(); var result = new TreeTable( null, referenceObject.TableRows, referenceObject.Format); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "tableColumns", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when parameter 'tableRows' contains a header row that does not span all of the columns in tableColumns", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(2).ToList()); var rows = new[] { new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).ToList()), }; var headerRows = new HeaderRows(rows, null); var tableRows = new TableRows(headerRows, null); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "tableRows contains a row or descendant row that does not span all 2 of the defined columns", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when parameter 'tableRows' contains a data row that does not span all of the columns in tableColumns", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(2).ToList()); var rows = new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new Row( Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), childRows: new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3)), new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }), new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }; var dataRows = new DataRows(rows, null); var tableRows = new TableRows(null, dataRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "tableRows contains a row or descendant row that does not span all 2 of the defined columns", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when parameter 'footerRows' contains a footer row that does not span all of the columns in tableColumns", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(2).ToList()); var rows = new[] { new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(2).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).ToList()), }; var footerRows = new FooterRows(rows, null); var tableRows = new TableRows(footerRows: footerRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "tableRows contains a row or descendant row that does not span all 2 of the defined columns", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when two columns have the same identifier", ConstructionFunc = () => { var tableColumns = new TableColumns(new[] { new Column("column-1"), new Column("column-2"), new Column("column-1"), }); var headerRows = new HeaderRows( new[] { new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }, null); var dataRows = new DataRows( new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new Row( Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), childRows: new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }), }); var tableRows = new TableRows(headerRows, dataRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "Two or more elements (i.e. columns, rows, cells) have the same identifier.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when two rows have the same identifier", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(3).ToList()); var headerRows = new HeaderRows( new[] { new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), "row-1"), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), "row-2"), }, null); var dataRows = new DataRows( new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), "row-3"), new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), childRows: new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), "row-1"), }), }); var tableRows = new TableRows(headerRows, dataRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "Two or more elements (i.e. columns, rows, cells) have the same identifier.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when two cells have the same identifier", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(3).ToList()); var headerRows = new HeaderRows( new[] { new FlatRow( new ICell[] { A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId(null), A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId("cell-1"), A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId(null), }), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }, null); var dataRows = new DataRows( new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new Row( Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), childRows: new[] { new Row( new ICell[] { A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(null).DeepCloneWithId(null), A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(null).DeepCloneWithId(null), A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(null).DeepCloneWithId("cell-1"), }), }), }); var tableRows = new TableRows(headerRows, dataRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "Two or more elements (i.e. columns, rows, cells) have the same identifier.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <TreeTable> { Name = "constructor should throw ArgumentException when a cell object is used multiple times", ConstructionFunc = () => { var tableColumns = new TableColumns(Some.ReadOnlyDummies <Column>(3).ToList()); var cell = A.Dummy <CellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId(null); var headerRows = new HeaderRows( new[] { new FlatRow( new ICell[] { A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId(null), cell, A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(1).DeepCloneWithId(null), }), new FlatRow(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), }, null); var dataRows = new DataRows( new[] { new Row(Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList()), new Row( Some.ReadOnlyDummies <NotSlottedCellBase>(3).Select(_ => _.DeepCloneWithColumnsSpanned(1)).ToList(), childRows: new[] { new Row( new ICell[] { A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(null).DeepCloneWithId(null), A.Dummy <NotSlottedCellBase>().DeepCloneWithColumnsSpanned(null).DeepCloneWithId(null), cell, }), }), }); var tableRows = new TableRows(headerRows, dataRows); var result = new TreeTable( tableColumns, tableRows); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "One or more ICell objects are used multiple times in the tree table.", }, }); DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <TreeTable> { Name = "DeepCloneWithTableColumns should deep clone object and replace TableColumns with the provided tableColumns", WithPropertyName = "TableColumns", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <TreeTable>(); var referenceObject = A.Dummy <TreeTable>().ThatIs(_ => !systemUnderTest.TableColumns.IsEqualTo(_.TableColumns) && (_.TableColumns.Columns.Count == systemUnderTest.TableColumns.Columns.Count)); var result = new SystemUnderTestDeepCloneWithValue <TreeTable> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.TableColumns, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <TreeTable> { Name = "DeepCloneWithTableRows should deep clone object and replace TableRows with the provided tableRows", WithPropertyName = "TableRows", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <TreeTable>(); var referenceObject = A.Dummy <TreeTable>().ThatIs(_ => !systemUnderTest.TableRows.IsEqualTo(_.TableRows) && ((!_.TableRows.GetAllRowsInOrder().Any()) || (_.TableRows.GetAllRowsInOrder().First().GetNumberOfColumnsSpanned() == systemUnderTest.TableColumns.Columns.Count))); var result = new SystemUnderTestDeepCloneWithValue <TreeTable> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.TableRows, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <TreeTable> { Name = "DeepCloneWithFormat should deep clone object and replace Format with the provided format", WithPropertyName = "Format", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <TreeTable>(); var referenceObject = A.Dummy <TreeTable>().ThatIs(_ => !systemUnderTest.Format.IsEqualTo(_.Format)); var result = new SystemUnderTestDeepCloneWithValue <TreeTable> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Format, }; return(result); }, }); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => new EquatableTestScenario <TreeTable> { Name = "Default Code Generated Scenario", ReferenceObject = ReferenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new TreeTable[] { new TreeTable( ReferenceObjectForEquatableTestScenarios.TableColumns, ReferenceObjectForEquatableTestScenarios.TableRows, ReferenceObjectForEquatableTestScenarios.Format), }, ObjectsThatAreNotEqualToReferenceObject = new TreeTable[] { new TreeTable( A.Dummy <TreeTable>().Whose(_ => !_.TableColumns.IsEqualTo(ReferenceObjectForEquatableTestScenarios.TableColumns) && (_.TableColumns.Columns.Count == ReferenceObjectForEquatableTestScenarios.TableColumns.Columns.Count)).TableColumns, ReferenceObjectForEquatableTestScenarios.TableRows, ReferenceObjectForEquatableTestScenarios.Format), new TreeTable( ReferenceObjectForEquatableTestScenarios.TableColumns, A.Dummy <TreeTable>().Whose(_ => (!_.TableRows.IsEqualTo(ReferenceObjectForEquatableTestScenarios.TableRows) && ((!_.TableRows.GetAllRowsInOrder().Any()) || (_.TableRows.GetAllRowsInOrder().First().GetNumberOfColumnsSpanned() == ReferenceObjectForEquatableTestScenarios.TableColumns.Columns.Count)))).TableRows, ReferenceObjectForEquatableTestScenarios.Format), new TreeTable( ReferenceObjectForEquatableTestScenarios.TableColumns, ReferenceObjectForEquatableTestScenarios.TableRows, A.Dummy <TreeTable>().Whose(_ => !_.Format.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Format)).Format), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), }, }); }
static ModelEqualityPublicSetReadOnlyListOfNullableTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static DateTimeFormatTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <DateTimeFormat> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'formatKind' is DateTimeFormatKind.Unknown scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <DateTimeFormat>(); var result = new DateTimeFormat( DateTimeFormatKind.Unknown, referenceObject.CultureKind, referenceObject.LocalizeTimeZone, referenceObject.LocalTimeZone); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "formatKind is Unknown", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <DateTimeFormat> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'cultureKind' is CultureKind.Unknown scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <DateTimeFormat>(); var result = new DateTimeFormat( referenceObject.FormatKind, CultureKind.Unknown, referenceObject.LocalizeTimeZone, referenceObject.LocalTimeZone); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "cultureKind is Unknown", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <DateTimeFormat> { Name = "constructor should throw ArgumentException when parameter 'localizeTimeZone' is false and parameter 'localTimeZone' is not null", ConstructionFunc = () => { var referenceObject = A.Dummy <DateTimeFormat>(); var result = new DateTimeFormat( referenceObject.FormatKind, referenceObject.CultureKind, false, A.Dummy <StandardTimeZone>()); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "localizeTimeZone is false, but localTimeZone is not null", }, }); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => { var referenceObjectForEquatableTestScenarios = A.Dummy <DateTimeFormat>().Whose(_ => _.LocalizeTimeZone == true); var result = new EquatableTestScenario <DateTimeFormat> { Name = "Default Code Generated Scenario", ReferenceObject = referenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new DateTimeFormat[] { new DateTimeFormat( referenceObjectForEquatableTestScenarios.FormatKind, referenceObjectForEquatableTestScenarios.CultureKind, referenceObjectForEquatableTestScenarios.LocalizeTimeZone, referenceObjectForEquatableTestScenarios.LocalTimeZone), }, ObjectsThatAreNotEqualToReferenceObject = new DateTimeFormat[] { new DateTimeFormat( A.Dummy <DateTimeFormat>().Whose(_ => !_.FormatKind.IsEqualTo(referenceObjectForEquatableTestScenarios.FormatKind)).FormatKind, referenceObjectForEquatableTestScenarios.CultureKind, referenceObjectForEquatableTestScenarios.LocalizeTimeZone, referenceObjectForEquatableTestScenarios.LocalTimeZone), new DateTimeFormat( referenceObjectForEquatableTestScenarios.FormatKind, A.Dummy <DateTimeFormat>().Whose(_ => !_.CultureKind.IsEqualTo(referenceObjectForEquatableTestScenarios.CultureKind)).CultureKind, referenceObjectForEquatableTestScenarios.LocalizeTimeZone, referenceObjectForEquatableTestScenarios.LocalTimeZone), new DateTimeFormat( referenceObjectForEquatableTestScenarios.FormatKind, referenceObjectForEquatableTestScenarios.CultureKind, A.Dummy <DateTimeFormat>().Whose(_ => !_.LocalizeTimeZone.IsEqualTo(referenceObjectForEquatableTestScenarios.LocalizeTimeZone)).LocalizeTimeZone, null), new DateTimeFormat( referenceObjectForEquatableTestScenarios.FormatKind, referenceObjectForEquatableTestScenarios.CultureKind, referenceObjectForEquatableTestScenarios.LocalizeTimeZone, A.Dummy <DateTimeFormat>().Whose(_ => !_.LocalTimeZone.IsEqualTo(referenceObjectForEquatableTestScenarios.LocalTimeZone)).LocalTimeZone), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), }, }; return(result); }); DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <DateTimeFormat> { Name = "DeepCloneWithFormatKind should deep clone object and replace FormatKind with the provided formatKind", WithPropertyName = "FormatKind", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <DateTimeFormat>(); var referenceObject = A.Dummy <DateTimeFormat>().ThatIs(_ => !systemUnderTest.FormatKind.IsEqualTo(_.FormatKind)); var result = new SystemUnderTestDeepCloneWithValue <DateTimeFormat> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.FormatKind, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <DateTimeFormat> { Name = "DeepCloneWithCultureKind should deep clone object and replace CultureKind with the provided cultureKind", WithPropertyName = "CultureKind", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <DateTimeFormat>(); var referenceObject = A.Dummy <DateTimeFormat>().ThatIs(_ => !systemUnderTest.CultureKind.IsEqualTo(_.CultureKind)); var result = new SystemUnderTestDeepCloneWithValue <DateTimeFormat> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.CultureKind, }; return(result); }, }); }
static ModelEqualityPrivateSetReadOnlyCollectionTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPrivateSetReadOnlyListOfNullableChild2Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPublicSetReadOnlyDictionaryOfNullableTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPrivateSetArrayOfNullableTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static OutputParameterDefinitionTValueTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <OutputParameterDefinition <Version> > { Name = "constructor should throw ArgumentNullException when parameter 'name' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <OutputParameterDefinition <Version> >(); var result = new OutputParameterDefinition <Version>( null, referenceObject.SqlDataType); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "name", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <OutputParameterDefinition <Version> > { Name = "constructor should throw ArgumentException when parameter 'name' is white space scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <OutputParameterDefinition <Version> >(); var result = new OutputParameterDefinition <Version>( Invariant($" {Environment.NewLine} "), referenceObject.SqlDataType); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "name", "white space", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <OutputParameterDefinition <Version> > { Name = "constructor should throw ArgumentException when parameter 'name' is not alphanumeric nor @ nor _", ConstructionFunc = () => { var referenceObject = A.Dummy <OutputParameterDefinition <Version> >(); var result = new OutputParameterDefinition <Version>( referenceObject.Name + "^", referenceObject.SqlDataType); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "name", "alphanumeric", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <OutputParameterDefinition <Version> > { Name = "constructor should throw ArgumentNullException when parameter 'sqlDataType' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <OutputParameterDefinition <Version> >(); var result = new OutputParameterDefinition <Version>( referenceObject.Name, null); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "sqlDataType", }, }); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => new EquatableTestScenario <OutputParameterDefinition <Version> > { Name = "Default Code Generated Scenario", ReferenceObject = ReferenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new OutputParameterDefinition <Version>[] { new OutputParameterDefinition <Version>( ReferenceObjectForEquatableTestScenarios.Name, ReferenceObjectForEquatableTestScenarios.SqlDataType), }, ObjectsThatAreNotEqualToReferenceObject = new OutputParameterDefinition <Version>[] { new OutputParameterDefinition <Version>( A.Dummy <OutputParameterDefinition <Version> >().Whose(_ => !_.Name.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Name)).Name, ReferenceObjectForEquatableTestScenarios.SqlDataType), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <Version>(), A.Dummy <Guid>(), A.Dummy <InputParameterDefinition <Version> >(), }, }); }
static UnitTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <Unit> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'kind' is UnitOfTimeKind.Invalid", ConstructionFunc = () => { var referenceObject = A.Dummy <Unit>(); var result = new Unit( UnitOfTimeKind.Invalid, referenceObject.Granularity); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "kind is UnitOfTimeKind.Invalid" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <Unit> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'granularity' is UnitOfTimeGranularity.Invalid", ConstructionFunc = () => { var referenceObject = A.Dummy <Unit>(); var result = new Unit( referenceObject.Kind, UnitOfTimeGranularity.Invalid); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "granularity is UnitOfTimeGranularity.Invalid" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <Unit> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'granularity' is UnitOfTimeGranularity.Unbounded", ConstructionFunc = () => { var referenceObject = A.Dummy <Unit>(); var result = new Unit( referenceObject.Kind, UnitOfTimeGranularity.Unbounded); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "granularity is UnitOfTimeGranularity.Unbounded" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <Unit> { Name = "constructor should throw ArgumentException when parameter 'granularity' is UnitOfTimeGranularity.Day and parameter 'kind' is not UnitOfTimeKind.Calendar", ConstructionFunc = () => { var result = new Unit( A.Dummy <UnitOfTimeKind>().ThatIsNot(UnitOfTimeKind.Calendar), UnitOfTimeGranularity.Day); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "granularity of UnitOfTimeGranularity.Day is only applicable when kind is UnitOfTimeKind.Calendar" }, }); DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <Unit> { Name = "DeepCloneWithKind should deep clone object and replace Kind with the provided kind", WithPropertyName = "Kind", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <Unit>().Whose(_ => _.Granularity != UnitOfTimeGranularity.Day); var referenceObject = A.Dummy <Unit>().ThatIs(_ => !systemUnderTest.Kind.IsEqualTo(_.Kind)); var result = new SystemUnderTestDeepCloneWithValue <Unit> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Kind, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <Unit> { Name = "DeepCloneWithGranularity should deep clone object and replace Granularity with the provided granularity", WithPropertyName = "Granularity", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <Unit>(); var referenceObject = A.Dummy <Unit>().ThatIs(_ => (!systemUnderTest.Granularity.IsEqualTo(_.Granularity)) && (_.Granularity != UnitOfTimeGranularity.Day)); var result = new SystemUnderTestDeepCloneWithValue <Unit> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Granularity, }; return(result); }, }); var referenceObjectForEquatableTestScenarios = A.Dummy <Unit>().Whose(_ => _.Granularity != UnitOfTimeGranularity.Day); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => new EquatableTestScenario <Unit> { Name = "Equatable Test Scenario", ReferenceObject = referenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new Unit[] { new Unit( referenceObjectForEquatableTestScenarios.Kind, referenceObjectForEquatableTestScenarios.Granularity), }, ObjectsThatAreNotEqualToReferenceObject = new Unit[] { new Unit( A.Dummy <Unit>().Whose(_ => (_.Granularity != UnitOfTimeGranularity.Day) && (!_.Kind.IsEqualTo(referenceObjectForEquatableTestScenarios.Kind))).Kind, referenceObjectForEquatableTestScenarios.Granularity), new Unit( referenceObjectForEquatableTestScenarios.Kind, A.Dummy <Unit>().Whose(_ => (_.Granularity != UnitOfTimeGranularity.Day) && (!_.Granularity.IsEqualTo(referenceObjectForEquatableTestScenarios.Granularity))).Granularity), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), }, }); }
static ModelEqualityPublicSetNullableTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPrivateSetReadOnlyDictionaryTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelHashingPublicSetNoneTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelEqualityPrivateSetArrayTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelEqualityPrivateSetReadOnlyDictionaryOfNullableTest() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ReportingPeriodTest() { DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithStart)} should deep clone object and replace {nameof(ReportingPeriod.Start)} with the provided start when {nameof(ReportingPeriod.End)} is {nameof(UnitOfTimeGranularity.Unbounded)} and provided start has the same {nameof(UnitOfTimeKind)} as {nameof(ReportingPeriod.End)}"), WithPropertyName = nameof(ReportingPeriod.Start), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.End.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => _.GetUnitOfTimeKind() == systemUnderTest.GetUnitOfTimeKind()); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Start, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithStart)} should deep clone object and replace {nameof(ReportingPeriod.Start)} with the provided start when {nameof(ReportingPeriod.End)} is bounded and provided start is {nameof(UnitOfTimeGranularity.Unbounded)} having the same {nameof(UnitOfTimeKind)}"), WithPropertyName = nameof(ReportingPeriod.Start), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.End.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => (_.Start.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded) && (_.Start.UnitOfTimeKind == systemUnderTest.End.UnitOfTimeKind)); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Start, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithStart)} should deep clone object and replace {nameof(ReportingPeriod.Start)} with the provided start when {nameof(ReportingPeriod.End)} is bounded and provided start is of the same type as and <= {nameof(ReportingPeriod.End)}"), WithPropertyName = nameof(ReportingPeriod.Start), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.End.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => (_.Start.GetType() == systemUnderTest.End.GetType()) && (_.Start <= systemUnderTest.End)); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Start, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithEnd)} should deep clone object and replace {nameof(ReportingPeriod.End)} with the provided end when {nameof(ReportingPeriod.Start)} is {nameof(UnitOfTimeGranularity.Unbounded)} and provided end has the same {nameof(UnitOfTimeKind)} as {nameof(ReportingPeriod.Start)}"), WithPropertyName = nameof(ReportingPeriod.End), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.Start.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => _.GetUnitOfTimeKind() == systemUnderTest.GetUnitOfTimeKind()); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.End, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithEnd)} should deep clone object and replace {nameof(ReportingPeriod.End)} with the provided end when {nameof(ReportingPeriod.Start)} is bounded and provided end is {nameof(UnitOfTimeGranularity.Unbounded)} having the same {nameof(UnitOfTimeKind)}"), WithPropertyName = nameof(ReportingPeriod.End), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.Start.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => (_.End.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded) && (_.End.UnitOfTimeKind == systemUnderTest.Start.UnitOfTimeKind)); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.End, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <ReportingPeriod> { Name = Invariant($"{nameof(ReportingPeriod.DeepCloneWithEnd)} should deep clone object and replace {nameof(ReportingPeriod.End)} with the provided end when {nameof(ReportingPeriod.Start)} is bounded and provided end is of the same type as and >= {nameof(ReportingPeriod.Start)}"), WithPropertyName = nameof(ReportingPeriod.End), SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <ReportingPeriod>().Whose(_ => _.Start.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); var referenceObject = A.Dummy <ReportingPeriod>().Whose(_ => (_.End.GetType() == systemUnderTest.Start.GetType()) && (_.End >= systemUnderTest.Start)); var result = new SystemUnderTestDeepCloneWithValue <ReportingPeriod> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.End, }; return(result); }, }); var unboundedStartReportingPeriod = A.Dummy <ReportingPeriod>().Whose(_ => _.Start.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded); var boundedStartReportingPeriod = A.Dummy <ReportingPeriod>().Whose(_ => _.Start.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); var unboundedEndReportingPeriod = A.Dummy <ReportingPeriod>().Whose(_ => _.End.UnitOfTimeGranularity == UnitOfTimeGranularity.Unbounded); var boundedEndReportingPeriod = A.Dummy <ReportingPeriod>().Whose(_ => _.End.UnitOfTimeGranularity != UnitOfTimeGranularity.Unbounded); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => new EquatableTestScenario <ReportingPeriod> { Name = "Reference object has unbounded Start. Create an End of the same UnitOfTimeKind that != reference object's End", ReferenceObject = unboundedStartReportingPeriod, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new[] { unboundedStartReportingPeriod.DeepClone(), }, ObjectsThatAreNotEqualToReferenceObject = new[] { new ReportingPeriod(unboundedStartReportingPeriod.Start, A.Dummy <UnitOfTime>().Whose(_ => (_.UnitOfTimeKind == unboundedStartReportingPeriod.GetUnitOfTimeKind()) && (_ != unboundedStartReportingPeriod.End))), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), } .Concat(TestCommon.GetDummyOfEachUnitOfTimeKind()) .ToArray(), }) .AddScenario(() => new EquatableTestScenario <ReportingPeriod> { Name = "Reference object has bounded Start. Create an End that is of the same type as reference object's Start (so it will be bounded), that is > but != reference object's Start", ReferenceObject = boundedStartReportingPeriod, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new[] { boundedStartReportingPeriod.DeepClone(), }, ObjectsThatAreNotEqualToReferenceObject = new[] { new ReportingPeriod(boundedStartReportingPeriod.Start, A.Dummy <UnitOfTime>().Whose(_ => (_.GetType() == boundedStartReportingPeriod.Start.GetType()) && (_ > boundedStartReportingPeriod.Start) && (_ != boundedStartReportingPeriod.End))), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), } .Concat(TestCommon.GetDummyOfEachUnitOfTimeKind()) .ToArray(), }) .AddScenario(() => new EquatableTestScenario <ReportingPeriod> { Name = "Reference object has unbounded End. Create an Start of the same UnitOfTimeKind that != reference object's Start", ReferenceObject = unboundedEndReportingPeriod, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new[] { unboundedEndReportingPeriod.DeepClone(), }, ObjectsThatAreNotEqualToReferenceObject = new[] { new ReportingPeriod(A.Dummy <UnitOfTime>().Whose(_ => (_.UnitOfTimeKind == unboundedEndReportingPeriod.GetUnitOfTimeKind()) && (_ != unboundedEndReportingPeriod.Start)), unboundedEndReportingPeriod.End), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), } .Concat(TestCommon.GetDummyOfEachUnitOfTimeKind()) .ToArray(), }) .AddScenario(() => new EquatableTestScenario <ReportingPeriod> { Name = "Reference object has bounded End. Create a Start that is of the same type as reference object's End (so it will be bounded), that is < but != reference object's End", ReferenceObject = boundedEndReportingPeriod, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new[] { boundedEndReportingPeriod.DeepClone(), }, ObjectsThatAreNotEqualToReferenceObject = new[] { new ReportingPeriod(A.Dummy <UnitOfTime>().Whose(_ => (_.GetType() == boundedEndReportingPeriod.End.GetType()) && (_ < boundedEndReportingPeriod.End) && (_ != boundedEndReportingPeriod.Start)), boundedEndReportingPeriod.End), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), } .Concat(TestCommon.GetDummyOfEachUnitOfTimeKind()) .ToArray(), }); StringRepresentationTestScenarios .RemoveAllScenarios() .AddScenario(() => new StringRepresentationTestScenario <ReportingPeriod> { Name = "String Representation - case 1", SystemUnderTestExpectedStringRepresentationFunc = () => new SystemUnderTestExpectedStringRepresentation <ReportingPeriod> { SystemUnderTest = new ReportingPeriod( new CalendarDay(2017, MonthOfYear.November, DayOfMonth.Thirty), new CalendarDay(2018, MonthOfYear.March, DayOfMonth.TwentyFour)), ExpectedStringRepresentation = "2017-11-30 to 2018-03-24", }, }); }
static ModelEqualityPublicSetArrayOfNullableChild1Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }
static ModelEqualityPublicSetReadOnlyCollectionOfNullableChild2Test() { EquatableTestScenarios.AddScenarios(LocalEquatableTestScenarios); }