public void ReturnsConstructorsWithWithExpectedAccessibility()
{
// Arrange
var sut = new AccessibleMembers(source, Accessibility.ProtectedInternal);
Constructor[] expected =
{
new Constructor(ConstructorInfo(MethodAttributes.FamORAssem | MethodAttributes.Static)),
new Constructor(ConstructorInfo(MethodAttributes.FamORAssem | MethodAttributes.Static)),
};
Constructor[] all =
{
new Constructor(ConstructorInfo(MethodAttributes.Public | MethodAttributes.Static)),
expected[0],
new Constructor(ConstructorInfo(MethodAttributes.Family | MethodAttributes.Static)),
expected[1],
new Constructor(ConstructorInfo(MethodAttributes.Private | MethodAttributes.Static)),
};
ConfiguredCall arrange = source.Constructors().Returns(all);
// Act
IEnumerable <Constructor> actual = sut.Constructors();
// Assert
Assert.Equal(expected, actual);
}
static Member <MemberInfo> Member(Type?declaringType = default)
{
MemberInfo info = Substitute.For <MemberInfo>();
ConfiguredCall arrange = info.DeclaringType.Returns(declaringType ?? typeof(UnexpectedType));
return(new TestMember(info));
}
public void ReturnsEventsWithWithExpectedAccessibilityOfAddMethod()
{
// Arrange
var sut = new AccessibleMembers(source, Accessibility.ProtectedInternal);
Event[] expected =
{
new Event(EventInfo(MethodAttributes.FamORAssem | MethodAttributes.Static)),
new Event(EventInfo(MethodAttributes.FamORAssem | MethodAttributes.Static)),
};
Event[] all =
{
new Event(EventInfo(MethodAttributes.Public | MethodAttributes.Static)),
expected[0],
new Event(EventInfo(MethodAttributes.Family | MethodAttributes.Static)),
expected[1],
new Event(EventInfo(MethodAttributes.Private | MethodAttributes.Static)),
};
ConfiguredCall arrange = source.Events().Returns(all);
// Act
IEnumerable <Event> actual = sut.Events();
// Assert
Assert.Equal(expected, actual);
}
public void ReturnsFieldsWithWithExpectedAccessibility()
{
// Arrange
var sut = new AccessibleMembers(source, Accessibility.ProtectedInternal);
Field[] expected =
{
new Field(FieldInfo(FieldAttributes.FamORAssem | FieldAttributes.Static)),
new Field(FieldInfo(FieldAttributes.FamORAssem | FieldAttributes.Static)),
};
Field[] all =
{
new Field(FieldInfo(FieldAttributes.Public | FieldAttributes.Static)),
expected[0],
new Field(FieldInfo(FieldAttributes.Family | FieldAttributes.Static)),
expected[1],
new Field(FieldInfo(FieldAttributes.Private | FieldAttributes.Static)),
};
ConfiguredCall arrange = source.Fields().Returns(all);
// Act
IEnumerable <Field> actual = sut.Fields();
// Assert
Assert.Equal(expected, actual);
}
public Int16ExtensionsTest()
{
spec = Substitute.ForPartsOf <FuzzyRange <short> >(fuzzy, short.MinValue, short.MaxValue);
FuzzyContext.Set(value, spec);
ConfiguredCall arrange = fuzzy.Build(spec).Returns(newValue);
}
static Member <MemberInfo> Member(string?name = default)
{
MemberInfo info = Substitute.For <MemberInfo>();
ConfiguredCall arrange = info.Name.Returns(name ?? Guid.NewGuid().ToString());
return(new TestMember(info));
}
public StringExtensionsTest()
{
spec = new FuzzyString(fuzzy);
FuzzyContext.Set(value, spec);
ConfiguredCall arrange = fuzzy.Build(spec).Returns(newValue);
}
public DateTimeExtensionsTest()
{
spec = Substitute.ForPartsOf <FuzzyRange <DateTime> >(fuzzy, DateTime.MinValue, DateTime.MaxValue);
FuzzyContext.Set(value, spec);
ConfiguredCall arrange = fuzzy.Build(spec).Returns(newValue);
}
public void ReturnsMembersWithMatchingDeclaringType()
{
Member <MemberInfo>[] expected = new[] { Member(declaringType), Member(declaringType) };
IEnumerable <Member <MemberInfo> > mixed = new[] { Member(), expected[0], Member(), expected[1], Member() };
ConfiguredCall arrange = source.GetEnumerator().Returns(mixed.GetEnumerator());
Assert.Equal(expected, sut);
}
public void ReturnsRangeInitializedWithGivenMinimumAndMaximumValues()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == maximum)).Returns(builtValue);
var sut = TestSize.Between(minimum, maximum);
Assert.Equal(builtValue, sut.Build(fuzzy));
}
public void GetReturnsParametersWithGivenParameterType()
{
var expected = new ParameterInfo[] { ParameterInfo(parameterType), ParameterInfo(parameterType) };
IEnumerable <ParameterInfo> mixed = new ParameterInfo[] { ParameterInfo(), expected[0], ParameterInfo(), expected[1], ParameterInfo() };
ConfiguredCall arrange = parameters.GetEnumerator().Returns(mixed.GetEnumerator());
Assert.Equal(expected, sut);
}
public void ReturnsRangeInitializedWithGivenValueValue()
{
int expected = random.Next();
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == expected && s.Maximum == expected)).Returns(builtValue);
var sut = TestSize.Exactly(expected);
Assert.Equal(builtValue, sut.Build(fuzzy));
}
public void ReturnsFuzzyInt32WhenMinimumIsMoreThanDefaultMaximum(int minimum, int expectedMaximum)
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == expectedMaximum)).Returns(builtValue);
Size <TestSize> sut = TestSize.Min(minimum);
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
public void ReturnsFuzzyInt32WithDefaultMinimumAndMaximum()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == 8 && s.Maximum == 13)).Returns(builtValue);
Size <TestSize> sut = new TestSize();
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
public void ReturnsElementAtFuzzyIndex() {
int expectedIndex = random.Next() % candidates.Count();
Expression<Predicate<FuzzyIndex<TestStruct>>> fuzzyIndex = f => ReferenceEquals(candidates, f.Field<IEnumerable<TestStruct>>().Value);
ConfiguredCall arrange = fuzzy.Build(Arg.Is(fuzzyIndex)).Returns(expectedIndex);
TestStruct actual = sut.Build();
Assert.Equal(candidates.ElementAt(expectedIndex), actual);
}
public void StoresValueAndSpecInFuzzyContext()
{
var value = new TestClass();
ConfiguredCall arrange = spec.Build().Returns(value);
TestClass act = sut.Build(spec);
Assert.Same(spec, FuzzyContext.Get <TestClass, Fuzzy <TestClass> >(value));
}
public void ReturnsFuzzyInt32WithGivenMinimumAndMaximum()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == maximum)).Returns(builtValue);
Size <TestSize> sut = TestSize.Between(minimum, maximum);
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
public void ReturnsValueBuiltBySpec()
{
var expected = new TestClass();
ConfiguredCall arrange = spec.Build().Returns(expected);
TestClass actual = sut.Build(spec);
Assert.Same(expected, actual);
}
public void ReturnsUriBasedOnNextFuzzyValue()
{
int next = random.Next();
ConfiguredCall arrange = fuzzy.Next().Returns(next);
Uri actual = sut.Build();
Assert.Equal($"https://fuzzy{next}/", actual.ToString());
}
public void ReturnsSingleInstanceGottenFromFilter()
{
var expected = new TestType();
ConfiguredCall arrange = enumerable.GetEnumerator().Returns(new[] { expected }.Cast <TestType>().GetEnumerator());
TestType actual = Selector <TestType> .Select(enumerable);
Assert.Same(expected, actual);
}
void ArrangeBuildOfFuzzyRange <T>(Func <T> generate) where T : struct, IComparable <T>
{
ConfiguredCall arrange = fuzzy.Build(Arg.Any <FuzzyRange <T> >())
.Returns(call => {
T initial = generate();
FuzzyContext.Set(initial, (FuzzyRange <T>)call[0]);
return(initial);
});
}
protected override void AssertExpectedFuzzyElementFactory()
{
var expected = new TestStruct(random.Next());
Expression <Predicate <FuzzyElement <TestStruct> > > fuzzyElement = f => ReferenceEquals(elements, f.Field <IEnumerable <TestStruct> >().Value);
ConfiguredCall arrange = fuzzy.Build(Arg.Is(fuzzyElement)).Returns(expected);
TestStruct actual = spec !.Field <Func <TestStruct> >().Value !();
Assert.Equal(expected, actual);
}
public void ReturnsIndexWithinBoundsOfCollection()
{
int expected = random.Next() % elements.Count();
Expression <Predicate <FuzzyRange <int> > > fuzzyInt = v => v.Minimum == 0 && v.Maximum == elements.Count() - 1;
ConfiguredCall arrange = fuzzy.Build(Arg.Is(fuzzyInt)).Returns(expected);
int actual = sut.Build();
Assert.Equal(expected, actual);
}
public void CalculatesValueBasedOnMinimumMaximumAndNextSample(ushort minimum, ushort maximum, int next, ushort expected)
{
sut.Minimum = minimum;
sut.Maximum = maximum;
ConfiguredCall arrange = fuzzy.Next().Returns(next);
ushort actual = sut.Build();
Assert.Equal(expected, actual);
}
public IComparableExtensionsTest() {
value = new TestStruct(random.Next());
spec = Substitute.ForPartsOf<FuzzyRange<TestStruct>>(fuzzy, new TestStruct(int.MinValue), new TestStruct(int.MaxValue));
minimum = new TestStruct(int.MinValue + random.Next() % short.MaxValue);
maximum = new TestStruct(int.MaxValue - random.Next() % short.MaxValue);
newValue = new TestStruct(random.Next());
FuzzyContext.Set(value, spec);
ConfiguredCall arrange = fuzzy.Build(spec).Returns(newValue);
}
public void ReturnsValueBuiltByFuzzyBoolean(bool expectedValue)
{
FuzzyBoolean? actualSpec = null;
ConfiguredCall arrange = fuzzy.Build(Arg.Do <FuzzyBoolean>(spec => actualSpec = spec)).Returns(expectedValue);
bool actualValue = fuzzy.Boolean();
Assert.Equal(expectedValue, actualValue);
Assert.Same(fuzzy, actualSpec !.Field <IFuzz>().Value);
}
public void ReturnsValueReturnedBySelector()
{
var filter = Substitute.For <IEnumerable <TestType> >();
var expected = new TestType();
ConfiguredCall arrange = select.Invoke(filter).Returns(expected);
TestType actual = filter.Single();
Assert.Same(expected, actual);
}
public void ReturnsFuzzyUInt16ValueConvertedToByte()
{
sut.Minimum = (byte)(random.Next() % sbyte.MaxValue);
sut.Maximum = (byte)(sut.Minimum + random.Next() % sbyte.MaxValue);
var expected = (ushort)(random.Next() % byte.MaxValue);
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <ushort> >(s => s.Minimum == sut.Minimum && s.Maximum == sut.Maximum)).Returns(expected);
byte actual = sut.Build();
Assert.Equal(expected, actual);
}
public void ReturnsDoubleValueComputedFromFuzzySignMantissaAndExponent(bool positive, ulong mantissa, short exponent, double expected)
{
ConfiguredCall arrange = fuzzy.Build(Arg.Any <Fuzzy <bool> >()).Returns(positive);
arrange = fuzzy.Build(Arg.Is <FuzzyRange <ulong> >(x => x.Minimum == 1 && x.Maximum == Math.Pow(2, 53) - 1)).Returns(mantissa);
arrange = fuzzy.Build(Arg.Is <FuzzyRange <short> >(x => x.Minimum == -1076 && x.Maximum == 972)).Returns(exponent);
double actual = sut.Build();
Assert.Equal(expected, actual);
}
public void ReturnsValueBuiltByFuzzyDateTimeOffset()
{
FuzzyDateTimeOffset?actualSpec = null;
var expectedValue = new System.DateTimeOffset(random.Next(), System.TimeSpan.Zero);
ConfiguredCall arrange = fuzzy.Build(Arg.Do <FuzzyDateTimeOffset>(spec => actualSpec = spec)).Returns(expectedValue);
System.DateTimeOffset actualValue = fuzzy.DateTimeOffset();
Assert.Equal(expectedValue, actualValue);
Assert.Same(fuzzy, actualSpec !.Field <IFuzz>().Value);
}
