public void IsEmpty_OnGenericCollectionSingleItem_ReturnsFalse() { var fixture = new MultipleMockingFixture(1); var singleItemCollection = fixture.Create<ICollection<object>>(); Assert.That(() => singleItemCollection.IsEmpty(), Is.False); }
public void NullableMin_OnSequence_WithNullSelector_ThrowsValidationException() { var fixture = new MultipleMockingFixture(); var sequence = fixture.Create<IEnumerable<GenericComparableStruct>>(); Func<GenericComparableStruct, GenericComparableStruct> nullFunc = null; Assert.That(() => sequence.NullableMin(nullFunc), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>()); }
public void IsEmpty_OnGenericCollectionEmpty_ReturnsTrue() { var fixture = new MultipleMockingFixture(); ICollection<object> emptyGenericCollection = fixture.Create<ICollection<object>>(); emptyGenericCollection.Clear(); Assert.That(() => emptyGenericCollection.IsEmpty(), Is.True); }
public void Exclude_OnEmptySequence_WithSequence_ReturnsEmptySequence() { var emptySequence = Enumerable.Empty<object>(); var fixture = new MultipleMockingFixture(); var sequence = fixture.Create<IEnumerable<object>>(); Assert.That(() => emptySequence.Exclude(sequence), Is.Empty); }
public void FlattenStrings_OnValidEnumerable_ReturnsCorrectString() { var fixture = new MultipleMockingFixture(); var testStrings = fixture.CreateMany<string>(5).ToList(); var expected = testStrings.Aggregate((result, current) => result + current); Assert.That(testStrings.FlattenStrings(), Is.EqualTo(expected)); }
public void Strip_OnEmptySource_WithMultiCharacters_ReturnsEmptyString() { var emptyString = string.Empty; var fixture = new MultipleMockingFixture(); var multipleCharacters = fixture.Create<IEnumerable<char>>(); Assert.That(() => emptyString.Strip(multipleCharacters), Is.Empty); }
public void ToHexString_OnValidArray_ConvertsToStringCorrectly() { var fixture = new MultipleMockingFixture(512); var validBytes = fixture.Create<byte[]>(); var expected = BitConverter.ToString(validBytes).Replace("-", string.Empty).ToLowerInvariant(); Assert.That(() => validBytes.ToHexString(), Is.EqualTo(expected)); }
public void Shuffle_OnSequenceOfOne_WithRandom_ReturnsSequenceOfOne() { var fixture = new MultipleMockingFixture(1); var sequenceOfOne = fixture.Create<object[]>(); var random = fixture.Create<Random>(); Assert.That(() => sequenceOfOne.Shuffle(random), Is.EqualTo(sequenceOfOne)); }
public void ToByteArray_OnValidHexString_ReturnsProperByteArray() { var fixture = new MultipleMockingFixture(256); var bytes = fixture.Create<byte[]>(); var hexString = BitConverter.ToString(bytes).Strip('-'); Assert.That(() => hexString.ToByteArray(), Is.EqualTo(bytes)); }
public void DistinctBy_OnDoubledSequence_WithKeySelector_ReturnsSingleSequence() { var fixture = new MultipleMockingFixture(); var singleSequence = fixture.Create<object[]>(); var doubleSequence = singleSequence.Concat(singleSequence); Func<object, object> objectFunc = o => o; Assert.That(() => doubleSequence.DistinctBy(objectFunc), Is.EqualTo(singleSequence)); }
public void RandomElement_OnCollectionSequence_EventuallyChoosesEachItem() { var fixture = new MultipleMockingFixture(10); var checkList = fixture.Create<object[]>(); var dic = checkList.ToDictionary(i => i, e => 0); var random = fixture.Create<Random>(); var maxIterations = 1000 * checkList.Count(); var iterations = 0; while (dic.ContainsValue(0)) { dic[checkList.RandomElement(random)]++; var i = iterations++; Assert.That(() => i, Is.LessThan(maxIterations), string.Format("Dictionary contains {0} items", dic.Values.Sum())); } }
public void DistinctBy_OnDoubledSequence_WithKeySelector_WithEqualityComparer_ReturnsSingleSequence() { var fixture = new MultipleMockingFixture(); var singleSequence = fixture.Create<object[]>(); var doubleSequence = singleSequence.Concat(singleSequence); Func<object, object> objectFunc = o => o; var mock = fixture.Create<Mock<IEqualityComparer<object>>>(); mock.Setup(e => e.GetHashCode()).Returns((object o) => o.GetHashCode()); mock.Setup(e => e.GetHashCode(It.IsAny<object>())).Returns((object o) => o.GetHashCode()); mock.Setup(e => e.Equals(It.IsAny<object>())).Returns((object o, object b) => o.GetHashCode() == b.GetHashCode()); mock.Setup(e => e.Equals(It.IsAny<object>(), It.IsAny<object>())).Returns((object o, object b) => o.GetHashCode() == b.GetHashCode()); var equalityComparer = mock.Object; Assert.That(() => doubleSequence.DistinctBy(objectFunc, equalityComparer), Is.EqualTo(singleSequence)); }
public void ContainsAny_OnEnumerableCharacters_OnEmptyString_ReturnsFalse() { string emptyString = string.Empty; var fixture = new MultipleMockingFixture(); var characters = fixture.Create<IEnumerable<char>>(); Assert.That(() => emptyString.ContainsAny(characters), Is.False); }
public void Append_OnSequence_WithElement_ReturnsAppendedSequence() { var fixture = new MultipleMockingFixture(); var objectArray = fixture.Create<object[]>(); var objectValue = fixture.Create<object>(); var appendedSequence = objectArray.Concat(objectValue.ToEnumerable()); Assert.That(() => objectArray.Append(objectValue), Is.EqualTo(appendedSequence)); }
public void ContainsOnlyOne_OnSequenceOfOne_ReturnsTrue() { var fixture = new MultipleMockingFixture(); var sequenceOfOne = fixture.CreateMany<object>(1); Assert.That(() => sequenceOfOne.ContainsOnlyOne(), Is.True); }
public void ContainsOnlyOne_OnSequenceOfThree_ReturnsFalse() { var fixture = new MultipleMockingFixture(); var sequenceOfThree = fixture.Create<object[]>(); Assert.That(() => sequenceOfThree.ContainsOnlyOne(), Is.False); }
public void ContainsOnlyOne_OnSequenceOfThree_PredicateNull_ThrowsValidationException() { var fixture = new MultipleMockingFixture(); var sequenceOfThree = fixture.Create<object[]>(); Func<object, bool> nullPredicate = null; Assert.That(() => sequenceOfThree.ContainsOnlyOne(nullPredicate), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>()); }
public void Shuffle_OnSequence_WithRandom_ReturnsAllOriginalElements() { const int count = 100; var fixture = new MultipleMockingFixture(count); var sequence = fixture.Create<object[]>(); var random = fixture.Create<Random>(); var shuffled = sequence.Shuffle(random).ToArray(); Assert.That(() => shuffled, Is.EquivalentTo(sequence)); }
public void IsEmpty_OnGenericEnumerableMultipleItem_ReturnsFalse() { var fixture = new MultipleMockingFixture(); var nonEmptyEnumerable = fixture.Create<IEnumerable<object>>(); Assert.That(() => nonEmptyEnumerable.IsEmpty(), Is.False); }
public void Prepend_OnSequence_WithElement_ReturnsElementPrependedToSequence() { var fixture = new MultipleMockingFixture(); var sequence = fixture.Create<IList<object>>(); var element = fixture.Create<object>(); var expected = element.ToEnumerable().Concat(sequence); Assert.That(sequence.Prepend(element), Is.EqualTo(expected)); }
public void MaxOrDefault_OnGenericEnumerable_WithNullValue_ReturnsGenericEnumerableMax() { var fixture = new MultipleMockingFixture(); var comparableArray = fixture.Create<GenericComparable[]>(); GenericComparable nullComparable = null; var comparableArrayMax = comparableArray.Max(); Assert.That(() => comparableArray.MaxOrDefault(nullComparable), Is.EqualTo(comparableArrayMax)); }
public void MaxOrDefault_OnGenericEnumerable_WithValue_WithFunc_ReturnsGenericEnumerableMax() { var fixture = new MultipleMockingFixture(); var comparableArray = fixture.Create<GenericComparable[]>(); var comparableValue = fixture.Create<GenericComparable>(); var comparableFunc = fixture.Create<Func<GenericComparable, GenericComparable>>(); var comparableArrayMax = comparableArray.Max(comparableFunc); Assert.That(() => comparableArray.MaxOrDefault(comparableFunc, comparableValue), Is.EqualTo(comparableArrayMax)); }
public void MaxOrDefault_OnGenericEnumerable_WithValue_WithNullFunc_ThrowsValidationException() { var fixture = new MultipleMockingFixture(); var comparableArray = fixture.Create<GenericComparable[]>(); var comparableValue = fixture.Create<GenericComparable>(); Func<GenericComparable, GenericComparable> nullFunc = null; Assert.That(() => comparableArray.MaxOrDefault(nullFunc, comparableValue), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>()); }
public void Shuffle_OnSequence_WithRandom_ReturnsDifferentSequence() { const int count = 100; var fixture = new MultipleMockingFixture(count); var sequence = fixture.Create<object[]>(); var random = fixture.Create<Random>(); var shuffled = sequence.Shuffle(random).ToArray(); var matches = 0; for (var i = 0; i < count; i++) { if (sequence[i] == shuffled[i]) { matches++; } else { break; } } Assert.That(() => matches, Is.LessThan(count)); }
public void ContainsAny_OnEnumerableCharacters_OnNullString_ThrowsValidationException() { string nullString = null; var fixture = new MultipleMockingFixture(); var characters = fixture.Create<char[]>(); Assert.That(() => nullString.ContainsAny(characters), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>()); }
public void ContainsOnlyOne_OnSequenceOfThree_OneMatchesPredicate_ReturnsTrue() { var fixture = new MultipleMockingFixture(); var sequenceOfThree = fixture.Create<object[]>(); Func<object, bool> objectFunc = o => o == sequenceOfThree.First(); Assert.That(() => sequenceOfThree.ContainsOnlyOne(objectFunc), Is.True); }
public void IsEmpty_OnNonGenericCollectionEmpty_ReturnsTrue() { var fixture = new MultipleMockingFixture(); var mock = fixture.Create<Mock<IEnumerable>>(); IEnumerable emptyNonGenericCollection = mock.Object; Assert.That(() => emptyNonGenericCollection.IsEmpty(), Is.True); }
public void Shuffle_OnSequence_WithNullRandom_ThrowsValidationException() { var fixture = new MultipleMockingFixture(); var sequence = fixture.Create<IEnumerable<object>>(); Random nullRandom = null; Assert.That(() => sequence.Shuffle(nullRandom), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>()); }
public void NullableMin_OnSequence_WithSelector_ReturnsMin() { var fixture = new MultipleMockingFixture(); var sequence = fixture.Create<IList<GenericComparableStruct>>(); var selector = fixture.Create<Func<GenericComparableStruct, GenericComparableStruct>>(); var min = sequence.Min(selector); Assert.That(() => sequence.NullableMin(selector), Is.EqualTo(min)); }
public void IsEmpty_OnNonGenericCollectionMultipleItem_ReturnsFalse() { var fixture = new MultipleMockingFixture(); IEnumerable nonEmptyNonGenericCollection = fixture.CreateMany<object>(); Assert.That(() => nonEmptyNonGenericCollection.IsEmpty(), Is.False); }