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); }