public void DoReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>(),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <ConcreteType>(node);
Action <ConcreteType> a =
ads => ads.Property1 = null;
// Act
var actual = sut.Do(a);
// Assert
var expected = new CompositeNodeComposer <ConcreteType>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>().Do(a),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <ConcreteType>().Do(a),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void WithSingleArgValueFactoryReturnsCorrectResult(string value)
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <PropertyHolder <string> >(node);
Func <string, string> valueFactory = _ => value;
// Act
var actual = sut.With(x => x.Property, valueFactory);
// Assert
var expected = new CompositeNodeComposer <PropertyHolder <string> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, valueFactory),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, valueFactory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromTripleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <long>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <long>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <long>(node);
Func <long, int, short, long> f = (x, y, z) => x;
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <long>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <long>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <long>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromNoArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
SpecimenBuilderNodeFactory.CreateComposer <float>(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Guid>(node);
Func <Guid> f = () => Guid.Empty;
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <Guid>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Guid>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <float>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Guid>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <decimal>(node);
var factory = new DelegatingSpecimenBuilder();
// Act
var actual = sut.FromFactory(factory);
// Assert
var expected = new CompositeNodeComposer <decimal>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void OmitAutoPropertiesAfterAddingAutoPropertiesReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
// Exercise system
var actual = sut.WithAutoProperties().OmitAutoProperties();
// Verify outcome
var expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().WithAutoProperties().OmitAutoProperties(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().WithAutoProperties().OmitAutoProperties(),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void WithExplicitValueReturnsCorrectResult(string value)
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <PropertyHolder <string> >(node);
// Exercise system
var actual = sut.With(x => x.Property, value);
// Verify outcome
var expected = new CompositeNodeComposer <PropertyHolder <string> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, value),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >().With(x => x.Property, value),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromSingleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <ulong>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <string>(node);
Func <int, string> f = i => i.ToString();
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <string>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <string>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <ulong>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <string>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void DoReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>(),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <AppDomainSetup>(node);
Action <AppDomainSetup> a =
ads => ads.DisallowApplicationBaseProbing = false;
// Exercise system
var actual = sut.Do(a);
// Verify outcome
var expected = new CompositeNodeComposer <AppDomainSetup>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>().Do(a),
SpecimenBuilderNodeFactory.CreateComposer <bool>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <AppDomainSetup>().Do(a),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromDoubleArgFuncReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
Func <int, int, Version> f = (mj, mn) => new Version(mj, mn);
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <string>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
SpecimenBuilderNodeFactory.CreateComposer <decimal>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <decimal>(node);
var factory = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.FromFactory(factory);
// Verify outcome
var expected = new CompositeNodeComposer <decimal>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
SpecimenBuilderNodeFactory.CreateComposer <int>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <decimal>().FromFactory(factory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Arrange
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
SpecimenBuilderNodeFactory.CreateComposer <Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <Version>(node);
Func <int, int, int, int, Version> f =
(mj, mn, b, r) => new Version(mj, mn, b, r);
// Act
var actual = sut.FromFactory(f);
// Assert
var expected = new CompositeNodeComposer <Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer <Guid>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <Version>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void WithoutReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >(),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >(),
SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer <FieldHolder <short> >(node);
// Exercise system
var actual = sut.Without(x => x.Field);
// Verify outcome
var expected = new CompositeNodeComposer <FieldHolder <short> >(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >().Without(x => x.Field),
SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <int> >(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer <FieldHolder <short> >().Without(x => x.Field),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void SutIsComposer()
{
// Arrange
var dummyNode = new CompositeSpecimenBuilder();
// Act
var sut = new CompositeNodeComposer <object>(dummyNode);
// Assert
Assert.IsAssignableFrom <ICustomizationComposer <object> >(sut);
}
public void SutIsSpecimenBuilderNode()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer<float>(dummyNode);
// Verify outcome
Assert.IsAssignableFrom<ISpecimenBuilderNode>(sut);
// Teardown
}
public void SutIsComposer()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer<object>(dummyNode);
// Verify outcome
Assert.IsAssignableFrom<ICustomizationComposer<object>>(sut);
// Teardown
}
public void SutIsSpecimenBuilderNode()
{
// Arrange
var dummyNode = new CompositeSpecimenBuilder();
// Act
var sut = new CompositeNodeComposer <float>(dummyNode);
// Assert
Assert.IsAssignableFrom <ISpecimenBuilderNode>(sut);
}
public void LegacyComposeReturnsCorrectResult()
{
// Arrange
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <UTF8Encoding>(dummyNode);
// Act
var actual = sut.Compose();
// Assert
Assert.Equal(sut, actual);
}
public void SutIsSpecimenBuilderNode()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer <float>(dummyNode);
// Verify outcome
Assert.IsAssignableFrom <ISpecimenBuilderNode>(sut);
// Teardown
}
public void SutIsComposer()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer <object>(dummyNode);
// Verify outcome
Assert.IsAssignableFrom <ICustomizationComposer <object> >(sut);
// Teardown
}
public void NodeIsCorrect()
{
// Arrange
var expected = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <string>(expected);
// Act
ISpecimenBuilderNode actual = sut.Node;
// Assert
Assert.Equal(expected, actual);
}
public void NodeIsCorrect()
{
// Fixture setup
var expected = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <string>(expected);
// Exercise system
ISpecimenBuilderNode actual = sut.Node;
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void LegacyComposeReturnsCorrectResult()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <UTF8Encoding>(dummyNode);
// Exercise system
var actual = sut.Compose();
// Verify outcome
Assert.Equal(sut, actual);
// Teardown
}
public void SutYieldsDecoratedBuilder()
{
// Arrange
var expected = new CompositeSpecimenBuilder();
// Act
var sut = new CompositeNodeComposer <uint>(expected);
// Assert
Assert.True(new[] { expected }.SequenceEqual(sut));
Assert.True(new object[] { expected }.SequenceEqual(
((System.Collections.IEnumerable)sut).Cast <object>()));
}
public void SutYieldsDecoratedBuilder()
{
// Fixture setup
var expected = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer <uint>(expected);
// Verify outcome
Assert.True(new[] { expected }.SequenceEqual(sut));
Assert.True(new object[] { expected }.SequenceEqual(
((System.Collections.IEnumerable)sut).Cast <object>()));
// Teardown
}
public void CustomizeAndComposeComplexType()
{
// Arrange
// Act
var result = new CompositeNodeComposer <DoublePropertyHolder <int, decimal> >(
new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, decimal> >(),
Scenario.CreateAutoPropertyBuilder()))
.With(x => x.Property2, 8m).WithAutoProperties().Create();
// Assert
Assert.Equal(1, result.Property1);
Assert.Equal(8, result.Property2);
}
public void ComposeSingleNodeReturnsCorrectResult()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer<uint>(dummyNode);
ISpecimenBuilderNode expected = new CompositeSpecimenBuilder();
// Exercise system
var actual = sut.Compose(new[] { expected });
// Verify outcome
var c =
Assert.IsAssignableFrom<CompositeNodeComposer<uint>>(actual);
Assert.Equal(expected, c.Node);
// Teardown
}
public void ComposeSingleNodeReturnsCorrectResult()
{
// Arrange
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <uint>(dummyNode);
ISpecimenBuilderNode expected = new CompositeSpecimenBuilder();
// Act
var actual = sut.Compose(new[] { expected });
// Assert
var c =
Assert.IsAssignableFrom <CompositeNodeComposer <uint> >(actual);
Assert.Equal(expected, c.Node);
}
public void ComposeSingleNodeReturnsCorrectResult()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <uint>(dummyNode);
ISpecimenBuilderNode expected = new CompositeSpecimenBuilder();
// Exercise system
var actual = sut.Compose(new[] { expected });
// Verify outcome
var c =
Assert.IsAssignableFrom <CompositeNodeComposer <uint> >(actual);
Assert.Equal(expected, c.Node);
// Teardown
}
public void CustomizeAndComposeComplexType()
{
// Fixture setup
// Exercise system
var result = new CompositeNodeComposer <DoublePropertyHolder <int, decimal> >(
new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer <DoublePropertyHolder <int, decimal> >(),
Scenario.CreateAutoPropertyBuilder()
)
).With(x => x.Property2, 8m).WithAutoProperties().Create();
// Verify outcome
Assert.Equal(1, result.Property1);
Assert.Equal(8, result.Property2);
// Teardown
}
public void ComposeReturnsCorrectResult()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer<uint>(dummyNode);
// Exercise system
var expectedBuilders = new[]
{
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder()
};
var actual = sut.Compose(expectedBuilders);
// Verify outcome
var c =
Assert.IsAssignableFrom<CompositeNodeComposer<uint>>(actual);
var composite =
Assert.IsAssignableFrom<CompositeSpecimenBuilder>(c.Node);
Assert.True(expectedBuilders.SequenceEqual(composite));
// Teardown
}
public void CreateReturnsCorrectResult()
{
// Arrange
var request = new object();
var context = new DelegatingSpecimenContext();
var expected = new object();
var builder = new DelegatingSpecimenBuilder
{
OnCreate = (r, c) => r == request && c == context ?
expected :
new NoSpecimen()
};
var sut = new CompositeNodeComposer <ushort>(
new CompositeSpecimenBuilder(
builder));
// Act
var actual = sut.Create(request, context);
// Assert
Assert.Equal(expected, actual);
}
public void ComposeReturnsCorrectResult()
{
// Arrange
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer <uint>(dummyNode);
// Act
var expectedBuilders = new[]
{
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder()
};
var actual = sut.Compose(expectedBuilders);
// Assert
var c =
Assert.IsAssignableFrom <CompositeNodeComposer <uint> >(actual);
var composite =
Assert.IsAssignableFrom <CompositeSpecimenBuilder>(c.Node);
Assert.True(expectedBuilders.SequenceEqual(composite));
}
public void CreateReturnsCorrectResult()
{
// Fixture setup
var request = new object();
var context = new DelegatingSpecimenContext();
var expected = new object();
var builder = new DelegatingSpecimenBuilder
{
OnCreate = (r, c) => r == request && c == context ?
expected :
new NoSpecimen(r)
};
var sut = new CompositeNodeComposer <ushort>(
new CompositeSpecimenBuilder(
builder));
// Exercise system
var actual = sut.Create(request, context);
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<decimal>(),
SpecimenBuilderNodeFactory.CreateComposer<int>(),
SpecimenBuilderNodeFactory.CreateComposer<decimal>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<decimal>(node);
var factory = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.FromFactory(factory);
// Verify outcome
var expected = new CompositeNodeComposer<decimal>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<decimal>().FromFactory(factory),
SpecimenBuilderNodeFactory.CreateComposer<int>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<decimal>().FromFactory(factory),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void CreateReturnsCorrectResult()
{
// Fixture setup
var request = new object();
var context = new DelegatingSpecimenContext();
var expected = new object();
var builder = new DelegatingSpecimenBuilder
{
OnCreate = (r, c) => r == request && c == context ?
expected :
new NoSpecimen(r)
};
var sut = new CompositeNodeComposer<ushort>(
new CompositeSpecimenBuilder(
builder));
// Exercise system
var actual = sut.Create(request, context);
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void WithExplicitValueReturnsCorrectResult(string value)
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<string>>(),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<string>>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<PropertyHolder<string>>(node);
// Exercise system
var actual = sut.With(x => x.Property, value);
// Verify outcome
var expected = new CompositeNodeComposer<PropertyHolder<string>>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<string>>().With(x => x.Property, value),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<string>>().With(x => x.Property, value),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void OmitAutoPropertiesAfterAddingAutoPropertiesReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
SpecimenBuilderNodeFactory.CreateComposer<string>(),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<Version>(node);
// Exercise system
var actual = sut.WithAutoProperties().OmitAutoProperties();
// Verify outcome
var expected = new CompositeNodeComposer<Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<Version>().WithAutoProperties().OmitAutoProperties(),
SpecimenBuilderNodeFactory.CreateComposer<string>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<Version>().WithAutoProperties().OmitAutoProperties(),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void SutYieldsDecoratedBuilder()
{
// Fixture setup
var expected = new CompositeSpecimenBuilder();
// Exercise system
var sut = new CompositeNodeComposer<uint>(expected);
// Verify outcome
Assert.True(new[] { expected }.SequenceEqual(sut));
Assert.True(new object[] { expected }.SequenceEqual(
((System.Collections.IEnumerable)sut).Cast<object>()));
// Teardown
}
public void CustomizeAndComposeComplexType()
{
// Fixture setup
// Exercise system
var result = new CompositeNodeComposer<DoublePropertyHolder<int, decimal>>(
new CompositeSpecimenBuilder(
SpecimenBuilderNodeFactory.CreateComposer<DoublePropertyHolder<int, decimal>>(),
Scenario.CreateAutoPropertyBuilder()
)
).With(x => x.Property2, 8m).WithAutoProperties().CreateAnonymous();
// Verify outcome
Assert.Equal(1, result.Property1);
Assert.Equal(8, result.Property2);
// Teardown
}
public void FromSingleArgFuncReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<string>(),
SpecimenBuilderNodeFactory.CreateComposer<ulong>(),
SpecimenBuilderNodeFactory.CreateComposer<string>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<string>(node);
Func<int, string> f = i => i.ToString();
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var expected = new CompositeNodeComposer<string>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<string>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer<ulong>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<string>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
SpecimenBuilderNodeFactory.CreateComposer<Guid>(),
SpecimenBuilderNodeFactory.CreateComposer<Version>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<Version>(node);
Func<int, int, int , int, Version> f =
(mj, mn, b, r) => new Version(mj, mn, b, r);
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var expected = new CompositeNodeComposer<Version>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<Version>().FromFactory(f),
SpecimenBuilderNodeFactory.CreateComposer<Guid>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<Version>().FromFactory(f),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void LegacyComposeReturnsCorrectResult()
{
// Fixture setup
var dummyNode = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer<UTF8Encoding>(dummyNode);
// Exercise system
var actual = sut.Compose();
// Verify outcome
Assert.Equal(sut, actual);
// Teardown
}
public void DoReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<AppDomainSetup>(),
SpecimenBuilderNodeFactory.CreateComposer<bool>(),
SpecimenBuilderNodeFactory.CreateComposer<AppDomainSetup>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<AppDomainSetup>(node);
Action<AppDomainSetup> a =
ads => ads.DisallowApplicationBaseProbing = false;
// Exercise system
var actual = sut.Do(a);
// Verify outcome
var expected = new CompositeNodeComposer<AppDomainSetup>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<AppDomainSetup>().Do(a),
SpecimenBuilderNodeFactory.CreateComposer<bool>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<AppDomainSetup>().Do(a),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void NodeIsCorrect()
{
// Fixture setup
var expected = new CompositeSpecimenBuilder();
var sut = new CompositeNodeComposer<string>(expected);
// Exercise system
ISpecimenBuilderNode actual = sut.Node;
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void WithoutReturnsCorrectResult()
{
// Fixture setup
var node = new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
SpecimenBuilderNodeFactory.CreateComposer<FieldHolder<short>>(),
SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<int>>(),
SpecimenBuilderNodeFactory.CreateComposer<FieldHolder<short>>(),
new DelegatingSpecimenBuilder());
var sut = new CompositeNodeComposer<FieldHolder<short>>(node);
// Exercise system
var actual = sut.Without(x => x.Field);
// Verify outcome
var expected = new CompositeNodeComposer<FieldHolder<short>>(
new CompositeSpecimenBuilder(
new DelegatingSpecimenBuilder(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<FieldHolder<short>>().Without(x => x.Field),
SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<int>>(),
(ISpecimenBuilder)SpecimenBuilderNodeFactory.CreateComposer<FieldHolder<short>>().Without(x => x.Field),
new DelegatingSpecimenBuilder()));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
