projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Bump corefx
[mono.git] / mcs / class / System.Drawing / Test / System.Drawing / GDIPlusTest.cs
diff --git a/mcs/class/System.Drawing/Test/System.Drawing/GDIPlusTest.cs b/mcs/class/System.Drawing/Test/System.Drawing/GDIPlusTest.cs
index 4e6c25725298c8f808a2ac4720fcbd63a8c4dece..939dbd8fe63a7298805a3548965cff9e81b1410e 100644 (file)
--- a/mcs/class/System.Drawing/Test/System.Drawing/GDIPlusTest.cs
+++ b/mcs/class/System.Drawing/Test/System.Drawing/GDIPlusTest.cs
@@ -40,6 +40,8 @@ namespace MonoTests.System.Drawing {
        [TestFixture]
        public class GDIPlusTest {
 
+               static readonly HandleRef HandleRefZero = new HandleRef (null, IntPtr.Zero);
+
                // for the moment this LOGFONT is different (and ok) from the one defined internally in SD
                [StructLayout (LayoutKind.Sequential, CharSet = CharSet.Auto)]
                public class LOGFONT {
@@ -71,10 +73,10 @@ namespace MonoTests.System.Drawing {
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
 
                        // test invalid conditions for #81829
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateCustomLineCap (IntPtr.Zero, path, LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-FillPath-Null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteCustomLineCap (cap), "GdipDeleteCustomLineCap-1");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateCustomLineCap (path, IntPtr.Zero, LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-StrokePath-Null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteCustomLineCap (cap), "GdipDeleteCustomLineCap-2");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateCustomLineCap (HandleRefZero, new HandleRef (this, path), LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-FillPath-Null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteCustomLineCap (new HandleRef (this, cap)), "GdipDeleteCustomLineCap-1");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateCustomLineCap (new HandleRef (this, path), HandleRefZero, LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-StrokePath-Null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteCustomLineCap (new HandleRef (this, cap)), "GdipDeleteCustomLineCap-2");
 
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
                }
@@ -110,12 +112,14 @@ namespace MonoTests.System.Drawing {
                public void CloneFontFamily ()
                {
                        IntPtr font_family = IntPtr.Zero;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCloneFontFamily (IntPtr.Zero, out font_family), "GdipCloneFontFamily(null)");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCloneFontFamily (HandleRefZero, out font_family), "GdipCloneFontFamily(null)");
 
                        GDIPlus.GdipCreateFontFamilyFromName ("Arial", IntPtr.Zero, out font_family);
                        if (font_family != IntPtr.Zero) {
+                               var font_family_handle = new HandleRef (this, font_family);
+
                                IntPtr clone;
-                               Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneFontFamily (font_family, out clone), "GdipCloneFontFamily(arial)");
+                               Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCloneFontFamily (font_family_handle, out clone), "GdipCloneFontFamily(arial)");
                                Assert.IsTrue (clone != IntPtr.Zero, "clone");
                                Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (font_family), "GdipDeleteFontFamily(arial)");
                                Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (clone), "GdipDeleteFontFamily(clone)");
@@ -249,7 +253,7 @@ namespace MonoTests.System.Drawing {
                [Test]
                public void DeleteBrush ()
                {
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteBrush (IntPtr.Zero), "GdipDeleteBrush");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDeleteBrush (HandleRefZero), "GdipDeleteBrush");
                }
 
                // Graphics
@@ -513,86 +517,88 @@ namespace MonoTests.System.Drawing {
                {
                        IntPtr path;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
-                       
+                       var pathHandle = new HandleRef (this, path);
+
                        IntPtr iter;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathIter (out iter, path), "GdipCreatePathIter");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreatePathIter (out iter, pathHandle), "GdipCreatePathIter");
+                       var iterHandle = new HandleRef (this, iter);
 
                        int count = -1;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterGetCount (IntPtr.Zero, out count), "GdipPathIterGetCount-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterGetCount (iter, out count), "GdipPathIterGetCount");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterGetCount (HandleRefZero, out count), "GdipPathIterGetCount-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetCount (iterHandle, out count), "GdipPathIterGetCount");
                        Assert.AreEqual (0, count, "count-1");
 
                        count = -1;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterGetSubpathCount (IntPtr.Zero, out count), "GdipPathIterGetSubpathCount-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iter, out count), "GdipPathIterGetSubpathCount");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterGetSubpathCount (HandleRefZero, out count), "GdipPathIterGetSubpathCount-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iterHandle, out count), "GdipPathIterGetSubpathCount");
                        Assert.AreEqual (0, count, "count-2");
 
                        bool curve;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterHasCurve (IntPtr.Zero, out curve), "GdipPathIterHasCurve-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterHasCurve (iter, out curve), "GdipPathIterHasCurve");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterHasCurve (HandleRefZero, out curve), "GdipPathIterHasCurve-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterHasCurve (iterHandle, out curve), "GdipPathIterHasCurve");
                        Assert.IsFalse (curve, "curve");
 
                        int result;
                        PointF[] points = new PointF[count];
                        byte[] types = new byte[count];
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (IntPtr.Zero, out result, points, types, count), "GdipPathIterEnumerate-iter");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iter, out result, null, types, count), "GdipPathIterEnumerate-points");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iter, out result, points, null, count), "GdipPathIterEnumerate-types");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iter, out result, points, types, -1), "GdipPathIterEnumerate-count");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iter, out result, points, types, count), "GdipPathIterEnumerate");
-
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (IntPtr.Zero, out result, points, types, 0, 0), "GdipPathIterCopyData-iter");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iter, out result, null, types, 0, 0), "GdipPathIterCopyData-points");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iter, out result, points, null, 0, 0), "GdipPathIterCopyData-types");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iter, out result, points, types, -1, 0), "GdipPathIterCopyData-start");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iter, out result, points, types, 0, -1), "GdipPathIterCopyData-end");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iter, out result, points, types, 0, 0), "GdipPathIterCopyData");
-
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterNextMarkerPath (IntPtr.Zero, out result, path), "GdipPathIterNextMarkerPath-iter");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iter, out result, IntPtr.Zero), "GdipPathIterNextMarkerPath-path");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iter, out result, path), "GdipPathIterNextMarkerPath");
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (HandleRefZero, out result, points, types, count), "GdipPathIterEnumerate-iter");
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, null, types, count), "GdipPathIterEnumerate-points");
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, null, count), "GdipPathIterEnumerate-types");
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, -1), "GdipPathIterEnumerate-count");
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, count), "GdipPathIterEnumerate");
+
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (HandleRefZero, out result, points, types, 0, 0), "GdipPathIterCopyData-iter");
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iterHandle, out result, null, types, 0, 0), "GdipPathIterCopyData-points");
+//                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, null, 0, 0), "GdipPathIterCopyData-types");
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, -1, 0), "GdipPathIterCopyData-start");
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, -1), "GdipPathIterCopyData-end");
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, 0), "GdipPathIterCopyData");
+
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextMarkerPath (HandleRefZero, out result, pathHandle), "GdipPathIterNextMarkerPath-iter");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, HandleRefZero), "GdipPathIterNextMarkerPath-path");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, pathHandle), "GdipPathIterNextMarkerPath");
 
                        result = -1;
                        int start = -1;
                        int end = -1;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterNextMarker (IntPtr.Zero, out result, out start, out end), "GdipPathIterNextMarker-iter");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextMarker (HandleRefZero, out result, out start, out end), "GdipPathIterNextMarker-iter");
                        start = -1;
                        end = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextMarker (iter, out result, out start, out end), "GdipPathIterNextMarker");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarker (iterHandle, out result, out start, out end), "GdipPathIterNextMarker");
                        Assert.AreEqual (0, result, "result-4");
                        Assert.AreEqual (-1, start, "start-1");
                        Assert.AreEqual (-1, end, "end-1");
 
                        byte pathType = 255;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterNextPathType (IntPtr.Zero, out result, out pathType, out start, out end), "GdipPathIterNextPathType-iter");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextPathType (HandleRefZero, out result, out pathType, out start, out end), "GdipPathIterNextPathType-iter");
                        pathType = 255;
                        start = -1;
                        end = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextPathType (iter, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextPathType (iterHandle, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
                        Assert.AreEqual (0, result, "result-5");
                        Assert.AreEqual (255, pathType, "pathType");
                        Assert.AreEqual (-1, start, "start-2");
                        Assert.AreEqual (-1, end, "end-2");
 
                        bool closed = false;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpathPath (IntPtr.Zero, out result, IntPtr.Zero, out closed), "GdipPathIterNextSubpathPath-iter");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpathPath (HandleRefZero, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath-iter");
                        closed = false;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iter, out result, IntPtr.Zero, out closed), "GdipPathIterNextSubpathPath-path");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iter, out result, path, out closed), "GdipPathIterNextSubpathPath");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath-path");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, pathHandle, out closed), "GdipPathIterNextSubpathPath");
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpath (IntPtr.Zero, out result, out start, out end, out closed), "GdipPathIterNextSubpath-iter");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpath (HandleRefZero, out result, out start, out end, out closed), "GdipPathIterNextSubpath-iter");
                        start = -1;
                        end = -1;
                        closed = false;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextSubpath (iter, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpath (iterHandle, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
                        Assert.AreEqual (-1, start, "start-3");
                        Assert.AreEqual (-1, end, "end-3");
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterRewind (IntPtr.Zero), "GdipPathIterRewind-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterRewind (iter), "GdipPathIterRewind");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterRewind (HandleRefZero), "GdipPathIterRewind-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterRewind (iterHandle), "GdipPathIterRewind");
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeletePathIter (IntPtr.Zero), "GdipDeletePathIter-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePathIter (iter), "GdipDeletePathIter");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDeletePathIter (HandleRefZero), "GdipDeletePathIter-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeletePathIter (iterHandle), "GdipDeletePathIter");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
                }
 
@@ -601,37 +607,38 @@ namespace MonoTests.System.Drawing {
                {
                        // a path isn't required to create an iterator - ensure we never crash for any api
                        IntPtr iter;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathIter (out iter, IntPtr.Zero), "GdipCreatePathIter-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreatePathIter (out iter, HandleRefZero), "GdipCreatePathIter-null");
+                       var iterHandle = new HandleRef (this, iter);
 
                        int count = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterGetCount (iter, out count), "GdipPathIterGetCount");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetCount (iterHandle, out count), "GdipPathIterGetCount");
                        Assert.AreEqual (0, count, "count-1");
 
                        count = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iter, out count), "GdipPathIterGetSubpathCount");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iterHandle, out count), "GdipPathIterGetSubpathCount");
                        Assert.AreEqual (0, count, "count-2");
 
                        bool curve;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterHasCurve (iter, out curve), "GdipPathIterHasCurve");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterHasCurve (iterHandle, out curve), "GdipPathIterHasCurve");
 
                        int result = -1;
-                       PointF[] points = new PointF[count];
-                       byte[] types = new byte[count];
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iter, out result, points, types, count), "GdipPathIterEnumerate");
-                       Assert.AreEqual (0, result, "result-1");
+//                     PointF[] points = new PointF[count];
+//                     byte[] types = new byte[count];
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, count), "GdipPathIterEnumerate");
+//                     Assert.AreEqual (0, result, "result-1");
 
-                       result = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iter, out result, points, types, 0, 0), "GdipPathIterCopyData");
-                       Assert.AreEqual (0, result, "result-2");
+//                     result = -1;
+//                     Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, 0), "GdipPathIterCopyData");
+//                     Assert.AreEqual (0, result, "result-2");
 
                        result = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iter, out result, IntPtr.Zero), "GdipPathIterNextMarkerPath");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, HandleRefZero), "GdipPathIterNextMarkerPath");
                        Assert.AreEqual (0, result, "result-3");
 
                        result = -1;
                        int start = -1;
                        int end = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextMarker (iter, out result, out start, out end), "GdipPathIterNextMarker");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarker (iterHandle, out result, out start, out end), "GdipPathIterNextMarker");
                        Assert.AreEqual (0, result, "result-4");
                        Assert.AreEqual (-1, start, "start-1");
                        Assert.AreEqual (-1, end, "end-1");
@@ -640,25 +647,25 @@ namespace MonoTests.System.Drawing {
                        byte pathType = 255;
                        start = -1;
                        end = -1;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextPathType (iter, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextPathType (iterHandle, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
                        Assert.AreEqual (0, result, "result-5");
                        Assert.AreEqual (255, pathType, "pathType");
                        Assert.AreEqual (-1, start, "start-2");
                        Assert.AreEqual (-1, end, "end-2");
 
                        bool closed = false;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iter, out result, IntPtr.Zero, out closed), "GdipPathIterNextSubpathPath");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath");
 
                        start = -1;
                        end = -1;
                        closed = false;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterNextSubpath (iter, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpath (iterHandle, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
                        Assert.AreEqual (-1, start, "start-3");
                        Assert.AreEqual (-1, end, "end-3");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterRewind (iter), "GdipPathIterRewind");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterRewind (iterHandle), "GdipPathIterRewind");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePathIter (iter), "GdipDeletePathIter");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeletePathIter (iterHandle), "GdipDeletePathIter");
                }
 
                // Matrix
@@ -954,29 +961,24 @@ namespace MonoTests.System.Drawing {
                public void ImageAttribute ()
                {
                        IntPtr attr;
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateImageAttributes (out attr), "GdipCreateImageAttributes");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateImageAttributes (out attr), "GdipCreateImageAttributes");
+                       var attrHandle = new HandleRef (this, attr);
 
                        IntPtr clone;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCloneImageAttributes (IntPtr.Zero, out clone), "GdipCloneImageAttributes");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneImageAttributes (attr, out clone), "GdipCloneImageAttributes");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCloneImageAttributes (HandleRefZero, out clone), "GdipCloneImageAttributes");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCloneImageAttributes (attrHandle, out clone), "GdipCloneImageAttributes");
+                       var cloneHandle = new HandleRef (this, clone);
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (attr, ColorAdjustType.Default, true, IntPtr.Zero, IntPtr.Zero, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-true-matrix1");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, true, null, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-true-matrix1");
                        // the first color matrix can be null if enableFlag is false
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attr, ColorAdjustType.Default, false, IntPtr.Zero, IntPtr.Zero, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-false-matrix1");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, false, null, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-false-matrix1");
                        ColorMatrix cm = new ColorMatrix ();
-                       IntPtr color = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (ColorMatrix)));
-                       try {
-                               Marshal.StructureToPtr (cm, color, false);
-                               Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (IntPtr.Zero, ColorAdjustType.Default, true, color, IntPtr.Zero, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-null");
-                               Assert.AreEqual (Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attr, ColorAdjustType.Default, true, color, IntPtr.Zero, ColorMatrixFlag.Default), "GdipCloneImageAttributes");
-                       }
-                       finally {
-                               Marshal.FreeHGlobal (color);
-                       }
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (HandleRefZero, ColorAdjustType.Default, true, cm, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, true, cm, null, ColorMatrixFlag.Default), "GdipCloneImageAttributes");
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDisposeImageAttributes (IntPtr.Zero), "GdipDisposeImageAttributes-null");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImageAttributes (attr), "GdipDisposeImageAttributes");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImageAttributes (clone), "GdipDisposeImageAttributes-clone");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDisposeImageAttributes (HandleRefZero), "GdipDisposeImageAttributes-null");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDisposeImageAttributes (attrHandle), "GdipDisposeImageAttributes");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDisposeImageAttributes (cloneHandle), "GdipDisposeImageAttributes-clone");
                }
 
                // PathGradientBrush
@@ -999,6 +1001,7 @@ namespace MonoTests.System.Drawing {
                        points = new PointF[2] { new PointF (1, 2), new PointF (20, 30) };
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradient (points, 2, WrapMode.Clamp, out brush), "two");
                        Assert.IsTrue (brush != IntPtr.Zero, "Handle");
+                       var brushHandle = new HandleRef (this, brush);
 
                        int count;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
@@ -1009,7 +1012,7 @@ namespace MonoTests.System.Drawing {
                        Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
                        // can't call that for 1 count!
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                }
 
                [Test]
@@ -1026,6 +1029,7 @@ namespace MonoTests.System.Drawing {
 
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradientFromPath (path, out brush), "path");
                        Assert.IsTrue (brush != IntPtr.Zero, "Handle");
+                       var brushHandle = new HandleRef (this, brush);                  
 
                        int count;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
@@ -1035,7 +1039,7 @@ namespace MonoTests.System.Drawing {
                        float[] positions = new float[count];
                        Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
                }
 
@@ -1051,6 +1055,7 @@ namespace MonoTests.System.Drawing {
                        IntPtr brush;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradientFromPath (path, out brush), "path");
                        Assert.IsTrue (brush != IntPtr.Zero, "Handle");
+                       var brushHandle = new HandleRef (this, brush);
 
                        int count;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
@@ -1060,7 +1065,7 @@ namespace MonoTests.System.Drawing {
                        float[] positions = new float[count];
                        Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
                }
 
@@ -1102,32 +1107,36 @@ namespace MonoTests.System.Drawing {
                        try {
                                int color = 0;
                                IntPtr brush;
+                               HandleRef brushHandle;
                                Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenBrushFill (IntPtr.Zero, out brush), "GdipGetPenBrushFill-null");
                                Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenBrushFill (pen, out brush), "GdipGetPenBrushFill");
+                               brushHandle = new HandleRef (this, brush);
+
                                try {
-                                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetSolidFillColor (IntPtr.Zero, out color), "GdipGetSolidFillColor-null");
-                                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetSolidFillColor (brush, out color), "GdipGetSolidFillColor-0");
+                                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetSolidFillColor (HandleRefZero, out color), "GdipGetSolidFillColor-null");
+                                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-0");
                                        Assert.AreEqual (0x7f0000ff, color, "color-0");
 
                                        Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetPenColor (IntPtr.Zero, 0x7fff0000), "GdipSetPenColor-null");
                                        Assert.AreEqual (Status.Ok, GDIPlus.GdipSetPenColor (pen, 0x7fff0000), "GdipSetPenColor");
 
-                                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetSolidFillColor (brush, out color), "GdipGetSolidFillColor-1");
+                                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-1");
                                        // previous brush color didn't change
                                        Assert.AreEqual (0x7f0000ff, color, "color-1");
                                }
                                finally {
-                                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                                }
 
                                Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenBrushFill (pen, out brush), "GdipGetPenBrushFill-2");
+                               brushHandle = new HandleRef (this, brush);
                                try {
-                                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetSolidFillColor (brush, out color), "GdipGetSolidFillColor-2");
+                                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-2");
                                        // new brush color is updated
                                        Assert.AreEqual (0x7fff0000, color, "color-2");
                                }
                                finally {
-                                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush-2");
+                                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush-2");
                                }
                        }
                        finally {
@@ -1207,7 +1216,7 @@ namespace MonoTests.System.Drawing {
 
                        IntPtr brush;
                        GDIPlus.GdipCreateSolidFill (0, out brush);
-
+                       var brushHandle = new HandleRef (this, brush);
 
                        Assert.AreEqual (Status.InvalidParameter,
                                         GDIPlus.GdipFillClosedCurveI (graphics, brush, new Point [] {}, 0),
@@ -1222,7 +1231,7 @@ namespace MonoTests.System.Drawing {
                                                                                      new Point (2, 2) }, 2),
                                         "FillClosedCurve with 2 pts");
                        
-                       GDIPlus.GdipDeleteBrush (brush);
+                       GDIPlus.GdipDeleteBrush (brushHandle);
                        
                        GDIPlus.GdipDeleteGraphics (graphics);
                        GDIPlus.GdipDisposeImage (image);
@@ -1344,19 +1353,22 @@ namespace MonoTests.System.Drawing {
                {
                        IntPtr image;
                        GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
+                       var imageHandle = new HandleRef (this, image);
 
                        IntPtr brush;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateTexture (IntPtr.Zero, WrapMode.Tile, out brush), "GdipCreateTexture-image");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture (image, (WrapMode)Int32.MinValue, out brush), "GdipCreateTexture-wrapmode");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateTexture (image, WrapMode.Tile, out brush), "GdipCreateTexture");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture (HandleRefZero, (int) WrapMode.Tile, out brush), "GdipCreateTexture-image");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture (imageHandle, Int32.MinValue, out brush), "GdipCreateTexture-wrapmode");
+
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateTexture (imageHandle, (int) WrapMode.Tile, out brush), "GdipCreateTexture");
+                       var brushHandle = new HandleRef (this, brush);                  
 
                        IntPtr image2;
 // this would throw an AccessViolationException under MS 2.0 (missing null check?)
 //                     Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetTextureImage (IntPtr.Zero, out image2), "GdipGetTextureImage-brush");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetTextureImage (brush, out image2), "GdipGetTextureImage");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureImage (brushHandle, out image2), "GdipGetTextureImage");
                        Assert.IsFalse (image == image2, "image");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image2), "GdipDisposeImage-image2");
                }
@@ -1366,34 +1378,37 @@ namespace MonoTests.System.Drawing {
                {
                        IntPtr image;
                        GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
+                       var imageHandle = new HandleRef (this, image);
 
                        IntPtr brush;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (IntPtr.Zero, WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (IntPtr.Zero, (WrapMode) Int32.MinValue, 0, 0, 10, 10, out brush), "GdipCreateTexture2-wrapmode");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, -1, 0, 0, 10, out brush), "GdipCreateTexture2-x");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 0, -1, 10, 0, out brush), "GdipCreateTexture2-y");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateTexture2 (image, WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
-
-                       WrapMode wm;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetTextureWrapMode (IntPtr.Zero, out wm), "GdipGetTextureWrapMode-brush");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetTextureWrapMode (brush, out wm), "GdipGetTextureWrapMode");
-                       Assert.AreEqual (WrapMode.Tile, wm, "WrapMode");
-
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetTextureWrapMode (IntPtr.Zero, WrapMode.Clamp), "GdipSetTextureWrapMode-brush");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipSetTextureWrapMode (brush, WrapMode.Clamp), "GdipSetTextureWrapMode");
-                       GDIPlus.GdipGetTextureWrapMode (brush, out wm);
-                       Assert.AreEqual (WrapMode.Clamp, wm, "WrapMode.Clamp");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (HandleRefZero, (int) WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (HandleRefZero, Int32.MinValue, 0, 0, 10, 10, out brush), "GdipCreateTexture2-wrapmode");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, -1, 0, 0, 10, out brush), "GdipCreateTexture2-x");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, -1, 10, 0, out brush), "GdipCreateTexture2-y");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
+                       Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
+
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
+                       var brushHandle = new HandleRef (this, brush);                  
+
+                       int wm;
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureWrapMode (HandleRefZero, out wm), "GdipGetTextureWrapMode-brush");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm), "GdipGetTextureWrapMode");
+                       Assert.AreEqual ((int) WrapMode.Tile, wm, "WrapMode");
+
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureWrapMode (HandleRefZero, (int) WrapMode.Clamp), "GdipSetTextureWrapMode-brush");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureWrapMode (brushHandle, (int) WrapMode.Clamp), "GdipSetTextureWrapMode");
+                       GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm);
+                       Assert.AreEqual ((int) WrapMode.Clamp, wm, "WrapMode.Clamp");
 
                        // an invalid WrapMode is ignored
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipSetTextureWrapMode (brush, (WrapMode) Int32.MinValue), "GdipSetTextureWrapMode-wrapmode");
-                       GDIPlus.GdipGetTextureWrapMode (brush, out wm);
-                       Assert.AreEqual (WrapMode.Clamp, wm, "WrapMode/Invalid");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureWrapMode (brushHandle, Int32.MinValue), "GdipSetTextureWrapMode-wrapmode");
+                       GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm);
+                       Assert.AreEqual ((int) WrapMode.Clamp, wm, "WrapMode/Invalid");
 
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
                }
 
@@ -1402,32 +1417,36 @@ namespace MonoTests.System.Drawing {
                {
                        IntPtr image;
                        GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
+                       var imageHandle = new HandleRef (this, image);
 
                        IntPtr brush;
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateTextureIA (IntPtr.Zero, IntPtr.Zero, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, -1, 0, 10, 10, out brush), "GdipCreateTexture2-x");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 0, -1, 10, 10, out brush), "GdipCreateTexture2-y");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
-                       Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateTextureIA (image, IntPtr.Zero, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
+                       Assert.AreEqual ((int)Status.InvalidParameter, GDIPlus.GdipCreateTextureIA (HandleRefZero, HandleRefZero, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, -1, 0, 10, 10, out brush), "GdipCreateTexture2-x");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, -1, 10, 10, out brush), "GdipCreateTexture2-y");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
+                       Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
+
+                       Assert.AreEqual ((int)Status.Ok, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
+                       var brushHandle = new HandleRef (this, brush);
 
                        // TODO - handle ImageAttribute in the tests
 
                        IntPtr matrix;
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix (out matrix), "GdipCreateMatrix");
+                       var matrixHandle = new HandleRef (this, matrix);
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (IntPtr.Zero, matrix), "GdipGetTextureTransform-brush");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (brush, IntPtr.Zero), "GdipGetTextureTransform-matrix");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipGetTextureTransform (brush, matrix), "GdipGetTextureTransform");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (HandleRefZero, matrixHandle), "GdipGetTextureTransform-brush");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (brushHandle, HandleRefZero), "GdipGetTextureTransform-matrix");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureTransform (brushHandle, matrixHandle), "GdipGetTextureTransform");
 
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (IntPtr.Zero, matrix), "GdipSetTextureTransform-brush");
-                       Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (brush, IntPtr.Zero), "GdipSetTextureTransform-matrix");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipSetTextureTransform (brush, matrix), "GdipSetTextureTransform");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (HandleRefZero, matrixHandle), "GdipSetTextureTransform-brush");
+                       Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (brushHandle, HandleRefZero), "GdipSetTextureTransform-matrix");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureTransform (brushHandle, matrixHandle), "GdipSetTextureTransform");
 
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
-                       Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteBrush (brush), "GdipDeleteBrush");
+                       Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
                        Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
                }
 
my mono mirror. check out Moved to http://github.com/mono/mono