public void TestReadBufferNull()
{
BigMemoryStream stream = new BigMemoryStream(5);
byte[] buffer = null;
Assert.Throws <ArgumentNullException>(() => stream.Read(buffer, 0, 1));
}
public void TestReadWriteOffset1()
{
BigMemoryStream stream = new BigMemoryStream(100);
byte[] values = new byte[] { 1, 3, 7, 6, 8, 9, 2, 3, 5, 76, 34, 12, 55, 4 };
stream.Write(values, 3, 4);
byte[] expected = values.Skip(3).Take(4).ToArray();
//Get just the bytes that were written
byte[] actual1 = new byte[4];
stream.Position = 0;
stream.Read(actual1, 0, 4);
CollectionAssert.AreEqual(expected, actual1);
//Get the bytes back using an offset on read too
byte[] actual2 = new byte[values.Length];
stream.Position = 0;
stream.Read(actual2, 3, 4);
for (int i = 3; i < 7; i++)
{
Assert.AreEqual(values[i], actual2[i]);
}
}
public void TestReadBufferTooSmallDueToOffset()
{
BigMemoryStream stream = new BigMemoryStream(5);
byte[] buffer = new byte[4];
Assert.Throws <ArgumentException>(() => stream.Read(buffer, 1, 4));
}
public void TestReadWriteBigAboveIntegerIndex()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
long fromStreamPos = (long)int.MaxValue + 1000;
BigMemoryStream stream = new BigMemoryStream(length);
stream.Position = fromStreamPos;
byte[] values = new byte[100];
for (byte i = 0; i < values.Length; i++)
{
values[i] = (byte)(i + 100);
}
stream.Write(values, 0, values.Length);
//Back to the start (fromStreamPos) to read the values back
stream.Position = fromStreamPos;
byte[] buffer = new byte[values.Length];
stream.Read(buffer, 0, values.Length);
CollectionAssert.AreEqual(values, buffer);
}
public void TestConstructorNoParams()
{
BigMemoryStream stream = new BigMemoryStream();
Assert.AreEqual(0, stream.Length);
Assert.AreEqual(true, stream.CanWrite);
}
public void TestDisposed()
{
BigMemoryStream stream = new BigMemoryStream(5);
stream.Close();
Assert.Throws <ObjectDisposedException>(() => stream.Position = 5);
}
private static FourBitDigitBigArray makeNew(long length)
{
//If length is odd, add one to it
bool odd = false;
if (length % 2 == 1)
{
odd = true;
length++;
}
Stream stream;
long streamLength = length / 2;
if (length > int.MaxValue)
{
stream = new BigMemoryStream(streamLength);
}
else
{
stream = new MemoryStream((int)streamLength);
}
stream.SetLength(streamLength);
//If the length was odd, set the last byte to 15 (last 4 bits are all 1's)
if (odd)
{
stream.Position = streamLength - 1;
stream.WriteByte(15);
}
FourBitDigitBigArray a = new FourBitDigitBigArray(stream);
return(a);
}
public void TestReadNegCount()
{
BigMemoryStream stream = new BigMemoryStream(5);
byte[] buffer = new byte[5];
Assert.Throws <ArgumentOutOfRangeException>(() => stream.Read(buffer, 1, -1));
}
public void TestReadWriteOffset2()
{
int length = 100;
int writeFrom = 27;
BigMemoryStream stream = new BigMemoryStream(length);
byte[] values = new byte[length];
for (byte i = 0; i < values.Length; i++)
{
values[i] = (byte)(i + 100);
}
List <byte> expected = Enumerable.Repeat((byte)0, writeFrom).ToList();
List <byte> expectedValues = values.Skip(writeFrom).Take(length - writeFrom).ToList();
expected.AddRange(expectedValues);
stream.Write(values, writeFrom, length - writeFrom);
//Back to the start to read the values back
stream.Position = 0;
byte[] buffer = new byte[length];
int numRead = stream.Read(buffer, writeFrom, length - writeFrom);
CollectionAssert.AreEqual(expected, buffer);
Assert.AreEqual(length - writeFrom, numRead);
}
public void TestConstructorWithBigCapacity()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
BigMemoryStream stream = new BigMemoryStream(length);
Assert.AreEqual(length, stream.Length);
}
public void TestReadByteEOS()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = 100;
int b = stream.ReadByte();
Assert.AreEqual(-1, b);
}
public void TestReadEOS()
{
BigMemoryStream stream = new BigMemoryStream(5);
byte[] buffer = new byte[1];
stream.Position = 5;
int bytesRead = stream.Read(buffer, 0, 1);
Assert.AreEqual(0, bytesRead);
}
public void TestPositionMovesOnRead()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = 5;
byte[] buffer = new byte[5];
stream.Read(buffer, 0, 5);
Assert.AreEqual(10, stream.Position);
}
public void TestPositionMovesOnReadByte()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = 5;
stream.ReadByte();
Assert.AreEqual(6, stream.Position);
}
public void TesPositionMovesOnWriteByte()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = 5;
stream.WriteByte(3);
Assert.AreEqual(6, stream.Position);
}
public void TestReadLastByteUnsetWithMaxSizeOfUnderlyingStream()
{
BigMemoryStream stream = new BigMemoryStream(BigMemoryStream.MEMORY_STREAM_MAX_SIZE);
stream.Position = stream.Length - 1;
int b = stream.ReadByte();
Assert.AreEqual(0, b);
}
public void TestReadByteEOSBig()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
BigMemoryStream stream = new BigMemoryStream(length);
stream.Position = length;
int b = stream.ReadByte();
Assert.AreEqual(-1, b);
}
public void TestReadWriteByte()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.WriteByte(5);
stream.Position = 0;
Assert.AreEqual(5, stream.ReadByte());
}
public void TestReadLastByteUnset()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = stream.Length - 1;
int b = stream.ReadByte();
Assert.AreEqual(0, b);
}
public void TestReadLastByteUnsetBig()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
BigMemoryStream stream = new BigMemoryStream(length);
stream.Position = stream.Length - 1;
int b = stream.ReadByte();
Assert.AreEqual(0, b);
}
public void TestSetPosition()
{
BigMemoryStream stream = new BigMemoryStream(10);
for (long i = 0; i < 10; i++)
{
stream.Position = i;
Assert.AreEqual(i, stream.Position);
}
}
public void TestReadWriteLastByteInStreamAtMaxOfUnderlyingStream()
{
BigMemoryStream stream = new BigMemoryStream(BigMemoryStream.MEMORY_STREAM_MAX_SIZE);
stream.Position = BigMemoryStream.MEMORY_STREAM_MAX_SIZE - 1;
stream.WriteByte(5);
stream.Position = BigMemoryStream.MEMORY_STREAM_MAX_SIZE - 1;
int b = stream.ReadByte();
Assert.AreEqual(5, b);
}
public void TestReadWriteLastByte()
{
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = 99;
stream.WriteByte(5);
stream.Position = 99;
int b = stream.ReadByte();
Assert.AreEqual(5, b);
}
public void TestReadWriteFirstByteInSecondUnderlyingStream()
{
long length = BigMemoryStream.MEMORY_STREAM_MAX_SIZE + 5;
BigMemoryStream stream = new BigMemoryStream(length);
stream.Position = BigMemoryStream.MEMORY_STREAM_MAX_SIZE;
stream.WriteByte(5);
stream.Position = BigMemoryStream.MEMORY_STREAM_MAX_SIZE;
int b = stream.ReadByte();
Assert.AreEqual(5, b);
}
public void TestReadWriteLastByteBig()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
BigMemoryStream stream = new BigMemoryStream(length);
stream.Position = length - 1;
stream.WriteByte(5);
stream.Position = length - 1;
int b = stream.ReadByte();
Assert.AreEqual(5, b);
}
//Constructor
public MemoryEfficientBigULongArray(long length, ulong maxValue = ulong.MaxValue)
{
Length = length;
MaxValue = maxValue;
//Calculate the number of bits to leave per value
bitsPerValue = calculateBitsPerValue(MaxValue);
//Calculate the number of bytes that will be used to store all of the values
long numBytes = calculateMinimumStreamLength();
//Store the array in memory by default
stream = new BigMemoryStream(numBytes);
}
//Constructor
public MemoryEfficientByteAlignedBigULongArray(long length, ulong maxValue = ulong.MaxValue)
{
Length = length;
MaxValue = maxValue;
//Calculate the number of bytes to leave per value
bytesPerValue = calculateBytesPerValue(MaxValue);
//Calculate the number of bytes that will be used to store all of the values
long numBytes = length * bytesPerValue;
//Store the array in memory by default (could be changed to another type of stream later)
stream = new BigMemoryStream(numBytes);
}
public void TestSetPositionBig()
{
long length = 3L * 1024L * 1024L * 1024L; //3GiB
BigMemoryStream stream = new BigMemoryStream(length);
//Small position on big stream
stream.Position = 10;
Assert.AreEqual(10, stream.Position);
//Big position on big stream
stream.Position = length - 5;
Assert.AreEqual(length - 5, stream.Position);
}
public void TestReadLastUnset()
{
byte[] expected = new byte[] { 0 };
BigMemoryStream stream = new BigMemoryStream(100);
stream.Position = stream.Length - 1;
byte[] buffer = new byte[1];
int bytesRead = stream.Read(buffer, 0, 1);
Assert.AreEqual(1, bytesRead);
CollectionAssert.AreEqual(expected, buffer);
}
public void TestReadLastUnsetWithMaxSizeOfUnderlyingStream()
{
byte[] expected = new byte[] { 0 };
BigMemoryStream stream = new BigMemoryStream(BigMemoryStream.MEMORY_STREAM_MAX_SIZE);
stream.Position = stream.Length - 1;
byte[] buffer = new byte[1];
int bytesRead = stream.Read(buffer, 0, 1);
Assert.AreEqual(1, bytesRead);
CollectionAssert.AreEqual(expected, buffer);
}
