public void WriteByte()
{
const int length = 1000;
using (var manager = new UmsManager(FileAccess.Write, length))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
var bytes = ArrayHelpers.CreateByteArray(length);
for (int index = 0; index < bytes.Length; index++)
{
stream.WriteByte(bytes[index]);
}
var memory = manager.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer <byte>());
stream.SetLength(0);
stream.Position = 1;
bytes = ArrayHelpers.CreateByteArray(length);
for (int index = 1; index < bytes.Length; index++)
{
stream.WriteByte(bytes[index]);
}
stream.Position = 0;
stream.WriteByte(bytes[0]);
memory = manager.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer <byte>());
}
}
public void CannotWriteWithOverflow()
{
using (var manager = new UmsManager(FileAccess.Write, 1000))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
stream.Position = long.MaxValue;
var bytes = new byte[3];
Assert.Throws <IOException>(() => Write(stream, bytes, 0, bytes.Length));
Assert.Throws <IOException>(() => stream.WriteByte(1));
}
}
public void Write()
{
const int length = 1000;
using (var manager = new UmsManager(FileAccess.Write, length))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
Assert.Equal(stream.Length, length);
var bytes = ArrayHelpers.CreateByteArray(length);
Write(stream, bytes.Copy(), 0, length);
var memory = manager.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer <byte>());
Write(stream, new byte[0], 0, 0);
stream.SetLength(1);
Assert.Equal(1, stream.Length);
stream.SetLength(4);
Assert.Equal(4, stream.Length);
stream.SetLength(0);
Assert.Equal(0, stream.Length);
stream.Position = 1;
bytes = ArrayHelpers.CreateByteArray(length - 1);
Write(stream, bytes, 0, length - 1);
memory = manager.ToArray();
for (int i = 0; i < bytes.Length; i++)
{
Assert.Equal(bytes[i], memory[i + 1]);
}
Assert.True(stream.WriteAsync(bytes, 0, bytes.Length, new CancellationToken(true)).IsCanceled);
stream.Position = 0;
bytes = ArrayHelpers.CreateByteArray(length);
for (int i = 0; i < 4; i++)
{
Task t = stream.WriteAsync(bytes, i * (bytes.Length / 4), bytes.Length / 4);
Assert.True(t.Status == TaskStatus.RanToCompletion);
}
Assert.Equal(bytes, manager.ToArray(), ArrayHelpers.Comparer <byte>());
}
}
public static void Write()
{
const int length = 1000;
using (var manager = new UmsManager(FileAccess.Write, length))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
Assert.Equal(stream.Length, length);
var bytes = ArrayHelpers.CreateByteArray(length);
stream.Write(bytes.Copy(), 0, length);
var memory = manager.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer <byte>());
stream.Write(new byte[0], 0, 0);
}
}
public static void CannotWriteWithOverflow()
{
using (var manager = new UmsManager(FileAccess.Write, 1000))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
if (IntPtr.Size == 4)
{
Assert.Throws <ArgumentOutOfRangeException>(() => stream.Position = long.MaxValue);
stream.Position = int.MaxValue;
}
else
{
stream.Position = long.MaxValue;
var bytes = new byte[3];
Assert.Throws <IOException>(() => stream.Write(bytes, 0, bytes.Length));
Assert.Throws <IOException>(() => stream.WriteByte(1));
}
}
}
public static void WriteByte()
{
var length = 1000;
using (var manager = new UmsManager(FileAccess.Write, length))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.WriteUmsInvariants(stream);
var bytes = ArrayHelpers.CreateByteArray(length);
for (int index = 0; index < bytes.Length; index++)
{
stream.WriteByte(bytes[index]);
}
var memory = manager.ToArray();
Assert.True(ArrayHelpers.Comparer <byte>().Equals(bytes, memory));
}
}
public static async Task CopyToAsyncTest()
{
byte[] testData = ArrayHelpers.CreateByteArray(8192);
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Position = 0;
await ums.CopyToAsync(destination);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
await ums.CopyToAsync(destination, 2);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
await ums.CopyToAsync(destination, 0x1000, new CancellationTokenSource().Token);
Assert.Equal(testData, destination.ToArray());
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => ums.CopyToAsync(destination, 0x1000, new CancellationToken(true)));
}
// copy to disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(() => ums.CopyToAsync(destination));
}
// copy from disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
ums.Dispose();
MemoryStream destination = new MemoryStream();
await Assert.ThrowsAsync <ObjectDisposedException>(() => ums.CopyToAsync(destination));
}
// copying to non-writable stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
await Assert.ThrowsAsync <NotSupportedException>(() => ums.CopyToAsync(destination));
}
// copying from non-readable stream should throw
using (var manager = new UmsManager(FileAccess.Write, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.WriteUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
await Assert.ThrowsAsync <NotSupportedException>(() => ums.CopyToAsync(destination));
}
}
public static void CopyToTest()
{
byte[] testData = ArrayHelpers.CreateByteArray(8192);
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Position = 0;
ums.CopyTo(destination);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
ums.CopyTo(destination, 1);
Assert.Equal(testData, destination.ToArray());
}
// copy to disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Dispose();
Assert.Throws <ObjectDisposedException>(() => ums.CopyTo(destination));
}
// copy from disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
ums.Dispose();
MemoryStream destination = new MemoryStream();
Assert.Throws <ObjectDisposedException>(() => ums.CopyTo(destination));
}
// copying to non-writable stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
Assert.Throws <NotSupportedException>(() => ums.CopyTo(destination));
}
// copying from non-readable stream should throw
using (var manager = new UmsManager(FileAccess.Write, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.WriteUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
Assert.Throws <NotSupportedException>(() => ums.CopyTo(destination));
}
}
