mcs/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 using System.Linq;
  35
  36 using NUnit.Framework;
  37
  38 namespace MonoTests.System.IO.MemoryMappedFiles {
  39
  40         [TestFixture]
  41         public class MemoryMappedFileTest {
  42
  43                 void AssertThrows<ExType> (Action del) where ExType : Exception {
  44                         bool thrown = false;
  45
  46                         try {
  47                                 del ();
  48                         } catch (ExType) {
  49                                 thrown = true;
  50                         }
  51                         Assert.IsTrue (thrown);
  52                 }
  53
  54                 static string tempDir = Path.Combine (Path.GetTempPath (), typeof (MemoryMappedFileTest).FullName);
  55
  56                 string fname;
  57
  58                 [SetUp]
  59                 protected void SetUp () {
  60                         if (Directory.Exists (tempDir))
  61                                 Directory.Delete (tempDir, true);
  62
  63                         Directory.CreateDirectory (tempDir);
  64
  65                         fname = Path.Combine (tempDir, "basic.txt");
  66
  67                         using (StreamWriter sw = new StreamWriter (fname)) {
  68                                 sw.WriteLine ("Hello!");
  69                                 sw.WriteLine ("World!");
  70                         }
  71                 }
  72
  73                 [TearDown]
  74                 protected void TearDown () {
  75                         if (Directory.Exists (tempDir))
  76                                 Directory.Delete (tempDir, true);
  77                 }
  78
  79                 [Test]
  80                 public void Basic () {
  81                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
  82
  83                         using (var stream = file.CreateViewStream ()) {
  84                                 TextReader r = new StreamReader (stream);
  85
  86                                 string s;
  87
  88                                 s = r.ReadLine ();
  89                                 Assert.AreEqual ("Hello!", s);
  90                                 s = r.ReadLine ();
  91                                 Assert.AreEqual ("World!", s);
  92                         }
  93                 }
  94
  95                 [Test]
  96                 public void CreateNew ()
  97                 {
  98                         // This must succeed
  99                         MemoryMappedFile.CreateNew (Path.Combine (tempDir, "createNew.test"), 8192);
 100                 }
 101
 102                 [Test]
 103                 [ExpectedException (typeof (IOException))]
 104                 public void CreateNew_OnExistingFile ()
 105                 {
 106                         // This must succeed
 107                         MemoryMappedFile.CreateNew (Path.Combine (tempDir, "createNew.test"), 8192);
 108
 109                         // This should fail, the file exists
 110                         MemoryMappedFile.CreateNew (Path.Combine (tempDir, "createNew.test"), 8192);
 111                 }
 112
 113                 // Call this twice, it should always work
 114                 [Test]
 115                 public void CreateOrOpen_Multiple ()
 116                 {
 117                         MemoryMappedFile.CreateOrOpen (Path.Combine (tempDir, "createOrOpen.test"), 8192);
 118                         MemoryMappedFile.CreateOrOpen (Path.Combine (tempDir, "createOrOpen.test"), 8192);
 119                 }
 120
 121                 [Test]
 122                 [ExpectedException(typeof(ArgumentOutOfRangeException))]
 123                 public void CreateFromFileWithSmallerCapacityThanFile ()
 124                 {
 125                         var f = Path.Combine (tempDir, "8192-file");
 126                         File.WriteAllBytes (f, new byte [8192]);
 127
 128                         // We are requesting fewer bytes to map.
 129                         MemoryMappedFile.CreateFromFile (f, FileMode.Open, "myMap", 4192);
 130                 }
 131
 132                 [Test]
 133                 public void CreateFromFile_Null () {
 134                         AssertThrows<ArgumentNullException> (delegate () {
 135                                         MemoryMappedFile.CreateFromFile (null);
 136                                 });
 137                 }
 138
 139                 [Test]
 140                 public void CreateViewStream_Offsets () {
 141                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 142
 143                         using (var stream = file.CreateViewStream (2, 3)) {
 144                                 byte[] arr = new byte [128];
 145
 146                                 int len = stream.Read (arr, 0, 128);
 147
 148                                 Assert.AreEqual (3, len);
 149
 150                                 Assert.AreEqual ('l', (char)arr [0]);
 151                                 Assert.AreEqual ('l', (char)arr [1]);
 152                                 Assert.AreEqual ('o', (char)arr [2]);
 153                         }
 154                 }
 155
 156                 [Test]
 157                 public void CreateViewStream_Rights () {
 158                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 159
 160                         using (var stream = file.CreateViewStream (0, 0, MemoryMappedFileAccess.Read)) {
 161                                 AssertThrows<NotSupportedException> (delegate () {
 162                                                 stream.WriteByte (0);
 163                                         });
 164                         }
 165
 166                         using (var stream = file.CreateViewStream (0, 0, MemoryMappedFileAccess.Write)) {
 167                                 AssertThrows<NotSupportedException> (delegate () {
 168                                                 stream.ReadByte ();
 169                                         });
 170                         }
 171                 }
 172
 173                 [Test]
 174                 public unsafe void CreateViewBasic () {
 175                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 176
 177                         using (var v = file.CreateViewAccessor ()) {
 178                                 string s = "";
 179
 180                                 // FIXME: Use using
 181                                 var handle = v.SafeMemoryMappedViewHandle;
 182                                 byte *b = null;
 183
 184                                 try {
 185                                         handle.AcquirePointer (ref b);
 186
 187                                         for (int i = 0; i < 5; ++i)
 188                                                 s += (char)b [i];
 189                                 } finally {
 190                                         handle.ReleasePointer ();
 191                                 }
 192
 193                                 Assert.AreEqual ("Hello", s);
 194                         }
 195                 }
 196
 197                 [Test]
 198                 public unsafe void ViewReadArray () {
 199                         var file = MemoryMappedFile.CreateFromFile (fname, FileMode.Open);
 200
 201                         using (var v = file.CreateViewAccessor ()) {
 202                                 var a = new byte [5];
 203                                 var n = v.ReadArray (0, a, 0, 5);
 204                                 Assert.AreEqual (5, n);
 205                                 var s = new string (Array.ConvertAll (a, b => (char)b));
 206                                 Assert.AreEqual ("Hello", s);
 207                         }
 208                 }
 209         }
 210 }
 211
 212 #endif
 213