protected override void Dispose(bool disposing)
{
try {
if (disposing)
{
_unmanagedStream.Close();
}
}
finally {
base.Dispose(disposing);
}
}
unsafe public IHttpActionResult Unmanaged()
{
//使用 UnmanagedMemoryStream 类读取和写入非托管内存。 使用 Marshal 类分配和解除分配非托管内存块。
// Create some data to read and write.
byte[] message = UnicodeEncoding.Unicode.GetBytes("Hello Angkor");
// Allocate a block of unmanaged memory and return an IntPtr object.
IntPtr memIntPtr = Marshal.AllocHGlobal(message.Length);
// Get a byte pointer from the IntPtr object.
byte* memBytePtr = (byte*)memIntPtr.ToPointer();
// Create an UnmanagedMemoryStream object using a pointer to unmanaged memory.
UnmanagedMemoryStream writeStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Write);
// Write the data.
writeStream.Write(message, 0, message.Length);
// Close the stream.
writeStream.Close();
// Create another UnmanagedMemoryStream object using a pointer to unmanaged memory.
UnmanagedMemoryStream readStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Read);
// Create a byte array to hold data from unmanaged memory.
byte[] outMessage = new byte[message.Length];
// Read from unmanaged memory to the byte array.
readStream.Read(outMessage, 0, message.Length);
// Close the stream.
readStream.Close();
// Display the data to the console.
var msg = UnicodeEncoding.Unicode.GetString(outMessage);
// Free the block of unmanaged memory.
Marshal.FreeHGlobal(memIntPtr);
return Json(msg);
}
internal SessionStateStoreData DoGet(HttpContext context,
String id,
UnsafeNativeMethods.StateProtocolExclusive exclusiveAccess,
out bool locked,
out TimeSpan lockAge,
out object lockId,
out SessionStateActions actionFlags) {
SessionStateStoreData item = null;
UnmanagedMemoryStream stream = null;
int contentLength;
UnsafeNativeMethods.SessionNDMakeRequestResults results;
// Set default return values
locked = false;
lockId = null;
lockAge = TimeSpan.Zero;
actionFlags = 0;
results.content = IntPtr.Zero;
try {
MakeRequest(UnsafeNativeMethods.StateProtocolVerb.GET,
id, exclusiveAccess, 0, 0, 0,
null, 0, s_networkTimeout, out results);
switch (results.httpStatus) {
case 200:
/* item found, deserialize it */
contentLength = results.contentLength;
if (contentLength > 0) {
try {
unsafe {
stream = new UnmanagedMemoryStream((byte*)results.content, contentLength);
}
item = SessionStateUtility.DeserializeStoreData(context, stream, s_configCompressionEnabled);
}
finally {
if(stream != null) {
stream.Close();
}
}
lockId = results.lockCookie;
actionFlags = (SessionStateActions) results.actionFlags;
}
break;
case 423:
/* state locked, return lock information */
if (0 <= results.lockAge) {
if (results.lockAge < Sec.ONE_YEAR) {
lockAge = new TimeSpan(0, 0, results.lockAge);
}
else {
lockAge = TimeSpan.Zero;
}
}
else {
DateTime now = DateTime.Now;
if (0 < results.lockDate && results.lockDate < now.Ticks) {
lockAge = now - new DateTime(results.lockDate);
}
else {
lockAge = TimeSpan.Zero;
}
}
locked = true;
lockId = results.lockCookie;
Debug.Assert((results.actionFlags & (int)SessionStateActions.InitializeItem) == 0,
"(results.actionFlags & (int)SessionStateActions.InitializeItem) == 0; uninitialized item cannot be locked");
break;
}
}
finally {
if (results.content != IntPtr.Zero) {
UnsafeNativeMethods.SessionNDFreeBody(new HandleRef(this, results.content));
}
}
return item;
}
public void Constructor2 ()
{
UnmanagedMemoryStream ums;
ums = new UnmanagedMemoryStream(mem_byteptr,
length, 999, FileAccess.Read);
Assert.IsTrue (ums.CanRead, "#A1");
Assert.IsTrue (ums.CanSeek, "#A2");
Assert.IsFalse (ums.CanWrite, "#A3");
Assert.AreEqual (999, ums.Capacity, "#A4");
Assert.AreEqual (length, ums.Length, "#A5");
Assert.AreEqual (0, ums.Position, "#A6");
ums.Close ();
ums = new UnmanagedMemoryStream(mem_byteptr,
length, 666, FileAccess.Write);
Assert.IsFalse (ums.CanRead, "#B1");
Assert.IsTrue (ums.CanSeek, "#B2");
Assert.IsTrue (ums.CanWrite, "#B3");
Assert.AreEqual (666, ums.Capacity, "#B4");
Assert.AreEqual (length, ums.Length, "#B5");
Assert.AreEqual (0, ums.Position, "#B6");
ums.Close ();
ums = new UnmanagedMemoryStream(mem_byteptr,
0, 0, FileAccess.ReadWrite);
Assert.IsTrue (ums.CanRead, "#C1");
Assert.IsTrue (ums.CanSeek, "#C2");
Assert.IsTrue (ums.CanWrite, "#C3");
Assert.AreEqual (0, ums.Capacity, "#C4");
Assert.AreEqual (0, ums.Length, "#C5");
Assert.AreEqual (0, ums.Position, "#C6");
ums.Close ();
}
public void SetLength_Negative ()
{
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
length, capacity, FileAccess.ReadWrite);
try {
ums.SetLength(-1);
Assert.Fail ("#1");
} catch (ArgumentOutOfRangeException ex) {
// Non-negative number required
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNotNull (ex.ParamName, "#5");
Assert.AreEqual ("length", ex.ParamName, "#6");
}
ums.Close();
}
private Bitmap fetchImage(UnmanagedMemoryStream memStream)
{
int buffer;
string id ="";
int width;
int height;
int max;
byte[] rgbValues = null;
Bitmap bitmap;
do
{
buffer = memStream.ReadByte();
id += (char)buffer;
} while (buffer != '\n' && buffer != ' ');
string dimension = "";
do
{
buffer = memStream.ReadByte();
dimension += (char)buffer;
} while (buffer != '\n' && buffer != ' ');
width = Convert.ToInt16(dimension);
dimension = "";
do
{
buffer = memStream.ReadByte();
dimension += (char)buffer;
} while (buffer != '\n' && buffer != ' ');
height = Convert.ToInt16(dimension);
string maxRGB = "";
do
{
buffer = memStream.ReadByte();
maxRGB += (char)buffer;
} while (buffer != '\n' && buffer != ' ');
max = Convert.ToInt16(maxRGB);
rgbValues = new byte[height * width * 3];
for (int i = 0; i < rgbValues.Length; i++)
{
rgbValues[i] = (byte)memStream.ReadByte();
}
memStream.Close();
try
{
bitmap = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
Rectangle rect = new Rectangle(0, 0, width, height);
System.Drawing.Imaging.BitmapData bmpData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);
IntPtr ptr = bmpData.Scan0;
byte[] bgrValues = new byte[rgbValues.Length];
for (int i = 0; i < rgbValues.Length; i += 3)
{
bgrValues[i] = rgbValues[i + 2];
bgrValues[i + 1] = rgbValues[i + 1];
bgrValues[i + 2] = rgbValues[i];
}
System.Runtime.InteropServices.Marshal.Copy(bgrValues, 0, ptr, bgrValues.Length);
bitmap.UnlockBits(bmpData);
return bitmap;
}
catch (Exception ex)
{
Console.WriteLine("Error creating new bitmap: " + ex.ToString());
}
return null;
}
public void WriteByte_Capacity_Exceeded ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, 1, 2, FileAccess.ReadWrite);
ums.WriteByte (0x44);
ums.WriteByte (0x45);
try {
ums.WriteByte (0x46);
Assert.Fail ("#1");
} catch (NotSupportedException ex) {
// Unable to expand length of this stream beyond its capacity
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
}
ums.Close();
}
public void SetLength ()
{
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
length, capacity, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.SetLength (length - 1);
Assert.AreEqual (capacity, ums.Capacity, "#A1");
Assert.AreEqual (length - 1, ums.Length, "#A2");
Assert.AreEqual (length - 1, ums.Position, "#A3");
ums.SetLength (length + 1);
Assert.AreEqual (capacity, ums.Capacity, "#B1");
Assert.AreEqual (length + 1, ums.Length, "#B2");
Assert.AreEqual (length - 1, ums.Position, "#B3");
ums.SetLength (length);
Assert.AreEqual (capacity, ums.Capacity, "#C1");
Assert.AreEqual (length, ums.Length, "#C2");
Assert.AreEqual (length - 1, ums.Position, "#C3");
ums.SetLength (0);
Assert.AreEqual (capacity, ums.Capacity, "#D1");
Assert.AreEqual (0, ums.Length, "#D2");
Assert.AreEqual (0, ums.Position, "#D3");
ums.SetLength (capacity);
Assert.AreEqual (capacity, ums.Capacity, "#E1");
Assert.AreEqual (capacity, ums.Length, "#E2");
Assert.AreEqual (0, ums.Position, "#E3");
ums.Close();
}
public void ReadByte ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#1");
Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#2");
ums.Close();
}
public void WriteByte ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, 3, 5, FileAccess.ReadWrite);
ums.WriteByte (testStreamData [0]);
Assert.AreEqual (5, ums.Capacity, "#A1");
Assert.AreEqual (1, ums.Position, "#A2");
Assert.AreEqual (3, ums.Length, "#A3");
ums.WriteByte (testStreamData [1]);
Assert.AreEqual (5, ums.Capacity, "#B1");
Assert.AreEqual (2, ums.Position, "#B2");
Assert.AreEqual (3, ums.Length, "#B3");
ums.WriteByte (testStreamData [2]);
Assert.AreEqual (5, ums.Capacity, "#C1");
Assert.AreEqual (3, ums.Position, "#C2");
Assert.AreEqual (3, ums.Length, "#C3");
ums.WriteByte (testStreamData [3]);
Assert.AreEqual (5, ums.Capacity, "#D1");
Assert.AreEqual (4, ums.Position, "#D2");
Assert.AreEqual (4, ums.Length, "#D3");
ums.WriteByte (testStreamData [4]);
Assert.AreEqual (5, ums.Capacity, "#E1");
Assert.AreEqual (5, ums.Position, "#E2");
Assert.AreEqual (5, ums.Length, "#E3");
ums.Seek (0, SeekOrigin.Begin);
Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#F1");
Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#F2");
Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#F3");
Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#F4");
Assert.AreEqual (testStreamData [4], ums.ReadByte (), "#F5");
ums.Close ();
}
public void Read ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
Assert.AreEqual (length / 2, ums.Read (readData, 0, (length / 2)), "#1");
VerifyTestData ("#2", readData, 0, (length / 2));
Assert.AreEqual (length / 2, ums.Position, "#3");
//Seek back to begining
ums.Seek (0, SeekOrigin.Begin);
//Read complete stream
Assert.AreEqual (length, ums.Read (readData, 0, length), "#4");
VerifyTestData ("#5", readData, 0, length);
Assert.AreEqual (length, ums.Position, "#6");
//Seek to mid of the stream and read till end
ums.Seek ((length / 2), SeekOrigin.Begin);
ums.Read (readData, 0, (length / 2));
VerifyTestData ("#7", readData, (length / 2), (length / 2));
Assert.AreEqual (length, ums.Position, "#8");
ums.Close ();
}
public void Read_EndOfStream ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, length * 2, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
Assert.AreEqual (0, ums.Read (readData, 0, 1), "#1");
ums.Seek(length + 1, SeekOrigin.Begin);
Assert.AreEqual (0, ums.Read (readData, 0, 1), "#2");
ums.Seek(length - 3, SeekOrigin.Begin);
Assert.AreEqual (3, ums.Read (readData, 0, 5), "#3");
ums.Seek(capacity + 1, SeekOrigin.Begin);
Assert.AreEqual (0, ums.Read (readData, 0, 1), "#4");
ums.Close ();
}
public void CanWrite_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
Assert.IsTrue (ums.CanWrite, "#1");
ums.Close ();
Assert.IsFalse (ums.CanWrite, "#2");
}
public void CanWrite ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
Assert.IsTrue (ums.CanWrite, "#1");
ums.Seek (length, SeekOrigin.Begin);
Assert.IsTrue (ums.CanWrite, "#2");
ums.Seek (capacity, SeekOrigin.Begin);
Assert.IsTrue (ums.CanWrite, "#3");
ums.Seek (capacity + 1, SeekOrigin.Begin);
Assert.IsTrue (ums.CanWrite, "#4");
ums.Seek (0, SeekOrigin.Begin);
Assert.IsTrue (ums.CanWrite, "#5");
ums.Close ();
}
public void Flush_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
ums.Flush();
}
public void Constructor1 ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
Assert.AreEqual ((long) length, ums.Capacity, "#1");
Assert.AreEqual ((long) length, ums.Length, "#2");
Assert.AreEqual (0L, ums.Position, "#3");
ums.Position = (length-2);
Assert.AreEqual ((long)(length - 2), ums.Position, "#4");
ums.Position = 0;
ums.Seek(3L, SeekOrigin.Begin);
Assert.AreEqual (3L, ums.Position, "#5");
Assert.IsTrue (ums.CanRead, "#6");
Assert.IsFalse (ums.CanWrite, "#7");
ums.Close();
}
public void ReadByte_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
ums.ReadByte();
}
public void Write_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
ums.Write(testStreamData, 0, length);
}
public void ReadByte_EndOfStream ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
ums.Seek(length, SeekOrigin.Begin);
Assert.AreEqual (-1, ums.ReadByte (), "#3");
ums.Seek(length + 1, SeekOrigin.Begin);
Assert.AreEqual (-1, ums.ReadByte (), "#4");
ums.Seek(capacity, SeekOrigin.Begin);
Assert.AreEqual (-1, ums.ReadByte (), "#5");
ums.Seek(capacity + 1, SeekOrigin.Begin);
Assert.AreEqual (-1, ums.ReadByte (), "#6");
ums.Close();
}
public void WriteByte_Stream_Closed ()
{
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
length, length, FileAccess.Write);
ums.Close();
ums.WriteByte(0x12);
}
public void ReadByte_WriteOnly ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Write);
try {
ums.ReadByte ();
Assert.Fail ("#1");
} catch (NotSupportedException ex) {
// Stream does not support reading
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
}
ums.Close();
}
public void WriteByte_Stream_ReadOnly ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
try {
ums.WriteByte (testStreamData [0]);
Assert.Fail ("#1");
} catch (NotSupportedException ex) {
// Stream does not support writing
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
}
ums.Close ();
}
public void Seek_Origin_Invalid ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, 5, 10, FileAccess.Read);
try {
ums.Seek(1, (SeekOrigin) 666);
Assert.Fail ("#1");
} catch (ArgumentException ex) {
// Invalid seek origin
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNull (ex.ParamName, "#5");
}
ums.Close();
}
public void SetLength_Capacity_Exceeded ()
{
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
length, capacity, FileAccess.ReadWrite);
try {
ums.SetLength (capacity + 1);
Assert.Fail ("#1");
} catch (IOException ex) {
// Unable to expand length of this stream beyond its capacity
Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
}
ums.Close();
}
public void Seek_Offset_Invalid ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
try {
ums.Seek(-1, SeekOrigin.Begin);
Assert.Fail ("#A1");
} catch (IOException ex) {
// An attempt was made to move the position before the beginning
// of the stream
Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
}
ums.Position = 2;
try {
ums.Seek(-3, SeekOrigin.Current);
Assert.Fail ("#B1");
} catch (IOException ex) {
// An attempt was made to move the position before the beginning
// of the stream
Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
}
ums.Close();
}
//returns bitmap image converted from the PANGU stream
public Bitmap getImage(float x, float y, float z, float yaw, float pitch, float roll , float fov)
{
try
{
unsafe
{
pan_protocol_set_aspect_ratio(sock, 1); //sets aspect ratio
pan_protocol_set_boulder_view(sock, 1, 0); //view boulders
pan_protocol_set_field_of_view(sock, fov); //set field of view
ulong t = 1024;
char* img;
img = pan_protocol_get_viewpoint_by_angle(sock, x, y, z, yaw, pitch, roll, &t); //gets the image
UnmanagedMemoryStream readStream = new UnmanagedMemoryStream((byte*)img, (long)t);
Bitmap bitmap = fetchImage(readStream);
readStream.Close();
readStream.Dispose();
return bitmap;
}
}
catch
{
return null; //Error at PANGU end.
}
}
public void Position_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
try {
long x = ums.Position;
Assert.Fail ("#1: " + x);
} catch (ObjectDisposedException) {
}
try {
ums.Position = 0;
Assert.Fail ("#2");
} catch (ObjectDisposedException) {
}
}
public override void Open(string filePath)
{
_content = File.ReadAllText(filePath);
int i = _content.IndexOf("%!");
if (i > 0)
{
_content = _content.Substring(i, _content.Length - i - 1);
}
i = _content.IndexOf("%%EOF");
if (i > -1)
{
_content = _content.Substring(0, i + 5);
}
if (this.Viewer.EPSClip)
{
unsafe
{
fixed (char* p = _content)
{
UnmanagedMemoryStream ums = new UnmanagedMemoryStream((byte*)p, _content.Length);
DSCTokenizer tokenizer = new DSCTokenizer(ums, true, BitConverter.IsLittleEndian);
DSCToken token = null;
while ((token = tokenizer.GetNextDSCKeywordToken()) != null)
{
if (token.Text == "%%BoundingBox:")
{
try
{
DSCToken v1 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd);
DSCToken v2 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd);
DSCToken v3 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd);
DSCToken v4 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd);
this.BoundingBox = new GhostscriptRectangle(
float.Parse(v1.Text, System.Globalization.CultureInfo.InvariantCulture),
float.Parse(v2.Text, System.Globalization.CultureInfo.InvariantCulture),
float.Parse(v3.Text, System.Globalization.CultureInfo.InvariantCulture),
float.Parse(v4.Text, System.Globalization.CultureInfo.InvariantCulture));
}
catch { }
break;
}
}
tokenizer.Dispose(); tokenizer = null;
ums.Close(); ums.Dispose(); ums = null;
}
}
}
this.FirstPageNumber = 1;
this.LastPageNumber = 1;
}
public void Write ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, length);
Assert.AreEqual (capacity, ums.Capacity, "#A1");
Assert.AreEqual (length, ums.Position, "#A2");
Assert.AreEqual (length, ums.Length, "#A3");
ums.Position = 0;
ums.Read (readData, 0, length);
Assert.AreEqual (capacity, ums.Capacity, "#B1");
Assert.AreEqual (length, ums.Position, "#B2");
Assert.AreEqual (length, ums.Length, "#B3");
VerifyTestData ("#B4", readData, 0, length);
ums.Write (testStreamData, 2, 2);
Assert.AreEqual (capacity, ums.Capacity, "#C1");
Assert.AreEqual (length + 2, ums.Position, "#C1");
Assert.AreEqual (length + 2, ums.Length, "#C2");
ums.Position = length;
Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#D1");
Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#D2");
ums.Close();
}
public void Seek_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close ();
ums.Seek (0, SeekOrigin.Begin);
}
public void PositionPointer_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
try {
byte* bptr = ums.PositionPointer;
Assert.Fail ("#1");
} catch (ObjectDisposedException) {
}
try {
// position pointer to somewhere within the capacity
ums.PositionPointer = (byte*) (capacity - 1);
Assert.Fail ("#2");
} catch (ObjectDisposedException) {
}
}
