private static CellBase InternalDeepCloneWithColumnsSpanned( CellBase cell, int columnsSpanned) { CellBase result; if (cell is SlottedCell slottedCell) { result = new SlottedCell( slottedCell.SlotIdToCellMap.ToDictionary(_ => _.Key, _ => (INotSlottedCell)((NotSlottedCellBase)_.Value).DeepCloneWithColumnsSpanned(columnsSpanned)), slottedCell.DefaultSlotId, slottedCell.Id, columnsSpanned, slottedCell.Details); } else { result = cell.DeepCloneWithColumnsSpanned(columnsSpanned); } return(result); }
public DataStructureDummyFactory() { // <------------------- ENUMS ------------------------> AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(Availability.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(AvailabilityCheckStatus.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(AvailabilityCheckStepAction.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BorderStyle.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BorderWeight.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BytesPayloadLinkedResourceKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CellOpExecutionOutcome.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CellOpExecutionStatus.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompareOperator.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(FillPatternStyle.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(HorizontalAlignment.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(InnerBorderEdges.None); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(LinkTarget.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MediaReferenceKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MessageFormatKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatDigitGroupKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatNegativeDisplayKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(NumberFormatPercentDisplayKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(OuterBorderSides.None); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SlotSelectionStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StringPayloadLinkedResourceKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UrlLinkedResourceKind.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ValidationStatus.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ValidationStepAction.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(Validity.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(VerticalAlignment.Unknown); // <------------------- INTERFACES ------------------------> AutoFixtureBackedDummyFactory.AddDummyCreator <IAvailabilityCheckCell>(A.Dummy <NotSlottedCellBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <ICell>(A.Dummy <CellBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <INotSlottedCell>(A.Dummy <NotSlottedCellBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <IValidationCell>(A.Dummy <NotSlottedCellBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <ICellValueFormat <Version> >(A.Dummy <CellValueFormatBase <Version> >); AutoFixtureBackedDummyFactory.AddDummyCreator <IHoverOver>(A.Dummy <HoverOverBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <ILink>(A.Dummy <SimpleLink>); AutoFixtureBackedDummyFactory.AddDummyCreator <ILinkedResource>(A.Dummy <LinkedResourceBase>); AutoFixtureBackedDummyFactory.AddDummyCreator <IOperationOutputCell <Version> >(A.Dummy <OperationCell <Version> >); // <------------------- OPERATIONS ------------------------> RegisterReturningOperation <bool>(); RegisterReturningOperation <decimal>(); RegisterReturningOperation <string>(); RegisterReturningOperation <ValidationResult>(); RegisterReturningOperation <AvailabilityCheckResult>(); RegisterReturningOperation <Availability>(); RegisterReturningOperation <Validity>(); RegisterReturningOperation <CellLocatorBase>(); RegisterReturningOperation <CompareOperator>(); // <------------------- MODELS ------------------------> // Report AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var numberOfSections = ThreadSafeRandom.Next(1, 4); var result = new Report(A.Dummy <string>(), Some.ReadOnlyDummies <Section>(numberOfSections).ToList(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), Some.ReadOnlyDummies <SimpleLink>().ToList(), A.Dummy <AdditionalReportInfo>(), A.Dummy <ReportFormat>()); return(result); }); // TreeTable AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var numberOfColumns = GetRandomNumberOfColumns(); var columns = Some.ReadOnlyDummies <Column>(numberOfColumns).ToList(); var tableColumns = new TableColumns(columns, A.Dummy <ColumnFormat>()); var tableRows = BuildTableRows(columns.Count); var result = new TreeTable(tableColumns, tableRows, A.Dummy <TableFormat>()); return(result); }); // TableRows AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = BuildTableRows(GetRandomNumberOfColumns()); return(result); }); // HeaderRows AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var headerRows = BuildFlatRows(GetRandomNumberOfColumns()); var result = new HeaderRows(headerRows, A.Dummy <HeaderRowsFormat>()); return(result); }); // DataRows AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var allDataRows = BuildDataRows(GetRandomNumberOfColumns()); var result = new DataRows(allDataRows, A.Dummy <DataRowsFormat>()); return(result); }); // FooterRows AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var footerRows = BuildFlatRows(GetRandomNumberOfColumns()); var result = new FooterRows(footerRows, A.Dummy <FooterRowsFormat>()); return(result); }); // Row AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = BuildDataRow(GetRandomNumberOfColumns()); return(result); }); // FlatRow AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = BuildFlatRow(GetRandomNumberOfColumns(), allowSpanningCells: true); return(result); }); // SlottedCell AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var columnsSpanned = GetRandomColumnsSpannedByCell(); var cells = Some.ReadOnlyDummies <NotSlottedCellBase>().Select(_ => _.DeepCloneWithColumnsSpanned(columnsSpanned)).Cast <NotSlottedCellBase>().ToList(); var slotIdToCellMap = cells.ToDictionary(_ => A.Dummy <string>(), _ => (INotSlottedCell)_); var defaultSlotId = slotIdToCellMap.ElementAt(ThreadSafeRandom.Next(0, slotIdToCellMap.Count)).Key; var result = new SlottedCell(slotIdToCellMap, defaultSlotId, A.Dummy <string>(), columnsSpanned, A.Dummy <string>()); return(result); }); // InputCell<Version> AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new InputCell <Version>( A.Dummy <string>(), GetRandomColumnsSpannedByCell(), A.Dummy <string>(), A.Dummy <Validation>(), Some.ReadOnlyDummies <CellValidationEventBase>().ToList(), A.Dummy <Availability>(), A.Dummy <AvailabilityCheck>(), Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(), Some.ReadOnlyDummies <CellInputEventBase>().ToList(), A.Dummy <ICellValueFormat <Version> >(), A.Dummy <CellFormat>(), A.Dummy <IHoverOver>()); return(result); }); // NullCell AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new NullCell( A.Dummy <string>(), GetRandomColumnsSpannedByCell(), A.Dummy <string>(), A.Dummy <Validation>(), Some.ReadOnlyDummies <CellValidationEventBase>().ToList(), A.Dummy <Availability>(), A.Dummy <AvailabilityCheck>(), Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(), A.Dummy <CellFormat>(), A.Dummy <IHoverOver>(), A.Dummy <ILink>()); return(result); }); // ConstCell<Version> AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new ConstCell <Version>( A.Dummy <Version>(), A.Dummy <string>(), GetRandomColumnsSpannedByCell(), A.Dummy <string>(), A.Dummy <Validation>(), Some.ReadOnlyDummies <CellValidationEventBase>().ToList(), A.Dummy <Availability>(), A.Dummy <AvailabilityCheck>(), Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(), A.Dummy <ICellValueFormat <Version> >(), A.Dummy <CellFormat>(), A.Dummy <IHoverOver>(), A.Dummy <ILink>()); return(result); }); // OperationOutputCell<Version> AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new OperationCell <Version>( A.Dummy <IReturningOperation <Version> >(), A.Dummy <string>(), GetRandomColumnsSpannedByCell(), A.Dummy <string>(), A.Dummy <Validation>(), Some.ReadOnlyDummies <CellValidationEventBase>().ToList(), A.Dummy <Availability>(), A.Dummy <AvailabilityCheck>(), Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>().ToList(), Some.ReadOnlyDummies <CellOpExecutionEventBase>().ToList(), A.Dummy <ICellValueFormat <Version> >(), A.Dummy <CellFormat>(), A.Dummy <IHoverOver>(), A.Dummy <ILink>()); return(result); }); // DateTimeFormat AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var localize = A.Dummy <bool>(); var result = new DateTimeFormat(A.Dummy <DateTimeFormatKind>(), A.Dummy <CultureKind>(), localize, localize ? A.Dummy <StandardTimeZone>() : (StandardTimeZone?)null); return(result); }); // ReportFormat AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var displayTimestamp = A.Dummy <bool>(); var result = new ReportFormat(displayTimestamp, displayTimestamp ? A.Dummy <DateTimeFormat>() : null, A.Dummy <ReportFormatOptions>()); return(result); }); // Color AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = Color.FromArgb(A.Dummy <byte>(), A.Dummy <byte>(), A.Dummy <byte>()); return(result); }); // Events AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellAvailabilityCheckClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellAvailabilityCheckDeterminedCellDisabledEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellAvailabilityCheckDeterminedCellEnabledEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellAvailabilityCheckFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellInputAppliedEvent <Version>(A.Dummy <UtcDateTime>(), A.Dummy <Version>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellInputClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellOpExecutionAbortedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellOpExecutionClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellOpExecutionCompletedEvent <Version>(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <Version>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellOpExecutionDeemedNotApplicableEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellOpExecutionFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationAbortedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationClearedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationDeemedNotApplicableEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationDeterminedCellInvalidEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationDeterminedCellValidEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator(() => { var result = new CellValidationFailedEvent(A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); }
static SlottedCellTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentNullException when parameter 'slotIdToCellMap' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( null, referenceObject.DefaultSlotId, referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'slotIdToCellMap' is an empty dictionary scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( new Dictionary <string, INotSlottedCell>(), referenceObject.DefaultSlotId, referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap", "is an empty dictionary", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'slotIdToCellMap' contains a key-value pair with a null value scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var dictionaryWithNullValue = referenceObject.SlotIdToCellMap.ToDictionary(_ => _.Key, _ => _.Value); var randomKey = dictionaryWithNullValue.Keys.ElementAt(ThreadSafeRandom.Next(0, dictionaryWithNullValue.Count)); dictionaryWithNullValue[randomKey] = null; var result = new SlottedCell( dictionaryWithNullValue, referenceObject.DefaultSlotId, referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap", "contains at least one key-value pair with a null value", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'slotIdToCellMap' contains a white space key", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var slotIdToCellMap = referenceObject.SlotIdToCellMap.ToDictionary(_ => _.Key, _ => _.Value); slotIdToCellMap.Add(" \r\n ", A.Dummy <INotSlottedCell>()); var result = new SlottedCell( slotIdToCellMap, referenceObject.DefaultSlotId, referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap", "contains at least one key-value pair with a white space key" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentNullException when parameter 'defaultSlotId' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, null, referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "defaultSlotId", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'defaultSlotId' is white space scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, Invariant($" {Environment.NewLine} "), referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "defaultSlotId", "white space", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'slotIdToCellMap' does not contain the specified defaultSlotId", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, A.Dummy <string>(), referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap does not contain the specified defaultSlotId" }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is 0", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, referenceObject.DefaultSlotId, referenceObject.Id, 0, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "columnsSpanned is 0; must be null or >= 1.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is -1", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, referenceObject.DefaultSlotId, referenceObject.Id, -1, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "columnsSpanned is -1; must be null or >= 1.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentOutOfRangeException when parameter 'columnsSpanned' is negative", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var result = new SlottedCell( referenceObject.SlotIdToCellMap, referenceObject.DefaultSlotId, referenceObject.Id, A.Dummy <NegativeInteger>(), referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentOutOfRangeException), ExpectedExceptionMessageContains = new[] { "must be null or >= 1.", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <SlottedCell> { Name = "constructor should throw ArgumentException when parameter 'slotIdToCellMap' contains a value whose ColumnsSpanned does not equal columnsSpanned (with null imputed to 1)", ConstructionFunc = () => { var referenceObject = A.Dummy <SlottedCell>(); var slotIdToCellMap = new Dictionary <string, INotSlottedCell> { { A.Dummy <string>(), new NullCell(columnsSpanned: referenceObject.ColumnsSpanned) }, { A.Dummy <string>(), new NullCell(columnsSpanned: referenceObject.ColumnsSpanned == null ? 2 : referenceObject.ColumnsSpanned + 1) }, { A.Dummy <string>(), new NullCell(columnsSpanned: referenceObject.ColumnsSpanned) }, }; var result = new SlottedCell( slotIdToCellMap, slotIdToCellMap.Keys.First(), referenceObject.Id, referenceObject.ColumnsSpanned, referenceObject.Details); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "slotIdToCellMap contains a cell that does not span the same number of columns as this cell." }, }); DeepCloneWithTestScenarios .RemoveAllScenarios() .AddScenario(() => new DeepCloneWithTestScenario <SlottedCell> { Name = "DeepCloneWithId should deep clone object and replace Id with the provided id", WithPropertyName = "Id", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SlottedCell>(); var referenceObject = A.Dummy <SlottedCell>().ThatIs(_ => !systemUnderTest.Id.IsEqualTo(_.Id)); var result = new SystemUnderTestDeepCloneWithValue <SlottedCell> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Id, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SlottedCell> { Name = "DeepCloneWithColumnsSpanned should deep clone object and replace ColumnsSpanned with the provided columnsSpanned", WithPropertyName = "ColumnsSpanned", SystemUnderTestDeepCloneWithValueFunc = () => { var slotIdToCellMap = new Dictionary <string, INotSlottedCell> { { A.Dummy <string>(), new NullCell() }, { A.Dummy <string>(), new NullCell() }, { A.Dummy <string>(), new NullCell() }, }; var systemUnderTest = new SlottedCell( slotIdToCellMap, slotIdToCellMap.Keys.First()); var result = new SystemUnderTestDeepCloneWithValue <SlottedCell> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = 1, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SlottedCell> { Name = "DeepCloneWithDetails should deep clone object and replace Details with the provided details", WithPropertyName = "Details", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SlottedCell>(); var referenceObject = A.Dummy <SlottedCell>().ThatIs(_ => !systemUnderTest.Details.IsEqualTo(_.Details)); var result = new SystemUnderTestDeepCloneWithValue <SlottedCell> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = referenceObject.Details, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SlottedCell> { Name = "DeepCloneWithSlotIdToCellMap should deep clone object and replace SlotIdToCellMap with the provided slotIdToCellMap", WithPropertyName = "SlotIdToCellMap", SystemUnderTestDeepCloneWithValueFunc = () => { var slotIdToCellMap = new Dictionary <string, INotSlottedCell> { { "abc", new NullCell() }, { A.Dummy <string>(), new NullCell() }, { A.Dummy <string>(), new NullCell() }, }; var systemUnderTest = new SlottedCell( slotIdToCellMap, slotIdToCellMap.Keys.First()); var result = new SystemUnderTestDeepCloneWithValue <SlottedCell> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = new Dictionary <string, INotSlottedCell> { { A.Dummy <string>(), new NullCell() }, { "abc", new NullCell() }, { A.Dummy <string>(), new NullCell() }, }, }; return(result); }, }) .AddScenario(() => new DeepCloneWithTestScenario <SlottedCell> { Name = "DeepCloneWithDefaultSlotId should deep clone object and replace DefaultSlotId with the provided defaultSlotId", WithPropertyName = "DefaultSlotId", SystemUnderTestDeepCloneWithValueFunc = () => { var systemUnderTest = A.Dummy <SlottedCell>().Whose(_ => _.SlotIdToCellMap.Count() > 1); var defaultSlotId = systemUnderTest.SlotIdToCellMap.Keys.First(_ => _ != systemUnderTest.DefaultSlotId); var result = new SystemUnderTestDeepCloneWithValue <SlottedCell> { SystemUnderTest = systemUnderTest, DeepCloneWithValue = defaultSlotId, }; return(result); }, }); EquatableTestScenarios .RemoveAllScenarios() .AddScenario(() => { var referenceObjectForEquatableTestScenarios = new SlottedCell( new Dictionary <string, INotSlottedCell> { { "abc", new NullCell(columnsSpanned: 1) }, { "def", new NullCell(columnsSpanned: 1) }, { "ghi", new NullCell(columnsSpanned: 1) }, }, "def", A.Dummy <string>(), 1, A.Dummy <string>()); return(new EquatableTestScenario <SlottedCell> { Name = "Default Code Generated Scenario", ReferenceObject = referenceObjectForEquatableTestScenarios, ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new SlottedCell[] { new SlottedCell( referenceObjectForEquatableTestScenarios.SlotIdToCellMap, referenceObjectForEquatableTestScenarios.DefaultSlotId, referenceObjectForEquatableTestScenarios.Id, referenceObjectForEquatableTestScenarios.ColumnsSpanned, referenceObjectForEquatableTestScenarios.Details), }, ObjectsThatAreNotEqualToReferenceObject = new SlottedCell[] { new SlottedCell( referenceObjectForEquatableTestScenarios.SlotIdToCellMap, referenceObjectForEquatableTestScenarios.DefaultSlotId, A.Dummy <SlottedCell>().Whose(_ => !_.Id.IsEqualTo(referenceObjectForEquatableTestScenarios.Id)).Id, referenceObjectForEquatableTestScenarios.ColumnsSpanned, referenceObjectForEquatableTestScenarios.Details), new SlottedCell( referenceObjectForEquatableTestScenarios.SlotIdToCellMap, referenceObjectForEquatableTestScenarios.DefaultSlotId, referenceObjectForEquatableTestScenarios.Id, referenceObjectForEquatableTestScenarios.ColumnsSpanned, A.Dummy <SlottedCell>().Whose(_ => !_.Details.IsEqualTo(referenceObjectForEquatableTestScenarios.Details)).Details), new SlottedCell( referenceObjectForEquatableTestScenarios.SlotIdToCellMap, referenceObjectForEquatableTestScenarios.DefaultSlotId, referenceObjectForEquatableTestScenarios.Id, null, referenceObjectForEquatableTestScenarios.Details), new SlottedCell( new Dictionary <string, INotSlottedCell> { { "abc", new NullCell(columnsSpanned: 1) }, { "def", new NullCell(columnsSpanned: 1) }, }, referenceObjectForEquatableTestScenarios.DefaultSlotId, referenceObjectForEquatableTestScenarios.Id, referenceObjectForEquatableTestScenarios.ColumnsSpanned, referenceObjectForEquatableTestScenarios.Details), new SlottedCell( referenceObjectForEquatableTestScenarios.SlotIdToCellMap, "abc", referenceObjectForEquatableTestScenarios.Id, referenceObjectForEquatableTestScenarios.ColumnsSpanned, referenceObjectForEquatableTestScenarios.Details), }, ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[] { A.Dummy <object>(), A.Dummy <string>(), A.Dummy <int>(), A.Dummy <int?>(), A.Dummy <Guid>(), A.Dummy <ConstCell <Version> >(), A.Dummy <InputCell <Version> >(), A.Dummy <NullCell>(), A.Dummy <OperationCell <Version> >(), }, }); }); }