public void TestWindowedNegativeWindowSizeException() { var sequence = Enumerable.Repeat(1, 10); AssertThrowsArgument.OutOfRangeException("size", () => sequence.Windowed(-5)); }
public void TestNullSequenceException2() { const IEnumerable <int> sequence = null; AssertThrowsArgument.NullException("sequence", () => sequence.Incremental((prev, next, i) => prev + next)); }
public void TestNegativeSubsetSize() { const int count = 10; var sequence = Enumerable.Range(1, count); AssertThrowsArgument.OutOfRangeException("subsetSize", () => sequence.Subsets(-5)); }
public void TestNegativeMaxValueException() { const int maxValue = -10; Assert.Less(maxValue, 0); AssertThrowsArgument.OutOfRangeException("maxValue", () => MoreEnumerable.Random(maxValue)); }
public void InsertWithIndexGreaterThanSourceLengthMaterialized(int count) { var source = Enumerable.Range(0, count).ToList(); var result = source.Insert(new[] { 97, 98, 99 }, count + 1); AssertThrowsArgument.OutOfRangeException("index", () => result.ForEach((e, index) => Assert.That(e, Is.EqualTo(source[index])))); }
public void AssertCountNegativeCount() { var source = new object[0]; AssertThrowsArgument.OutOfRangeException("count", () => source.AssertCount(-1)); AssertThrowsArgument.OutOfRangeException("count", () => source.AssertCount(-1, BreakingFunc.Of <int, int, Exception>())); }
public void TestMinValueGreaterThanMaxValueException() { const int minValue = 100; const int maxValue = 10; Assert.Greater(minValue, maxValue); AssertThrowsArgument.OutOfRangeException("minValue", () => MoreEnumerable.Random(minValue, maxValue)); }
public void TestRandomSubsetLongerThanSequence() { const int count = 100; const int subsetSize = count + 5; var sequence = Enumerable.Range(1, count); AssertThrowsArgument.OutOfRangeException("subsetSize", () => { sequence.RandomSubset(subsetSize).Consume(); }); }
public void TestSubsetLargerThanSequence() { const int count = 10; var sequence = Enumerable.Range(1, count); var result = sequence.Subsets(count + 5); AssertThrowsArgument.OutOfRangeException("subsetSize", () => { result.Consume(); // this particular exception is deferred until sequence evaluation }); }
public void InsertWithIndexGreaterThanSourceLengthMaterialized(int count) { var seq1 = Enumerable.Range(0, count).ToList(); var seq2 = new[] { 97, 98, 99 }; using var test1 = seq1.AsTestingSequence(); using var test2 = seq2.AsTestingSequence(); var result = test1.Insert(test2, count + 1); AssertThrowsArgument.OutOfRangeException("index", () => result.ForEach((e, index) => Assert.That(e, Is.EqualTo(seq1[index])))); }
public void CountBetweenWithMaxLesserThanMin() { AssertThrowsArgument.OutOfRangeException("max", () => new[] { 1 }.CountBetween(1, 0)); }
public void TestLeadZeroOffset() { AssertThrowsArgument.OutOfRangeException("offset", () => Enumerable.Range(1, 100).Lead(0, (val, leadVal) => val + leadVal)); }
public void InsertWithNegativeIndex() { AssertThrowsArgument.OutOfRangeException("index", () => Enumerable.Range(1, 10).Insert(new[] { 97, 98, 99 }, -1)); }
public void BatchNegativeSize() { AssertThrowsArgument.OutOfRangeException("size", () => new object[0].Batch(-1)); }
public void BatchZeroSize() { AssertThrowsArgument.OutOfRangeException("size", () => new object[0].Batch(0)); }
public void TestExcludeNegativeCountException() { AssertThrowsArgument.OutOfRangeException("count", () => Enumerable.Range(1, 10).Exclude(0, -5)); }
public void TakeEveryOutOfRangeZeroStep() { AssertThrowsArgument.OutOfRangeException("step", () => new object[0].TakeEvery(0)); }
public void MoveWithNegativeToIndex() { AssertThrowsArgument.OutOfRangeException("toIndex", () => new[] { 1 }.Move(0, 0, -1)); }
public void TestRandomSubsetNegativeSubsetSize2() { AssertThrowsArgument.OutOfRangeException("subsetSize", () => Enumerable.Range(1, 10).RandomSubset(-1, new Random())); }
public void TestNegativeRepeatCount() { AssertThrowsArgument.OutOfRangeException("count", () => Enumerable.Range(1, 10).Repeat(-3)); }
public void ExactlyWithNegativeCount() { AssertThrowsArgument.OutOfRangeException("count", () => new[] { 1 }.Exactly(-1)); }
public void PadStartWithSelectorWithNegativeWidth() { AssertThrowsArgument.Exception("width", () => new int[0].PadStart(-1, x => x)); }
public void PadStartWithPaddingWithNegativeWidth() { AssertThrowsArgument.Exception("width", () => new int[0].PadStart(-1, 1)); }
public void CountBetweenWithNegativeMax() { AssertThrowsArgument.OutOfRangeException("max", () => new[] { 1 }.CountBetween(0, -1)); }
public void TestExcludeNegativeStartIndexException() { AssertThrowsArgument.OutOfRangeException("startIndex", () => Enumerable.Range(1, 10).Exclude(-10, 10)); }
public void TakeEveryNegativeSkip() { AssertThrowsArgument.OutOfRangeException("step", () => new object[0].TakeEvery(-1)); }
public void WindowLeftWithNegativeWindowSize() { AssertThrowsArgument.OutOfRangeException("size", () => Enumerable.Repeat(1, 10).WindowLeft(-5)); }
public void MoveWithNegativeFromIndex() { AssertThrowsArgument.OutOfRangeException("fromIndex", () => new[] { 1 }.Move(-1, 0, 0)); }
public void AtLeastWithNegativeCount() { AssertThrowsArgument.OutOfRangeException("count", () => new[] { 1 }.AtLeast(-1)); }
public void MoveWithNegativeCount() { AssertThrowsArgument.OutOfRangeException("count", () => new[] { 1 }.Move(0, -1, 0)); }