public void BuilderIsCorrect()
{
// Fixture setup
var expected = new DelegatingSpecimenBuilder();
var sut = new NodeComposer<Guid>(expected);
// Exercise system
ISpecimenBuilder actual = sut.Builder;
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void SutYieldsDecoratedBuilder()
{
// Fixture setup
var expected = new DelegatingSpecimenBuilder();
// Exercise system
var sut = new NodeComposer<Guid>(expected);
// Verify outcome
Assert.True(new[] { expected }.SequenceEqual(sut));
Assert.True(new object[] { expected }.SequenceEqual(
((System.Collections.IEnumerable)sut).Cast<object>()));
// Teardown
}
public void CreateComposerReturnsCorrectResult()
{
// Fixture setup
// Exercise system
NodeComposer<int> actual =
SpecimenBuilderNodeFactory.CreateComposer<int>();
// Verify outcome
var expected = new NodeComposer<int>(
SpecimenBuilderNodeFactory.CreateTypedNode(
typeof(int),
new MethodInvoker(
new ModestConstructorQuery())));
Assert.True(expected.GraphEquals(actual, new NodeComparer()));
// Teardown
}
public void FromTripleArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <decimal>();
Func <int, Guid, Version, decimal> f = (i, g, v) => i;
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var factory = new SpecimenFactory <int, Guid, Version, decimal>(f);
var expected = new NodeComposer <decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromNoArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <long>();
Func <long> f = () => 0;
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var factory = new SpecimenFactory <long>(f);
var expected = new NodeComposer <long>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(long), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromSeedReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <decimal>();
Func <decimal, decimal> f = d => d;
// Exercise system
var actual = sut.FromSeed(f);
// Verify outcome
var factory = new SeededFactory <decimal>(f);
var expected = new NodeComposer <decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <Version>();
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 factory = new SpecimenFactory <int, int, int, int, Version>(f);
var expected = new NodeComposer <Version>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Version), factory));
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 NodeComposer<object>(builder);
// Exercise system
var actual = sut.Create(request, context);
// Verify outcome
Assert.Equal(expected, actual);
// 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 NodeComposer <object>(builder);
// Act
var actual = sut.Create(request, context);
// Assert
Assert.Equal(expected, actual);
}
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()
};
var sut = new NodeComposer <object>(builder);
// Exercise system
var actual = sut.Create(request, context);
// Verify outcome
Assert.Equal(expected, actual);
// Teardown
}
public void WithExplicitValueReturnsCorrectResult(string value)
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >();
var pi = typeof(PropertyHolder <string>).GetProperty("Property");
// Exercise system
var actual = sut.With(x => x.Property, value);
// Verify outcome
var expected = new NodeComposer <PropertyHolder <string> >(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor(
new Postprocessor(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(PropertyHolder <string>)))),
new AutoPropertiesCommand(
typeof(PropertyHolder <string>),
new InverseRequestSpecification(
new EqualRequestSpecification(
pi,
new MemberInfoEqualityComparer()))),
new FalseRequestSpecification()
),
new BindingCommand <PropertyHolder <string>, string>(x => x.Property, value),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder <string>)),
new ExactTypeSpecification(typeof(PropertyHolder <string>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder <string>)),
new ExactTypeSpecification(typeof(PropertyHolder <string>)))));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void WithExplicitSingleArgValueFactoryReturnsCorrectResult()
{
// Arrange
var sut = SpecimenBuilderNodeFactory.CreateComposer <PropertyHolder <string> >();
var pi = typeof(PropertyHolder <string>).GetProperty("Property");
Func <string, string> valueFactory = v => v;
// Act
var actual = sut.With(x => x.Property, valueFactory);
// Assert
var expected = new NodeComposer <PropertyHolder <string> >(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor(
new Postprocessor(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(PropertyHolder <string>)))),
new AutoPropertiesCommand(
typeof(PropertyHolder <string>),
new InverseRequestSpecification(
new EqualRequestSpecification(
pi,
new MemberInfoEqualityComparer()))),
new FalseRequestSpecification()),
new BindingCommand <PropertyHolder <string>, string>(x => x.Property, ctx => valueFactory((string)ctx.Resolve(typeof(string)))),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder <string>)),
new ExactTypeSpecification(typeof(PropertyHolder <string>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder <string>)),
new ExactTypeSpecification(typeof(PropertyHolder <string>)))));
var n = Assert.IsAssignableFrom <ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
}
public void FromNoArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<long>();
Func<long> f = () => 0;
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var factory = new SpecimenFactory<long>(f);
var expected = new NodeComposer<long>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(long), factory));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void WithAutoPropertiesTrueFollowedByFromFactoryReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<string>>();
Func<PropertyHolder<string>> f =
() => new PropertyHolder<string>();
// Exercise system
var actual = sut.WithAutoProperties(true).FromFactory(f);
// Verify outcome
var expected = new NodeComposer<PropertyHolder<string>>(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor<PropertyHolder<string>>(
new NoSpecimenOutputGuard(
new SpecimenFactory<PropertyHolder<string>>(f),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(PropertyHolder<string>)))),
new AutoPropertiesCommand<PropertyHolder<string>>().Execute,
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<string>)),
new ExactTypeSpecification(typeof(PropertyHolder<string>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<string>)),
new ExactTypeSpecification(typeof(PropertyHolder<string>)))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void WithoutReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<FieldHolder<short>>();
var fi = typeof(FieldHolder<short>).GetField("Field");
// Exercise system
var actual = sut.Without(x => x.Field);
// Verify outcome
var expected = new NodeComposer<FieldHolder<short>>(
new CompositeSpecimenBuilder(
new Omitter(
new EqualRequestSpecification(
fi,
new MemberInfoEqualityComparer())),
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(FieldHolder<short>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(FieldHolder<short>)),
new ExactTypeSpecification(typeof(FieldHolder<short>))))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void SuccessiveWithValueReturnsCorrectResult(
string value1,
int value2)
{
// Fixture setup
var sut =
SpecimenBuilderNodeFactory.CreateComposer<DoublePropertyHolder<string, int>>();
var pi1 = typeof(DoublePropertyHolder<string, int>).GetProperty("Property1");
var pi2 = typeof(DoublePropertyHolder<string, int>).GetProperty("Property2");
// Exercise system
var actual = sut
.With(x => x.Property1, value1)
.With(x => x.Property2, value2);
// Verify outcome
var expected = new NodeComposer<DoublePropertyHolder<string, int>>(
new CompositeSpecimenBuilder(
new Omitter(
new EqualRequestSpecification(
pi2,
new MemberInfoEqualityComparer())),
new CompositeSpecimenBuilder(
new Omitter(
new EqualRequestSpecification(
pi1,
new MemberInfoEqualityComparer())),
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor<DoublePropertyHolder<string, int>>(
new Postprocessor<DoublePropertyHolder<string, int>>(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(DoublePropertyHolder<string, int>)))),
new BindingCommand<DoublePropertyHolder<string, int>, string>(x => x.Property1, value1).Execute,
new OrRequestSpecification(
new SeedRequestSpecification(typeof(DoublePropertyHolder<string, int>)),
new ExactTypeSpecification(typeof(DoublePropertyHolder<string, int>)))),
new BindingCommand<DoublePropertyHolder<string, int>, int>(x => x.Property2, value2).Execute,
new OrRequestSpecification(
new SeedRequestSpecification(typeof(DoublePropertyHolder<string, int>)),
new ExactTypeSpecification(typeof(DoublePropertyHolder<string, int>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(DoublePropertyHolder<string, int>)),
new ExactTypeSpecification(typeof(DoublePropertyHolder<string, int>)))))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public NodeComposerEquatable(NodeComposer <T> item)
: base(item)
{
}
public void WithAutoPropertiesTrueFollowedByDoReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<int>>();
Action<PropertyHolder<int>> a = ph => ph.Property = 42;
// Exercise system
var actual = sut.WithAutoProperties(true).Do(a);
// Verify outcome
var expected = new NodeComposer<PropertyHolder<int>>(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor<PropertyHolder<int>>(
new Postprocessor<PropertyHolder<int>>(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(PropertyHolder<int>)))),
a),
new AutoPropertiesCommand<PropertyHolder<int>>().Execute,
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<int>)),
new ExactTypeSpecification(typeof(PropertyHolder<int>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<int>)),
new ExactTypeSpecification(typeof(PropertyHolder<int>)))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromSpecimenBuilderFactoryReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<Guid>();
var builder = new DelegatingSpecimenBuilder();
// Exercise system
var actual = sut.FromFactory(builder);
// Verify outcome
var expected = new NodeComposer<Guid>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Guid), builder));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromSeedReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<decimal>();
Func<decimal, decimal> f = d => d;
// Exercise system
var actual = sut.FromSeed(f);
// Verify outcome
var factory = new SeededFactory<decimal>(f);
var expected = new NodeComposer<decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void SutIsCorrectInitialGraph()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<int>();
// Exercise system
// Verify outcome
var factory = new MethodInvoker(new ModestConstructorQuery());
var expected = new NodeComposer<int>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(int), factory));
Assert.True(expected.GraphEquals(sut, new NodeComparer()));
// Teardown
}
public void FromTripleArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<decimal>();
Func<int, Guid, Version, decimal> f = (i, g, v) => i;
// Exercise system
var actual = sut.FromFactory(f);
// Verify outcome
var factory = new SpecimenFactory<int, Guid, Version, decimal>(f);
var expected = new NodeComposer<decimal>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(decimal), factory));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void FromQuadrupleArgFuncReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<Version>();
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 factory = new SpecimenFactory<int, int, int, int, Version>(f);
var expected = new NodeComposer<Version>(
SpecimenBuilderNodeFactory.CreateTypedNode(typeof(Version), factory));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
public void DoReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<AppDomainSetup>();
Action<AppDomainSetup> a = ads => ads.DisallowApplicationBaseProbing = false;
// Exercise system
var actual = sut.Do(a);
// Verify outcome
var expected = new NodeComposer<AppDomainSetup>(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor<AppDomainSetup>(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(AppDomainSetup)))),
a),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(AppDomainSetup)),
new ExactTypeSpecification(typeof(AppDomainSetup)))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}
protected override bool EqualsInstance(NodeComposer <T> other)
{
return(true);
}
public void WithAnonymousValueReturnsCorrectResult()
{
// Fixture setup
var sut = SpecimenBuilderNodeFactory.CreateComposer<PropertyHolder<int>>();
// Exercise system
var actual = sut.With(x => x.Property);
// Verify outcome
var expected = new NodeComposer<PropertyHolder<int>>(
new FilteringSpecimenBuilder(
new CompositeSpecimenBuilder(
new Postprocessor<PropertyHolder<int>>(
new NoSpecimenOutputGuard(
new MethodInvoker(
new ModestConstructorQuery()),
new InverseRequestSpecification(
new SeedRequestSpecification(
typeof(PropertyHolder<int>)))),
new BindingCommand<PropertyHolder<int>, int>(x => x.Property),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<int>)),
new ExactTypeSpecification(typeof(PropertyHolder<int>)))),
new SeedIgnoringRelay()),
new OrRequestSpecification(
new SeedRequestSpecification(typeof(PropertyHolder<int>)),
new ExactTypeSpecification(typeof(PropertyHolder<int>)))));
var n = Assert.IsAssignableFrom<ISpecimenBuilderNode>(actual);
Assert.True(expected.GraphEquals(n, new NodeComparer()));
// Teardown
}