class/System.Core/Test/System.IO.MemoryMappedFiles/MemoryMappedFileTest.cs

   1 //
   2 // MemoryMappedFileTest.cs
   3 //
   4 // Author:
   5 //   Zoltan Varga (vargaz@gmail.com)
   6 //
   7 // (C) 2009 Novell, Inc. (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 #if NET_4_0
  30
  31 using System;
  32 using System.IO;
  33 using System.IO.MemoryMappedFiles;
  34
  35 using NUnit.Framework;
  36
  37 namespace MonoTests.System.IO.MemoryMappedFiles {
  38
  39         [TestFixture]
  40         public class MemoryMappedFileTest {
  41
  42                 void AssertThrows<ExType> (Action del) where ExType : Exception {
  43                         bool thrown = false;
  44
  45                         try {
  46                                 del ();
  47                         } catch (ExType) {
  48                                 thrown = true;
  49                         }
  50                         Assert.IsTrue (thrown);
  51                 }
  52
  53                 static string tempDir = Path.Combine (Path.GetTempPath (), typeof (MemoryMappedFileTest).FullName);
  54
  55                 string fname;
  56
  57                 [SetUp]
  58                 protected void SetUp () {
  59                         if (Directory.Exists (tempDir))
  60                                 Directory.Delete (tempDir, true);
  61
  62                         Directory.CreateDirectory (tempDir);
  63
  64                         fname = Path.Combine (tempDir, "basic.txt");
  65
  66                         using (StreamWriter sw = new StreamWriter (fname)) {
  67                                 sw.WriteLine ("Hello!");
  68                                 sw.WriteLine ("World!");
  69                         }
  70                 }
  71
  72                 [TearDown]
  73                 protected void TearDown () {
  74                         if (Directory.Exists (tempDir))
  75                                 Directory.Delete (tempDir, true);
  76                 }
  77
  78                 [Test]
  79                 public void Basic () {
  80                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
  81
  82                         using (var stream = file.CreateViewStream ()) {
  83                                 TextReader r = new StreamReader (stream);
  84
  85                                 string s;
  86
  87                                 s = r.ReadLine ();
  88                                 Assert.AreEqual ("Hello!", s);
  89                                 s = r.ReadLine ();
  90                                 Assert.AreEqual ("World!", s);
  91                         }
  92                 }
  93
  94                 [Test]
  95                 public void CreateFromFile_Null () {
  96                         AssertThrows<ArgumentNullException> (delegate () {
  97                                         MemoryMappedFile.CreateFromFile (null);
  98                                 });
  99                 }
 100
 101                 [Test]
 102                 public void CreateViewStream_Offsets () {
 103                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 104
 105                         using (var stream = file.CreateViewStream (2, 3)) {
 106                                 byte[] arr = new byte [128];
 107
 108                                 int len = stream.Read (arr, 0, 128);
 109
 110                                 Assert.AreEqual (3, len);
 111
 112                                 Assert.AreEqual ('l', (char)arr [0]);
 113                                 Assert.AreEqual ('l', (char)arr [1]);
 114                                 Assert.AreEqual ('o', (char)arr [2]);
 115                         }
 116                 }
 117
 118                 [Test]
 119                 public void CreateViewStream_Rights () {
 120                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 121
 122                         using (var stream = file.CreateViewStream (0, 0, MemoryMappedFileAccess.Read)) {
 123                                 AssertThrows<NotSupportedException> (delegate () {
 124                                                 stream.WriteByte (0);
 125                                         });
 126                         }
 127
 128                         using (var stream = file.CreateViewStream (0, 0, MemoryMappedFileAccess.Write)) {
 129                                 AssertThrows<NotSupportedException> (delegate () {
 130                                                 stream.ReadByte ();
 131                                         });
 132                         }
 133                 }
 134
 135                 [Test]
 136                 public unsafe void CreateViewBasic () {
 137                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 138
 139                         using (var v = file.CreateViewAccessor ()) {
 140                                 string s = "";
 141
 142                                 // FIXME: Use using
 143                                 var handle = v.SafeMemoryMappedViewHandle;
 144                                 byte *b = null;
 145
 146                                 try {
 147                                         handle.AcquirePointer (ref b);
 148
 149                                         for (int i = 0; i < 5; ++i)
 150                                                 s += (char)b [i];
 151                                 } finally {
 152                                         handle.ReleasePointer ();
 153                                 }
 154
 155                                 Assert.AreEqual ("Hello", s);
 156                         }
 157                 }
 158         }
 159 }
 160
 161 #endif
 162