mcs/class/System.Drawing/Test/System.Drawing/GDIPlusTest.cs

   1 //
   2 // Direct GDI+ API unit tests
   3 //
   4 // Authors:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2006-2007 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 using System;
  30 using System.Drawing;
  31 using System.Drawing.Drawing2D;
  32 using System.Drawing.Imaging;
  33 using System.Drawing.Text;
  34 using System.IO;
  35 using System.Runtime.InteropServices;
  36 using NUnit.Framework;
  37
  38 namespace MonoTests.System.Drawing {
  39
  40         [TestFixture]
  41         public class GDIPlusTest {
  42
  43                 static readonly HandleRef HandleRefZero = new HandleRef (null, IntPtr.Zero);
  44
  45                 // for the moment this LOGFONT is different (and ok) from the one defined internally in SD
  46                 [StructLayout (LayoutKind.Sequential, CharSet = CharSet.Auto)]
  47                 public class LOGFONT {
  48                         public int lfHeight = 0;
  49                         public int lfWidth = 0;
  50                         public int lfEscapement = 0;
  51                         public int lfOrientation = 0;
  52                         public int lfWeight = 0;
  53                         public byte lfItalic = 0;
  54                         public byte lfUnderline = 0;
  55                         public byte lfStrikeOut = 0;
  56                         public byte lfCharSet = 0;
  57                         public byte lfOutPrecision = 0;
  58                         public byte lfClipPrecision = 0;
  59                         public byte lfQuality = 0;
  60                         public byte lfPitchAndFamily = 0;
  61                         [MarshalAs (UnmanagedType.ByValTStr, SizeConst = 32)]
  62                         public string lfFaceName = null;
  63                 }
  64
  65                 // CustomLineCap
  66
  67                 [Test]
  68                 public void CreateCustomLineCap ()
  69                 {
  70                         IntPtr cap;
  71
  72                         IntPtr path;
  73                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
  74
  75                         // test invalid conditions for #81829
  76                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateCustomLineCap (HandleRefZero, new HandleRef (this, path), LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-FillPath-Null");
  77                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteCustomLineCap (new HandleRef (this, cap)), "GdipDeleteCustomLineCap-1");
  78                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateCustomLineCap (new HandleRef (this, path), HandleRefZero, LineCap.Flat, 1.0f, out cap), "GdipCreateCustomLineCap-StrokePath-Null");
  79                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteCustomLineCap (new HandleRef (this, cap)), "GdipDeleteCustomLineCap-2");
  80
  81                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
  82                 }
  83
  84                 // FontFamily
  85                 [Test]
  86                 public void DeleteFontFamily ()
  87                 {
  88                         // invalid image pointer (null)
  89                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteFontFamily (IntPtr.Zero), "null");
  90
  91                         IntPtr font_family;
  92                         GDIPlus.GdipCreateFontFamilyFromName ("Arial", IntPtr.Zero, out font_family);
  93                         if (font_family != IntPtr.Zero)
  94                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (font_family), "first");
  95                         else
  96                                 Assert.Ignore ("Arial isn't available on this platform");
  97                 }
  98
  99                 [Test]
 100                 [Category ("NotWorking")]
 101                 public void DeleteFontFamily_DoubleDispose ()
 102                 {
 103                         IntPtr font_family;
 104                         GDIPlus.GdipGetGenericFontFamilySerif (out font_family);
 105                         // first dispose
 106                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (font_family), "first");
 107                         // second dispose
 108                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (font_family), "second");
 109                 }
 110
 111                 [Test]
 112                 public void CloneFontFamily ()
 113                 {
 114                         IntPtr font_family = IntPtr.Zero;
 115                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCloneFontFamily (HandleRefZero, out font_family), "GdipCloneFontFamily(null)");
 116
 117                         GDIPlus.GdipCreateFontFamilyFromName ("Arial", IntPtr.Zero, out font_family);
 118                         if (font_family != IntPtr.Zero) {
 119                                 var font_family_handle = new HandleRef (this, font_family);
 120
 121                                 IntPtr clone;
 122                                 Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCloneFontFamily (font_family_handle, out clone), "GdipCloneFontFamily(arial)");
 123                                 Assert.IsTrue (clone != IntPtr.Zero, "clone");
 124                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (font_family), "GdipDeleteFontFamily(arial)");
 125                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (clone), "GdipDeleteFontFamily(clone)");
 126                         } else
 127                                 Assert.Ignore ("Arial isn't available on this platform");
 128                 }
 129
 130                 // Font
 131                 [Test]
 132                 public void CreateFont ()
 133                 {
 134                         IntPtr family;
 135                         GDIPlus.GdipCreateFontFamilyFromName ("Arial", IntPtr.Zero, out family);
 136                         if (family == IntPtr.Zero)
 137                                 Assert.Ignore ("Arial isn't available on this platform");
 138
 139                         IntPtr font;
 140                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateFont (family, 10f, FontStyle.Regular, GraphicsUnit.Point, out font), "GdipCreateFont");
 141                         Assert.IsTrue (font != IntPtr.Zero, "font");
 142
 143                         LOGFONT lf = new LOGFONT ();
 144                         lf.lfCharSet = 1;
 145                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetLogFont (font, IntPtr.Zero, (object) lf), "GdipGetLogFont-null-graphics");
 146                         Assert.AreEqual (0, lf.lfCharSet, "lfCharSet-null-graphics");
 147                         // other lf members looks like garbage
 148
 149                         IntPtr image;
 150                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 151                         Assert.IsTrue (image != IntPtr.Zero, "image");
 152
 153                         IntPtr graphics;
 154                         GDIPlus.GdipGetImageGraphicsContext (image, out graphics);
 155                         Assert.IsTrue (graphics != IntPtr.Zero, "graphics");
 156
 157                         lf.lfCharSet = 1;
 158                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetLogFont (IntPtr.Zero, graphics, (object) lf), "GdipGetLogFont-null");
 159                         Assert.AreEqual (0, lf.lfCharSet, "lfCharSet-null");
 160
 161                         lf.lfCharSet = 1;
 162                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetLogFont (font, graphics, (object) lf), "GdipGetLogFont");
 163                         Assert.AreEqual (0, lf.lfCharSet, "lfCharSet");
 164                         // strangely this is 1 in the managed side
 165
 166                         lf.lfCharSet = 2;
 167                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetLogFont (font, graphics, (object) lf), "GdipGetLogFont-2");
 168                         Assert.AreEqual (0, lf.lfCharSet, "lfCharSet");
 169                         // strangely this is 2 in the managed side
 170
 171                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFont (font), "GdipDeleteFont");
 172                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteFont (IntPtr.Zero), "GdipDeleteFont-null");
 173
 174                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (family), "GdipDeleteFontFamily");
 175                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
 176                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteGraphics (graphics), "GdipDeleteGraphics");
 177                 }
 178
 179                 // Bitmap
 180                 [Test]
 181                 public void CreateBitmapFromScan0 ()
 182                 {
 183                         IntPtr bmp;
 184                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateBitmapFromScan0 (-1, 10, 10, PixelFormat.Format32bppArgb, IntPtr.Zero, out bmp), "negative width");
 185                 }
 186
 187                 [Test]
 188                 public void Format1bppIndexed_GetSetPixel ()
 189                 {
 190                         IntPtr bmp;
 191                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format1bppIndexed, IntPtr.Zero, out bmp), "GdipCreateBitmapFromScan0");
 192                         Assert.IsTrue (bmp != IntPtr.Zero, "bmp");
 193                         try {
 194                                 int argb;
 195                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipBitmapGetPixel (bmp, 0, 0, out argb), "GdipBitmapGetPixel");
 196                                 Assert.AreEqual (-16777216, argb, "argb");
 197                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipBitmapSetPixel (bmp, 0, 0, argb), "GdipBitmapSetPixel");
 198                         }
 199                         finally {
 200                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (bmp), "GdipDisposeImage");
 201                         }
 202                 }
 203
 204                 [Test]
 205                 [Category ("NotWorking")] // libgdiplus doesn't support this format
 206                 public void Format16bppGrayScale_GetSetPixel ()
 207                 {
 208                         IntPtr bmp;
 209                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format16bppGrayScale, IntPtr.Zero, out bmp), "GdipCreateBitmapFromScan0");
 210                         Assert.IsTrue (bmp != IntPtr.Zero, "bmp");
 211                         try {
 212                                 int argb = 0;
 213                                 // and MS GDI+ can get or set pixels on it
 214                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipBitmapGetPixel (bmp, 0, 0, out argb), "GdipBitmapGetPixel");
 215                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipBitmapSetPixel (bmp, 0, 0, argb), "GdipBitmapSetPixel");
 216                         }
 217                         finally {
 218                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (bmp), "GdipDisposeImage");
 219                         }
 220                 }
 221
 222                 [Test]
 223                 public void Unlock ()
 224                 {
 225                         IntPtr bmp;
 226                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out bmp);
 227                         Assert.IsTrue (bmp != IntPtr.Zero, "bmp");
 228
 229                         BitmapData bd = null;
 230                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipBitmapUnlockBits (bmp, bd), "BitmapData");
 231
 232                         bd = new BitmapData ();
 233                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipBitmapUnlockBits (IntPtr.Zero, bd), "handle");
 234
 235                         Assert.AreEqual (Status.Win32Error, GDIPlus.GdipBitmapUnlockBits (bmp, bd), "not locked");
 236
 237                         Rectangle rect = new Rectangle (2, 2, 5, 5);
 238                         Assert.AreEqual (Status.Ok, GDIPlus.GdipBitmapLockBits (bmp, ref rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, bd), "locked");
 239                         Assert.AreEqual (Status.Win32Error, GDIPlus.GdipBitmapLockBits (bmp, ref rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, bd), "second lock");
 240
 241                         Assert.AreEqual (rect.Width, bd.Width, "Width");
 242                         Assert.AreEqual (rect.Height, bd.Height, "Height");
 243                         Assert.AreEqual (PixelFormat.Format24bppRgb, bd.PixelFormat, "PixelFormat");
 244
 245                         Assert.AreEqual (Status.Ok, GDIPlus.GdipBitmapUnlockBits (bmp, bd), "unlocked");
 246
 247                         Assert.AreEqual (Status.Win32Error, GDIPlus.GdipBitmapUnlockBits (bmp, bd), "unlocked-twice");
 248
 249                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (bmp), "GdipDisposeImage");
 250                 }
 251
 252                 // Brush
 253                 [Test]
 254                 public void DeleteBrush ()
 255                 {
 256                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDeleteBrush (HandleRefZero), "GdipDeleteBrush");
 257                 }
 258
 259                 // Graphics
 260                 [Test]
 261                 public void GdipGetImageGraphicsContext_Null ()
 262                 {
 263                         IntPtr graphics;
 264                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetImageGraphicsContext (IntPtr.Zero, out graphics), "GdipGetImageGraphicsContext");
 265                 }
 266
 267                 private void Graphics_DrawImage (IntPtr image, bool metafile)
 268                 {
 269                         IntPtr graphics;
 270                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageGraphicsContext (image, out graphics), "GdipGetImageGraphicsContext");
 271                         Assert.IsTrue (graphics != IntPtr.Zero, "graphics");
 272
 273                         if (metafile) {
 274                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImage (graphics, image, Single.MinValue, Single.MaxValue), "FloatMinMax");
 275                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageI (graphics, image, Int32.MinValue, Int32.MaxValue), "IntMinMax");
 276                         } else {
 277                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImage (graphics, image, Single.MinValue, Single.MaxValue), "FloatOverflow");
 278                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImage (graphics, image, 1073741888, 0), "FloatXMax");
 279                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImage (graphics, image, 1073741889, 0), "FloatXMaxOverflow");
 280                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImage (graphics, image, 0, 1073741888), "FloatYMax");
 281                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImage (graphics, image, 0, 1073741889), "FloatYMaxOverflow");
 282                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImage (graphics, image, -1073741888, 0), "FloatXMin");
 283                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImage (graphics, image, -1073741889, 0), "FloatXMinOverflow");
 284                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImage (graphics, image, 0, -1073741888), "FloatYMin");
 285                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImage (graphics, image, 0, -1073741889), "FloatYMinOverflow");
 286
 287                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImageI (graphics, image, Int32.MinValue, Int32.MaxValue), "IntOverflow");
 288                                 // the real limit of MS GDI+ is 1073741951 but differs (by a very few) from the float limit
 289                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageI (graphics, image, 1073741824, 0), "IntXMax");
 290                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImageI (graphics, image, 1073741952, 0), "IntXMaxOverflow");
 291                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageI (graphics, image, 0, 1073741824), "IntYMax");
 292                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImageI (graphics, image, 0, 1073741952), "IntYMaxOverflow");
 293                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageI (graphics, image, -1073741824, 0), "IntXMin");
 294                                 // the real limit of MS GDI+ is -1073741825 but int-to-float convertion in libgdiplus turns this into a -1073741824
 295                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImageI (graphics, image, -1073741899, 0), "IntXMinOverflow");
 296                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageI (graphics, image, 0, -1073741824), "IntYMin");
 297                                 Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipDrawImageI (graphics, image, 0, -1073741899), "IntYMinOverflow");
 298                         }
 299
 300                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Display, IntPtr.Zero, null, IntPtr.Zero), "Display");
 301                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Document, IntPtr.Zero, null, IntPtr.Zero), "Document");
 302                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Inch, IntPtr.Zero, null, IntPtr.Zero), "Inch");
 303                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Millimeter, IntPtr.Zero, null, IntPtr.Zero), "Millimeter");
 304                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Pixel, IntPtr.Zero, null, IntPtr.Zero), "Pixel");
 305                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.Point, IntPtr.Zero, null, IntPtr.Zero), "Point");
 306                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, GraphicsUnit.World, IntPtr.Zero, null, IntPtr.Zero), "World");
 307                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawImageRectRectI (graphics, image, 0, 0, 10, 10, 0, 0, 10, 10, (GraphicsUnit) Int32.MinValue, IntPtr.Zero, null, IntPtr.Zero), "invalid");
 308
 309                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteGraphics (graphics), "GdipDeleteGraphics");
 310                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteGraphics (IntPtr.Zero), "GdipDeleteGraphics-null");
 311                 }
 312
 313                 [Test]
 314                 public void Graphics_FromImage_Bitmap ()
 315                 {
 316                         IntPtr image;
 317                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 318                         Assert.IsTrue (image != IntPtr.Zero, "image");
 319
 320                         Graphics_DrawImage (image, false);
 321
 322                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
 323                 }
 324
 325                 [Test]
 326                 [Category ("NotWorking")] // incomplete GdipDrawImageRectRect[I] support
 327                 public void Graphics_FromImage_Metafile ()
 328                 {
 329                         using (Bitmap bmp = new Bitmap (100, 100, PixelFormat.Format32bppArgb)) {
 330                                 using (Graphics g = Graphics.FromImage (bmp)) {
 331                                         IntPtr metafile = IntPtr.Zero;
 332                                         IntPtr hdc = g.GetHdc ();
 333                                         try {
 334                                                 RectangleF rect = new RectangleF (10, 20, 100, 200);
 335                                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipRecordMetafileFileName ("test-drawimage.emf", hdc, EmfType.EmfPlusOnly, ref rect, MetafileFrameUnit.GdiCompatible, null, out metafile), "GdipRecordMetafileFileName");
 336                                                 Assert.IsTrue (metafile != IntPtr.Zero, "image");
 337
 338                                                 Graphics_DrawImage (metafile, true);
 339                                         }
 340                                         finally {
 341                                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (metafile), "GdipDisposeImage");
 342                                         }
 343                                 }
 344                         }
 345                 }
 346
 347                 [Test]
 348                 public void GdipCreateFromHDC_Null ()
 349                 {
 350                         IntPtr graphics;
 351                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateFromHDC (IntPtr.Zero, out graphics), "GdipCreateFromHDC(null)");
 352                 }
 353
 354                 [Test]
 355                 public void DrawRectangles ()
 356                 {
 357                         IntPtr image;
 358                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 359                         Assert.IsTrue (image != IntPtr.Zero, "image");
 360
 361                         IntPtr graphics;
 362                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageGraphicsContext (image, out graphics), "GdipGetImageGraphicsContext");
 363                         Assert.IsTrue (graphics != IntPtr.Zero, "graphics");
 364
 365                         Rectangle[] r = new Rectangle[1] { new Rectangle (1, 2, -2, -1) };
 366                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectanglesI (graphics, IntPtr.Zero, r, 1), "GdipDrawRectanglesI-PenNull");
 367
 368                         RectangleF[] rf = new RectangleF[2] { new RectangleF (1, 2, -2, -1), new RectangleF (0, 0, 10, 10) };
 369                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectangles (graphics, IntPtr.Zero, rf, 2), "GdipDrawRectanglesI-PenNull");
 370
 371                         IntPtr pen;
 372                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePen1 (0, 0f, GraphicsUnit.World, out pen), "GdipCreatePen1");
 373                         Assert.IsTrue (pen != IntPtr.Zero, "pen");
 374
 375                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectanglesI (IntPtr.Zero, pen, r, 1), "GdipDrawRectanglesI-GraphicsNull");
 376                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectangles (IntPtr.Zero, pen, rf, 2), "GdipDrawRectangles-GraphicsNull");
 377
 378                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectanglesI (graphics, pen, null, 1), "GdipDrawRectanglesI-RectanglesNull");
 379                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectangles (graphics, pen, null, 1), "GdipDrawRectangles-RectanglesNull");
 380
 381                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectanglesI (graphics, pen, new Rectangle[0], 0), "GdipDrawRectanglesI-RectanglesEmpty");
 382                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectangles (graphics, pen, new RectangleF[0], 0), "GdipDrawRectangles-RectanglesEmpty");
 383
 384                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectanglesI (graphics, pen, r, -1), "GdipDrawRectanglesI-RectanglesNegative");
 385                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDrawRectangles (graphics, pen, rf, -1), "GdipDrawRectangles-RectanglesNegative");
 386
 387                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawRectanglesI (graphics, pen, r, 1), "GdipDrawRectanglesI-Rectangles1");
 388                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDrawRectangles (graphics, pen, rf, 2), "GdipDrawRectangles-Rectangles2");
 389
 390                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePen (pen), "GdipDeletePen");
 391
 392                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteGraphics (graphics), "GdipDeleteGraphics");
 393                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
 394                 }
 395
 396                 [Test]
 397                 public void MeasureCharacterRanges ()
 398                 {
 399                         IntPtr image;
 400                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 401                         Assert.IsTrue (image != IntPtr.Zero, "image");
 402
 403                         IntPtr graphics;
 404                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageGraphicsContext (image, out graphics), "GdipGetImageGraphicsContext");
 405                         Assert.IsTrue (graphics != IntPtr.Zero, "graphics");
 406
 407                         IntPtr family;
 408                         GDIPlus.GdipCreateFontFamilyFromName ("Arial", IntPtr.Zero, out family);
 409                         if (family == IntPtr.Zero)
 410                                 Assert.Ignore ("Arial isn't available on this platform");
 411
 412                         IntPtr font;
 413                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateFont (family, 10f, FontStyle.Regular, GraphicsUnit.Point, out font), "GdipCreateFont");
 414                         Assert.IsTrue (font != IntPtr.Zero, "font");
 415
 416                         RectangleF layout = new RectangleF ();
 417                         IntPtr[] regions = new IntPtr[1];
 418                         IntPtr format;
 419                         Assert.AreEqual (Status.Ok, GDIPlus.GdipStringFormatGetGenericDefault (out format), "GdipStringFormatGetGenericDefault");
 420
 421                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipMeasureCharacterRanges (IntPtr.Zero, "a", 1, font, ref layout, format, 1, out regions[0]), "GdipMeasureCharacterRanges-null");
 422                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipMeasureCharacterRanges (graphics, null, 0, font, ref layout, format, 1, out regions[0]), "GdipMeasureCharacterRanges-null string");
 423
 424                         int count;
 425                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatMeasurableCharacterRangeCount (format, out count), "GdipGetStringFormatMeasurableCharacterRangeCount");
 426                         Assert.AreEqual (0, count, "count");
 427                         Assert.AreEqual (Status.Ok, GDIPlus.GdipMeasureCharacterRanges (graphics, "a", 1, font, ref layout, format, 1, out regions[0]), "GdipMeasureCharacterRanges");
 428
 429                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (format), "GdipDeleteStringFormat");
 430                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteGraphics (graphics), "GdipDeleteGraphics");
 431                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFont (font), "GdipDeleteFont");
 432                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteFontFamily (family), "GdipDeleteFontFamily");
 433                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
 434                 }
 435
 436                 // GraphicsPath
 437                 [Test]
 438                 public void GetPointCount_Zero ()
 439                 {
 440                         IntPtr path;
 441                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
 442                         Assert.IsTrue (path != IntPtr.Zero, "Handle");
 443
 444                         int count;
 445                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPointCount (IntPtr.Zero, out count), "GdipGetPointCount-null");
 446                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPointCount (path, out count), "GdipGetPointCount");
 447                         Assert.AreEqual (0, count, "Count");
 448
 449                         PointF[] points = new PointF[count];
 450                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathPoints (IntPtr.Zero, points, count), "GdipGetPathPoints-null-1");
 451                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathPoints (path, null, count), "GdipGetPathPoints-null-2");
 452                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathPoints (path, points, count), "GdipGetPathPoints");
 453                         // can't get the points if the count is zero!
 454
 455                         byte[] types = new byte[count];
 456                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathTypes (IntPtr.Zero, types, count), "GdipGetPathTypes-null-1");
 457                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathTypes (path, null, count), "GdipGetPathTypes-null-2");
 458                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathTypes (path, types, count), "GdipGetPathTypes");
 459                         // can't get the types if the count is zero!
 460
 461                         PointF[] pts_2f = new PointF[2] { new PointF (2f, 4f), new PointF (10f, 30f) };
 462                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipAddPathLine2 (IntPtr.Zero, pts_2f, pts_2f.Length), "GdipAddPathLine2-null-path");
 463                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipAddPathLine2 (path, null, pts_2f.Length), "GdipAddPathLine2-null-points");
 464                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipAddPathLine2 (path, pts_2f, -1), "GdipAddPathLine2-negative-count");
 465                         Assert.AreEqual (Status.Ok, GDIPlus.GdipAddPathLine2 (path, pts_2f, pts_2f.Length), "GdipAddPathLine2");
 466
 467                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPointCount (path, out count), "GdipGetPointCount");
 468                         Assert.AreEqual (2, count, "Count");
 469
 470                         points = new PointF[count];
 471                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathPoints (path, points, count), "GdipGetPathPoints-ok");
 472
 473                         types = new byte[count];
 474                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathTypes (path, types, count), "GdipGetPathTypes-ok");
 475
 476                         Assert.AreEqual (Status.Ok, GDIPlus.GdipResetPath (path), "GdipResetPath");
 477                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipResetPath (IntPtr.Zero), "GdipResetPath-null");
 478
 479                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
 480                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeletePath (IntPtr.Zero), "GdipDeletePath-null");
 481                 }
 482
 483                 [Test]
 484                 public void Widen ()
 485                 {
 486                         IntPtr pen;
 487                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePen1 (0, 0f, GraphicsUnit.World, out pen), "GdipCreatePen1");
 488
 489                         IntPtr path;
 490                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
 491
 492                         IntPtr matrix;
 493                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix (out matrix), "GdipCreateMatrix");
 494
 495                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipWidenPath (IntPtr.Zero, pen, matrix, 1.0f), "GdipWidenPath-null-path");
 496                         // empty path
 497                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipWidenPath (path, pen, matrix, 1.0f), "GdipWidenPath");
 498
 499                         // add something to the path
 500                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipAddPathLine (IntPtr.Zero, 1, 1, 10, 10), "GdipAddPathLine");
 501                         Assert.AreEqual (Status.Ok, GDIPlus.GdipAddPathLine (path, 1, 1, 10, 10), "GdipAddPathLine");
 502
 503                         int count;
 504                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPointCount (path, out count), "GdipGetPointCount");
 505                         Assert.AreEqual (2, count, "Count");
 506
 507                         Assert.AreEqual (Status.Ok, GDIPlus.GdipWidenPath (path, pen, matrix, 1.0f), "GdipWidenPath-2");
 508
 509                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
 510                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
 511                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePen (pen), "GdipDeletePen");
 512                 }
 513
 514                 // GraphicsPathIterator
 515                 [Test]
 516                 public void GraphicsPathIterator ()
 517                 {
 518                         IntPtr path;
 519                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
 520                         var pathHandle = new HandleRef (this, path);
 521
 522                         IntPtr iter;
 523                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreatePathIter (out iter, pathHandle), "GdipCreatePathIter");
 524                         var iterHandle = new HandleRef (this, iter);
 525
 526                         int count = -1;
 527                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterGetCount (HandleRefZero, out count), "GdipPathIterGetCount-null");
 528                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetCount (iterHandle, out count), "GdipPathIterGetCount");
 529                         Assert.AreEqual (0, count, "count-1");
 530
 531                         count = -1;
 532                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterGetSubpathCount (HandleRefZero, out count), "GdipPathIterGetSubpathCount-null");
 533                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iterHandle, out count), "GdipPathIterGetSubpathCount");
 534                         Assert.AreEqual (0, count, "count-2");
 535
 536                         bool curve;
 537                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterHasCurve (HandleRefZero, out curve), "GdipPathIterHasCurve-null");
 538                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterHasCurve (iterHandle, out curve), "GdipPathIterHasCurve");
 539                         Assert.IsFalse (curve, "curve");
 540
 541                         int result;
 542                         PointF[] points = new PointF[count];
 543                         byte[] types = new byte[count];
 544 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (HandleRefZero, out result, points, types, count), "GdipPathIterEnumerate-iter");
 545 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, null, types, count), "GdipPathIterEnumerate-points");
 546 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, null, count), "GdipPathIterEnumerate-types");
 547 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, -1), "GdipPathIterEnumerate-count");
 548 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, count), "GdipPathIterEnumerate");
 549
 550 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (HandleRefZero, out result, points, types, 0, 0), "GdipPathIterCopyData-iter");
 551 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iterHandle, out result, null, types, 0, 0), "GdipPathIterCopyData-points");
 552 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, null, 0, 0), "GdipPathIterCopyData-types");
 553 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, -1, 0), "GdipPathIterCopyData-start");
 554 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, -1), "GdipPathIterCopyData-end");
 555 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, 0), "GdipPathIterCopyData");
 556
 557                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextMarkerPath (HandleRefZero, out result, pathHandle), "GdipPathIterNextMarkerPath-iter");
 558                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, HandleRefZero), "GdipPathIterNextMarkerPath-path");
 559                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, pathHandle), "GdipPathIterNextMarkerPath");
 560
 561                         result = -1;
 562                         int start = -1;
 563                         int end = -1;
 564                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextMarker (HandleRefZero, out result, out start, out end), "GdipPathIterNextMarker-iter");
 565                         start = -1;
 566                         end = -1;
 567                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarker (iterHandle, out result, out start, out end), "GdipPathIterNextMarker");
 568                         Assert.AreEqual (0, result, "result-4");
 569                         Assert.AreEqual (-1, start, "start-1");
 570                         Assert.AreEqual (-1, end, "end-1");
 571
 572                         byte pathType = 255;
 573                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextPathType (HandleRefZero, out result, out pathType, out start, out end), "GdipPathIterNextPathType-iter");
 574                         pathType = 255;
 575                         start = -1;
 576                         end = -1;
 577                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextPathType (iterHandle, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
 578                         Assert.AreEqual (0, result, "result-5");
 579                         Assert.AreEqual (255, pathType, "pathType");
 580                         Assert.AreEqual (-1, start, "start-2");
 581                         Assert.AreEqual (-1, end, "end-2");
 582
 583                         bool closed = false;
 584                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpathPath (HandleRefZero, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath-iter");
 585                         closed = false;
 586                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath-path");
 587                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, pathHandle, out closed), "GdipPathIterNextSubpathPath");
 588
 589                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterNextSubpath (HandleRefZero, out result, out start, out end, out closed), "GdipPathIterNextSubpath-iter");
 590                         start = -1;
 591                         end = -1;
 592                         closed = false;
 593                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpath (iterHandle, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
 594                         Assert.AreEqual (-1, start, "start-3");
 595                         Assert.AreEqual (-1, end, "end-3");
 596
 597                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipPathIterRewind (HandleRefZero), "GdipPathIterRewind-null");
 598                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterRewind (iterHandle), "GdipPathIterRewind");
 599
 600                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDeletePathIter (HandleRefZero), "GdipDeletePathIter-null");
 601                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeletePathIter (iterHandle), "GdipDeletePathIter");
 602                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
 603                 }
 604
 605                 [Test]
 606                 public void GraphicsPathIterator_WithoutPath ()
 607                 {
 608                         // a path isn't required to create an iterator - ensure we never crash for any api
 609                         IntPtr iter;
 610                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreatePathIter (out iter, HandleRefZero), "GdipCreatePathIter-null");
 611                         var iterHandle = new HandleRef (this, iter);
 612
 613                         int count = -1;
 614                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetCount (iterHandle, out count), "GdipPathIterGetCount");
 615                         Assert.AreEqual (0, count, "count-1");
 616
 617                         count = -1;
 618                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterGetSubpathCount (iterHandle, out count), "GdipPathIterGetSubpathCount");
 619                         Assert.AreEqual (0, count, "count-2");
 620
 621                         bool curve;
 622                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterHasCurve (iterHandle, out curve), "GdipPathIterHasCurve");
 623
 624                         int result = -1;
 625 //                      PointF[] points = new PointF[count];
 626 //                      byte[] types = new byte[count];
 627 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterEnumerate (iterHandle, out result, points, types, count), "GdipPathIterEnumerate");
 628 //                      Assert.AreEqual (0, result, "result-1");
 629
 630 //                      result = -1;
 631 //                      Assert.AreEqual (Status.Ok, GDIPlus.GdipPathIterCopyData (iterHandle, out result, points, types, 0, 0), "GdipPathIterCopyData");
 632 //                      Assert.AreEqual (0, result, "result-2");
 633
 634                         result = -1;
 635                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarkerPath (iterHandle, out result, HandleRefZero), "GdipPathIterNextMarkerPath");
 636                         Assert.AreEqual (0, result, "result-3");
 637
 638                         result = -1;
 639                         int start = -1;
 640                         int end = -1;
 641                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextMarker (iterHandle, out result, out start, out end), "GdipPathIterNextMarker");
 642                         Assert.AreEqual (0, result, "result-4");
 643                         Assert.AreEqual (-1, start, "start-1");
 644                         Assert.AreEqual (-1, end, "end-1");
 645
 646                         result = -1;
 647                         byte pathType = 255;
 648                         start = -1;
 649                         end = -1;
 650                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextPathType (iterHandle, out result, out pathType, out start, out end), "GdipPathIterNextPathType");
 651                         Assert.AreEqual (0, result, "result-5");
 652                         Assert.AreEqual (255, pathType, "pathType");
 653                         Assert.AreEqual (-1, start, "start-2");
 654                         Assert.AreEqual (-1, end, "end-2");
 655
 656                         bool closed = false;
 657                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpathPath (iterHandle, out result, HandleRefZero, out closed), "GdipPathIterNextSubpathPath");
 658
 659                         start = -1;
 660                         end = -1;
 661                         closed = false;
 662                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterNextSubpath (iterHandle, out result, out start, out end, out closed), "GdipPathIterNextSubpath");
 663                         Assert.AreEqual (-1, start, "start-3");
 664                         Assert.AreEqual (-1, end, "end-3");
 665
 666                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipPathIterRewind (iterHandle), "GdipPathIterRewind");
 667
 668                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeletePathIter (iterHandle), "GdipDeletePathIter");
 669                 }
 670
 671                 // Matrix
 672                 [Test]
 673                 public void Matrix ()
 674                 {
 675                         IntPtr matrix;
 676                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix (out matrix), "GdipCreateMatrix");
 677                         Assert.IsTrue (matrix != IntPtr.Zero, "Handle");
 678
 679                         bool result;
 680                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipIsMatrixIdentity (IntPtr.Zero, out result), "GdipIsMatrixIdentity-null");
 681                         Assert.AreEqual (Status.Ok, GDIPlus.GdipIsMatrixIdentity (matrix, out result), "GdipIsMatrixIdentity");
 682                         Assert.IsTrue (result, "identity");
 683
 684                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipIsMatrixInvertible (IntPtr.Zero, out result), "GdipIsMatrixInvertible-null");
 685                         Assert.AreEqual (Status.Ok, GDIPlus.GdipIsMatrixInvertible (matrix, out result), "GdipIsMatrixInvertible");
 686                         Assert.IsTrue (result, "invertible");
 687
 688                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipInvertMatrix (IntPtr.Zero), "GdipInvertMatrix-null");
 689                         Assert.AreEqual (Status.Ok, GDIPlus.GdipInvertMatrix (matrix), "GdipInvertMatrix");
 690
 691                         PointF[] points = new PointF[1];
 692                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipTransformMatrixPoints (IntPtr.Zero, points, 1), "GdipTransformMatrixPoints-null-points-1");
 693                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipTransformMatrixPoints (matrix, null, 1), "GdipTransformMatrixPoints-matrix-points-1");
 694                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipTransformMatrixPoints (matrix, points, 0), "GdipTransformMatrixPoints-matrix-points-0");
 695                         Assert.AreEqual (Status.Ok, GDIPlus.GdipTransformMatrixPoints (matrix, points, 1), "GdipTransformMatrixPoints");
 696
 697                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipVectorTransformMatrixPoints (IntPtr.Zero, points, 1), "GdipVectorTransformMatrixPoints-null-points-1");
 698                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipVectorTransformMatrixPoints (matrix, null, 1), "GdipVectorTransformMatrixPoints-matrix-points-1");
 699                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipVectorTransformMatrixPoints (matrix, points, 0), "GdipVectorTransformMatrixPoints-matrix-points-0");
 700                         Assert.AreEqual (Status.Ok, GDIPlus.GdipVectorTransformMatrixPoints (matrix, points, 1), "GdipVectorTransformMatrixPoints");
 701
 702                         IntPtr clone;
 703                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCloneMatrix (IntPtr.Zero, out clone), "GdipCloneMatrix");
 704                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneMatrix (matrix, out clone), "GdipCloneMatrix");
 705                         Assert.IsTrue (clone != IntPtr.Zero, "Handle-clone");
 706
 707                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipIsMatrixEqual (IntPtr.Zero, clone, out result), "GdipIsMatrixEqual-null-clone");
 708                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipIsMatrixEqual (matrix, IntPtr.Zero, out result), "GdipIsMatrixEqual-matrix-null");
 709                         Assert.AreEqual (Status.Ok, GDIPlus.GdipIsMatrixEqual (matrix, clone, out result), "GdipIsMatrixEqual-matrix-clone");
 710                         Assert.IsTrue (result, "equal");
 711
 712                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipMultiplyMatrix (IntPtr.Zero, clone, MatrixOrder.Append), "GdipMultiplyMatrix-null-clone-append");
 713                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipMultiplyMatrix (matrix, IntPtr.Zero, MatrixOrder.Prepend), "GdipMultiplyMatrix-matrix-null-prepend");
 714                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipMultiplyMatrix (matrix, clone, (MatrixOrder)Int32.MinValue), "GdipMultiplyMatrix-matrix-clone-invalid");
 715                         Assert.AreEqual (Status.Ok, GDIPlus.GdipMultiplyMatrix (matrix, clone, MatrixOrder.Append), "GdipMultiplyMatrix-matrix-clone-append");
 716
 717                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipTranslateMatrix (IntPtr.Zero, 1f, 2f, MatrixOrder.Append), "GdipTranslateMatrix-null-append");
 718                         Assert.AreEqual (Status.Ok, GDIPlus.GdipTranslateMatrix (matrix, Single.NaN, Single.NegativeInfinity, MatrixOrder.Prepend), "GdipTranslateMatrix-nan-append");
 719                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipTranslateMatrix (matrix, 1f, 2f, (MatrixOrder) Int32.MinValue), "GdipTranslateMatrix-matrix-invalid");
 720                         Assert.AreEqual (Status.Ok, GDIPlus.GdipTranslateMatrix (matrix, 1f, 2f, MatrixOrder.Append), "GdipTranslateMatrix-matrix-append");
 721
 722                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipScaleMatrix (IntPtr.Zero, 1f, 2f, MatrixOrder.Append), "GdipScaleMatrix-null-append");
 723                         Assert.AreEqual (Status.Ok, GDIPlus.GdipScaleMatrix (matrix, Single.NaN, Single.NegativeInfinity, MatrixOrder.Prepend), "GdipScaleMatrix-nan-append");
 724                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipScaleMatrix (matrix, 1f, 2f, (MatrixOrder) Int32.MinValue), "GdipScaleMatrix-matrix-invalid");
 725                         Assert.AreEqual (Status.Ok, GDIPlus.GdipScaleMatrix (matrix, 1f, 2f, MatrixOrder.Append), "GdipScaleMatrix-matrix-append");
 726
 727                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipShearMatrix (IntPtr.Zero, 1f, 2f, MatrixOrder.Append), "GdipShearMatrix-null-append");
 728                         Assert.AreEqual (Status.Ok, GDIPlus.GdipShearMatrix (matrix, Single.NaN, Single.NegativeInfinity, MatrixOrder.Prepend), "GdipShearMatrix-nan-append");
 729                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipShearMatrix (matrix, 1f, 2f, (MatrixOrder) Int32.MinValue), "GdipShearMatrix-matrix-invalid");
 730                         Assert.AreEqual (Status.Ok, GDIPlus.GdipShearMatrix (matrix, 1f, 2f, MatrixOrder.Append), "GdipShearMatrix-matrix-append");
 731
 732                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteMatrix (IntPtr.Zero), "GdipDeleteMatrix-null");
 733                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
 734                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (clone), "GdipDeleteMatrix-clone");
 735                 }
 736
 737                 [Test]
 738                 public void Matrix2 ()
 739                 {
 740                         IntPtr matrix;
 741                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix2 (Single.MinValue, Single.MaxValue, Single.NegativeInfinity,
 742                                 Single.PositiveInfinity, Single.NaN, Single.Epsilon, out matrix), "GdipCreateMatrix2");
 743                         Assert.IsTrue (matrix != IntPtr.Zero, "Handle");
 744
 745                         // check data
 746                         float[] elements = new float[6];
 747                         IntPtr data = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (float)) * 6);
 748                         try {
 749                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMatrixElements (IntPtr.Zero, data), "GdipSetMatrixElements-null-matrix");
 750                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMatrixElements (matrix, IntPtr.Zero), "GdipSetMatrixElements-null-data");
 751                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetMatrixElements (matrix, data), "GdipSetMatrixElements-null-matrix");
 752                                 Marshal.Copy (data, elements, 0, 6);
 753                                 Assert.AreEqual (Single.MinValue, elements [0], "0");
 754                                 Assert.AreEqual (Single.MaxValue, elements [1], "1");
 755                                 Assert.AreEqual (Single.NegativeInfinity, elements [2], "2");
 756                                 Assert.AreEqual (Single.PositiveInfinity, elements [3], "3");
 757                                 Assert.AreEqual (Single.NaN, elements [4], "4");
 758                                 Assert.AreEqual (Single.Epsilon, elements [5], "5");
 759                         }
 760                         finally {
 761                                 Marshal.FreeHGlobal (data);
 762                         }
 763
 764                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetMatrixElements (IntPtr.Zero, 0f, 0f, 0f, 0f, 0f, 0f), "GdipSetMatrixElements-null");
 765                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetMatrixElements (matrix, 0f, 0f, 0f, 0f, 0f, 0f), "GdipSetMatrixElements");
 766
 767                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
 768                 }
 769
 770                 [Test]
 771                 public void Matrix3 ()
 772                 {
 773                         RectangleF rect = new RectangleF ();
 774                         IntPtr matrix;
 775                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateMatrix3 (ref rect, null, out matrix), "GdipCreateMatrix3-null");
 776
 777                         // provding less than 3 points would results in AccessViolationException under MS 2.0 but can't happen using the managed SD code
 778                         PointF[] points = new PointF[3];
 779                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateMatrix3 (ref rect, points, out matrix), "GdipCreateMatrix3-empty-rect");
 780                         rect = new RectangleF (10f, 20f, 0f, 40f);
 781                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateMatrix3 (ref rect, points, out matrix), "GdipCreateMatrix3-empty-width");
 782                         rect = new RectangleF (10f, 20f, 30f, 0f);
 783                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreateMatrix3 (ref rect, points, out matrix), "GdipCreateMatrix3-empty-height");
 784
 785                         rect = new RectangleF (0f, 0f, 30f, 40f);
 786                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix3 (ref rect, points, out matrix), "GdipCreateMatrix3-3");
 787                         Assert.IsTrue (matrix != IntPtr.Zero, "Handle");
 788
 789                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
 790                 }
 791
 792                 // Image
 793                 [Test]
 794                 public void DisposeImage ()
 795                 {
 796                         // invalid image pointer (null)
 797                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDisposeImage (IntPtr.Zero), "null");
 798
 799                         IntPtr image;
 800                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 801                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "first");
 802                 }
 803
 804                 [Test]
 805                 [Category ("NotWorking")]
 806                 public void DisposeImage_Dual ()
 807                 {
 808                         IntPtr image;
 809                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 810                         // first dispose
 811                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "first");
 812                         // second dispose
 813                         Assert.AreEqual (Status.ObjectBusy, GDIPlus.GdipDisposeImage (image), "second");
 814                 }
 815
 816                 [Test]
 817                 [Category ("NotWorking")] // libgdiplus doesn't implement GdipGetImageThumbnail (it is done inside S.D)
 818                 public void GetImageThumbnail ()
 819                 {
 820                         IntPtr ptr;
 821
 822                         // invalid image pointer (null)
 823                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetImageThumbnail (IntPtr.Zero, 10, 10, out ptr, IntPtr.Zero, IntPtr.Zero));
 824
 825                         IntPtr image;
 826                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 827                         try {
 828                                 // invalid width (0)
 829                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageThumbnail (image, 0, 10, out ptr, IntPtr.Zero, IntPtr.Zero));
 830                                 // invalid width (negative)
 831                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageThumbnail (image, 0x8000000, 10, out ptr, IntPtr.Zero, IntPtr.Zero));
 832                                 // invalid height (0)
 833                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageThumbnail (image, 10, 0, out ptr, IntPtr.Zero, IntPtr.Zero));
 834                                 // invalid height (negative)
 835                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageThumbnail (image, 10, 0x8000000, out ptr, IntPtr.Zero, IntPtr.Zero));
 836                         }
 837                         finally {
 838                                 GDIPlus.GdipDisposeImage (image);
 839                         }
 840                 }
 841
 842                 [Test]
 843                 public void Icon ()
 844                 {
 845                         string filename = TestBitmap.getInFile ("bitmaps/64x64x256.ico");
 846                         IntPtr bitmap;
 847                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateBitmapFromFile (filename, out bitmap), "GdipCreateBitmapFromFile");
 848                         try {
 849                                 int size;
 850                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImagePaletteSize (bitmap, out size), "GdipGetImagePaletteSize");
 851                                 Assert.AreEqual (1032, size, "size");
 852
 853                                 IntPtr clone;
 854                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneImage (bitmap, out clone), "GdipCloneImage");
 855                                 try {
 856                                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImagePaletteSize (clone, out size), "GdipGetImagePaletteSize/Clone");
 857                                         Assert.AreEqual (1032, size, "size/clone");
 858                                 }
 859                                 finally {
 860                                         GDIPlus.GdipDisposeImage (clone);
 861                                 }
 862
 863                                 IntPtr palette = Marshal.AllocHGlobal (size);
 864                                 try {
 865
 866                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetImagePalette (IntPtr.Zero, palette, size), "GdipGetImagePalette(null,palette,size)");
 867                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetImagePalette (bitmap, IntPtr.Zero, size), "GdipGetImagePalette(bitmap,null,size)");
 868                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetImagePalette (bitmap, palette, 0), "GdipGetImagePalette(bitmap,palette,0)");
 869                                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImagePalette (bitmap, palette, size), "GdipGetImagePalette");
 870
 871                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetImagePalette (IntPtr.Zero, palette), "GdipSetImagePalette(null,palette)");
 872                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetImagePalette (bitmap, IntPtr.Zero), "GdipSetImagePalette(bitmap,null)");
 873                                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetImagePalette (bitmap, palette), "GdipSetImagePalette");
 874                                 }
 875                                 finally {
 876                                         Marshal.FreeHGlobal (palette);
 877                                 }
 878                         }
 879                         finally {
 880                                 GDIPlus.GdipDisposeImage (bitmap);
 881                         }
 882                 }
 883
 884                 [Test]
 885                 public void FromFile_IndexedBitmap ()
 886                 {
 887                         // despite it's name it's a 4bpp indexed bitmap
 888                         string filename = TestBitmap.getInFile ("bitmaps/almogaver1bit.bmp");
 889                         IntPtr graphics;
 890
 891                         IntPtr image;
 892                         Assert.AreEqual (Status.Ok, GDIPlus.GdipLoadImageFromFile (filename, out image), "GdipLoadImageFromFile");
 893                         try {
 894                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageGraphicsContext (image, out graphics), "GdipGetImageGraphicsContext/image");
 895                                 Assert.AreEqual (IntPtr.Zero, graphics, "image/graphics");
 896                         }
 897                         finally {
 898                                 GDIPlus.GdipDisposeImage (image);
 899                         }
 900
 901                         IntPtr bitmap;
 902                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateBitmapFromFile (filename, out bitmap), "GdipCreateBitmapFromFile");
 903                         try {
 904                                 Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageGraphicsContext (bitmap, out graphics), "GdipGetImageGraphicsContext/bitmap");
 905                                 Assert.AreEqual (IntPtr.Zero, graphics, "bitmap/graphics");
 906                         }
 907                         finally {
 908                                 GDIPlus.GdipDisposeImage (bitmap);
 909                         }
 910                 }
 911
 912                 [Test]
 913                 public void GdipLoadImageFromFile_FileNotFound ()
 914                 {
 915                         string filename = "filenotfound";
 916
 917                         IntPtr image;
 918                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipLoadImageFromFile (filename, out image), "GdipLoadImageFromFile");
 919                         Assert.AreEqual (IntPtr.Zero, image, "image handle");
 920
 921                         // this doesn't throw a OutOfMemoryException
 922                         Assert.Throws<FileNotFoundException> (() => Image.FromFile (filename));
 923                 }
 924
 925                 [Test]
 926                 public void GdipCreateBitmapFromFile_FileNotFound ()
 927                 {
 928                         string filename = "filenotfound";
 929
 930                         IntPtr bitmap;
 931                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateBitmapFromFile (filename, out bitmap), "GdipCreateBitmapFromFile");
 932                         Assert.AreEqual (IntPtr.Zero, bitmap, "bitmap handle");
 933
 934                         Assert.Throws<ArgumentException> (() => new Bitmap (filename));
 935                 }
 936
 937                 [Test]
 938                 public void Encoder ()
 939                 {
 940                         IntPtr image;
 941                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
 942
 943                         Guid g = new Guid ();
 944                         uint size = UInt32.MaxValue;
 945                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetEncoderParameterListSize (IntPtr.Zero, ref g, out size), "GdipGetEncoderParameterListSize-null-guid-uint");
 946                         Assert.AreEqual (UInt32.MaxValue, size, "size-1");
 947                         // note: can't test a null Guid (it's a struct)
 948 #if false
 949                         Assert.AreEqual (Status. FileNotFound, GDIPlus.GdipGetEncoderParameterListSize (image, ref g, out size), "GdipGetEncoderParameterListSize-image-badguid-uint");
 950                         Assert.AreEqual (UInt32.MaxValue, size, "size-2");
 951
 952                         g = new Guid ("{B96B3CAE-0728-11D3-9D7B-0000F81EF32E}");
 953                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetEncoderParameterListSize (image, ref g, out size), "GdipGetEncoderParameterListSize-image-guid-uint");
 954                         Assert.AreEqual (UInt32.MaxValue, size, "size-3");
 955 #endif
 956                         GDIPlus.GdipDisposeImage (image);
 957                 }
 958
 959                 // ImageAttribute
 960                 [Test]
 961                 public void ImageAttribute ()
 962                 {
 963                         IntPtr attr;
 964                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateImageAttributes (out attr), "GdipCreateImageAttributes");
 965                         var attrHandle = new HandleRef (this, attr);
 966
 967                         IntPtr clone;
 968                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCloneImageAttributes (HandleRefZero, out clone), "GdipCloneImageAttributes");
 969                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCloneImageAttributes (attrHandle, out clone), "GdipCloneImageAttributes");
 970                         var cloneHandle = new HandleRef (this, clone);
 971
 972                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, true, null, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-true-matrix1");
 973                         // the first color matrix can be null if enableFlag is false
 974                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, false, null, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-false-matrix1");
 975                         ColorMatrix cm = new ColorMatrix ();
 976                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetImageAttributesColorMatrix (HandleRefZero, ColorAdjustType.Default, true, cm, null, ColorMatrixFlag.Default), "GdipSetImageAttributesColorMatrix-null");
 977                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetImageAttributesColorMatrix (attrHandle, ColorAdjustType.Default, true, cm, null, ColorMatrixFlag.Default), "GdipCloneImageAttributes");
 978
 979                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipDisposeImageAttributes (HandleRefZero), "GdipDisposeImageAttributes-null");
 980                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDisposeImageAttributes (attrHandle), "GdipDisposeImageAttributes");
 981                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDisposeImageAttributes (cloneHandle), "GdipDisposeImageAttributes-clone");
 982                 }
 983
 984                 // PathGradientBrush
 985                 [Test]
 986                 public void CreatePathGradient ()
 987                 {
 988                         PointF[] points = null;
 989                         IntPtr brush;
 990                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradient (points, 0, WrapMode.Clamp, out brush), "null");
 991
 992                         points = new PointF [0];
 993                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradient (points, 0, WrapMode.Clamp, out brush), "empty");
 994
 995                         points = new PointF[1];
 996                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradient (points, 1, WrapMode.Clamp, out brush), "one");
 997
 998                         points = null;
 999                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradient (points, 2, WrapMode.Clamp, out brush), "null/two");
1000
1001                         points = new PointF[2] { new PointF (1, 2), new PointF (20, 30) };
1002                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradient (points, 2, WrapMode.Clamp, out brush), "two");
1003                         Assert.IsTrue (brush != IntPtr.Zero, "Handle");
1004                         var brushHandle = new HandleRef (this, brush);
1005
1006                         int count;
1007                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
1008                         Assert.AreEqual (1, count, "blend count");
1009
1010                         int[] colors = new int[count];
1011                         float[] positions = new float[count];
1012                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
1013                         // can't call that for 1 count!
1014
1015                         Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1016                 }
1017
1018                 [Test]
1019                 public void CreatePathGradient_FromPath_Line ()
1020                 {
1021                         IntPtr path;
1022                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
1023
1024                         IntPtr brush;
1025                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradientFromPath (IntPtr.Zero, out brush), "null");
1026                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipCreatePathGradientFromPath (path, out brush), "empty path");
1027
1028                         Assert.AreEqual (Status.Ok, GDIPlus.GdipAddPathLine (path, 1, 1, 10, 10), "GdipAddPathLine");
1029
1030                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradientFromPath (path, out brush), "path");
1031                         Assert.IsTrue (brush != IntPtr.Zero, "Handle");
1032                         var brushHandle = new HandleRef (this, brush);
1033
1034                         int count;
1035                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
1036                         Assert.AreEqual (1, count, "blend count");
1037
1038                         int[] colors = new int[count];
1039                         float[] positions = new float[count];
1040                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
1041
1042                         Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1043                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
1044                 }
1045
1046                 [Test]
1047                 public void CreatePathGradient_FromPath_Lines ()
1048                 {
1049                         IntPtr path;
1050                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePath (FillMode.Alternate, out path), "GdipCreatePath");
1051
1052                         PointF[] pts_2f = new PointF[2] { new PointF (2f, 4f), new PointF (10f, 30f) };
1053                         Assert.AreEqual (Status.Ok, GDIPlus.GdipAddPathLine2 (path, pts_2f, pts_2f.Length), "GdipAddPathLine2");
1054
1055                         IntPtr brush;
1056                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePathGradientFromPath (path, out brush), "path");
1057                         Assert.IsTrue (brush != IntPtr.Zero, "Handle");
1058                         var brushHandle = new HandleRef (this, brush);
1059
1060                         int count;
1061                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPathGradientBlendCount (brush, out count), "GdipGetPathGradientBlendCount");
1062                         Assert.AreEqual (1, count, "blend count");
1063
1064                         int[] colors = new int[count];
1065                         float[] positions = new float[count];
1066                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPathGradientPresetBlend (brush, colors, positions, count), "GdipGetPathGradientBlend");
1067
1068                         Assert.AreEqual (0, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1069                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePath (path), "GdipDeletePath");
1070                 }
1071
1072                 // Pen
1073                 [Test]
1074                 public void CreatePen ()
1075                 {
1076                         IntPtr pen;
1077                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePen1 (0, 0f, GraphicsUnit.World, out pen), "GdipCreatePen1");
1078                         Assert.IsTrue (pen != IntPtr.Zero, "pen");
1079
1080                         DashStyle ds;
1081                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenDashStyle (pen, out ds), "GdipGetPenDashStyle");
1082                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenDashStyle (IntPtr.Zero, out ds), "GdipGetPenDashStyle-null");
1083
1084                         ds = DashStyle.Custom;
1085                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetPenDashStyle (pen, ds), "GdipSetPenDashStyle");
1086                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetPenDashStyle (IntPtr.Zero, ds), "GdipSetPenDashStyle-null");
1087
1088                         int count;
1089                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenDashCount (pen, out count), "GdipGetPenDashCount");
1090                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenDashCount (IntPtr.Zero, out count), "GdipGetPenDashCount-null");
1091                         Assert.AreEqual (0, count, "count");
1092
1093                         float[] dash = new float[count];
1094                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetPenDashArray (pen, dash, count), "GdipGetPenDashArray");
1095                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenDashArray (IntPtr.Zero, dash, count), "GdipGetPenDashArray-null-pen");
1096                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenDashArray (pen, null, count), "GdipGetPenDashArray-null-dash");
1097
1098                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePen (pen), "GdipDeletePen");
1099                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeletePen (IntPtr.Zero), "GdipDeletePen-null");
1100                 }
1101
1102                 [Test]
1103                 public void PenColor_81266 ()
1104                 {
1105                         IntPtr pen;
1106                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreatePen1 (0x7f0000ff, 1f, GraphicsUnit.Pixel, out pen), "GdipCreatePen1");
1107                         try {
1108                                 int color = 0;
1109                                 IntPtr brush;
1110                                 HandleRef brushHandle;
1111                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetPenBrushFill (IntPtr.Zero, out brush), "GdipGetPenBrushFill-null");
1112                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenBrushFill (pen, out brush), "GdipGetPenBrushFill");
1113                                 brushHandle = new HandleRef (this, brush);
1114
1115                                 try {
1116                                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetSolidFillColor (HandleRefZero, out color), "GdipGetSolidFillColor-null");
1117                                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-0");
1118                                         Assert.AreEqual (0x7f0000ff, color, "color-0");
1119
1120                                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetPenColor (IntPtr.Zero, 0x7fff0000), "GdipSetPenColor-null");
1121                                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetPenColor (pen, 0x7fff0000), "GdipSetPenColor");
1122
1123                                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-1");
1124                                         // previous brush color didn't change
1125                                         Assert.AreEqual (0x7f0000ff, color, "color-1");
1126                                 }
1127                                 finally {
1128                                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1129                                 }
1130
1131                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPenBrushFill (pen, out brush), "GdipGetPenBrushFill-2");
1132                                 brushHandle = new HandleRef (this, brush);
1133                                 try {
1134                                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetSolidFillColor (brushHandle, out color), "GdipGetSolidFillColor-2");
1135                                         // new brush color is updated
1136                                         Assert.AreEqual (0x7fff0000, color, "color-2");
1137                                 }
1138                                 finally {
1139                                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush-2");
1140                                 }
1141                         }
1142                         finally {
1143                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDeletePen (pen), "GdipDeletePen");
1144                         }
1145                 }
1146
1147                 // Region
1148                 [Test]
1149                 public void CreateRegionRgnData ()
1150                 {
1151                         IntPtr region;
1152                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateRegionRgnData (null, 0, out region));
1153
1154                         byte[] data = new byte[0];
1155                         Assert.AreEqual (Status.GenericError, GDIPlus.GdipCreateRegionRgnData (data, 0, out region));
1156                 }
1157
1158                 [Test]
1159                 public void DrawingOperations ()
1160                 {
1161                         IntPtr graphics, image;
1162
1163                         IntPtr pen;
1164                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero,
1165                                                            out image);
1166
1167                         GDIPlus.GdipGetImageGraphicsContext (image, out graphics);
1168                         GDIPlus.GdipCreatePen1 (0, 0f, GraphicsUnit.World, out pen);
1169
1170                         // DrawCurve
1171
1172                         Assert.AreEqual (Status.InvalidParameter,
1173                                          GDIPlus.GdipDrawCurveI (IntPtr.Zero, IntPtr.Zero, null, 0));
1174
1175                         Assert.AreEqual (Status.InvalidParameter,
1176                                          GDIPlus.GdipDrawCurveI (graphics, pen, new Point [] {}, 0),
1177                                          "DrawCurve with no pts");
1178                         Assert.AreEqual (Status.InvalidParameter,
1179                                          GDIPlus.GdipDrawCurveI (graphics, pen,
1180                                                                  new Point [] { new Point (1, 1) }, 1),
1181                                          "DrawCurve with 1 pt");
1182                         Assert.AreEqual (Status.Ok,
1183                                          GDIPlus.GdipDrawCurveI (graphics, pen,
1184                                                                  new Point [] { new Point (1, 1),
1185                                                                                 new Point (2, 2) }, 2),
1186                                          "DrawCurve with 2 pts");
1187
1188                         // DrawClosedCurve
1189
1190                         Assert.AreEqual (Status.InvalidParameter,
1191                                          GDIPlus.GdipDrawClosedCurveI (graphics, pen, new Point [] {}, 0),
1192                                          "DrawClosedCurve with no pts");
1193                         Assert.AreEqual (Status.InvalidParameter,
1194                                          GDIPlus.GdipDrawClosedCurveI (graphics, pen,
1195                                                                        new Point [] { new Point (1, 1) }, 1),
1196                                          "DrawClosedCurve with 1 pt");
1197                         Assert.AreEqual (Status.InvalidParameter,
1198                                          GDIPlus.GdipDrawClosedCurveI (graphics, pen,
1199                                                                        new Point [] { new Point (1, 1),
1200                                                                                       new Point (2, 2) }, 2),
1201                                          "DrawClosedCurve with 2 pt2");
1202
1203                         // DrawPolygon
1204
1205                         Assert.AreEqual (Status.InvalidParameter,
1206                                          GDIPlus.GdipDrawPolygonI (graphics, pen, new Point [] {}, 0),
1207                                          "DrawPolygon with no pts");
1208                         Assert.AreEqual (Status.InvalidParameter,
1209                                          GDIPlus.GdipDrawPolygonI (graphics, pen,
1210                                                                    new Point [] { new Point (1, 1) }, 1),
1211                                          "DrawPolygon with only one pt");
1212
1213                         GDIPlus.GdipDeletePen (pen);
1214
1215                         // FillClosedCurve
1216
1217                         IntPtr brush;
1218                         GDIPlus.GdipCreateSolidFill (0, out brush);
1219                         var brushHandle = new HandleRef (this, brush);
1220
1221                         Assert.AreEqual (Status.InvalidParameter,
1222                                          GDIPlus.GdipFillClosedCurveI (graphics, brush, new Point [] {}, 0),
1223                                          "FillClosedCurve with no pts");
1224                         Assert.AreEqual (Status.Ok,
1225                                          GDIPlus.GdipFillClosedCurveI (graphics, brush,
1226                                                                                                 new Point [] { new Point (1, 1) }, 1),
1227                                          "FillClosedCurve with 1 pt");
1228                         Assert.AreEqual (Status.Ok,
1229                                          GDIPlus.GdipFillClosedCurveI (graphics, brush,
1230                                                                        new Point [] { new Point (1, 1),
1231                                                                                       new Point (2, 2) }, 2),
1232                                          "FillClosedCurve with 2 pts");
1233
1234                         GDIPlus.GdipDeleteBrush (brushHandle);
1235
1236                         GDIPlus.GdipDeleteGraphics (graphics);
1237                         GDIPlus.GdipDisposeImage (image);
1238                 }
1239
1240                 // StringFormat
1241                 private void CheckStringFormat (IntPtr sf, StringFormatFlags exepcted_flags, StringTrimming expected_trimmings)
1242                 {
1243                         StringAlignment sa = StringAlignment.Center;
1244                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatAlign (IntPtr.Zero, out sa), "GdipGetStringFormatAlign-null");
1245                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatAlign (sf, out sa), "GdipGetStringFormatAlign");
1246                         Assert.AreEqual (StringAlignment.Near, sa, "StringAlignment-1");
1247
1248                         StringAlignment la = StringAlignment.Center;
1249                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatLineAlign (IntPtr.Zero, out la), "GdipGetStringFormatLineAlign-null");
1250                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatLineAlign (sf, out la), "GdipGetStringFormatLineAlign");
1251                         Assert.AreEqual (StringAlignment.Near, la, "StringAlignment-2");
1252
1253                         StringFormatFlags flags = StringFormatFlags.DirectionRightToLeft;
1254                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatFlags (IntPtr.Zero, out flags), "GdipGetStringFormatFlags-null");
1255                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatFlags (sf, out flags), "GdipGetStringFormatFlags");
1256                         Assert.AreEqual (exepcted_flags, flags, "StringFormatFlags");
1257
1258                         HotkeyPrefix hotkey = HotkeyPrefix.Show;
1259                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatHotkeyPrefix (IntPtr.Zero, out hotkey), "GdipGetStringFormatHotkeyPrefix-null");
1260                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatHotkeyPrefix (sf, out hotkey), "GdipGetStringFormatHotkeyPrefix");
1261                         Assert.AreEqual (HotkeyPrefix.None, hotkey, "HotkeyPrefix");
1262
1263                         StringTrimming trimming = StringTrimming.None;
1264                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatTrimming (IntPtr.Zero, out trimming), "GdipGetStringFormatTrimming-null");
1265                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatTrimming (sf, out trimming), "GdipGetStringFormatTrimming");
1266                         Assert.AreEqual (expected_trimmings, trimming, "StringTrimming");
1267
1268                         StringDigitSubstitute sub = StringDigitSubstitute.Traditional;
1269                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatDigitSubstitution (IntPtr.Zero, 0, out sub), "GdipGetStringFormatDigitSubstitution-null");
1270                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatDigitSubstitution (sf, 0, out sub), "GdipGetStringFormatDigitSubstitution");
1271                         Assert.AreEqual (StringDigitSubstitute.User, sub, "StringDigitSubstitute");
1272
1273                         int count;
1274                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatMeasurableCharacterRangeCount (IntPtr.Zero, out count), "GdipGetStringFormatMeasurableCharacterRangeCount-null");
1275                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatMeasurableCharacterRangeCount (sf, out count), "GdipGetStringFormatMeasurableCharacterRangeCount");
1276                         Assert.AreEqual (0, count, "count");
1277                 }
1278
1279                 [Test]
1280                 public void StringFormat ()
1281                 {
1282                         IntPtr sf;
1283                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateStringFormat (Int32.MinValue, Int32.MinValue, out sf), "GdipCreateStringFormat");
1284
1285                         CheckStringFormat (sf, (StringFormatFlags) Int32.MinValue, StringTrimming.Character);
1286
1287                         CharacterRange[] ranges = new CharacterRange[32];
1288                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetStringFormatMeasurableCharacterRanges (IntPtr.Zero, 1, ranges), "GdipSetStringFormatMeasurableCharacterRanges-null");
1289                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetStringFormatMeasurableCharacterRanges (IntPtr.Zero, -1, ranges), "GdipSetStringFormatMeasurableCharacterRanges-negative");
1290                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetStringFormatMeasurableCharacterRanges (sf, 1, ranges), "GdipSetStringFormatMeasurableCharacterRanges");
1291                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetStringFormatMeasurableCharacterRanges (sf, 32, ranges), "GdipSetStringFormatMeasurableCharacterRanges-32");
1292                         Assert.AreEqual (Status.ValueOverflow, GDIPlus.GdipSetStringFormatMeasurableCharacterRanges (sf, 33, ranges), "GdipSetStringFormatMeasurableCharacterRanges-33");
1293
1294                         float first = Single.MinValue;
1295                         float[] tabs = new float[1];
1296                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetStringFormatTabStops (IntPtr.Zero, 1.0f, 1, tabs), "GdipSetStringFormatTabStops-null");
1297                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetStringFormatTabStops (sf, 1.0f, 1, null), "GdipSetStringFormatTabStops-null/tabs");
1298
1299                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetStringFormatTabStops (sf, 1.0f, -1, tabs), "GdipSetStringFormatTabStops-negative");
1300                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatTabStops (sf, 1, out first, tabs), "GdipGetStringFormatTabStops-negative");
1301                         Assert.AreEqual (0.0f, first, "first-negative");
1302
1303                         Assert.AreEqual (Status.Ok, GDIPlus.GdipSetStringFormatTabStops (sf, 1.0f, 1, tabs), "GdipSetStringFormatTabStops");
1304                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatTabStops (sf, 1, out first, tabs), "GdipGetStringFormatTabStops");
1305                         Assert.AreEqual (1.0f, first, "first");
1306
1307                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipDeleteStringFormat (IntPtr.Zero), "GdipDeleteStringFormat-null");
1308                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (sf), "GdipDeleteStringFormat");
1309                 }
1310
1311                 [Test]
1312                 public void StringFormat_Clone ()
1313                 {
1314                         IntPtr sf;
1315                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateStringFormat (Int32.MinValue, Int32.MinValue, out sf), "GdipCreateStringFormat");
1316
1317                         IntPtr clone;
1318                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCloneStringFormat (IntPtr.Zero, out clone), "GdipCloneStringFormat");
1319                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneStringFormat (sf, out clone), "GdipCloneStringFormat");
1320
1321                         CheckStringFormat (clone, (StringFormatFlags) Int32.MinValue, StringTrimming.Character);
1322
1323                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (clone), "GdipDeleteStringFormat-clone");
1324                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (sf), "GdipDeleteStringFormat");
1325                 }
1326
1327                 [Test]
1328                 public void StringFormat_GenericDefault ()
1329                 {
1330                         IntPtr sf;
1331                         Assert.AreEqual (Status.Ok, GDIPlus.GdipStringFormatGetGenericDefault (out sf), "GdipStringFormatGetGenericDefault");
1332
1333                         CheckStringFormat (sf, (StringFormatFlags) 0, StringTrimming.Character);
1334
1335                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (sf), "GdipDeleteStringFormat");
1336                 }
1337
1338                 [Test]
1339                 public void StringFormat_GenericTypographic ()
1340                 {
1341                         IntPtr sf;
1342                         Assert.AreEqual (Status.Ok, GDIPlus.GdipStringFormatGetGenericTypographic (out sf), "GdipStringFormatGetGenericTypographic");
1343
1344                         StringFormatFlags flags = StringFormatFlags.NoClip | StringFormatFlags.LineLimit | StringFormatFlags.FitBlackBox;
1345                         CheckStringFormat (sf, flags , StringTrimming.None);
1346
1347                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteStringFormat (sf), "GdipDeleteStringFormat");
1348                 }
1349
1350                 // TextureBrush
1351                 [Test]
1352                 public void Texture ()
1353                 {
1354                         IntPtr image;
1355                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
1356                         var imageHandle = new HandleRef (this, image);
1357
1358                         IntPtr brush;
1359                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture (HandleRefZero, (int) WrapMode.Tile, out brush), "GdipCreateTexture-image");
1360                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture (imageHandle, Int32.MinValue, out brush), "GdipCreateTexture-wrapmode");
1361
1362                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateTexture (imageHandle, (int) WrapMode.Tile, out brush), "GdipCreateTexture");
1363                         var brushHandle = new HandleRef (this, brush);
1364
1365                         IntPtr image2;
1366 // this would throw an AccessViolationException under MS 2.0 (missing null check?)
1367 //                      Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetTextureImage (IntPtr.Zero, out image2), "GdipGetTextureImage-brush");
1368                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureImage (brushHandle, out image2), "GdipGetTextureImage");
1369                         Assert.IsFalse (image == image2, "image");
1370
1371                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1372                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
1373                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image2), "GdipDisposeImage-image2");
1374                 }
1375
1376                 [Test]
1377                 public void Texture2 ()
1378                 {
1379                         IntPtr image;
1380                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
1381                         var imageHandle = new HandleRef (this, image);
1382
1383                         IntPtr brush;
1384                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (HandleRefZero, (int) WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
1385                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipCreateTexture2 (HandleRefZero, Int32.MinValue, 0, 0, 10, 10, out brush), "GdipCreateTexture2-wrapmode");
1386                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
1387                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
1388                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, -1, 0, 0, 10, out brush), "GdipCreateTexture2-x");
1389                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, -1, 10, 0, out brush), "GdipCreateTexture2-y");
1390                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
1391                         Assert.AreEqual ((int) Status.OutOfMemory, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
1392
1393                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipCreateTexture2 (imageHandle, (int) WrapMode.Tile, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
1394                         var brushHandle = new HandleRef (this, brush);
1395
1396                         int wm;
1397                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureWrapMode (HandleRefZero, out wm), "GdipGetTextureWrapMode-brush");
1398                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm), "GdipGetTextureWrapMode");
1399                         Assert.AreEqual ((int) WrapMode.Tile, wm, "WrapMode");
1400
1401                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureWrapMode (HandleRefZero, (int) WrapMode.Clamp), "GdipSetTextureWrapMode-brush");
1402                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureWrapMode (brushHandle, (int) WrapMode.Clamp), "GdipSetTextureWrapMode");
1403                         GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm);
1404                         Assert.AreEqual ((int) WrapMode.Clamp, wm, "WrapMode.Clamp");
1405
1406                         // an invalid WrapMode is ignored
1407                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureWrapMode (brushHandle, Int32.MinValue), "GdipSetTextureWrapMode-wrapmode");
1408                         GDIPlus.GdipGetTextureWrapMode (brushHandle, out wm);
1409                         Assert.AreEqual ((int) WrapMode.Clamp, wm, "WrapMode/Invalid");
1410
1411                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1412                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
1413                 }
1414
1415                 [Test]
1416                 public void TextureIA ()
1417                 {
1418                         IntPtr image;
1419                         GDIPlus.GdipCreateBitmapFromScan0 (10, 10, 0, PixelFormat.Format32bppArgb, IntPtr.Zero, out image);
1420                         var imageHandle = new HandleRef (this, image);
1421
1422                         IntPtr brush;
1423                         Assert.AreEqual ((int)Status.InvalidParameter, GDIPlus.GdipCreateTextureIA (HandleRefZero, HandleRefZero, 0, 0, 10, 10, out brush), "GdipCreateTexture2-image");
1424                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 0, 10, out brush), "GdipCreateTexture2-width");
1425                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 10, 0, out brush), "GdipCreateTexture2-height");
1426                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, -1, 0, 10, 10, out brush), "GdipCreateTexture2-x");
1427                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, -1, 10, 10, out brush), "GdipCreateTexture2-y");
1428                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 1, 0, 10, 10, out brush), "GdipCreateTexture2-too-wide");
1429                         Assert.AreEqual ((int)Status.OutOfMemory, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 1, 10, 10, out brush), "GdipCreateTexture2-too-tall");
1430
1431                         Assert.AreEqual ((int)Status.Ok, GDIPlus.GdipCreateTextureIA (imageHandle, HandleRefZero, 0, 0, 10, 10, out brush), "GdipCreateTexture2");
1432                         var brushHandle = new HandleRef (this, brush);
1433
1434                         // TODO - handle ImageAttribute in the tests
1435
1436                         IntPtr matrix;
1437                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMatrix (out matrix), "GdipCreateMatrix");
1438                         var matrixHandle = new HandleRef (this, matrix);
1439
1440                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (HandleRefZero, matrixHandle), "GdipGetTextureTransform-brush");
1441                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipGetTextureTransform (brushHandle, HandleRefZero), "GdipGetTextureTransform-matrix");
1442                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipGetTextureTransform (brushHandle, matrixHandle), "GdipGetTextureTransform");
1443
1444                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (HandleRefZero, matrixHandle), "GdipSetTextureTransform-brush");
1445                         Assert.AreEqual ((int) Status.InvalidParameter, GDIPlus.GdipSetTextureTransform (brushHandle, HandleRefZero), "GdipSetTextureTransform-matrix");
1446                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipSetTextureTransform (brushHandle, matrixHandle), "GdipSetTextureTransform");
1447
1448                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDeleteMatrix (matrix), "GdipDeleteMatrix");
1449                         Assert.AreEqual ((int) Status.Ok, GDIPlus.GdipDeleteBrush (brushHandle), "GdipDeleteBrush");
1450                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
1451                 }
1452
1453                 // Get the input directory depending on the runtime
1454                 internal string getInFile (string file)
1455                 {
1456                         string sRslt = Path.GetFullPath ("../System.Drawing/" + file);
1457
1458                         if (!File.Exists (sRslt))
1459                                 sRslt = "Test/System.Drawing/" + file;
1460
1461                         return sRslt;
1462                 }
1463
1464                 private void CheckMetafileHeader (MetafileHeader header)
1465                 {
1466                         MetafileHeader mh1 = new Metafile (getInFile ("bitmaps/telescope_01.wmf")).GetMetafileHeader ();
1467                         // compare MetafileHeader
1468                         Assert.AreEqual (mh1.Bounds.X, header.Bounds.X, "Bounds.X");
1469                         Assert.AreEqual (mh1.Bounds.Y, header.Bounds.Y, "Bounds.Y");
1470                         Assert.AreEqual (mh1.Bounds.Width, header.Bounds.Width, "Bounds.Width");
1471                         Assert.AreEqual (mh1.Bounds.Height, header.Bounds.Height, "Bounds.Height");
1472                         Assert.AreEqual (mh1.DpiX, header.DpiX, "DpiX");
1473                         Assert.AreEqual (mh1.DpiY, header.DpiY, "DpiY");
1474                         Assert.AreEqual (mh1.EmfPlusHeaderSize, header.EmfPlusHeaderSize, "EmfPlusHeaderSize");
1475                         Assert.AreEqual (mh1.LogicalDpiX, header.LogicalDpiX, "LogicalDpiX");
1476                         Assert.AreEqual (mh1.LogicalDpiY, header.LogicalDpiY, "LogicalDpiY");
1477                         Assert.AreEqual (mh1.MetafileSize, header.MetafileSize, "MetafileSize");
1478                         Assert.AreEqual (mh1.Type, header.Type, "Type");
1479                         Assert.AreEqual (mh1.Version, header.Version, "Version");
1480                         // compare MetaHeader
1481                         MetaHeader mh1h = mh1.WmfHeader;
1482                         MetaHeader mh2h = header.WmfHeader;
1483                         Assert.AreEqual (mh1h.HeaderSize, mh2h.HeaderSize, "HeaderSize");
1484                         Assert.AreEqual (mh1h.MaxRecord, mh2h.MaxRecord, "MaxRecord");
1485                         Assert.AreEqual (mh1h.NoObjects, mh2h.NoObjects, "NoObjects");
1486                         Assert.AreEqual (mh1h.NoParameters, mh2h.NoParameters, "NoParameters");
1487                         Assert.AreEqual (mh1h.Size, mh2h.Size, "Size");
1488                         Assert.AreEqual (mh1h.Type, mh2h.Type, "Type");
1489                         Assert.AreEqual (mh1h.Version, mh2h.Version, "Version");
1490                 }
1491
1492                 [Test]
1493                 public void Metafile ()
1494                 {
1495                         string filename = getInFile ("bitmaps/telescope_01.wmf");
1496                         IntPtr metafile = IntPtr.Zero;
1497
1498                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipCreateMetafileFromFile (null, out metafile), "GdipCreateMetafileFromFile(null)");
1499                         Assert.AreEqual (Status.GenericError, GDIPlus.GdipCreateMetafileFromFile ("doesnotexists", out metafile), "GdipCreateMetafileFromFile(doesnotexists)");
1500                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMetafileFromFile (filename, out metafile), "GdipCreateMetafileFromFile");
1501
1502                         // looks like it applies to EmfOnly and EmfDual (not EmfPlus or Wmf*)
1503                         uint limit = UInt32.MaxValue;
1504                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileDownLevelRasterizationLimit (IntPtr.Zero, ref limit), "GdipGetMetafileDownLevelRasterizationLimit/null");
1505                         Assert.AreEqual (Status.WrongState, GDIPlus.GdipGetMetafileDownLevelRasterizationLimit (metafile, ref limit), "GdipGetMetafileDownLevelRasterizationLimit");
1506                         Assert.AreEqual (UInt32.MaxValue, limit, "DownLevelRasterizationLimit");
1507                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipSetMetafileDownLevelRasterizationLimit (IntPtr.Zero, limit), "GdipSetMetafileDownLevelRasterizationLimit/null");
1508                         Assert.AreEqual (Status.WrongState, GDIPlus.GdipSetMetafileDownLevelRasterizationLimit (metafile, limit), "GdipSetMetafileDownLevelRasterizationLimit");
1509
1510                         int size = Marshal.SizeOf (typeof (MetafileHeader));
1511                         IntPtr header = Marshal.AllocHGlobal (size);
1512                         try {
1513                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromMetafile (IntPtr.Zero, header), "GdipGetMetafileHeaderFromMetafile(null,header)");
1514 // We get access violation here!
1515 //                              Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromMetafile (metafile, IntPtr.Zero), "GdipGetMetafileHeaderFromMetafile(metafile,null)");
1516                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetMetafileHeaderFromMetafile (metafile, header), "GdipGetMetafileHeaderFromMetafile(metafile,header)");
1517
1518                                 MetafileHeader mh2 = new Metafile (getInFile ("bitmaps/telescope_01.wmf")).GetMetafileHeader ();
1519                                 Marshal.PtrToStructure (header, mh2);
1520                                 CheckMetafileHeader (mh2);
1521                         }
1522                         finally {
1523                                 Marshal.FreeHGlobal (header);
1524                         }
1525
1526                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (metafile), "GdipDisposeImage");
1527                 }
1528
1529                 [Test]
1530                 public void Metafile_GetMetafileHeaderFromFile ()
1531                 {
1532                         string filename = getInFile ("bitmaps/telescope_01.wmf");
1533
1534                         int size = Marshal.SizeOf (typeof (MetafileHeader));
1535                         IntPtr ptr = Marshal.AllocHGlobal (size);
1536                         try {
1537                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromFile ("does-not-exists", ptr), "GdipGetMetafileHeaderFromFile(doesnotexists,ptr)");
1538                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromFile (null, ptr), "GdipGetMetafileHeaderFromFile(null,ptr)");
1539 // We get access violation here!
1540 //                              Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromFile (filename, IntPtr.Zero), "GdipGetMetafileHeaderFromFile(file,null)");
1541                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipGetMetafileHeaderFromFile (filename, ptr), "GdipGetMetafileHeaderFromFile(file,ptr)");
1542
1543                                 MetafileHeader header = new Metafile (getInFile ("bitmaps/telescope_01.wmf")).GetMetafileHeader ();
1544                                 Marshal.PtrToStructure (ptr, header);
1545                                 CheckMetafileHeader (header);
1546                         }
1547                         finally {
1548                                 Marshal.FreeHGlobal (ptr);
1549                         }
1550                 }
1551
1552                 [Test]
1553                 public void Metafile_Hemf ()
1554                 {
1555                         string filename = getInFile ("bitmaps/telescope_01.wmf");
1556                         IntPtr metafile = IntPtr.Zero;
1557                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMetafileFromFile (filename, out metafile), "GdipCreateMetafileFromFile");
1558
1559                         IntPtr emf = IntPtr.Zero;
1560                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetHemfFromMetafile (IntPtr.Zero, out emf), "GdipGetHemfFromMetafile(null,emf)");
1561                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetHemfFromMetafile (metafile, out emf), "GdipGetHemfFromMetafile(metafile,emf)");
1562
1563                         int size = Marshal.SizeOf (typeof (MetafileHeader));
1564                         IntPtr header = Marshal.AllocHGlobal (size);
1565                         try {
1566                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromEmf (IntPtr.Zero, header), "GdipGetMetafileHeaderFromEmf(null,header)");
1567 // We get access violation here!
1568 //                              Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromEmf (emf, IntPtr.Zero), "GdipGetMetafileHeaderFromEmf(emf,null)");
1569                                 // the HEMF handle cannot be used here
1570                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetMetafileHeaderFromEmf (emf, header), "GdipGetMetafileHeaderFromEmf(emf,header)");
1571                         }
1572                         finally {
1573                                 Marshal.FreeHGlobal (header);
1574                         }
1575
1576                         Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (metafile), "GdipDisposeImage");
1577                 }
1578
1579                 private void InImageAPI (IntPtr image)
1580                 {
1581                         IntPtr ptr = IntPtr.Zero;
1582                         Assert.AreEqual (Status.OutOfMemory, GDIPlus.GdipGetImageGraphicsContext (image, out ptr), "GdipGetImageGraphicsContext");
1583
1584                         RectangleF bounds;
1585                         GraphicsUnit unit = GraphicsUnit.Display;
1586                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageBounds (image, out bounds, ref unit), "GdipGetImageBounds");
1587                         Assert.AreEqual (-30, bounds.X, "bounds.X");
1588                         Assert.AreEqual (-40, bounds.Y, "bounds.Y");
1589                         Assert.AreEqual (3096, bounds.Width, "bounds.Width");
1590                         Assert.AreEqual (4127, bounds.Height, "bounds.Height");
1591                         Assert.AreEqual (GraphicsUnit.Pixel, unit, "uint");
1592
1593                         float width, height;
1594                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageDimension (image, out width, out height), "GdipGetImageDimension");
1595                         Assert.AreEqual (12976.6328f, width, 0.001f, "GdipGetImageDimension/Width");
1596                         Assert.AreEqual (17297.9863f, height, 0.001f, "GdipGetImageDimension/Height");
1597
1598                         ImageType type;
1599                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageType (image, out type), "GdipGetImageType");
1600                         Assert.AreEqual (ImageType.Metafile, type, "Metafile");
1601
1602                         uint w;
1603                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageWidth (image, out w), "GdipGetImageWidth");
1604                         Assert.AreEqual (3096, w, "GdipGetImageWidth/Width");
1605
1606                         uint h;
1607                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageHeight (image, out h), "GdipGetImageHeight");
1608                         Assert.AreEqual (4127, h, "GdipGetImageHeight/Height");
1609
1610                         float horz;
1611                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageHorizontalResolution (image, out horz), "GdipGetImageHorizontalResolution");
1612                         Assert.AreEqual (606, horz, "HorizontalResolution");
1613
1614                         float vert;
1615                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageVerticalResolution (image, out vert), "GdipGetImageVerticalResolution");
1616                         Assert.AreEqual (606, vert, "VerticalResolution");
1617
1618                         int flags;
1619                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageFlags (image, out flags), "GdipGetImageFlags");
1620                         Assert.AreEqual (327683, flags, "Flags");
1621
1622                         Guid format;
1623                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImageRawFormat (image, out format), "GdipGetImageRawFormat");
1624                         Assert.AreEqual ("b96b3cad-0728-11d3-9d7b-0000f81ef32e", format.ToString (), "Format");
1625
1626                         PixelFormat pformat;
1627                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetImagePixelFormat (image, out pformat), "GdipGetImagePixelFormat");
1628                         Assert.AreEqual (PixelFormat.Format32bppRgb, pformat, "PixelFormat");
1629
1630                         uint count;
1631                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageGetFrameDimensionsCount (image, out count), "GdipImageGetFrameDimensionsCount");
1632                         Assert.AreEqual (1, count, "FrameDimensionsCount");
1633
1634                         Guid[] dimid = new Guid[1];
1635                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageGetFrameDimensionsList (image, dimid, count), "GdipImageGetFrameDimensionsList");
1636                         Assert.AreEqual ("7462dc86-6180-4c7e-8e3f-ee7333a7a483", dimid[0].ToString (), "Id[0]");
1637                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipImageGetFrameDimensionsList (image, dimid, 0), "GdipImageGetFrameDimensionsList/0");
1638                         Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipImageGetFrameDimensionsList (image, dimid, 2), "GdipImageGetFrameDimensionsList/2");
1639
1640                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageGetFrameCount (image, ref dimid[0], out count), "GdipImageGetFrameCount");
1641                         Assert.AreEqual (1, count, "FrameCount");
1642                         Guid g = Guid.Empty;
1643                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageGetFrameCount (image, ref g, out count), "GdipImageGetFrameCount/Empty");
1644                         Assert.AreEqual (1, count, "FrameCount/Empty");
1645
1646                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageSelectActiveFrame (image, ref dimid[0], 0), "GdipImageSelectActiveFrame");
1647                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageSelectActiveFrame (image, ref g, 0), "GdipImageSelectActiveFrame/Empty");
1648                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageSelectActiveFrame (image, ref dimid[0], Int32.MinValue), "GdipImageSelectActiveFrame/MinValue");
1649                         Assert.AreEqual (Status.Ok, GDIPlus.GdipImageSelectActiveFrame (image, ref dimid[0], Int32.MaxValue), "GdipImageSelectActiveFrame/MaxValue");
1650
1651                         // woohoo :)
1652                         foreach (RotateFlipType rft in Enum.GetValues (typeof (RotateFlipType))) {
1653                                 Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipImageRotateFlip (image, rft), rft.ToString ());
1654                         }
1655
1656                         int size;
1657                         Assert.AreEqual (Status.GenericError, GDIPlus.GdipGetImagePaletteSize (image, out size), "GdipGetImagePaletteSize");
1658                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetImagePalette (image, image, 1024), "GdipGetImagePalette");
1659                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipSetImagePalette (image, image), "GdipSetImagePalette");
1660
1661                         Assert.AreEqual (Status.Ok, GDIPlus.GdipGetPropertyCount (image, out count), "GdipGetPropertyCount");
1662                         Assert.AreEqual (0, count, "PropertyCount");
1663                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetPropertyIdList (image, 0, new int[1]), "GdipGetPropertyIdList");
1664                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetPropertyItemSize (image, 0, out size), "GdipGetPropertyItemSize");
1665                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetPropertyItem (image, 0, size, image), "GdipGetPropertyItem");
1666                         int numbers;
1667                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetPropertySize (image, out size, out numbers), "GdipGetPropertySize");
1668                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipRemovePropertyItem (image, 0), "GdipRemovePropertyItem");
1669                         //Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipSetPropertyItem (image, image), "GdipSetPropertyItem");
1670                         Assert.AreEqual (Status.NotImplemented, GDIPlus.GdipGetAllPropertyItems (image, 1000, 1, image), "GdipGetAllPropertyItems");
1671
1672                         Guid wmf = ImageFormat.Wmf.Guid;
1673                         Assert.AreEqual (Status.FileNotFound, GDIPlus.GdipGetEncoderParameterListSize (image, ref wmf, out count), "GdipGetEncoderParameterListSize/wmf");
1674                         Assert.AreEqual (Status.FileNotFound, GDIPlus.GdipGetEncoderParameterListSize (image, ref g, out count), "GdipGetEncoderParameterListSize/unknown");
1675
1676                         Assert.AreEqual (Status.FileNotFound, GDIPlus.GdipGetEncoderParameterList (image, ref wmf, count, image), "GdipGetEncoderParameterList/wmf");
1677                         Assert.AreEqual (Status.FileNotFound, GDIPlus.GdipGetEncoderParameterList (image, ref g, count, image), "GdipGetEncoderParameterList/unknown");
1678
1679                         IntPtr clone;
1680                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCloneImage (image, out clone), "GdipCloneImage");
1681                         try {
1682                                 Assert.IsFalse (image == clone, "Handle");
1683                         }
1684                         finally {
1685                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (clone), "GdipDisposeImage");
1686                         }
1687                 }
1688
1689                 [Test]
1690                 public void MetafileAsImage_InImageAPI ()
1691                 {
1692                         string filename = getInFile ("bitmaps/telescope_01.wmf");
1693                         IntPtr image = IntPtr.Zero;
1694
1695                         Assert.AreEqual (Status.Ok, GDIPlus.GdipLoadImageFromFile (filename, out image), "GdipLoadImageFromFile");
1696                         try {
1697                                 InImageAPI (image);
1698                         }
1699                         finally {
1700                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (image), "GdipDisposeImage");
1701                         }
1702                 }
1703
1704                 [Test]
1705                 public void Metafile_InImageAPI ()
1706                 {
1707                         string filename = getInFile ("bitmaps/telescope_01.wmf");
1708                         IntPtr metafile = IntPtr.Zero;
1709
1710                         Assert.AreEqual (Status.Ok, GDIPlus.GdipCreateMetafileFromFile (filename, out metafile), "GdipCreateMetafileFromFile");
1711                         try {
1712                                 InImageAPI (metafile);
1713                         }
1714                         finally {
1715                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipDisposeImage (metafile), "GdipDisposeImage");
1716                         }
1717                 }
1718
1719                 private void RecordFileName (IntPtr hdc, EmfType type, MetafileFrameUnit unit)
1720                 {
1721                         string filename = String.Format ("test-{0}-{1}.emf", type, unit);
1722                         IntPtr metafile;
1723                         RectangleF rect = new RectangleF (10, 20, 100, 200);
1724                         Status status = GDIPlus.GdipRecordMetafileFileName (filename, hdc, type, ref rect, unit, filename, out metafile);
1725                         if (metafile != IntPtr.Zero)
1726                                 GDIPlus.GdipDisposeImage (metafile);
1727                         if (status == Status.Ok)
1728                                 File.Delete (filename);
1729                         Assert.AreEqual (Status.Ok, status, filename);
1730                 }
1731
1732                 private Status RecordFileName_EmptyRectangle (IntPtr hdc, MetafileFrameUnit unit)
1733                 {
1734                         string filename = String.Format ("emptyrectangle-{0}.emf", unit);
1735                         IntPtr metafile = IntPtr.Zero;
1736                         RectangleF empty = new RectangleF ();
1737                         Status status = GDIPlus.GdipRecordMetafileFileName (filename, hdc, EmfType.EmfPlusDual, ref empty, unit, filename, out metafile);
1738                         if (metafile != IntPtr.Zero)
1739                                 GDIPlus.GdipDisposeImage (metafile);
1740                         if (status == Status.Ok)
1741                                 File.Delete (filename);
1742                         return status;
1743                 }
1744
1745                 [Test]
1746                 public void RecordMetafileFileName ()
1747                 {
1748                         using (Bitmap bmp = new Bitmap (100, 100, PixelFormat.Format32bppArgb)) {
1749                                 using (Graphics g = Graphics.FromImage (bmp)) {
1750                                         IntPtr hdc = g.GetHdc ();
1751                                         try {
1752                                                 IntPtr metafile;
1753                                                 RectangleF rect = new RectangleF ();
1754                                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipRecordMetafileFileName (null, hdc, EmfType.EmfPlusOnly, ref rect, MetafileFrameUnit.GdiCompatible, "unit test", out metafile), "filename-null");
1755                                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipRecordMetafileFileName ("a.emf", IntPtr.Zero, EmfType.EmfPlusOnly, ref rect, MetafileFrameUnit.GdiCompatible, "unit test", out metafile), "hdc-null");
1756                                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipRecordMetafileFileName ("b.emf", hdc, (EmfType)Int32.MaxValue, ref rect, MetafileFrameUnit.GdiCompatible, "unit test", out metafile), "type-invalid");
1757                                                 Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipRecordMetafileFileName ("c.emf", hdc, EmfType.EmfPlusOnly, ref rect, (MetafileFrameUnit)Int32.MaxValue, "unit test", out metafile), "unit-invalid");
1758                                                 Assert.AreEqual (Status.Ok, GDIPlus.GdipRecordMetafileFileName ("d.emf", hdc, EmfType.EmfPlusOnly, ref rect, MetafileFrameUnit.GdiCompatible, null, out metafile), "description-null");
1759                                                 GDIPlus.GdipDisposeImage (metafile);
1760                                                 File.Delete ("d.emf");
1761                                                 // test some variations
1762                                                 Assert.AreEqual (Status.GenericError, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.Document), "EmptyRectangle-Document");
1763                                                 Assert.AreEqual (Status.GenericError, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.Inch), "EmptyRectangle-Inch");
1764                                                 Assert.AreEqual (Status.GenericError, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.Millimeter), "EmptyRectangle-Millimeter");
1765                                                 Assert.AreEqual (Status.GenericError, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.Pixel), "EmptyRectangle-Pixel");
1766                                                 Assert.AreEqual (Status.GenericError, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.Point), "EmptyRectangle-Point");
1767                                                 Assert.AreEqual (Status.Ok, RecordFileName_EmptyRectangle (hdc, MetafileFrameUnit.GdiCompatible), "EmptyRectangle-GdiCompatible");
1768                                                 RecordFileName (hdc, EmfType.EmfOnly, MetafileFrameUnit.Document);
1769                                                 RecordFileName (hdc, EmfType.EmfPlusDual, MetafileFrameUnit.GdiCompatible);
1770                                                 RecordFileName (hdc, EmfType.EmfPlusOnly, MetafileFrameUnit.Inch);
1771                                                 RecordFileName (hdc, EmfType.EmfOnly, MetafileFrameUnit.Millimeter);
1772                                                 RecordFileName (hdc, EmfType.EmfPlusDual, MetafileFrameUnit.Pixel);
1773                                                 RecordFileName (hdc, EmfType.EmfPlusOnly, MetafileFrameUnit.Point);
1774                                         }
1775                                         finally {
1776                                                 g.ReleaseHdc (hdc);
1777                                         }
1778                                 }
1779                         }
1780                 }
1781         }
1782 }