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