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