public void ShouldEnumerateOnlyOnceAndReturnSecondElement_WhenEnumerableAndAskingForSameElement()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var second0 = smartList[1];
var second1 = smartList[1];
var second2 = smartList[1];
// Assert
Assert.Equal("b", second0);
Assert.Equal("b", second1);
Assert.Equal("b", second2);
Assert.True(enumerable.Enumerated);
Assert.Equal(2, enumerable.NextIndex);
}
public void ShouldContinueEnumerating_WhenAskingSubsequentIndices()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var second = smartList[1];
var fourth = smartList[3];
var fifth = smartList[4];
// Assert
Assert.Equal("b", second);
Assert.Equal("d", fourth);
Assert.Equal("e", fifth);
Assert.True(enumerable.Enumerated);
Assert.Equal(5, enumerable.NextIndex);
}
public void ShouldReturnEnumeratorThatCanEnumerateElements_WhenEnumerable()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
bool hasNext = enumerator.MoveNext();
string element = enumerator.Current;
bool hasMore = enumerator.MoveNext();
// Assert
Assert.True(hasNext);
Assert.False(hasMore);
Assert.True(enumerable.Enumerated);
Assert.Equal("c", element);
Assert.Equal(3, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public void ShouldContinueEnumerating_WhenAskingIndexPastEnumeratedPart()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var fifth = smartList[4];
// Assert
Assert.Equal("e", fifth);
Assert.True(enumerable.Enumerated);
Assert.Equal(5, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public void ShouldReturnCachedValue_WhenAskingEnumeratedIndex()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var second = smartList[1];
// Assert
Assert.Equal("b", second);
Assert.True(enumerable.Enumerated);
Assert.Equal(3, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public void ShouldEnumerateOnce_WhenAskingForCountMultipleTimes()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
// Act
var count0 = smartList.Count;
var count1 = smartList.Count;
var count2 = smartList.Count;
// Assert
Assert.Equal(3, count0);
Assert.Equal(3, count1);
Assert.Equal(3, count2);
Assert.True(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldReturnCount_WhenFullyEnumerated()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var count = smartList.Count;
// Assert
Assert.Equal(3, count);
Assert.True(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldEnumerateEnumerableAndReturnOne_WhenEnumerableIsSingleton()
{
// Arrange
IEnumerable <string> Singleton()
{
yield return("a");
}
var enumerable = new CheckingEnumerable <string>(Singleton());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(1, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldEnumerateAndReturnZero_WhenEnumerableIsEmpty()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(0, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldReturnEnumeratorButDoesNotEnumerate_WhenEnumerable()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
// Assert
Assert.NotNull(enumerator);
Assert.False(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldEnumerateAndReturnCount_WhenEnumerable()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(3, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldEnumerateAndReturnSecondElement_WhenEnumerable()
{
// Arrange
IEnumerable <string> Singleton()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Singleton());
var smartList = new SmartList <string>(enumerable);
// Act
var second = smartList[1];
// Assert
Assert.Equal("b", second);
Assert.True(enumerable.Enumerated);
Assert.Equal(2, enumerable.NextIndex);
}
public void ShouldReturnEnumeratorThatImmediatelyReturnsFalse_WhenEmptyEnumerable()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
bool hasNext = enumerator.MoveNext();
// Assert
Assert.False(hasNext);
Assert.True(enumerable.Enumerated);
Assert.Equal(0, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
