class/corlib/Test/System.Runtime.InteropServices/SafeHandleTest.cs

   1 //
   2 // System.Runtime.InteropServices.SafeHandle Test Cases
   3 //
   4 // Authors:
   5 //      Miguel de Icaza (miguel@novell.com)
   6 //
   7 // Copyright (C) 2004-2006 Novell, Inc (http://www.novell.com)
   8 //
   9 #if NET_2_0
  10 using NUnit.Framework;
  11 using System;
  12 using System.Runtime.InteropServices;
  13 using System.Security;
  14 using Microsoft.Win32.SafeHandles;
  15
  16 namespace MonoTests.System.Runtime.InteropServices
  17 {
  18         [TestFixture]
  19         public class SafeHandleTest
  20         {
  21                 //
  22                 // This mimics SafeFileHandle, but does not actually own a handle
  23                 // We use this to test ownership and dispose exceptions.
  24                 //
  25                 public class FakeSafeHandle : SafeHandleZeroOrMinusOneIsInvalid
  26                 {
  27                         public bool released = false;
  28
  29                         public FakeSafeHandle (): base (true)
  30                         {
  31                         }
  32
  33                         public FakeSafeHandle (bool ownership) : base (ownership)
  34                         {
  35                         }
  36
  37                         protected override bool ReleaseHandle ()
  38                         {
  39                                 released = true;
  40                                 return true;
  41                         }
  42                 }
  43
  44                 [Test]
  45                 [ExpectedException (typeof (ObjectDisposedException))]
  46                 public void Dispose1 ()
  47                 {
  48                         FakeSafeHandle sf = new FakeSafeHandle ();
  49
  50                         sf.DangerousRelease ();
  51                         sf.DangerousRelease ();
  52                 }
  53
  54                 [Test]
  55                 [ExpectedException (typeof (ObjectDisposedException))]
  56                 public void Dispose2 ()
  57                 {
  58                         FakeSafeHandle sf = new FakeSafeHandle ();
  59
  60                         sf.DangerousRelease ();
  61                         sf.Close ();
  62                 }
  63
  64                 [Test]
  65                 [ExpectedException (typeof (ObjectDisposedException))]
  66                 public void Dispose3 ()
  67                 {
  68                         FakeSafeHandle sf = new FakeSafeHandle ();
  69
  70                         sf.Close ();
  71                         sf.DangerousRelease ();
  72                 }
  73
  74                 [Test]
  75                 public void NoReleaseUnowned ()
  76                 {
  77                         FakeSafeHandle sf = new FakeSafeHandle (false);
  78
  79                         sf.Close ();
  80                         Assert.AreEqual (sf.released, false, "r1");
  81
  82                         sf = new FakeSafeHandle (false);
  83                         sf.DangerousRelease ();
  84                         Assert.AreEqual (sf.released, false, "r2");
  85
  86                         sf = new FakeSafeHandle (false);
  87                         ((IDisposable) sf).Dispose ();
  88                         Assert.AreEqual (sf.released, false, "r3");
  89                 }
  90
  91                 //
  92                 // This test does a DangerousAddRef on a new instance
  93                 // of a custom user Safe Handle, and it just happens
  94                 // that the default value for the handle is an invalid
  95                 // handle.
  96                 //
  97                 // .NET does not throw an exception in this case, so
  98                 // we should not either
  99                 //
 100                 [Test]
 101                 public void DangerousAddRefOnNewInstance ()
 102                 {
 103                         var h = new IntPtrSafe ();
 104                         var success = false;
 105                         h.DangerousAddRef (ref success);
 106                         Assert.AreEqual (success, true, "daroni");
 107                 }
 108
 109                 public class IntPtrSafe : SafeHandle {
 110                         public IntPtrSafe() : base(IntPtr.Zero, true)
 111                         {
 112                         }
 113
 114                         protected override bool ReleaseHandle()
 115                         {
 116                                 return true;
 117                         }
 118
 119                         public IntPtr Handle { get; set; }
 120
 121                         public override bool IsInvalid
 122                         {
 123                                 get { return Handle == IntPtr.Zero; }
 124                         }
 125                 }
 126         }
 127 }
 128
 129 #endif