public void UseSuccessfulConstructor(
FakedClass fake)
{
"Given a class with multiple constructors"
.See <FakedClass>();
"And the parameterless constructor throws"
.See(() => new FakedClass());
"And the class has a one-parameter constructor"
.See(() => new FakedClass(A.Dummy <IDisposable>()));
"And the class has a two-parameter constructor"
.See(() => new FakedClass(A.Dummy <IDisposable>(), A.Dummy <string>()));
"When I create a fake of the class"
.x(() => fake = this.CreateFake <FakedClass>());
"Then the fake is instantiated using the two-parameter constructor"
.x(() => fake.WasTwoParameterConstructorCalled.Should().BeTrue());
"And the fake doesn't remember the failing constructor call"
.x(() => fake.WasParameterlessConstructorCalled
.Should().BeFalse("because the parameterless constructor was called for a different fake object"));
"And the one-parameter constructor was not tried"
.x(() => FakedClass.ParameterListLengthsForAttemptedConstructors.Should().BeEquivalentTo(0, 2));
}
public static void EqualsSameFake(FakedClass fake, bool equalsResult)
{
"Given a faked class instance"
.x(() => fake = A.Fake <FakedClass>());
"When I compare it to itself using Equals"
.x(() => equalsResult = fake.Equals(fake));
"Then it compares as equal"
.x(() => equalsResult.Should().BeTrue());
}
public static void ToStringDescribesFake(FakedClass fake, string toStringValue)
{
"Given a faked class instance"
.x(() => fake = A.Fake <FakedClass>());
"When I call ToString on it"
.x(() => toStringValue = fake.ToString());
"Then it indicates that it's a fake"
.x(() => toStringValue.Should().Be("Faked FakeItEasy.Specs.UnconfiguredFakeSpecs+FakedClass"));
}
public void UseSuccessfulConstructor(
FakedClass fake,
IEnumerable <int> parameterListLengthsForAttemptedConstructors)
{
"Given a class with multiple constructors"
.See <FakedClass>();
"And the parameterless constructor throws"
.See(() => new FakedClass());
"And the class has a one-parameter constructor"
.See(() => new FakedClass(default));
public static void EqualsDifferentInstanceOfSameFakedType(FakedClass fake1, FakedClass fake2, bool equalsResult)
{
"Given a faked class instance"
.x(() => fake1 = A.Fake <FakedClass>());
"And a second faked class instance of the same type"
.x(() => fake2 = A.Fake <FakedClass>());
"When I compare the instances using Equals"
.x(() => equalsResult = fake1.Equals(fake2));
"Then they compare as unequal"
.x(() => equalsResult.Should().BeFalse());
}
public static void UseSuccessfulConstructor(
FakedClass fake)
{
"When faking a class whose first constructor fails"
.x(() => fake = A.Fake <FakedClass>());
"It should instantiate the fake using the successful constructor with the longest parameter list"
.x(() => fake.WasTwoParameterConstructorCalled.Should().BeTrue());
"And the fake should not remember the failing constructor call"
.x(() => fake.WasParameterlessConstructorCalled
.Should().BeFalse("because the parameterless constructor was called for a different fake object"));
"And it should only have tried the parameterless constructor and one with the longest parameter list"
.x(() => FakedClass.ParameterListLengthsForAttemptedConstructors.Should().BeEquivalentTo(0, 2));
}
public static void FakeableProperty(
FakedClass fake,
IFoo result)
{
"Given a type with a virtual fakeable-type property"
.x(() => { }); // see FakedClasss
"And a fake of that type"
.x(() => fake = A.Fake <FakedClass>());
"When I get the property value"
.x(() => result = fake.FakeableProperty);
"Then the value will be a Dummy"
.x(() => result.IsADummy.Should().BeTrue("because the property value should be a Dummy"));
}
public void UseSuccessfulConstructor(
FakedClass fake)
{
"when faking a class whose first constructor fails"
.x(() => fake = A.Fake<FakedClass>());
"it should instantiate the fake using the successful constructor with the longest parameter list"
.x(() => fake.WasTwoParameterConstructorCalled.Should().BeTrue());
"it should instantiate a fake that does not remember the failing constructor call"
.x(() => fake.WasParameterlessConstructorCalled
.Should().BeFalse("because the parameterless constructor was called for a different fake object"));
"it should only have tried the parameterless constructor and one with the longest parameter list"
.x(() => FakedClass.ParameterListLengthsForAttemptedConstructors.Should().BeEquivalentTo(0, 2));
}
public void VirtualProperties(
FakedClass fake)
{
"when faking a class with virtual properties"
.x(() => fake = A.Fake<FakedClass>());
"it should return a default value when a reference type property is called during the constructor"
.x(() => fake.StringPropertyValueDuringConstructorCall.Should().Be(string.Empty));
// The test for the default value of a value type is a regression test for https://github.com/FakeItEasy/FakeItEasy/issues/368:
"it should return a default value when a value type property is called during the constructor"
.x(() => fake.ValueTypePropertyValueDuringConstructorCall.Should().Be(0));
"it should return the value assigned during constructor when a reference type property is gotten after the constructor"
.x(() => fake.StringProperty.Should().Be("value set in constructor"));
"it should return the value assigned during constructor when a value type property is gotten after the constructor"
.x(() => fake.ValueTypeProperty.Should().Be(123456));
}
public static void VirtualReferenceTypeProperty(
FakedClass fake,
string result)
{
"Given a type with a default constructor"
.x(() => { }); // see FakedClass
"And the constructor assigns a value to a virtual reference-type property"
.x(() => { }); // see FakedClass.ctor()
"And a fake of that type"
.x(() => fake = A.Fake <FakedClass>());
"When I fetch the property value"
.x(() => result = fake.StringProperty);
"Then it will be the value assigned during construction"
.x(() => result.Should().Be("value set in constructor"));
}
public static void VirtualProperties(
FakedClass fake)
{
"when faking a class with virtual properties"
.x(() => fake = A.Fake <FakedClass>());
"it should return a default value when a reference type property is called during the constructor"
.x(() => fake.StringPropertyValueDuringConstructorCall.Should().Be(string.Empty));
// The test for the default value of a value type is a regression test for https://github.com/FakeItEasy/FakeItEasy/issues/368:
"it should return a default value when a value type property is called during the constructor"
.x(() => fake.ValueTypePropertyValueDuringConstructorCall.Should().Be(0));
"it should return the value assigned during constructor when a reference type property is gotten after the constructor"
.x(() => fake.StringProperty.Should().Be("value set in constructor"));
"it should return the value assigned during constructor when a value type property is gotten after the constructor"
.x(() => fake.ValueTypeProperty.Should().Be(123456));
}
public static void VirtualPropertiesCalledDuringConstruction(
FakedClass fake)
{
"Given a type with a default constructor"
.x(() => { }); // see FakedClass
"And the constructor calls some virtual properties"
.x(() => { }); // see FakedClass.ctor()
"And the properties return non-default values"
.x(() => { }); // see FakedClass.StringProperty, FakedClass.ValueTypeProperty
"When I create a fake of the type"
.x(() => fake = A.Fake <FakedClass>());
"Then the reference-type property will return a default value"
.x(() => fake.StringPropertyValueDuringConstructorCall.Should().Be(string.Empty));
"And the value-type property will return a default value"
.x(() => fake.ValueTypePropertyValueDuringConstructorCall.Should().Be(0));
}
public void UseSuccessfulConstructor(
FakedClass fake,
IEnumerable <int> parameterListLengthsForAttemptedConstructors)
{
"Given a class with multiple constructors"
.See <FakedClass>();
"And the parameterless constructor throws"
.See(() => new FakedClass());
"And the class has a one-parameter constructor"
.See(() => new FakedClass(new ArgumentThatShouldNeverBeResolved()));
"And the class has a two-parameter constructor"
.See(() => new FakedClass(A.Dummy <IDisposable>(), string.Empty));
"When I create a fake of the class"
.x(() =>
{
lock (FakedClass.ParameterListLengthsForAttemptedConstructors)
{
FakedClass.ParameterListLengthsForAttemptedConstructors.Clear();
fake = this.CreateFake <FakedClass>();
parameterListLengthsForAttemptedConstructors = new List <int>(FakedClass.ParameterListLengthsForAttemptedConstructors);
}
});
"Then the fake is instantiated using the two-parameter constructor"
.x(() => fake.WasTwoParameterConstructorCalled.Should().BeTrue());
"And the fake doesn't remember the failing constructor call"
.x(() => fake.WasParameterlessConstructorCalled
.Should().BeFalse("because the parameterless constructor was called for a different fake object"));
"And the one-parameter constructor was not tried"
.x(() => parameterListLengthsForAttemptedConstructors.Should().NotContain(1));
"And the argument for the unused constructor was never resolved"
.x(() => ArgumentThatShouldNeverBeResolved.WasResolved.Should().BeFalse());
}