mcs/class/corlib/Test/System.IO/UnmanagedMemoryStreamTest.cs

   1 //
   2 // System.IO.UnmanagedMemoryStreamTest.cs
   3 //
   4 // Authors:
   5 //      Sridhar Kulkarni (sridharkulkarni@gmail.com)
   6 //      Gert Driesen (drieseng@users.sourceforge.net)
   7 //      Sebastien Pouliot  <sebastien@ximian.com>
   8 //
   9 // (c) 2006 Sridhar Kulkarni.
  10 // Copyright (C) 2004, 2009 Novell (http://www.novell.com)
  11 //
  12
  13 using System;
  14 using System.Collections;
  15 using System.IO;
  16 using System.Runtime.InteropServices;
  17 using System.Text;
  18
  19 using NUnit.Framework;
  20
  21 namespace MonoTests.System.IO
  22 {
  23         [TestFixture]
  24         public unsafe class UnmanagedMemoryStreamTest {
  25                 byte[] testStreamData;
  26                 byte[] readData;
  27                 IntPtr mem_intptr = IntPtr.Zero;
  28                 byte* mem_byteptr = null;
  29                 int length;
  30                 int capacity;
  31
  32                 [SetUp]
  33                 public void SetUp()
  34                 {
  35                         testStreamData = UnicodeEncoding.Unicode.GetBytes("Here is some mono testdata");
  36                         length = testStreamData.Length;
  37                         capacity = testStreamData.Length * 2;
  38                         mem_intptr = Marshal.AllocHGlobal(capacity);
  39                         mem_byteptr = (byte*)mem_intptr.ToPointer();
  40                         readData = new byte[length];
  41                 }
  42
  43                 [TearDown]
  44                 public void TearDown ()
  45                 {
  46                         if (mem_intptr != IntPtr.Zero)
  47                                 Marshal.FreeHGlobal (mem_intptr);
  48                 }
  49
  50                 //
  51                 // Verify that the first count bytes in testBytes are the same as
  52                 // the count bytes from index start in testStreamData
  53                 //
  54                 void VerifyTestData (string id, byte [] testBytes, int start, int count)
  55                 {
  56                         if (testBytes == null)
  57                                 Assert.Fail(id + "+1 testBytes is null");
  58
  59                         if (start < 0 ||
  60                             count < 0 ||
  61                             start + count > testStreamData.Length ||
  62                             start > testStreamData.Length)
  63                                 throw new ArgumentOutOfRangeException(id + "+2");
  64
  65                         for (int test = 0; test < count; test++)
  66                         {
  67                                 if (testBytes[test] == testStreamData[start + test])
  68                                         continue;
  69
  70                                 string failStr = "testByte {0} (testStream {1}) was <{2}>, expecting <{3}>";
  71                                 failStr = String.Format(failStr,
  72                                                         test,
  73                                                         start + test,
  74                                                         testBytes[test],
  75                                                         testStreamData[start + test]);
  76                                 Assert.Fail(id + "-3" + failStr);
  77                         }
  78                 }
  79
  80                 [Test]
  81                 public void Constructor1 ()
  82                 {
  83                         UnmanagedMemoryStream ums = new
  84                                 UnmanagedMemoryStream(mem_byteptr, length);
  85                         Assert.AreEqual ((long) length, ums.Capacity, "#1");
  86                         Assert.AreEqual ((long) length, ums.Length, "#2");
  87                         Assert.AreEqual (0L, ums.Position, "#3");
  88                         ums.Position = (length-2);
  89                         Assert.AreEqual ((long)(length - 2), ums.Position, "#4");
  90                         ums.Position = 0;
  91                         ums.Seek(3L, SeekOrigin.Begin);
  92                         Assert.AreEqual (3L, ums.Position, "#5");
  93                         Assert.IsTrue (ums.CanRead, "#6");
  94                         Assert.IsFalse (ums.CanWrite, "#7");
  95                         ums.Close();
  96                 }
  97
  98                 [Test]
  99                 public void Constructor1_Length_Negative ()
 100                 {
 101                         try {
 102                                 new UnmanagedMemoryStream(mem_byteptr, -1);
 103                                 Assert.Fail ("#1");
 104                         } catch (ArgumentOutOfRangeException ex) {
 105                                 // Non-negative number required
 106                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 107                                 Assert.IsNull (ex.InnerException, "#3");
 108                                 Assert.IsNotNull (ex.Message, "#4");
 109                                 Assert.IsNotNull (ex.ParamName, "#5");
 110                                 Assert.AreEqual ("length", ex.ParamName, "#6");
 111                         }
 112                 }
 113
 114                 [Test]
 115                 public void Constructor1_Pointer_Null ()
 116                 {
 117                         try {
 118                                 new UnmanagedMemoryStream((byte*) null, -1);
 119                                 Assert.Fail ("#1");
 120                         } catch (ArgumentNullException ex) {
 121                                 // Value cannot be null
 122                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 123                                 Assert.IsNull (ex.InnerException, "#3");
 124                                 Assert.IsNotNull (ex.Message, "#4");
 125                                 Assert.IsNotNull (ex.ParamName, "#5");
 126                                 Assert.AreEqual ("pointer", ex.ParamName, "#6");
 127                         }
 128                 }
 129
 130                 [Test]
 131                 public void Constructor2 ()
 132                 {
 133                         UnmanagedMemoryStream ums;
 134
 135                         ums = new UnmanagedMemoryStream(mem_byteptr,
 136                                 length, 999, FileAccess.Read);
 137                         Assert.IsTrue (ums.CanRead, "#A1");
 138                         Assert.IsTrue (ums.CanSeek, "#A2");
 139                         Assert.IsFalse (ums.CanWrite, "#A3");
 140                         Assert.AreEqual (999, ums.Capacity, "#A4");
 141                         Assert.AreEqual (length, ums.Length, "#A5");
 142                         Assert.AreEqual (0, ums.Position, "#A6");
 143                         ums.Close ();
 144
 145                         ums = new UnmanagedMemoryStream(mem_byteptr,
 146                                 length, 666, FileAccess.Write);
 147                         Assert.IsFalse (ums.CanRead, "#B1");
 148                         Assert.IsTrue (ums.CanSeek, "#B2");
 149                         Assert.IsTrue (ums.CanWrite, "#B3");
 150                         Assert.AreEqual (666, ums.Capacity, "#B4");
 151                         Assert.AreEqual (length, ums.Length, "#B5");
 152                         Assert.AreEqual (0, ums.Position, "#B6");
 153                         ums.Close ();
 154
 155                         ums = new UnmanagedMemoryStream(mem_byteptr,
 156                                 0, 0, FileAccess.ReadWrite);
 157                         Assert.IsTrue (ums.CanRead, "#C1");
 158                         Assert.IsTrue (ums.CanSeek, "#C2");
 159                         Assert.IsTrue (ums.CanWrite, "#C3");
 160                         Assert.AreEqual (0, ums.Capacity, "#C4");
 161                         Assert.AreEqual (0, ums.Length, "#C5");
 162                         Assert.AreEqual (0, ums.Position, "#C6");
 163                         ums.Close ();
 164                 }
 165
 166                 [Test]
 167                 public void Constructor2_Access_Invalid ()
 168                 {
 169                         try {
 170                                 new UnmanagedMemoryStream(mem_byteptr, 0, 0, (FileAccess) 666);
 171                                 Assert.Fail ("#1");
 172                         } catch (ArgumentOutOfRangeException ex) {
 173                                 // Enum value was out of legal range
 174                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 175                                 Assert.IsNull (ex.InnerException, "#3");
 176                                 Assert.IsNotNull (ex.Message, "#4");
 177                                 Assert.IsNotNull (ex.ParamName, "#5");
 178                                 Assert.AreEqual ("access", ex.ParamName, "#6");
 179                         }
 180                 }
 181
 182                 [Test]
 183                 public void Constructor2_Capacity_Negative ()
 184                 {
 185                         try {
 186                                 new UnmanagedMemoryStream(mem_byteptr, 0, -1, FileAccess.Read);
 187                                 Assert.Fail ("#1");
 188                         } catch (ArgumentOutOfRangeException ex) {
 189                                 // Non-negative number required
 190                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 191                                 Assert.IsNull (ex.InnerException, "#3");
 192                                 Assert.IsNotNull (ex.Message, "#4");
 193                                 Assert.IsNotNull (ex.ParamName, "#5");
 194                                 Assert.AreEqual ("capacity", ex.ParamName, "#6");
 195                         }
 196                 }
 197
 198                 [Test]
 199                 public void Constructor2_Length_Negative ()
 200                 {
 201                         try {
 202                                 new UnmanagedMemoryStream(mem_byteptr, -1, 0, FileAccess.Read);
 203                                 Assert.Fail ("#1");
 204                         } catch (ArgumentOutOfRangeException ex) {
 205                                 // Non-negative number required
 206                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 207                                 Assert.IsNull (ex.InnerException, "#3");
 208                                 Assert.IsNotNull (ex.Message, "#4");
 209                                 Assert.IsNotNull (ex.ParamName, "#5");
 210                                 Assert.AreEqual ("length", ex.ParamName, "#6");
 211                         }
 212                 }
 213
 214                 [Test]
 215                 public void Constructor2_Length_Overflow ()
 216                 {
 217                         try {
 218                                 new UnmanagedMemoryStream(mem_byteptr, 5, 3, FileAccess.Read);
 219                                 Assert.Fail ("#1");
 220                         } catch (ArgumentOutOfRangeException ex) {
 221                                 // The length cannot be greater than the capacity
 222                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 223                                 Assert.IsNull (ex.InnerException, "#3");
 224                                 Assert.IsNotNull (ex.Message, "#4");
 225                                 Assert.IsNotNull (ex.ParamName, "#5");
 226                                 Assert.AreEqual ("length", ex.ParamName, "#6");
 227                         }
 228                 }
 229
 230                 [Test]
 231                 public void Constructor2_Pointer_Null ()
 232                 {
 233                         try {
 234                                 new UnmanagedMemoryStream((byte*) null, 5, 3, FileAccess.Read);
 235                                 Assert.Fail ("#1");
 236                         } catch (ArgumentNullException ex) {
 237                                 // Value cannot be null
 238                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 239                                 Assert.IsNull (ex.InnerException, "#3");
 240                                 Assert.IsNotNull (ex.Message, "#4");
 241                                 Assert.IsNotNull (ex.ParamName, "#5");
 242                                 Assert.AreEqual ("pointer", ex.ParamName, "#6");
 243                         }
 244                 }
 245
 246                 [Test]
 247                 [ExpectedException (typeof (ObjectDisposedException))]
 248                 public void Flush_Stream_Closed ()
 249                 {
 250                         UnmanagedMemoryStream ums = new
 251                                 UnmanagedMemoryStream(mem_byteptr, length);
 252                         ums.Close();
 253                         ums.Flush();
 254                 }
 255
 256                 [Test]
 257                 public void CanRead ()
 258                 {
 259                         UnmanagedMemoryStream ums = new
 260                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Read);
 261                         Assert.IsTrue (ums.CanRead, "#1");
 262                         ums.Seek (length, SeekOrigin.Begin);
 263                         Assert.IsTrue (ums.CanRead, "#2");
 264                         ums.Seek (capacity, SeekOrigin.Begin);
 265                         Assert.IsTrue (ums.CanRead, "#3");
 266                         ums.Seek (capacity + 1, SeekOrigin.Begin);
 267                         Assert.IsTrue (ums.CanRead, "#4");
 268                         ums.Seek (0, SeekOrigin.Begin);
 269                         Assert.IsTrue (ums.CanRead, "#5");
 270                         ums.Close ();
 271                 }
 272
 273                 [Test]
 274                 public void CanRead_Stream_Closed ()
 275                 {
 276                         UnmanagedMemoryStream ums = new
 277                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 278                         ums.Close ();
 279                         Assert.IsFalse (ums.CanRead);
 280                 }
 281
 282                 [Test]
 283                 public void CanSeek ()
 284                 {
 285                         UnmanagedMemoryStream ums = new
 286                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Read);
 287                         Assert.IsTrue (ums.CanSeek, "#1");
 288                         ums.Seek (length, SeekOrigin.Begin);
 289                         Assert.IsTrue (ums.CanSeek, "#2");
 290                         ums.Seek (capacity, SeekOrigin.Begin);
 291                         Assert.IsTrue (ums.CanSeek, "#3");
 292                         ums.Seek (capacity + 1, SeekOrigin.Begin);
 293                         Assert.IsTrue (ums.CanSeek, "#4");
 294                         ums.Seek (0, SeekOrigin.Begin);
 295                         Assert.IsTrue (ums.CanSeek, "#5");
 296                         ums.Close ();
 297                 }
 298
 299                 [Test]
 300                 public void CanSeek_Stream_Closed ()
 301                 {
 302                         UnmanagedMemoryStream ums = new
 303                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 304                         Assert.IsTrue (ums.CanSeek, "#1");
 305                         ums.Close ();
 306                         Assert.IsFalse (ums.CanSeek, "#2");
 307                 }
 308
 309                 [Test]
 310                 public void CanWrite ()
 311                 {
 312                         UnmanagedMemoryStream ums = new
 313                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 314                         Assert.IsTrue (ums.CanWrite, "#1");
 315                         ums.Seek (length, SeekOrigin.Begin);
 316                         Assert.IsTrue (ums.CanWrite, "#2");
 317                         ums.Seek (capacity, SeekOrigin.Begin);
 318                         Assert.IsTrue (ums.CanWrite, "#3");
 319                         ums.Seek (capacity + 1, SeekOrigin.Begin);
 320                         Assert.IsTrue (ums.CanWrite, "#4");
 321                         ums.Seek (0, SeekOrigin.Begin);
 322                         Assert.IsTrue (ums.CanWrite, "#5");
 323                         ums.Close ();
 324                 }
 325
 326                 [Test]
 327                 public void CanWrite_Stream_Closed ()
 328                 {
 329                         UnmanagedMemoryStream ums = new
 330                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 331                         Assert.IsTrue (ums.CanWrite, "#1");
 332                         ums.Close ();
 333                         Assert.IsFalse (ums.CanWrite, "#2");
 334                 }
 335
 336                 [Test]
 337                 public void Read ()
 338                 {
 339                         UnmanagedMemoryStream ums = new
 340                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 341                         ums.Write (testStreamData, 0, testStreamData.Length);
 342                         ums.Position = 0;
 343
 344                         Assert.AreEqual (length / 2, ums.Read (readData, 0, (length / 2)), "#1");
 345                         VerifyTestData ("#2", readData, 0, (length / 2));
 346                         Assert.AreEqual (length / 2, ums.Position, "#3");
 347
 348                         //Seek back to begining
 349                         ums.Seek (0, SeekOrigin.Begin);
 350
 351                         //Read complete stream
 352                         Assert.AreEqual (length, ums.Read (readData, 0, length), "#4");
 353                         VerifyTestData ("#5", readData, 0, length);
 354                         Assert.AreEqual (length, ums.Position, "#6");
 355
 356                         //Seek to mid of the stream and read till end
 357                         ums.Seek ((length / 2), SeekOrigin.Begin);
 358                         ums.Read (readData, 0, (length / 2));
 359                         VerifyTestData ("#7", readData, (length / 2), (length / 2));
 360                         Assert.AreEqual (length, ums.Position, "#8");
 361                         ums.Close ();
 362                 }
 363
 364                 [Test]
 365                 public void Read_Buffer_Null ()
 366                 {
 367                         UnmanagedMemoryStream ums = new
 368                                 UnmanagedMemoryStream(mem_byteptr, length);
 369                         try {
 370                                 ums.Read((byte []) null, 0, 0);
 371                                 Assert.Fail ("#1");
 372                         } catch (ArgumentNullException ex) {
 373                                 // Value cannot be null
 374                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 375                                 Assert.IsNull (ex.InnerException, "#3");
 376                                 Assert.IsNotNull (ex.Message, "#4");
 377                                 Assert.IsNotNull (ex.ParamName, "#5");
 378                                 Assert.AreEqual ("buffer", ex.ParamName, "#6");
 379                         }
 380                 }
 381
 382                 [Test]
 383                 [ExpectedException (typeof (ObjectDisposedException))]
 384                 public void Read_Stream_Closed ()
 385                 {
 386                         UnmanagedMemoryStream ums = new
 387                                 UnmanagedMemoryStream(mem_byteptr, length);
 388                         ums.Close();
 389                         ums.Read(readData, 0, 0);
 390                 }
 391
 392                 [Test]
 393                 public void Read_Count_Negative ()
 394                 {
 395                         UnmanagedMemoryStream ums = new
 396                                 UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
 397                         ums.Write (testStreamData, 0, testStreamData.Length);
 398                         ums.Position = 0;
 399                         try {
 400                                 ums.Read (readData, 0, -1);
 401                                 Assert.Fail ("#1");
 402                         } catch (ArgumentOutOfRangeException ex) {
 403                                 // Non-negative number required
 404                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 405                                 Assert.IsNull (ex.InnerException, "#3");
 406                                 Assert.IsNotNull (ex.Message, "#4");
 407                                 Assert.IsNotNull (ex.ParamName, "#5");
 408                                 Assert.AreEqual ("count", ex.ParamName, "#6");
 409                         }
 410                 }
 411
 412                 [Test]
 413                 public void Read_Count_Overlow ()
 414                 {
 415                         UnmanagedMemoryStream ums = new
 416                                 UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
 417                         ums.Write (testStreamData, 0, testStreamData.Length);
 418                         ums.Position = 0;
 419                         try {
 420                                 ums.Read (readData, 1, readData.Length);
 421                                 Assert.Fail ("#1");
 422                         } catch (ArgumentException ex) {
 423                                 // Offset and length were out of bounds for the array or count
 424                                 // is greater than the number of elements from index to the end
 425                                 // of the source collection
 426                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 427                                 Assert.IsNull (ex.InnerException, "#3");
 428                                 Assert.IsNotNull (ex.Message, "#4");
 429                                 Assert.IsNull (ex.ParamName, "#5");
 430                         }
 431                 }
 432
 433                 [Test]
 434                 public void Read_EndOfStream ()
 435                 {
 436                         UnmanagedMemoryStream ums = new
 437                                 UnmanagedMemoryStream(mem_byteptr, length, length * 2, FileAccess.ReadWrite);
 438                         ums.Write (testStreamData, 0, testStreamData.Length);
 439                         Assert.AreEqual (0, ums.Read (readData, 0, 1), "#1");
 440                         ums.Seek(length + 1, SeekOrigin.Begin);
 441                         Assert.AreEqual (0, ums.Read (readData, 0, 1), "#2");
 442                         ums.Seek(length - 3, SeekOrigin.Begin);
 443                         Assert.AreEqual (3, ums.Read (readData, 0, 5), "#3");
 444                         ums.Seek(capacity + 1, SeekOrigin.Begin);
 445                         Assert.AreEqual (0, ums.Read (readData, 0, 1), "#4");
 446                         ums.Close ();
 447                 }
 448
 449                 [Test]
 450                 public void Read_Offset_Negative ()
 451                 {
 452                         UnmanagedMemoryStream ums = new
 453                                 UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
 454                         ums.Write (testStreamData, 0, testStreamData.Length);
 455                         ums.Position = 0;
 456                         try {
 457                                 ums.Read (readData, -1, 0);
 458                                 Assert.Fail ("#1");
 459                         } catch (ArgumentOutOfRangeException ex) {
 460                                 // Non-negative number required
 461                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 462                                 Assert.IsNull (ex.InnerException, "#3");
 463                                 Assert.IsNotNull (ex.Message, "#4");
 464                                 Assert.IsNotNull (ex.ParamName, "#5");
 465                                 Assert.AreEqual ("offset", ex.ParamName, "#6");
 466                         }
 467                 }
 468
 469                 [Test]
 470                 public void Read_Offset_Overflow ()
 471                 {
 472                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, length, FileAccess.ReadWrite)) {
 473                                 ums.Write (testStreamData, 0, testStreamData.Length);
 474                                 ums.Position = 0;
 475                                 try {
 476                                         ums.Read (readData, Int32.MaxValue, 0);
 477                                         Assert.Fail ("#1");
 478                                 }
 479                                 catch (ArgumentException ex) {
 480                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 481                                         Assert.IsNull (ex.InnerException, "#3");
 482                                         Assert.IsNotNull (ex.Message, "#4");
 483                                         Assert.IsNull (ex.ParamName, "#5");
 484                                 }
 485                         }
 486                 }
 487
 488                 [Test]
 489                 public void Read_Count_Overflow ()
 490                 {
 491                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, length, FileAccess.ReadWrite)) {
 492                                 ums.Write (testStreamData, 0, testStreamData.Length);
 493                                 ums.Position = 0;
 494                                 try {
 495                                         ums.Read (readData, 0, Int32.MaxValue);
 496                                         Assert.Fail ("#1");
 497                                 }
 498                                 catch (ArgumentException ex) {
 499                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 500                                         Assert.IsNull (ex.InnerException, "#3");
 501                                         Assert.IsNotNull (ex.Message, "#4");
 502                                         Assert.IsNull (ex.ParamName, "#5");
 503                                 }
 504                         }
 505                 }
 506
 507                 [Test]
 508                 public void Read_WriteOnly ()
 509                 {
 510                         UnmanagedMemoryStream ums = new
 511                                 UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.Write);
 512                         try {
 513                                 ums.Read(readData, 0, 1);
 514                                 Assert.Fail ("#1");
 515                         } catch (NotSupportedException ex) {
 516                                 // Stream does not support reading
 517                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 518                                 Assert.IsNull (ex.InnerException, "#3");
 519                                 Assert.IsNotNull (ex.Message, "#4");
 520                         }
 521                         ums.Close();
 522                 }
 523
 524                 [Test]
 525                 public void ReadByte ()
 526                 {
 527                         UnmanagedMemoryStream ums = new
 528                                 UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
 529                         ums.Write (testStreamData, 0, testStreamData.Length);
 530                         ums.Position = 0;
 531                         Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#1");
 532                         Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#2");
 533                         ums.Close();
 534                 }
 535
 536                 [Test]
 537                 [ExpectedException (typeof (ObjectDisposedException))]
 538                 public void ReadByte_Stream_Closed ()
 539                 {
 540                         UnmanagedMemoryStream ums = new
 541                                 UnmanagedMemoryStream(mem_byteptr, length);
 542                         ums.Close();
 543                         ums.ReadByte();
 544                 }
 545
 546                 [Test]
 547                 public void ReadByte_EndOfStream ()
 548                 {
 549                         UnmanagedMemoryStream ums = new
 550                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 551                         ums.Write (testStreamData, 0, testStreamData.Length);
 552                         ums.Position = 0;
 553                         ums.Seek(length, SeekOrigin.Begin);
 554                         Assert.AreEqual (-1, ums.ReadByte (), "#3");
 555                         ums.Seek(length + 1, SeekOrigin.Begin);
 556                         Assert.AreEqual (-1, ums.ReadByte (), "#4");
 557                         ums.Seek(capacity, SeekOrigin.Begin);
 558                         Assert.AreEqual (-1, ums.ReadByte (), "#5");
 559                         ums.Seek(capacity + 1, SeekOrigin.Begin);
 560                         Assert.AreEqual (-1, ums.ReadByte (), "#6");
 561                         ums.Close();
 562                 }
 563
 564                 [Test]
 565                 public void ReadByte_WriteOnly ()
 566                 {
 567                         UnmanagedMemoryStream ums = new
 568                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Write);
 569                         try {
 570                                 ums.ReadByte ();
 571                                 Assert.Fail ("#1");
 572                         } catch (NotSupportedException ex) {
 573                                 // Stream does not support reading
 574                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 575                                 Assert.IsNull (ex.InnerException, "#3");
 576                                 Assert.IsNotNull (ex.Message, "#4");
 577                         }
 578                         ums.Close();
 579                 }
 580
 581                 [Test]
 582                 public void Seek ()
 583                 {
 584                         UnmanagedMemoryStream ums = new
 585                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Write);
 586                         Assert.AreEqual (5, ums.Seek (5, SeekOrigin.Begin), "#A1");
 587                         Assert.AreEqual (5, ums.Position, "#A2");
 588                         Assert.AreEqual (length, ums.Length, "#A3");
 589
 590                         ums.Seek (2, SeekOrigin.Current);
 591                         //Assert.AreEqual (7, ums.Seek (2, SeekOrigin.Current), "#B1");
 592                         Assert.AreEqual (7, ums.Position, "#B2");
 593                         Assert.AreEqual (length, ums.Length, "#B3");
 594
 595                         Assert.AreEqual (length + 2, ums.Seek (2, SeekOrigin.End), "#C1");
 596                         Assert.AreEqual (length + 2, ums.Position, "#C2");
 597                         Assert.AreEqual (length, ums.Length, "#C3");
 598
 599                         Assert.AreEqual (0, ums.Seek (0, SeekOrigin.Begin), "#D1");
 600                         Assert.AreEqual (0, ums.Position, "#D2");
 601                         Assert.AreEqual (length, ums.Length, "#D3");
 602
 603                         Assert.AreEqual (length - 2, ums.Seek (-2, SeekOrigin.End), "#E1");
 604                         Assert.AreEqual (length - 2, ums.Position, "#E2");
 605                         Assert.AreEqual (length, ums.Length, "#E3");
 606
 607                         Assert.AreEqual (length - 5, ums.Seek (-3, SeekOrigin.Current), "#F1");
 608                         Assert.AreEqual (length - 5, ums.Position, "#F2");
 609                         Assert.AreEqual (length, ums.Length, "#F3");
 610
 611                         Assert.AreEqual (capacity + 5, ums.Seek (capacity + 5, SeekOrigin.Begin), "#G1");
 612                         Assert.AreEqual (capacity + 5, ums.Position, "#G2");
 613                         Assert.AreEqual (length, ums.Length, "#G3");
 614                 }
 615
 616                 [Test]
 617                 public void Seek_Origin_Invalid ()
 618                 {
 619                         UnmanagedMemoryStream ums = new
 620                                 UnmanagedMemoryStream(mem_byteptr, 5, 10, FileAccess.Read);
 621                         try {
 622                                 ums.Seek(1, (SeekOrigin) 666);
 623                                 Assert.Fail ("#1");
 624                         } catch (ArgumentException ex) {
 625                                 // Invalid seek origin
 626                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 627                                 Assert.IsNull (ex.InnerException, "#3");
 628                                 Assert.IsNotNull (ex.Message, "#4");
 629                                 Assert.IsNull (ex.ParamName, "#5");
 630                         }
 631                         ums.Close();
 632                 }
 633
 634                 [Test]
 635                 public void Seek_Offset_Invalid ()
 636                 {
 637                         UnmanagedMemoryStream ums = new
 638                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 639                         ums.Write (testStreamData, 0, testStreamData.Length);
 640                         ums.Position = 0;
 641                         try {
 642                                 ums.Seek(-1, SeekOrigin.Begin);
 643                                 Assert.Fail ("#A1");
 644                         } catch (IOException ex) {
 645                                 // An attempt was made to move the position before the beginning
 646                                 // of the stream
 647                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
 648                                 Assert.IsNull (ex.InnerException, "#A3");
 649                                 Assert.IsNotNull (ex.Message, "#A4");
 650                         }
 651
 652                         ums.Position = 2;
 653                         try {
 654                                 ums.Seek(-3, SeekOrigin.Current);
 655                                 Assert.Fail ("#B1");
 656                         } catch (IOException ex) {
 657                                 // An attempt was made to move the position before the beginning
 658                                 // of the stream
 659                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
 660                                 Assert.IsNull (ex.InnerException, "#B3");
 661                                 Assert.IsNotNull (ex.Message, "#B4");
 662                         }
 663
 664                         ums.Close();
 665                 }
 666
 667                 [Test]
 668                 public void Seek_Begin_Overflow ()
 669                 {
 670                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, 5, 10, FileAccess.Read)) {
 671                                 Assert.AreEqual (Int64.MaxValue, ums.Seek (Int64.MaxValue, SeekOrigin.Begin), "Seek");
 672                                 Assert.AreEqual (Int64.MaxValue, ums.Position, "Position");
 673                                 try {
 674                                         byte* p = ums.PositionPointer;
 675                                         Assert.Fail ("#1");
 676                                 }
 677                                 catch (IndexOutOfRangeException ex) {
 678                                         Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#2");
 679                                         Assert.IsNull (ex.InnerException, "#3");
 680                                         Assert.IsNotNull (ex.Message, "#4");
 681                                 }
 682                         }
 683                 }
 684
 685                 [Test]
 686                 public void Seek_Current_Overflow ()
 687                 {
 688                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, 5, 10, FileAccess.Read)) {
 689                                 ums.ReadByte ();
 690                                 try {
 691                                         ums.Seek (Int64.MaxValue, SeekOrigin.Current);
 692                                         Assert.Fail ("#1");
 693                                 }
 694                                 catch (IOException ex) {
 695                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 696                                         Assert.IsNull (ex.InnerException, "#3");
 697                                         Assert.IsNotNull (ex.Message, "#4");
 698                                 }
 699                         }
 700                 }
 701
 702                 [Test]
 703                 public void Seek_End_Overflow ()
 704                 {
 705                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, 5, 10, FileAccess.Read)) {
 706                                 try {
 707                                         ums.Seek (Int64.MaxValue, SeekOrigin.End);
 708                                         Assert.Fail ("#1");
 709                                 }
 710                                 catch (IOException ex) {
 711                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 712                                         Assert.IsNull (ex.InnerException, "#3");
 713                                         Assert.IsNotNull (ex.Message, "#4");
 714                                 }
 715                         }
 716                 }
 717
 718                 [Test]
 719                 [ExpectedException (typeof (ObjectDisposedException))]
 720                 public void Seek_Stream_Closed ()
 721                 {
 722                         UnmanagedMemoryStream ums = new
 723                                 UnmanagedMemoryStream(mem_byteptr, length);
 724                         ums.Close ();
 725                         ums.Seek (0, SeekOrigin.Begin);
 726                 }
 727
 728                 [Test]
 729                 public void Write ()
 730                 {
 731                         UnmanagedMemoryStream ums = new
 732                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 733                         ums.Write (testStreamData, 0, length);
 734                         Assert.AreEqual (capacity, ums.Capacity, "#A1");
 735                         Assert.AreEqual (length, ums.Position, "#A2");
 736                         Assert.AreEqual (length, ums.Length, "#A3");
 737                         ums.Position = 0;
 738                         ums.Read (readData, 0, length);
 739                         Assert.AreEqual (capacity, ums.Capacity, "#B1");
 740                         Assert.AreEqual (length, ums.Position, "#B2");
 741                         Assert.AreEqual (length, ums.Length, "#B3");
 742                         VerifyTestData ("#B4", readData, 0, length);
 743                         ums.Write (testStreamData, 2, 2);
 744                         Assert.AreEqual (capacity, ums.Capacity, "#C1");
 745                         Assert.AreEqual (length + 2, ums.Position, "#C1");
 746                         Assert.AreEqual (length + 2, ums.Length, "#C2");
 747                         ums.Position = length;
 748                         Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#D1");
 749                         Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#D2");
 750                         ums.Close();
 751                 }
 752
 753                 [Test]
 754                 public void Write_Capacity_Exceeded ()
 755                 {
 756                         UnmanagedMemoryStream ums = new
 757                                 UnmanagedMemoryStream(mem_byteptr, length, length + 2, FileAccess.ReadWrite);
 758                         ums.Write (testStreamData, 0, length);
 759                         ums.Write (testStreamData, 0, 2);
 760                         try {
 761                                 ums.Write (testStreamData, 0, 1);
 762                                 Assert.Fail ("#1");
 763                         } catch (NotSupportedException ex) {
 764                                 // Unable to expand length of this stream beyond its capacity
 765                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 766                                 Assert.IsNull (ex.InnerException, "#3");
 767                                 Assert.IsNotNull (ex.Message, "#4");
 768                         }
 769                         ums.Close();
 770                 }
 771
 772                 [Test]
 773                 public void Write_Count_Negative ()
 774                 {
 775                         UnmanagedMemoryStream ums = new
 776                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 777                         try {
 778                                 ums.Write (testStreamData, 0, -1);
 779                                 Assert.Fail ("#1");
 780                         } catch (ArgumentOutOfRangeException ex) {
 781                                 // Non-negative number required
 782                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 783                                 Assert.IsNull (ex.InnerException, "#3");
 784                                 Assert.IsNotNull (ex.Message, "#4");
 785                                 Assert.IsNotNull (ex.ParamName, "#5");
 786                                 Assert.AreEqual ("count", ex.ParamName, "#6");
 787                         }
 788                         ums.Close();
 789                 }
 790
 791                 [Test]
 792                 public void Write_Offset_Negative ()
 793                 {
 794                         UnmanagedMemoryStream ums = new
 795                                 UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
 796                         try {
 797                                 ums.Write (testStreamData, -1, testStreamData.Length);
 798                                 Assert.Fail ("#1");
 799                         } catch (ArgumentOutOfRangeException ex) {
 800                                 // Non-negative number required
 801                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 802                                 Assert.IsNull (ex.InnerException, "#3");
 803                                 Assert.IsNotNull (ex.Message, "#4");
 804                                 Assert.IsNotNull (ex.ParamName, "#5");
 805                                 Assert.AreEqual ("offset", ex.ParamName, "#6");
 806                         }
 807                         ums.Close();
 808                 }
 809
 810                 [Test]
 811                 public void Write_Offset_Overflow ()
 812                 {
 813                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, capacity, FileAccess.ReadWrite)) {
 814                                 try {
 815                                         ums.Write (testStreamData, Int32.MaxValue, 1);
 816                                         Assert.Fail ("#1");
 817                                 }
 818                                 catch (ArgumentException ex) {
 819                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 820                                         Assert.IsNull (ex.InnerException, "#3");
 821                                         Assert.IsNotNull (ex.Message, "#4");
 822                                         Assert.IsNull (ex.ParamName, "#5");
 823                                 }
 824                         }
 825                 }
 826
 827                 [Test]
 828                 public void Write_Count_Overflow ()
 829                 {
 830                         using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, capacity, FileAccess.ReadWrite)) {
 831                                 try {
 832                                         ums.Write (testStreamData, 1, Int32.MaxValue);
 833                                         Assert.Fail ("#1");
 834                                 }
 835                                 catch (ArgumentException ex) {
 836                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 837                                         Assert.IsNull (ex.InnerException, "#3");
 838                                         Assert.IsNotNull (ex.Message, "#4");
 839                                         Assert.IsNull (ex.ParamName, "#5");
 840                                 }
 841                         }
 842                 }
 843
 844                 [Test]
 845                 [ExpectedException (typeof (ObjectDisposedException))]
 846                 public void Write_Stream_Closed ()
 847                 {
 848                         UnmanagedMemoryStream ums = new
 849                                 UnmanagedMemoryStream(mem_byteptr, length);
 850                         ums.Close();
 851                         ums.Write(testStreamData, 0, length);
 852                 }
 853
 854                 [Test]
 855                 public void Write_Stream_ReadOnly ()
 856                 {
 857                         UnmanagedMemoryStream ums = new
 858                                 UnmanagedMemoryStream(mem_byteptr, length);
 859                         try {
 860                                 ums.Write(testStreamData, 0, length);
 861                                 Assert.Fail ("#1");
 862                         } catch (NotSupportedException ex) {
 863                                 // Stream does not support writing
 864                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 865                                 Assert.IsNull (ex.InnerException, "#3");
 866                                 Assert.IsNotNull (ex.Message, "#4");
 867                         }
 868                         ums.Close();
 869                 }
 870
 871                 [Test]
 872                 public void WriteByte ()
 873                 {
 874                         UnmanagedMemoryStream ums = new
 875                                 UnmanagedMemoryStream(mem_byteptr, 3, 5, FileAccess.ReadWrite);
 876                         ums.WriteByte (testStreamData [0]);
 877                         Assert.AreEqual (5, ums.Capacity, "#A1");
 878                         Assert.AreEqual (1, ums.Position, "#A2");
 879                         Assert.AreEqual (3, ums.Length, "#A3");
 880                         ums.WriteByte (testStreamData [1]);
 881                         Assert.AreEqual (5, ums.Capacity, "#B1");
 882                         Assert.AreEqual (2, ums.Position, "#B2");
 883                         Assert.AreEqual (3, ums.Length, "#B3");
 884                         ums.WriteByte (testStreamData [2]);
 885                         Assert.AreEqual (5, ums.Capacity, "#C1");
 886                         Assert.AreEqual (3, ums.Position, "#C2");
 887                         Assert.AreEqual (3, ums.Length, "#C3");
 888                         ums.WriteByte (testStreamData [3]);
 889                         Assert.AreEqual (5, ums.Capacity, "#D1");
 890                         Assert.AreEqual (4, ums.Position, "#D2");
 891                         Assert.AreEqual (4, ums.Length, "#D3");
 892                         ums.WriteByte (testStreamData [4]);
 893                         Assert.AreEqual (5, ums.Capacity, "#E1");
 894                         Assert.AreEqual (5, ums.Position, "#E2");
 895                         Assert.AreEqual (5, ums.Length, "#E3");
 896                         ums.Seek (0, SeekOrigin.Begin);
 897                         Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#F1");
 898                         Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#F2");
 899                         Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#F3");
 900                         Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#F4");
 901                         Assert.AreEqual (testStreamData [4], ums.ReadByte (), "#F5");
 902                         ums.Close ();
 903                 }
 904
 905                 [Test]
 906                 [ExpectedException (typeof (ObjectDisposedException))]
 907                 public void WriteByte_Stream_Closed ()
 908                 {
 909                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
 910                                 length, length, FileAccess.Write);
 911                         ums.Close();
 912                         ums.WriteByte(0x12);
 913                 }
 914
 915                 [Test]
 916                 public void WriteByte_Capacity_Exceeded ()
 917                 {
 918                         UnmanagedMemoryStream ums = new
 919                                 UnmanagedMemoryStream(mem_byteptr, 1, 2, FileAccess.ReadWrite);
 920                         ums.WriteByte (0x44);
 921                         ums.WriteByte (0x45);
 922                         try {
 923                                 ums.WriteByte (0x46);
 924                                 Assert.Fail ("#1");
 925                         } catch (NotSupportedException ex) {
 926                                 // Unable to expand length of this stream beyond its capacity
 927                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 928                                 Assert.IsNull (ex.InnerException, "#3");
 929                                 Assert.IsNotNull (ex.Message, "#4");
 930                         }
 931                         ums.Close();
 932                 }
 933
 934                 [Test]
 935                 public void WriteByte_Stream_ReadOnly ()
 936                 {
 937                         UnmanagedMemoryStream ums = new
 938                                 UnmanagedMemoryStream(mem_byteptr, length);
 939                         try {
 940                                 ums.WriteByte (testStreamData [0]);
 941                                 Assert.Fail ("#1");
 942                         } catch (NotSupportedException ex) {
 943                                 // Stream does not support writing
 944                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 945                                 Assert.IsNull (ex.InnerException, "#3");
 946                                 Assert.IsNotNull (ex.Message, "#4");
 947                         }
 948                         ums.Close ();
 949                 }
 950
 951                 [Test]
 952                 public void SetLength ()
 953                 {
 954                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
 955                                 length, capacity, FileAccess.ReadWrite);
 956                         ums.Write (testStreamData, 0, testStreamData.Length);
 957                         ums.SetLength (length - 1);
 958                         Assert.AreEqual (capacity, ums.Capacity, "#A1");
 959                         Assert.AreEqual (length - 1, ums.Length, "#A2");
 960                         Assert.AreEqual (length - 1, ums.Position, "#A3");
 961                         ums.SetLength (length + 1);
 962                         Assert.AreEqual (capacity, ums.Capacity, "#B1");
 963                         Assert.AreEqual (length + 1, ums.Length, "#B2");
 964                         Assert.AreEqual (length - 1, ums.Position, "#B3");
 965                         ums.SetLength (length);
 966                         Assert.AreEqual (capacity, ums.Capacity, "#C1");
 967                         Assert.AreEqual (length, ums.Length, "#C2");
 968                         Assert.AreEqual (length - 1, ums.Position, "#C3");
 969                         ums.SetLength (0);
 970                         Assert.AreEqual (capacity, ums.Capacity, "#D1");
 971                         Assert.AreEqual (0, ums.Length, "#D2");
 972                         Assert.AreEqual (0, ums.Position, "#D3");
 973                         ums.SetLength (capacity);
 974                         Assert.AreEqual (capacity, ums.Capacity, "#E1");
 975                         Assert.AreEqual (capacity, ums.Length, "#E2");
 976                         Assert.AreEqual (0, ums.Position, "#E3");
 977                         ums.Close();
 978                 }
 979
 980                 [Test]
 981                 public void SetLength_Capacity_Exceeded ()
 982                 {
 983                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
 984                                 length, capacity, FileAccess.ReadWrite);
 985                         try {
 986                                 ums.SetLength (capacity + 1);
 987                                 Assert.Fail ("#1");
 988                         } catch (IOException ex) {
 989                                 // Unable to expand length of this stream beyond its capacity
 990                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 991                                 Assert.IsNull (ex.InnerException, "#3");
 992                                 Assert.IsNotNull (ex.Message, "#4");
 993                         }
 994                         ums.Close();
 995                 }
 996
 997                 [Test]
 998                 public void SetLength_Negative ()
 999                 {
1000                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
1001                                 length, capacity, FileAccess.ReadWrite);
1002                         try {
1003                                 ums.SetLength(-1);
1004                                 Assert.Fail ("#1");
1005                         } catch (ArgumentOutOfRangeException ex) {
1006                                 // Non-negative number required
1007                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1008                                 Assert.IsNull (ex.InnerException, "#3");
1009                                 Assert.IsNotNull (ex.Message, "#4");
1010                                 Assert.IsNotNull (ex.ParamName, "#5");
1011                                 Assert.AreEqual ("length", ex.ParamName, "#6");
1012                         }
1013                         ums.Close();
1014                 }
1015
1016                 [Test]
1017                 public void SetLength_Stream_ReadOnly ()
1018                 {
1019                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
1020                                 length);
1021                         try {
1022                                 ums.SetLength (length);
1023                                 Assert.Fail ("#1");
1024                         } catch (NotSupportedException ex) {
1025                                 // Stream does not support writing
1026                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
1027                                 Assert.IsNull (ex.InnerException, "#3");
1028                                 Assert.IsNotNull (ex.Message, "#4");
1029                         }
1030                         ums.Close();
1031                 }
1032
1033                 [Test]
1034                 [ExpectedException (typeof (ObjectDisposedException))]
1035                 public void Capacity_Stream_Closed ()
1036                 {
1037                         UnmanagedMemoryStream ums = new
1038                                 UnmanagedMemoryStream(mem_byteptr, length);
1039                         ums.Close();
1040                         long capacity = ums.Capacity;
1041                 }
1042
1043                 [Test]
1044                 [ExpectedException (typeof (ObjectDisposedException))]
1045                 public void Length_Stream_Closed ()
1046                 {
1047                         UnmanagedMemoryStream ums = new
1048                                 UnmanagedMemoryStream(mem_byteptr, length);
1049                         ums.Close();
1050                         long x = ums.Length;
1051                 }
1052
1053                 [Test]
1054                 public void Position ()
1055                 {
1056                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
1057                                 length, capacity, FileAccess.ReadWrite);
1058                         Assert.AreEqual (0, ums.Position, "#1");
1059                         ums.Position = capacity;
1060                         Assert.AreEqual (capacity, ums.Position, "#2");
1061                         ums.Position = length;
1062                         Assert.AreEqual (length, ums.Position, "#3");
1063                         ums.Position = int.MaxValue;
1064                         Assert.AreEqual (int.MaxValue, ums.Position, "#4");
1065                         ums.Position = 0;
1066                         Assert.AreEqual (0, ums.Position, "#5");
1067                         ums.Close();
1068                 }
1069
1070                 [Test]
1071                 public void Position_MaxValue_Exceeded ()
1072                 {
1073                         UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr,
1074                                 length, capacity, FileAccess.ReadWrite);
1075                         try {
1076                                 ums.Position = 0x80000000;
1077                                 Assert.Fail ("#1");
1078                         } catch (ArgumentOutOfRangeException ex) {
1079                                 // MemoryStream length must be non-negative and less than
1080                                 // 2^31 - 1 - origin
1081                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1082                                 Assert.IsNull (ex.InnerException, "#3");
1083                                 Assert.IsNotNull (ex.Message, "#4");
1084                                 Assert.IsNotNull (ex.ParamName, "#5");
1085                                 Assert.AreEqual ("value", ex.ParamName, "#6");
1086                         }
1087                         ums.Close();
1088                 }
1089
1090                 [Test]
1091                 public void Position_Negative ()
1092                 {
1093                         UnmanagedMemoryStream ums = new
1094                                 UnmanagedMemoryStream(mem_byteptr, length);
1095                         try {
1096                                 ums.Position = -1;
1097                                 Assert.Fail ("#1");
1098                         } catch (ArgumentOutOfRangeException ex) {
1099                                 // Non-negative number required
1100                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1101                                 Assert.IsNull (ex.InnerException, "#3");
1102                                 Assert.IsNotNull (ex.Message, "#4");
1103                                 Assert.IsNotNull (ex.ParamName, "#5");
1104                                 Assert.AreEqual ("value", ex.ParamName, "#6");
1105                         }
1106                         ums.Close ();
1107                 }
1108
1109                 [Test]
1110                 public void Position_Overflow ()
1111                 {
1112                         byte [] n = new byte [8];
1113                         fixed (byte* p = n) {
1114                                 UnmanagedMemoryStream m = new UnmanagedMemoryStream (p, 8);
1115                                 Assert.AreEqual (0, m.Position, "Position-0");
1116                                 m.Position += 9;
1117                                 Assert.AreEqual (9, m.Position, "Position-1");
1118                                 try {
1119                                         byte* p2 = m.PositionPointer;
1120                                         Assert.Fail ("PositionPointer");
1121                                 }
1122                                 catch (IndexOutOfRangeException) {
1123                                         // expected
1124                                 }
1125                         }
1126                 }
1127
1128                 [Test]
1129                 public void Position_Stream_Closed ()
1130                 {
1131                         UnmanagedMemoryStream ums = new
1132                                 UnmanagedMemoryStream(mem_byteptr, length);
1133                         ums.Close();
1134                         try {
1135                                 long x = ums.Position;
1136                                 Assert.Fail ("#1: " + x);
1137                         } catch (ObjectDisposedException) {
1138                         }
1139
1140                         try {
1141                                 ums.Position = 0;
1142                                 Assert.Fail ("#2");
1143                         } catch (ObjectDisposedException) {
1144                         }
1145                 }
1146
1147                 [Test]
1148                 public void PositionPointer_Stream_Closed ()
1149                 {
1150                         UnmanagedMemoryStream ums = new
1151                                 UnmanagedMemoryStream(mem_byteptr, length);
1152                         ums.Close();
1153                         try {
1154                                 byte* bptr = ums.PositionPointer;
1155                                 Assert.Fail ("#1");
1156                         } catch (ObjectDisposedException) {
1157                         }
1158
1159                         try {
1160                                 // position pointer to somewhere within the capacity
1161                                 ums.PositionPointer = (byte*) (capacity - 1);
1162                                 Assert.Fail ("#2");
1163                         } catch (ObjectDisposedException) {
1164                         }
1165                 }
1166
1167                 [Test]
1168                 [ExpectedException (typeof(IOException))]
1169                 public void PositionPointer_Underflow ()
1170                 {
1171                         byte [] n = new byte [8];
1172                         fixed (byte *p = n){
1173                                 UnmanagedMemoryStream m = new UnmanagedMemoryStream (p, 8);
1174                                 m.PositionPointer = p-1;
1175                         }
1176                 }
1177
1178                 [Test]
1179                 public void PositionPointer_Overflow ()
1180                 {
1181                         byte [] n = new byte [8];
1182                         fixed (byte* p = n) {
1183                                 UnmanagedMemoryStream m = new UnmanagedMemoryStream (p, 8);
1184                                 Assert.AreEqual (0, m.Position, "Position-0");
1185                                 m.PositionPointer = p + 9;
1186                                 Assert.AreEqual (9, m.Position, "Position-1");
1187                                 try {
1188                                         byte* p2 = m.PositionPointer;
1189                                         Assert.Fail ("PositionPointer");
1190                                 }
1191                                 catch (IndexOutOfRangeException) {
1192                                         // expected
1193                                 }
1194                         }
1195                 }
1196
1197                 [Test]
1198                 public void PositionPointer_Set ()
1199                 {
1200                         byte [] n = new byte [8];
1201                         n [4] = 65;
1202                         fixed (byte* p = n) {
1203                                 UnmanagedMemoryStream m = new UnmanagedMemoryStream (p, 8, 8, FileAccess.ReadWrite);
1204                                 m.PositionPointer = p + 4;
1205                                 Assert.AreEqual (65, m.ReadByte (), "read");
1206                                 m.WriteByte (42);
1207                         }
1208                         Assert.AreEqual (42, n [5], "write");
1209                 }
1210
1211                 class MyUnmanagedMemoryStream : UnmanagedMemoryStream {
1212
1213                         public MyUnmanagedMemoryStream ()
1214                         {
1215                         }
1216
1217                         public void MyInitialize (byte* pointer, long length, long capacity, FileAccess access)
1218                         {
1219                                 Initialize (pointer, length, capacity, access);
1220                         }
1221                 }
1222
1223                 [Test]
1224                 public void Defaults_Can_Properties ()
1225                 {
1226                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1227                         Assert.IsFalse (s.CanRead, "CanRead");
1228                         Assert.IsFalse (s.CanSeek, "CanSeek");
1229                         Assert.IsFalse (s.CanWrite, "CanWrite");
1230                 }
1231
1232                 [Test]
1233                 [ExpectedException (typeof (ObjectDisposedException))]
1234                 public void Defaults_Capacity ()
1235                 {
1236                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1237                         Assert.AreEqual (0, s.Capacity, "Capacity");
1238                 }
1239
1240                 [Test]
1241                 [ExpectedException (typeof (ObjectDisposedException))]
1242                 public void Defaults_Length ()
1243                 {
1244                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1245                         Assert.AreEqual (0, s.Length, "Length");
1246                 }
1247
1248                 [Test]
1249                 [ExpectedException (typeof (ObjectDisposedException))]
1250                 public void Defaults_Position ()
1251                 {
1252                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1253                         Assert.AreEqual (0, s.Position, "Position");
1254                 }
1255
1256                 [Test]
1257                 [ExpectedException (typeof (ObjectDisposedException))]
1258                 public void Defaults_PositionPointer ()
1259                 {
1260                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1261                         byte* pp = s.PositionPointer;
1262                 }
1263
1264                 [Test]
1265                 [ExpectedException (typeof (InvalidOperationException))]
1266                 public void Defaults_ReadTimeout ()
1267                 {
1268                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1269                         Assert.AreEqual (0, s.ReadTimeout, "ReadTimeout");
1270                 }
1271
1272                 [Test]
1273                 [ExpectedException (typeof (InvalidOperationException))]
1274                 public void Defaults_WriteTimeout ()
1275                 {
1276                         MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ();
1277                         Assert.AreEqual (0, s.WriteTimeout, "WriteTimeout");
1278                 }
1279
1280                 [Test]
1281                 [ExpectedException (typeof (ArgumentNullException))]
1282                 public void Initialize_Pointer_Null ()
1283                 {
1284                         using (MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ()) {
1285                                 s.MyInitialize (null, 0, 0, FileAccess.Read);
1286                         }
1287                 }
1288
1289                 [Test]
1290                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1291                 public void Initialize_Length_Negative ()
1292                 {
1293                         using (MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ()) {
1294                                 s.MyInitialize (mem_byteptr, -1, 0, FileAccess.Read);
1295                         }
1296                 }
1297
1298                 [Test]
1299                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1300                 public void Initialize_Capacity_Negative ()
1301                 {
1302                         using (MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ()) {
1303                                 s.MyInitialize (mem_byteptr, 0, -1, FileAccess.Read);
1304                         }
1305                 }
1306
1307                 [Test]
1308                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1309                 public void Initialize_Access_Invalid ()
1310                 {
1311                         using (MyUnmanagedMemoryStream s = new MyUnmanagedMemoryStream ()) {
1312                                 s.MyInitialize (mem_byteptr, 0, 1, (FileAccess) Int32.MinValue);
1313                         }
1314                 }
1315         }
1316 }