mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/GraphicsPathTest.cs

   1 //
   2 // System.Drawing.GraphicsPath 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 SC = System.ComponentModel;
  31 using System.Drawing;
  32 using System.Drawing.Drawing2D;
  33 using System.Security.Permissions;
  34 using NUnit.Framework;
  35
  36 namespace MonoTests.System.Drawing.Drawing2D {
  37
  38         [TestFixture]
  39         [SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
  40         public class GraphicsPathTest {
  41
  42                 private const float Pi4 = (float) (Math.PI / 4);
  43                 // let's tolerate a few differences
  44                 private const float Delta = 0.0003f;
  45
  46                 private void CheckEmpty (string prefix, GraphicsPath gp)
  47                 {
  48                         Assert.AreEqual (0, gp.PathData.Points.Length, "PathData.Points");
  49                         Assert.AreEqual (0, gp.PathData.Types.Length, "PathData.Types");
  50                         Assert.AreEqual (0, gp.PointCount, prefix + "PointCount");
  51                 }
  52
  53                 [Test]
  54                 public void Constructor_InvalidFillMode ()
  55                 {
  56                         GraphicsPath gp = new GraphicsPath ((FillMode) Int32.MinValue);
  57                         Assert.AreEqual (Int32.MinValue, (int) gp.FillMode, "FillMode");
  58                         CheckEmpty ("InvalidFillMode.", gp);
  59                 }
  60
  61                 [Test]
  62                 [ExpectedException (typeof (ArgumentNullException))]
  63                 public void Constructor_Point_Null_Byte ()
  64                 {
  65                         new GraphicsPath ((Point[]) null, new byte[1]);
  66                 }
  67
  68                 [Test]
  69                 [ExpectedException (typeof (NullReferenceException))]
  70                 public void Constructor_Point_Byte_Null ()
  71                 {
  72                         new GraphicsPath (new Point[1], null);
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (ArgumentException))]
  77                 public void Constructor_Point_Byte_LengthMismatch ()
  78                 {
  79                         new GraphicsPath (new Point[1], new byte [2]);
  80                 }
  81
  82                 [Test]
  83                 [ExpectedException (typeof (ArgumentNullException))]
  84                 public void Constructor_PointF_Null_Byte ()
  85                 {
  86                         new GraphicsPath ((PointF[])null, new byte [1]);
  87                 }
  88
  89                 [Test]
  90                 [ExpectedException (typeof (NullReferenceException))]
  91                 public void Constructor_PointF_Byte_Null ()
  92                 {
  93                         new GraphicsPath ( new PointF[1], null);
  94                 }
  95
  96                 [Test]
  97                 [ExpectedException (typeof (ArgumentException))]
  98                 public void Constructor_PointF_Byte_LengthMismatch ()
  99                 {
 100                         new GraphicsPath (new PointF[2], new byte [1]);
 101                 }
 102
 103                 [Test]
 104                 public void GraphicsPath_Empty ()
 105                 {
 106                         GraphicsPath gp = new GraphicsPath ();
 107                         Assert.AreEqual (FillMode.Alternate, gp.FillMode, "Empty.FillMode");
 108                         CheckEmpty ("Empty.", gp);
 109
 110                         GraphicsPath clone = (GraphicsPath) gp.Clone ();
 111                         Assert.AreEqual (FillMode.Alternate, gp.FillMode, "Clone.FillMode");
 112                         CheckEmpty ("Clone.", gp);
 113
 114                         gp.Reverse ();
 115                         CheckEmpty ("Reverse.", gp);
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (ArgumentException))]
 120                 public void GraphicsPath_Empty_PathPoints ()
 121                 {
 122                         Assert.IsNull (new GraphicsPath ().PathPoints);
 123                 }
 124
 125                 [Test]
 126                 [ExpectedException (typeof (ArgumentException))]
 127                 public void GraphicsPath_Empty_PathTypes ()
 128                 {
 129                         Assert.IsNull (new GraphicsPath ().PathTypes);
 130                 }
 131
 132                 [Test]
 133                 public void GraphicsPath_SamePoint ()
 134                 {
 135                         Point[] points = new Point [] {
 136                                 new Point (1, 1),
 137                                 new Point (1, 1),
 138                                 new Point (1, 1),
 139                                 new Point (1, 1),
 140                                 new Point (1, 1),
 141                                 new Point (1, 1),
 142                         };
 143                         byte [] types = new byte [6] { 0, 1, 1, 1, 1, 1 };
 144                         using (GraphicsPath gp = new GraphicsPath (points, types)) {
 145                                 Assert.AreEqual (6, gp.PointCount, "0-PointCount");
 146                         }
 147                         types [0] = 1;
 148                         using (GraphicsPath gp = new GraphicsPath (points, types)) {
 149                                 Assert.AreEqual (6, gp.PointCount, "1-PointCount");
 150                         }
 151                 }
 152
 153                 [Test]
 154                 public void GraphicsPath_SamePointF ()
 155                 {
 156                         PointF [] points = new PointF [] {
 157                                 new PointF (1f, 1f),
 158                                 new PointF (1f, 1f),
 159                                 new PointF (1f, 1f),
 160                                 new PointF (1f, 1f),
 161                                 new PointF (1f, 1f),
 162                                 new PointF (1f, 1f),
 163                         };
 164                         byte [] types = new byte [6] { 0, 1, 1, 1, 1, 1 };
 165                         using (GraphicsPath gp = new GraphicsPath (points, types)) {
 166                                 Assert.AreEqual (6, gp.PointCount, "0-PointCount");
 167                         }
 168                         types [0] = 1;
 169                         using (GraphicsPath gp = new GraphicsPath (points, types)) {
 170                                 Assert.AreEqual (6, gp.PointCount, "1-PointCount");
 171                         }
 172                 }
 173
 174                 [Test]
 175                 [ExpectedException (typeof (SC.InvalidEnumArgumentException))]
 176                 public void FillMode_Invalid ()
 177                 {
 178                         // constructor accept an invalid FillMode
 179                         GraphicsPath gp = new GraphicsPath ((FillMode) Int32.MaxValue);
 180                         Assert.AreEqual (Int32.MaxValue, (int) gp.FillMode, "MaxValue");
 181                         // but you can't set the FillMode property to an invalid value ;-)
 182                         gp.FillMode = (FillMode) Int32.MaxValue;
 183                 }
 184
 185                 [Test]
 186                 public void PathData_CannotChange ()
 187                 {
 188                         GraphicsPath gp = new GraphicsPath ();
 189                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
 190
 191                         Assert.AreEqual (1f, gp.PathData.Points[0].X, "Points[0].X");
 192                         Assert.AreEqual (1f, gp.PathData.Points[0].Y, "Points[0].Y");
 193
 194                         // now try to change the first point
 195                         gp.PathData.Points[0] = new Point (0, 0);
 196                         // the changes isn't reflected in the property
 197                         Assert.AreEqual (1f, gp.PathData.Points[0].X, "Points[0].X-1");
 198                         Assert.AreEqual (1f, gp.PathData.Points[0].Y, "Points[0].Y-1");
 199                 }
 200
 201                 [Test]
 202                 public void PathPoints_CannotChange ()
 203                 {
 204                         GraphicsPath gp = new GraphicsPath ();
 205                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
 206
 207                         Assert.AreEqual (1f, gp.PathPoints[0].X, "PathPoints[0].X");
 208                         Assert.AreEqual (1f, gp.PathPoints[0].Y, "PathPoints[0].Y");
 209
 210                         // now try to change the first point
 211                         gp.PathPoints[0] = new Point (0, 0);
 212                         // the changes isn't reflected in the property
 213                         Assert.AreEqual (1f, gp.PathPoints[0].X, "PathPoints[0].X-1");
 214                         Assert.AreEqual (1f, gp.PathPoints[0].Y, "PathPoints[0].Y-1");
 215                 }
 216
 217                 [Test]
 218                 public void PathTypes_CannotChange ()
 219                 {
 220                         GraphicsPath gp = new GraphicsPath ();
 221                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
 222
 223                         Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
 224
 225                         // now try to change the first type
 226                         gp.PathTypes[0] = 1;
 227                         // the changes isn't reflected in the property
 228                         Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]-1");
 229                 }
 230
 231                 private void CheckArc (GraphicsPath path)
 232                 {
 233                         Assert.AreEqual (4, path.PathPoints.Length, "PathPoints");
 234                         Assert.AreEqual (4, path.PathTypes.Length, "PathPoints");
 235                         Assert.AreEqual (4, path.PathData.Points.Length, "PathData");
 236
 237                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 238                         RectangleF rect = path.GetBounds ();
 239                         Assert.AreEqual (2.99962401f, rect.X, Delta, "Bounds.X");
 240                         Assert.AreEqual (2.01370716f, rect.Y, Delta, "Bounds.Y");
 241                         Assert.AreEqual (0f, rect.Width, Delta, "Bounds.Width");
 242                         Assert.AreEqual (0.0137047768f, rect.Height, "Bounds.Height");
 243
 244                         Assert.AreEqual (2.99990582f, path.PathData.Points[0].X, Delta, "Points[0].X");
 245                         Assert.AreEqual (2.01370716f, path.PathPoints[0].Y, Delta, "Points[0].Y");
 246                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
 247                         Assert.AreEqual (2.99984312f, path.PathData.Points[1].X, Delta, "Points[1].X");
 248                         Assert.AreEqual (2.018276f, path.PathPoints[1].Y, Delta, "Points[1].Y");
 249                         Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
 250                         Assert.AreEqual (2.99974918f, path.PathData.Points[2].X, Delta, "Points[2].X");
 251                         Assert.AreEqual (2.02284455f, path.PathPoints[2].Y, Delta, "Points[2].Y");
 252                         Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
 253                         Assert.AreEqual (2.999624f, path.PathData.Points[3].X, Delta, "Points[3].X");
 254                         Assert.AreEqual (2.027412f, path.PathPoints[3].Y, Delta, "Points[3].Y");
 255                         Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
 256                 }
 257
 258                 [Test]
 259                 public void AddArc_Rectangle ()
 260                 {
 261                         GraphicsPath gp = new GraphicsPath ();
 262                         gp.AddArc (new Rectangle (1, 1, 2, 2), Pi4, Pi4);
 263                         CheckArc (gp);
 264                 }
 265
 266                 [Test]
 267                 public void AddArc_RectangleF ()
 268                 {
 269                         GraphicsPath gp = new GraphicsPath ();
 270                         gp.AddArc (new RectangleF (1f, 1f, 2f, 2f), Pi4, Pi4);
 271                         CheckArc (gp);
 272                 }
 273
 274                 [Test]
 275                 public void AddArc_Int ()
 276                 {
 277                         GraphicsPath gp = new GraphicsPath ();
 278                         gp.AddArc (1, 1, 2, 2, Pi4, Pi4);
 279                         CheckArc (gp);
 280                 }
 281
 282                 [Test]
 283                 public void AddArc_Float ()
 284                 {
 285                         GraphicsPath gp = new GraphicsPath ();
 286                         gp.AddArc (1f, 1f, 2f, 2f, Pi4, Pi4);
 287                         CheckArc (gp);
 288                 }
 289
 290                 private void CheckBezier (GraphicsPath path)
 291                 {
 292                         Assert.AreEqual (4, path.PointCount, "PointCount");
 293                         Assert.AreEqual (4, path.PathPoints.Length, "PathPoints");
 294                         Assert.AreEqual (4, path.PathTypes.Length, "PathPoints");
 295                         Assert.AreEqual (4, path.PathData.Points.Length, "PathData");
 296
 297                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 298                         RectangleF rect = path.GetBounds ();
 299                         Assert.AreEqual (1f, rect.X, "Bounds.X");
 300                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
 301                         Assert.AreEqual (3f, rect.Width, "Bounds.Width");
 302                         Assert.AreEqual (3f, rect.Height, "Bounds.Height");
 303
 304                         Assert.AreEqual (1f, path.PathData.Points[0].X, "Points[0].X");
 305                         Assert.AreEqual (1f, path.PathPoints[0].Y, "Points[0].Y");
 306                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
 307                         Assert.AreEqual (2f, path.PathData.Points[1].X, "Points[1].X");
 308                         Assert.AreEqual (2f, path.PathPoints[1].Y, "Points[1].Y");
 309                         Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
 310                         Assert.AreEqual (3f, path.PathData.Points[2].X, "Points[2].X");
 311                         Assert.AreEqual (3f, path.PathPoints[2].Y, "Points[2].Y");
 312                         Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
 313                         Assert.AreEqual (4f, path.PathData.Points[3].X, "Points[3].X");
 314                         Assert.AreEqual (4f, path.PathPoints[3].Y, "Points[3].Y");
 315                         Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
 316                 }
 317
 318                 [Test]
 319                 public void AddBezier_Point ()
 320                 {
 321                         GraphicsPath gp = new GraphicsPath ();
 322                         gp.AddBezier (new Point (1, 1), new Point (2, 2), new Point (3, 3), new Point (4, 4));
 323                         CheckBezier (gp);
 324                 }
 325
 326                 [Test]
 327                 public void AddBezier_PointF ()
 328                 {
 329                         GraphicsPath gp = new GraphicsPath ();
 330                         gp.AddBezier (new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f), new PointF (4f, 4f));
 331                         CheckBezier (gp);
 332                 }
 333
 334                 [Test]
 335                 public void AddBezier_Int ()
 336                 {
 337                         GraphicsPath gp = new GraphicsPath ();
 338                         gp.AddBezier (1, 1, 2, 2, 3, 3, 4, 4);
 339                         CheckBezier (gp);
 340                 }
 341
 342                 [Test]
 343                 public void AddBezier_Float ()
 344                 {
 345                         GraphicsPath gp = new GraphicsPath ();
 346                         gp.AddBezier (1f, 1f, 2f, 2f, 3f, 3f, 4f, 4f);
 347                         CheckBezier (gp);
 348                 }
 349
 350                 [Test]
 351                 public void AddBezier_SamePoint ()
 352                 {
 353                         GraphicsPath gp = new GraphicsPath ();
 354                         gp.AddBezier (1, 1, 1, 1, 1, 1, 1, 1);
 355                         // all points are present
 356                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
 357                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 358                         Assert.AreEqual (3, gp.PathTypes [1], "1-PathTypes[1]");
 359                         Assert.AreEqual (3, gp.PathTypes [2], "1-PathTypes[2]");
 360                         Assert.AreEqual (3, gp.PathTypes [3], "1-PathTypes[3]");
 361
 362                         gp.AddBezier (new Point (1, 1), new Point (1, 1), new Point (1, 1), new Point (1, 1));
 363                         // the first point (move to) can be compressed (i.e. removed)
 364                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
 365                         Assert.AreEqual (3, gp.PathTypes [4], "2-PathTypes[4]");
 366                         Assert.AreEqual (3, gp.PathTypes [5], "2-PathTypes[5]");
 367                         Assert.AreEqual (3, gp.PathTypes [6], "2-PathTypes[6]");
 368                 }
 369
 370                 [Test]
 371                 public void AddBezier_SamePointF ()
 372                 {
 373                         GraphicsPath gp = new GraphicsPath ();
 374                         gp.AddBezier (new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f));
 375                         // all points are present
 376                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
 377                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 378                         Assert.AreEqual (3, gp.PathTypes [1], "1-PathTypes[1]");
 379                         Assert.AreEqual (3, gp.PathTypes [2], "1-PathTypes[2]");
 380                         Assert.AreEqual (3, gp.PathTypes [3], "1-PathTypes[3]");
 381
 382                         gp.AddBezier (new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f));
 383                         // the first point (move to) can be compressed (i.e. removed)
 384                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
 385                         Assert.AreEqual (3, gp.PathTypes [4], "2-PathTypes[4]");
 386                         Assert.AreEqual (3, gp.PathTypes [5], "2-PathTypes[5]");
 387                         Assert.AreEqual (3, gp.PathTypes [6], "2-PathTypes[6]");
 388                 }
 389
 390                 [Test]
 391                 [ExpectedException (typeof (ArgumentNullException))]
 392                 public void AddBeziers_Point_Null ()
 393                 {
 394                         new GraphicsPath ().AddBeziers ((Point[]) null);
 395                 }
 396
 397                 [Test]
 398                 [ExpectedException (typeof (ArgumentException))]
 399                 public void AddBeziers_3_Points ()
 400                 {
 401                         GraphicsPath gp = new GraphicsPath ();
 402                         gp.AddBeziers (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
 403                 }
 404
 405                 [Test]
 406                 public void AddBeziers_Point ()
 407                 {
 408                         GraphicsPath gp = new GraphicsPath ();
 409                         gp.AddBeziers (new Point[4] { new Point (1, 1), new Point (2, 2), new Point (3, 3), new Point (4, 4) });
 410                         CheckBezier (gp);
 411                 }
 412
 413                 [Test]
 414                 [ExpectedException (typeof (ArgumentNullException))]
 415                 public void AddBeziers_PointF_Null ()
 416                 {
 417                         new GraphicsPath ().AddBeziers ((PointF[]) null);
 418                 }
 419
 420                 [Test]
 421                 [ExpectedException (typeof (ArgumentException))]
 422                 public void AddBeziers_3_PointFs ()
 423                 {
 424                         GraphicsPath gp = new GraphicsPath ();
 425                         gp.AddBeziers (new PointF[3] { new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f) });
 426                 }
 427
 428                 [Test]
 429                 public void AddBeziers_PointF ()
 430                 {
 431                         GraphicsPath gp = new GraphicsPath ();
 432                         gp.AddBeziers (new PointF[4] { new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f), new PointF (4f, 4f) });
 433                         CheckBezier (gp);
 434                 }
 435
 436                 [Test]
 437                 public void AddBeziers_SamePoint ()
 438                 {
 439                         Point [] points = new Point [4] { new Point (1, 1), new Point (1, 1), new Point (1, 1), new Point (1, 1) };
 440                         GraphicsPath gp = new GraphicsPath ();
 441                         gp.AddBeziers (points);
 442                         // all points are present
 443                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
 444                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 445                         Assert.AreEqual (3, gp.PathTypes [1], "1-PathTypes[1]");
 446                         Assert.AreEqual (3, gp.PathTypes [2], "1-PathTypes[2]");
 447                         Assert.AreEqual (3, gp.PathTypes [3], "1-PathTypes[3]");
 448
 449                         gp.AddBeziers (points);
 450                         // the first point (move to) can be compressed (i.e. removed)
 451                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
 452                         Assert.AreEqual (3, gp.PathTypes [4], "2-PathTypes[4]");
 453                         Assert.AreEqual (3, gp.PathTypes [5], "2-PathTypes[5]");
 454                         Assert.AreEqual (3, gp.PathTypes [6], "2-PathTypes[6]");
 455                 }
 456
 457                 [Test]
 458                 public void AddBeziers_SamePointF ()
 459                 {
 460                         PointF[] points = new PointF [4] { new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f) };
 461                         GraphicsPath gp = new GraphicsPath ();
 462                         gp.AddBeziers (points);
 463                         // all points are present
 464                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
 465                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 466                         Assert.AreEqual (3, gp.PathTypes [1], "1-PathTypes[1]");
 467                         Assert.AreEqual (3, gp.PathTypes [2], "1-PathTypes[2]");
 468                         Assert.AreEqual (3, gp.PathTypes [3], "1-PathTypes[3]");
 469
 470                         gp.AddBeziers (points);
 471                         // the first point (move to) can be compressed (i.e. removed)
 472                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
 473                         Assert.AreEqual (3, gp.PathTypes [4], "2-PathTypes[4]");
 474                         Assert.AreEqual (3, gp.PathTypes [5], "2-PathTypes[5]");
 475                         Assert.AreEqual (3, gp.PathTypes [6], "2-PathTypes[6]");
 476                 }
 477
 478                 private void CheckEllipse (GraphicsPath path)
 479                 {
 480                         Assert.AreEqual (13, path.PathPoints.Length, "PathPoints");
 481                         Assert.AreEqual (13, path.PathTypes.Length, "PathPoints");
 482                         Assert.AreEqual (13, path.PathData.Points.Length, "PathData");
 483
 484                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 485                         RectangleF rect = path.GetBounds ();
 486                         Assert.AreEqual (1f, rect.X, "Bounds.X");
 487                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
 488                         Assert.AreEqual (2f, rect.Width, "Bounds.Width");
 489                         Assert.AreEqual (2f, rect.Height, "Bounds.Height");
 490
 491                         Assert.AreEqual (0, path.PathData.Types[0], "PathData.Types[0]");
 492                         for (int i = 1; i < 12; i++)
 493                                 Assert.AreEqual (3, path.PathTypes[i], "PathTypes" + i.ToString ());
 494                         Assert.AreEqual (131, path.PathData.Types[12], "PathData.Types[12]");
 495                 }
 496
 497                 [Test]
 498                 public void AddEllipse_Rectangle ()
 499                 {
 500                         GraphicsPath gp = new GraphicsPath ();
 501                         gp.AddEllipse (new Rectangle (1, 1, 2, 2));
 502                         CheckEllipse (gp);
 503                 }
 504
 505                 [Test]
 506                 public void AddEllipse_RectangleF ()
 507                 {
 508                         GraphicsPath gp = new GraphicsPath ();
 509                         gp.AddEllipse (new RectangleF (1f, 1f, 2f, 2f));
 510                         CheckEllipse (gp);
 511                 }
 512
 513                 [Test]
 514                 public void AddEllipse_Int ()
 515                 {
 516                         GraphicsPath gp = new GraphicsPath ();
 517                         gp.AddEllipse (1, 1, 2, 2);
 518                         CheckEllipse (gp);
 519                 }
 520
 521                 [Test]
 522                 public void AddEllipse_Float ()
 523                 {
 524                         GraphicsPath gp = new GraphicsPath ();
 525                         gp.AddEllipse (1f, 1f, 2f, 2f);
 526                         CheckEllipse (gp);
 527                 }
 528
 529                 private void CheckLine (GraphicsPath path)
 530                 {
 531                         Assert.AreEqual (2, path.PathPoints.Length, "PathPoints");
 532                         Assert.AreEqual (2, path.PathTypes.Length, "PathPoints");
 533                         Assert.AreEqual (2, path.PathData.Points.Length, "PathData");
 534
 535                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 536                         RectangleF rect = path.GetBounds ();
 537                         Assert.AreEqual (1f, rect.X, "Bounds.X");
 538                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
 539                         Assert.AreEqual (1f, rect.Width, "Bounds.Width");
 540                         Assert.AreEqual (1f, rect.Height, "Bounds.Height");
 541
 542                         Assert.AreEqual (1f, path.PathData.Points[0].X, "Points[0].X");
 543                         Assert.AreEqual (1f, path.PathPoints[0].Y, "Points[0].Y");
 544                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
 545                         Assert.AreEqual (2f, path.PathData.Points[1].X, "Points[1].X");
 546                         Assert.AreEqual (2f, path.PathPoints[1].Y, "Points[1].Y");
 547                         Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
 548                 }
 549
 550                 [Test]
 551                 public void AddLine_Point ()
 552                 {
 553                         GraphicsPath gp = new GraphicsPath ();
 554                         gp.AddLine (new Point (1, 1), new Point (2, 2));
 555                         CheckLine (gp);
 556                 }
 557
 558                 [Test]
 559                 public void AddLine_PointF ()
 560                 {
 561                         GraphicsPath gp = new GraphicsPath ();
 562                         gp.AddLine (new PointF (1f, 1f), new PointF (2f, 2f));
 563                         CheckLine (gp);
 564                 }
 565
 566                 [Test]
 567                 public void AddLine_Int ()
 568                 {
 569                         GraphicsPath gp = new GraphicsPath ();
 570                         gp.AddLine (1, 1, 2, 2);
 571                         CheckLine (gp);
 572                 }
 573
 574                 [Test]
 575                 public void AddLine_Float ()
 576                 {
 577                         GraphicsPath gp = new GraphicsPath ();
 578                         gp.AddLine (1f, 1f, 2f, 2f);
 579                         CheckLine (gp);
 580                 }
 581
 582                 [Test]
 583                 public void AddLine_SamePoint ()
 584                 {
 585                         GraphicsPath gp = new GraphicsPath ();
 586                         gp.AddLine (new Point (1, 1), new Point (1, 1));
 587                         Assert.AreEqual (2, gp.PointCount, "1-PointCount");
 588                         Assert.AreEqual (0, gp.PathTypes[0], "1-PathTypes[0]");
 589                         Assert.AreEqual (1, gp.PathTypes[1], "1-PathTypes[1]");
 590
 591                         gp.AddLine (new Point (1, 1), new Point (1, 1));
 592                         // 3 not 4 points, the first point (only) is compressed
 593                         Assert.AreEqual (3, gp.PointCount, "2-PointCount");
 594                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
 595                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
 596                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
 597
 598                         gp.AddLine (new Point (1, 1), new Point (1, 1));
 599                         // 4 not 5 (or 6) points, the first point (only) is compressed
 600                         Assert.AreEqual (4, gp.PointCount, "3-PointCount");
 601                         Assert.AreEqual (0, gp.PathTypes [0], "3-PathTypes[0]");
 602                         Assert.AreEqual (1, gp.PathTypes [1], "3-PathTypes[1]");
 603                         Assert.AreEqual (1, gp.PathTypes [2], "3-PathTypes[2]");
 604                         Assert.AreEqual (1, gp.PathTypes [3], "3-PathTypes[3]");
 605                 }
 606
 607                 [Test]
 608                 public void AddLine_SamePointF ()
 609                 {
 610                         GraphicsPath gp = new GraphicsPath ();
 611                         gp.AddLine (new PointF (49.2f, 157f), new PointF (49.2f, 157f));
 612                         Assert.AreEqual (2, gp.PointCount, "PointCount");
 613                         Assert.AreEqual (0, gp.PathTypes [0], "PathTypes[0]");
 614                         Assert.AreEqual (1, gp.PathTypes [1], "PathTypes[1]");
 615
 616                         gp.AddLine (new PointF (49.2f, 157f), new PointF (49.2f, 157f));
 617                         // 3 not 4 points, the first point (only) is compressed
 618                         Assert.AreEqual (3, gp.PointCount, "2-PointCount");
 619                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
 620                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
 621                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
 622                 }
 623
 624                 [Test]
 625                 public void AddLine_SamePointsF ()
 626                 {
 627                         GraphicsPath gp = new GraphicsPath ();
 628                         gp.AddLine (new PointF (49.2f, 157f), new PointF (75.6f, 196f));
 629                         gp.AddLine (new PointF (75.6f, 196f), new PointF (102f, 209f));
 630                         Assert.AreEqual (3, gp.PointCount, "1-PointCount");
 631                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 632                         Assert.AreEqual (1, gp.PathTypes [1], "1-PathTypes[1]");
 633                         Assert.AreEqual (1, gp.PathTypes [2], "1-PathTypes[2]");
 634
 635                         gp.AddLine (new PointF (102f, 209f), new PointF (75.6f, 196f));
 636                         Assert.AreEqual (4, gp.PointCount, "2-PointCount");
 637                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
 638                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
 639                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
 640                         Assert.AreEqual (1, gp.PathTypes [3], "2-PathTypes[3]");
 641                 }
 642
 643                 [Test]
 644                 [ExpectedException (typeof (ArgumentNullException))]
 645                 public void AddLines_Point_Null ()
 646                 {
 647                         new GraphicsPath ().AddLines ((Point[])null);
 648                 }
 649
 650                 [Test]
 651                 [ExpectedException (typeof (ArgumentException))]
 652                 public void AddLines_Point_0 ()
 653                 {
 654                         GraphicsPath gp = new GraphicsPath ();
 655                         gp.AddLines (new Point[0]);
 656                         CheckLine (gp);
 657                 }
 658
 659                 [Test]
 660                 public void AddLines_Point_1 ()
 661                 {
 662                         GraphicsPath gp = new GraphicsPath ();
 663                         gp.AddLines (new Point[1] { new Point (1, 1) });
 664                         // Special case - a line with a single point is valid
 665                         Assert.AreEqual (1, gp.PointCount, "PointCount");
 666                         Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
 667                 }
 668
 669                 [Test]
 670                 public void AddLines_Point ()
 671                 {
 672                         GraphicsPath gp = new GraphicsPath ();
 673                         gp.AddLines (new Point[2] { new Point (1, 1), new Point (2, 2) });
 674                         CheckLine (gp);
 675                 }
 676
 677                 [Test]
 678                 [ExpectedException (typeof (ArgumentNullException))]
 679                 public void AddLines_PointF_Null ()
 680                 {
 681                         new GraphicsPath ().AddLines ((PointF[]) null);
 682                 }
 683
 684                 [Test]
 685                 [ExpectedException (typeof (ArgumentException))]
 686                 public void AddLines_PointF_0 ()
 687                 {
 688                         GraphicsPath gp = new GraphicsPath ();
 689                         gp.AddLines (new PointF[0]);
 690                         CheckLine (gp);
 691                 }
 692
 693                 [Test]
 694                 public void AddLines_PointF_1 ()
 695                 {
 696                         GraphicsPath gp = new GraphicsPath ();
 697                         gp.AddLines (new PointF[1] { new PointF (1f, 1f) });
 698                         // Special case - a line with a single point is valid
 699                         Assert.AreEqual (1, gp.PointCount, "PointCount");
 700                         Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
 701                 }
 702
 703                 [Test]
 704                 public void AddLines_PointF ()
 705                 {
 706                         GraphicsPath gp = new GraphicsPath ();
 707                         gp.AddLines (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) });
 708                         CheckLine (gp);
 709                 }
 710
 711                 [Test]
 712                 public void AddLines_SamePoint ()
 713                 {
 714                         Point [] points = new Point [] { new Point (1, 1), new Point (1, 1) };
 715                         GraphicsPath gp = new GraphicsPath ();
 716                         gp.AddLines (points);
 717                         Assert.AreEqual (2, gp.PointCount, "1-PointCount");
 718                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
 719                         Assert.AreEqual (1, gp.PathTypes [1], "1-PathTypes[1]");
 720
 721                         gp.AddLines (points);
 722                         // 3 not 4 points, the first point (only) is compressed
 723                         Assert.AreEqual (3, gp.PointCount, "2-PointCount");
 724                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
 725                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
 726                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
 727
 728                         gp.AddLines (points);
 729                         // 4 not 5 (or 6) points, the first point (only) is compressed
 730                         Assert.AreEqual (4, gp.PointCount, "3-PointCount");
 731                         Assert.AreEqual (0, gp.PathTypes [0], "3-PathTypes[0]");
 732                         Assert.AreEqual (1, gp.PathTypes [1], "3-PathTypes[1]");
 733                         Assert.AreEqual (1, gp.PathTypes [2], "3-PathTypes[2]");
 734                         Assert.AreEqual (1, gp.PathTypes [3], "3-PathTypes[3]");
 735                 }
 736
 737                 [Test]
 738                 public void AddLines_SamePointF ()
 739                 {
 740                         PointF [] points = new PointF [] { new PointF (49.2f, 157f), new PointF (49.2f, 157f), new PointF (49.2f, 157f), new PointF (49.2f, 157f) };
 741                         GraphicsPath gp = new GraphicsPath ();
 742                         gp.AddLines (points);
 743                         // all identical points are added
 744                         Assert.AreEqual (4, gp.PointCount, "PointCount");
 745                         Assert.AreEqual (0, gp.PathTypes [0], "PathTypes[0]");
 746                         Assert.AreEqual (1, gp.PathTypes [1], "PathTypes[1]");
 747                         Assert.AreEqual (1, gp.PathTypes [2], "PathTypes[2]");
 748                         Assert.AreEqual (1, gp.PathTypes [3], "PathTypes[3]");
 749
 750                         gp.AddLines (points);
 751                         // only the first new point is compressed
 752                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
 753                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
 754                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
 755                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
 756                         Assert.AreEqual (1, gp.PathTypes [3], "2-PathTypes[3]");
 757                         Assert.AreEqual (1, gp.PathTypes [4], "2-PathTypes[4]");
 758                         Assert.AreEqual (1, gp.PathTypes [5], "2-PathTypes[5]");
 759                         Assert.AreEqual (1, gp.PathTypes [6], "2-PathTypes[6]");
 760                 }
 761
 762                 private void CheckPie (GraphicsPath path)
 763                 {
 764                         // the number of points generated for a Pie isn't the same between Mono and MS
 765 #if false
 766                         Assert.AreEqual (5, path.PathPoints.Length, "PathPoints");
 767                         Assert.AreEqual (5, path.PathTypes.Length, "PathPoints");
 768                         Assert.AreEqual (5, path.PathData.Points.Length, "PathData");
 769
 770                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 771                         RectangleF rect = path.GetBounds ();
 772                         Assert.AreEqual (2f, rect.X, "Bounds.X");
 773                         Assert.AreEqual (2f, rect.Y, "Bounds.Y");
 774                         Assert.AreEqual (0.9999058f, rect.Width, "Bounds.Width");
 775                         Assert.AreEqual (0.0274119377f, rect.Height, "Bounds.Height");
 776
 777                         Assert.AreEqual (2f, path.PathData.Points[0].X, "Points[0].X");
 778                         Assert.AreEqual (2f, path.PathPoints[0].Y, "Points[0].Y");
 779                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
 780                         Assert.AreEqual (2.99990582f, path.PathData.Points[1].X, "Points[1].X");
 781                         Assert.AreEqual (2.01370716f, path.PathPoints[1].Y, "Points[1].Y");
 782                         Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
 783                         Assert.AreEqual (2.99984312f, path.PathData.Points[2].X, "Points[2].X");
 784                         Assert.AreEqual (2.018276f, path.PathPoints[2].Y, "Points[2].Y");
 785                         Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
 786                         Assert.AreEqual (2.99974918f, path.PathData.Points[3].X, "Points[2].X");
 787                         Assert.AreEqual (2.02284455f, path.PathPoints[3].Y, "Points[2].Y");
 788                         Assert.AreEqual (3, path.PathData.Types[3], "Types[2]");
 789                         Assert.AreEqual (2.999624f, path.PathData.Points[4].X, "Points[3].X");
 790                         Assert.AreEqual (2.027412f, path.PathPoints[4].Y, "Points[3].Y");
 791                         Assert.AreEqual (131, path.PathTypes[4], "Types[3]");
 792 #endif
 793                 }
 794
 795                 [Test]
 796                 public void AddPie_Rect ()
 797                 {
 798                         GraphicsPath gp = new GraphicsPath ();
 799                         gp.AddPie (new Rectangle (1, 1, 2, 2), Pi4, Pi4);
 800                         CheckPie (gp);
 801                 }
 802
 803                 [Test]
 804                 public void AddPie_Int ()
 805                 {
 806                         GraphicsPath gp = new GraphicsPath ();
 807                         gp.AddPie (1, 1, 2, 2, Pi4, Pi4);
 808                         CheckPie (gp);
 809                 }
 810
 811                 [Test]
 812                 public void AddPie_Float ()
 813                 {
 814                         GraphicsPath gp = new GraphicsPath ();
 815                         gp.AddPie (1f, 1f, 2f, 2f, Pi4, Pi4);
 816                         CheckPie (gp);
 817                 }
 818
 819                 private void CheckPolygon (GraphicsPath path)
 820                 {
 821                         // an extra point is generated by Mono (libgdiplus)
 822 #if false
 823                         Assert.AreEqual (3, path.PathPoints.Length, "PathPoints");
 824                         Assert.AreEqual (3, path.PathTypes.Length, "PathPoints");
 825                         Assert.AreEqual (3, path.PathData.Points.Length, "PathData");
 826 #endif
 827                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 828                         RectangleF rect = path.GetBounds ();
 829                         Assert.AreEqual (1f, rect.X, "Bounds.X");
 830                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
 831                         Assert.AreEqual (2f, rect.Width, "Bounds.Width");
 832                         Assert.AreEqual (2f, rect.Height, "Bounds.Height");
 833
 834                         Assert.AreEqual (1f, path.PathData.Points[0].X, "Points[0].X");
 835                         Assert.AreEqual (1f, path.PathPoints[0].Y, "Points[0].Y");
 836                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
 837                         Assert.AreEqual (2f, path.PathData.Points[1].X, "Points[1].X");
 838                         Assert.AreEqual (2f, path.PathPoints[1].Y, "Points[1].Y");
 839                         Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
 840                         Assert.AreEqual (3f, path.PathData.Points[2].X, "Points[2].X");
 841                         Assert.AreEqual (3f, path.PathPoints[2].Y, "Points[2].Y");
 842                         // the extra point change the type of the last point
 843 #if false
 844                         Assert.AreEqual (129, path.PathData.Types[2], "Types[2]");
 845 #endif
 846                 }
 847
 848                 [Test]
 849                 [ExpectedException (typeof (ArgumentNullException))]
 850                 public void AddPolygon_Point_Null ()
 851                 {
 852                         new GraphicsPath ().AddPolygon ((Point[]) null);
 853                 }
 854
 855                 [Test]
 856                 [ExpectedException (typeof (ArgumentException))]
 857                 public void AddPolygon_Point_Empty ()
 858                 {
 859                         new GraphicsPath ().AddPolygon (new Point[0]);
 860                 }
 861
 862                 [Test]
 863                 [ExpectedException (typeof (ArgumentException))]
 864                 public void AddPolygon_Point_1 ()
 865                 {
 866                         GraphicsPath gp = new GraphicsPath ();
 867                         gp.AddPolygon (new Point[1] { new Point (1, 1) });
 868                 }
 869
 870                 [Test]
 871                 [ExpectedException (typeof (ArgumentException))]
 872                 public void AddPolygon_Point_2 ()
 873                 {
 874                         GraphicsPath gp = new GraphicsPath ();
 875                         gp.AddPolygon (new Point[2] { new Point (1, 1), new Point (2, 2) });
 876                 }
 877
 878                 [Test]
 879                 public void AddPolygon_Point_3 ()
 880                 {
 881                         GraphicsPath gp = new GraphicsPath ();
 882                         gp.AddPolygon (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
 883                         CheckPolygon (gp);
 884                 }
 885
 886                 [Test]
 887                 [ExpectedException (typeof (ArgumentNullException))]
 888                 public void AddPolygon_PointF_Null ()
 889                 {
 890                         new GraphicsPath ().AddPolygon ((PointF[]) null);
 891                 }
 892
 893                 [Test]
 894                 [ExpectedException (typeof (ArgumentException))]
 895                 public void AddPolygon_PointF_Empty ()
 896                 {
 897                         new GraphicsPath ().AddPolygon (new PointF[0]);
 898                 }
 899
 900                 [Test]
 901                 [ExpectedException (typeof (ArgumentException))]
 902                 public void AddPolygon_PointF_1 ()
 903                 {
 904                         GraphicsPath gp = new GraphicsPath ();
 905                         gp.AddPolygon (new PointF[1] { new PointF (1f, 1f) });
 906                 }
 907
 908                 [Test]
 909                 [ExpectedException (typeof (ArgumentException))]
 910                 public void AddPolygon_PointF_2 ()
 911                 {
 912                         GraphicsPath gp = new GraphicsPath ();
 913                         gp.AddPolygon (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) });
 914                 }
 915
 916                 [Test]
 917                 public void AddPolygon_PointF_3 ()
 918                 {
 919                         GraphicsPath gp = new GraphicsPath ();
 920                         gp.AddPolygon (new PointF[3] { new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f) });
 921                         CheckPolygon (gp);
 922                 }
 923
 924                 [Test]
 925                 public void AddPolygon_SamePoint ()
 926                 {
 927                         Point [] points = new Point [3] { new Point (1, 1), new Point (1, 1), new Point (1, 1) };
 928                         GraphicsPath gp = new GraphicsPath ();
 929                         gp.AddPolygon (points);
 930                         // all identical points are added
 931                         Assert.AreEqual (3, gp.PointCount, "PointCount");
 932                         Assert.AreEqual (0, gp.PathTypes [0], "PathTypes[0]");
 933                         Assert.AreEqual (1, gp.PathTypes [1], "PathTypes[1]");
 934                         Assert.AreEqual (129, gp.PathTypes [2], "PathTypes[2]");
 935
 936                         gp.AddPolygon (points);
 937                         // all identical points are added (again)
 938                         Assert.AreEqual (6, gp.PointCount, "2-PointCount");
 939                         Assert.AreEqual (0, gp.PathTypes [3], "2-PathTypes[3]");
 940                         Assert.AreEqual (1, gp.PathTypes [4], "2-PathTypes[4]");
 941                         Assert.AreEqual (129, gp.PathTypes [5], "2-PathTypes[5]");
 942
 943                         gp.AddLines (points);
 944                         // all identical points are added as a line (because previous point is closed)
 945                         Assert.AreEqual (9, gp.PointCount, "3-PointCount");
 946                         Assert.AreEqual (0, gp.PathTypes [6], "3-PathTypes[6]");
 947                         Assert.AreEqual (1, gp.PathTypes [7], "3-PathTypes[7]");
 948                         Assert.AreEqual (1, gp.PathTypes [8], "3-PathTypes[8]");
 949
 950                         gp.AddPolygon (points);
 951                         // all identical points are added (again)
 952                         Assert.AreEqual (12, gp.PointCount, "4-PointCount");
 953                         Assert.AreEqual (0, gp.PathTypes [9], "4-PathTypes[9]");
 954                         Assert.AreEqual (1, gp.PathTypes [10], "4-PathTypes[10]");
 955                         Assert.AreEqual (129, gp.PathTypes [11], "4-PathTypes[11]");
 956                 }
 957
 958                 [Test]
 959                 public void AddPolygon_SamePointF ()
 960                 {
 961                         PointF [] points = new PointF [3] { new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f) };
 962                         GraphicsPath gp = new GraphicsPath ();
 963                         gp.AddPolygon (points);
 964                         // all identical points are added
 965                         Assert.AreEqual (3, gp.PointCount, "PointCount");
 966                         Assert.AreEqual (0, gp.PathTypes [0], "PathTypes[0]");
 967                         Assert.AreEqual (1, gp.PathTypes [1], "PathTypes[1]");
 968                         Assert.AreEqual (129, gp.PathTypes [2], "PathTypes[2]");
 969
 970                         gp.AddPolygon (points);
 971                         // all identical points are added (again)
 972                         Assert.AreEqual (6, gp.PointCount, "2-PointCount");
 973                         Assert.AreEqual (0, gp.PathTypes [3], "2-PathTypes[3]");
 974                         Assert.AreEqual (1, gp.PathTypes [4], "2-PathTypes[4]");
 975                         Assert.AreEqual (129, gp.PathTypes [5], "2-PathTypes[5]");
 976
 977                         gp.AddLines (points);
 978                         // all identical points are added as a line (because previous point is closed)
 979                         Assert.AreEqual (9, gp.PointCount, "3-PointCount");
 980                         Assert.AreEqual (0, gp.PathTypes [6], "3-PathTypes[6]");
 981                         Assert.AreEqual (1, gp.PathTypes [7], "3-PathTypes[7]");
 982                         Assert.AreEqual (1, gp.PathTypes [8], "3-PathTypes[8]");
 983
 984                         gp.AddPolygon (points);
 985                         // all identical points are added (again)
 986                         Assert.AreEqual (12, gp.PointCount, "4-PointCount");
 987                         Assert.AreEqual (0, gp.PathTypes [9], "4-PathTypes[9]");
 988                         Assert.AreEqual (1, gp.PathTypes [10], "4-PathTypes[10]");
 989                         Assert.AreEqual (129, gp.PathTypes [11], "4-PathTypes[11]");
 990                 }
 991
 992                 private void CheckRectangle (GraphicsPath path, int count)
 993                 {
 994                         Assert.AreEqual (count, path.PathPoints.Length, "PathPoints");
 995                         Assert.AreEqual (count, path.PathTypes.Length, "PathPoints");
 996                         Assert.AreEqual (count, path.PathData.Points.Length, "PathData");
 997
 998                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
 999                         RectangleF rect = path.GetBounds ();
1000                         Assert.AreEqual (1f, rect.X, "Bounds.X");
1001                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
1002                         Assert.AreEqual (2f, rect.Width, "Bounds.Width");
1003                         Assert.AreEqual (2f, rect.Height, "Bounds.Height");
1004
1005                         // check first four points (first rectangle)
1006                         Assert.AreEqual (1f, path.PathData.Points[0].X, "Points[0].X");
1007                         Assert.AreEqual (1f, path.PathPoints[0].Y, "Points[0].Y");
1008                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
1009                         Assert.AreEqual (3f, path.PathData.Points[1].X, "Points[1].X");
1010                         Assert.AreEqual (1f, path.PathPoints[1].Y, "Points[1].Y");
1011                         Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
1012                         Assert.AreEqual (3f, path.PathData.Points[2].X, "Points[2].X");
1013                         Assert.AreEqual (3f, path.PathPoints[2].Y, "Points[2].Y");
1014                         Assert.AreEqual (1, path.PathData.Types[2], "Types[2]");
1015                         Assert.AreEqual (1f, path.PathData.Points[3].X, "Points[3].X");
1016                         Assert.AreEqual (3f, path.PathPoints[3].Y, "Points[3].Y");
1017                         Assert.AreEqual (129, path.PathTypes[3], "Types[3]");
1018                 }
1019
1020                 [Test]
1021                 public void AddRectangle_Int ()
1022                 {
1023                         GraphicsPath gp = new GraphicsPath ();
1024                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
1025                         CheckRectangle (gp, 4);
1026                 }
1027
1028                 [Test]
1029                 public void AddRectangle_Float ()
1030                 {
1031                         GraphicsPath gp = new GraphicsPath ();
1032                         gp.AddRectangle (new RectangleF (1f, 1f, 2f, 2f));
1033                         CheckRectangle (gp, 4);
1034                 }
1035
1036                 [Test]
1037                 public void AddRectangle_SamePoint ()
1038                 {
1039                         GraphicsPath gp = new GraphicsPath ();
1040                         gp.AddRectangle (new Rectangle (1, 1, 0, 0));
1041                         Assert.AreEqual (0, gp.PointCount, "0-PointCount");
1042
1043                         gp.AddRectangle (new Rectangle (1, 1, 1, 1));
1044                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
1045                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
1046                         Assert.AreEqual (1, gp.PathTypes [1], "1-PathTypes[1]");
1047                         Assert.AreEqual (1, gp.PathTypes [2], "1-PathTypes[2]");
1048                         Assert.AreEqual (129, gp.PathTypes [3], "1-PathTypes[3]");
1049                         PointF end = gp.PathPoints [3];
1050
1051                         // add rectangle at the last path point
1052                         gp.AddRectangle (new Rectangle ((int)end.X, (int)end.Y, 1, 1));
1053                         // no compression (different type)
1054                         Assert.AreEqual (8, gp.PointCount, "2-PointCount");
1055                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
1056                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
1057                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
1058                         Assert.AreEqual (129, gp.PathTypes [3], "2-PathTypes[3]");
1059                 }
1060
1061                 [Test]
1062                 public void AddRectangle_SamePointF ()
1063                 {
1064                         GraphicsPath gp = new GraphicsPath ();
1065                         gp.AddRectangle (new RectangleF (1f, 1f, 0f, 0f));
1066                         Assert.AreEqual (0, gp.PointCount, "0-PointCount");
1067
1068                         gp.AddRectangle (new RectangleF (1f, 1f, 1f, 1f));
1069                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
1070                         Assert.AreEqual (0, gp.PathTypes [0], "1-PathTypes[0]");
1071                         Assert.AreEqual (1, gp.PathTypes [1], "1-PathTypes[1]");
1072                         Assert.AreEqual (1, gp.PathTypes [2], "1-PathTypes[2]");
1073                         Assert.AreEqual (129, gp.PathTypes [3], "1-PathTypes[3]");
1074                         PointF end = gp.PathPoints [3];
1075
1076                         // add rectangle at the last path point
1077                         gp.AddRectangle (new RectangleF (end.X, end.Y, 1f, 1f));
1078                         // no compression (different type)
1079                         Assert.AreEqual (8, gp.PointCount, "2-PointCount");
1080                         Assert.AreEqual (0, gp.PathTypes [0], "2-PathTypes[0]");
1081                         Assert.AreEqual (1, gp.PathTypes [1], "2-PathTypes[1]");
1082                         Assert.AreEqual (1, gp.PathTypes [2], "2-PathTypes[2]");
1083                         Assert.AreEqual (129, gp.PathTypes [3], "2-PathTypes[3]");
1084                 }
1085
1086                 [Test]
1087                 [ExpectedException (typeof (ArgumentNullException))]
1088                 public void AddRectangles_Int_Null ()
1089                 {
1090                         GraphicsPath gp = new GraphicsPath ();
1091                         gp.AddRectangles ((Rectangle[]) null);
1092                 }
1093
1094                 [Test]
1095                 [ExpectedException (typeof (ArgumentException))]
1096                 public void AddRectangles_Int_Empty ()
1097                 {
1098                         GraphicsPath gp = new GraphicsPath ();
1099                         gp.AddRectangles (new Rectangle[0]);
1100                         CheckRectangle (gp, 4);
1101                 }
1102
1103                 [Test]
1104                 public void AddRectangles_Int ()
1105                 {
1106                         GraphicsPath gp = new GraphicsPath ();
1107                         gp.AddRectangles (new Rectangle[1] { new Rectangle (1, 1, 2, 2) });
1108                         CheckRectangle (gp, 4);
1109                 }
1110
1111                 [Test]
1112                 [ExpectedException (typeof (ArgumentNullException))]
1113                 public void AddRectangles_Float_Null ()
1114                 {
1115                         GraphicsPath gp = new GraphicsPath ();
1116                         gp.AddRectangles ((RectangleF[]) null);
1117                 }
1118
1119                 [Test]
1120                 [ExpectedException (typeof (ArgumentException))]
1121                 public void AddRectangles_Float_Empty ()
1122                 {
1123                         GraphicsPath gp = new GraphicsPath ();
1124                         gp.AddRectangles ( new RectangleF[0]);
1125                         CheckRectangle (gp, 4);
1126                 }
1127
1128                 [Test]
1129                 public void AddRectangles_Float ()
1130                 {
1131                         GraphicsPath gp = new GraphicsPath ();
1132                         gp.AddRectangles (new RectangleF [1] { new RectangleF (1f, 1f, 2f, 2f) });
1133                         CheckRectangle (gp, 4);
1134                 }
1135
1136                 [Test]
1137                 public void AddRectangles_Two ()
1138                 {
1139                         GraphicsPath gp = new GraphicsPath ();
1140                         gp.AddRectangles (new RectangleF[2] {
1141                                 new RectangleF (1f, 1f, 2f, 2f),
1142                                 new RectangleF (2f, 2f, 1f, 1f) } );
1143                         RectangleF rect = gp.GetBounds ();
1144                         Assert.AreEqual (1f, rect.X, "Bounds.X");
1145                         Assert.AreEqual (1f, rect.Y, "Bounds.Y");
1146                         Assert.AreEqual (2f, rect.Width, "Bounds.Width");
1147                         Assert.AreEqual (2f, rect.Height, "Bounds.Height");
1148                         // second rectangle is completely within the first one
1149                         CheckRectangle (gp, 8);
1150                 }
1151
1152                 [Test]
1153                 public void AddRectangles_SamePoint ()
1154                 {
1155                         Rectangle r1 = new Rectangle (1, 1, 0, 0);
1156                         Rectangle r2 = new Rectangle (1, 1, 1, 1);
1157                         Rectangle r3 = new Rectangle (1, 2, 1, 1);
1158
1159                         GraphicsPath gp = new GraphicsPath ();
1160                         gp.AddRectangles (new Rectangle[] { r1, r2, r3 });
1161                         Assert.AreEqual (8, gp.PointCount, "1-PointCount");
1162                         // first rect is ignore, then all other 2x4 (8) points are present, no compression
1163                 }
1164
1165                 [Test]
1166                 [ExpectedException (typeof (ArgumentNullException))]
1167                 public void AddPath_Null ()
1168                 {
1169                         new GraphicsPath ().AddPath (null, false);
1170                 }
1171
1172                 [Test]
1173                 public void AddPath ()
1174                 {
1175                         GraphicsPath gpr = new GraphicsPath ();
1176                         gpr.AddRectangle (new Rectangle (1, 1, 2, 2));
1177                         GraphicsPath gp = new GraphicsPath ();
1178                         gp.AddPath (gpr, true);
1179                         CheckRectangle (gp, 4);
1180                 }
1181
1182                 private void CheckClosedCurve (GraphicsPath path)
1183                 {
1184                         Assert.AreEqual (10, path.PathPoints.Length, "PathPoints");
1185                         Assert.AreEqual (10, path.PathTypes.Length, "PathPoints");
1186                         Assert.AreEqual (10, path.PathData.Points.Length, "PathData");
1187
1188                         // GetBounds (well GdipGetPathWorldBounds) isn't very precise with curves
1189                         RectangleF rect = path.GetBounds ();
1190                         Assert.AreEqual (0.8333333f, rect.X, 0.2f, "Bounds.X");
1191                         Assert.AreEqual (0.8333333f, rect.Y, 0.2f, "Bounds.Y");
1192                         Assert.AreEqual (2.33333278f, rect.Width, 0.4f, "Bounds.Width");
1193                         Assert.AreEqual (2.33333278f, rect.Height, 0.4f, "Bounds.Height");
1194
1195                         Assert.AreEqual (0, path.PathData.Types[0], "PathData.Types[0]");
1196                         for (int i = 1; i < 9; i++)
1197                                 Assert.AreEqual (3, path.PathTypes[i], "PathTypes" + i.ToString ());
1198                         Assert.AreEqual (131, path.PathData.Types[9], "PathData.Types[9]");
1199                 }
1200
1201                 [Test]
1202                 [ExpectedException (typeof (ArgumentNullException))]
1203                 public void AddClosedCurve_Point_Null ()
1204                 {
1205                         new GraphicsPath ().AddClosedCurve ((Point[])null);
1206                 }
1207
1208                 [Test]
1209                 [ExpectedException (typeof (ArgumentException))]
1210                 public void AddClosedCurve_Point_0 ()
1211                 {
1212                         GraphicsPath gp = new GraphicsPath ();
1213                         gp.AddClosedCurve (new Point [0]);
1214                 }
1215
1216                 [Test]
1217                 [ExpectedException (typeof (ArgumentException))]
1218                 public void AddClosedCurve_Point_1 ()
1219                 {
1220                         GraphicsPath gp = new GraphicsPath ();
1221                         gp.AddClosedCurve (new Point[1] { new Point (1, 1) });
1222                 }
1223
1224                 [Test]
1225                 [ExpectedException (typeof (ArgumentException))]
1226                 public void AddClosedCurve_Point_2 ()
1227                 {
1228                         GraphicsPath gp = new GraphicsPath ();
1229                         gp.AddClosedCurve (new Point[2] { new Point (1, 1), new Point (2, 2) });
1230                 }
1231
1232                 [Test]
1233                 public void AddClosedCurve_Point_3 ()
1234                 {
1235                         GraphicsPath gp = new GraphicsPath ();
1236                         gp.AddClosedCurve (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
1237                         CheckClosedCurve (gp);
1238                 }
1239
1240                 [Test]
1241                 [ExpectedException (typeof (ArgumentNullException))]
1242                 public void AddClosedCurve_PointF_Null ()
1243                 {
1244                         new GraphicsPath ().AddClosedCurve ((PointF[]) null);
1245                 }
1246
1247                 [Test]
1248                 [ExpectedException (typeof (ArgumentException))]
1249                 public void AddClosedCurve_PointF_0 ()
1250                 {
1251                         GraphicsPath gp = new GraphicsPath ();
1252                         gp.AddClosedCurve (new PointF[0]);
1253                 }
1254
1255                 [Test]
1256                 [ExpectedException (typeof (ArgumentException))]
1257                 public void AddClosedCurve_PointF_1 ()
1258                 {
1259                         GraphicsPath gp = new GraphicsPath ();
1260                         gp.AddClosedCurve (new PointF[1] { new PointF (1f, 1f) });
1261                 }
1262
1263                 [Test]
1264                 [ExpectedException (typeof (ArgumentException))]
1265                 public void AddClosedCurve_PointF_2 ()
1266                 {
1267                         GraphicsPath gp = new GraphicsPath ();
1268                         gp.AddClosedCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) });
1269                 }
1270
1271                 [Test]
1272                 public void AddClosedCurve_PointF_3 ()
1273                 {
1274                         GraphicsPath gp = new GraphicsPath ();
1275                         gp.AddClosedCurve (new PointF[3] { new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f) });
1276                         CheckClosedCurve (gp);
1277                 }
1278
1279                 [Test]
1280                 public void AddClosedCurve_SamePoint ()
1281                 {
1282                         Point [] points = new Point [3] { new Point (1, 1), new Point (1, 1), new Point (1, 1) };
1283                         GraphicsPath gp = new GraphicsPath ();
1284                         gp.AddClosedCurve (points);
1285                         Assert.AreEqual (10, gp.PointCount, "1-PointCount");
1286                         gp.AddClosedCurve (points);
1287                         Assert.AreEqual (20, gp.PointCount, "2-PointCount");
1288                 }
1289
1290                 [Test]
1291                 public void AddClosedCurve_SamePointF ()
1292                 {
1293                         PointF [] points = new PointF [3] { new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f) };
1294                         GraphicsPath gp = new GraphicsPath ();
1295                         gp.AddClosedCurve (points);
1296                         Assert.AreEqual (10, gp.PointCount, "1-PointCount");
1297                         gp.AddClosedCurve (points);
1298                         Assert.AreEqual (20, gp.PointCount, "2-PointCount");
1299                 }
1300
1301                 private void CheckCurve (GraphicsPath path)
1302                 {
1303                         Assert.AreEqual (4, path.PathPoints.Length, "PathPoints");
1304                         Assert.AreEqual (4, path.PathTypes.Length, "PathPoints");
1305                         Assert.AreEqual (4, path.PathData.Points.Length, "PathData");
1306
1307                         // GetBounds (well GdipGetPathWorldBounds) isn't implemented
1308                         RectangleF rect = path.GetBounds ();
1309                         Assert.AreEqual (1.0f, rect.X, "Bounds.X");
1310                         Assert.AreEqual (1.0f, rect.Y, "Bounds.Y");
1311                         Assert.AreEqual (1.0f, rect.Width, "Bounds.Width");
1312                         Assert.AreEqual (1.0f, rect.Height, "Bounds.Height");
1313
1314                         Assert.AreEqual (1f, path.PathData.Points[0].X, "Points[0].X");
1315                         Assert.AreEqual (1f, path.PathPoints[0].Y, "Points[0].Y");
1316                         Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
1317                         // Mono has wrong? results
1318 #if false
1319                         Assert.AreEqual (1.16666663f, path.PathData.Points[1].X, "Points[1].X");
1320                         Assert.AreEqual (1.16666663f, path.PathPoints[1].Y, "Points[1].Y");
1321 #endif
1322                         Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
1323                         // Mono has wrong? results
1324 #if false
1325                         Assert.AreEqual (1.83333325f, path.PathData.Points[2].X, "Points[2].X");
1326                         Assert.AreEqual (1.83333325f, path.PathPoints[2].Y, "Points[2].Y");
1327 #endif
1328                         Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
1329                         Assert.AreEqual (2f, path.PathData.Points[3].X, "Points[3].X");
1330                         Assert.AreEqual (2f, path.PathPoints[3].Y, "Points[3].Y");
1331                         Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
1332                 }
1333
1334                 [Test]
1335                 [ExpectedException (typeof (ArgumentNullException))]
1336                 public void AddCurve_Point_Null ()
1337                 {
1338                         new GraphicsPath ().AddCurve ((Point[]) null);
1339                 }
1340
1341                 [Test]
1342                 [ExpectedException (typeof (ArgumentException))]
1343                 public void AddCurve_Point_0 ()
1344                 {
1345                         GraphicsPath gp = new GraphicsPath ();
1346                         gp.AddCurve (new Point[0]);
1347                 }
1348
1349                 [Test]
1350                 [ExpectedException (typeof (ArgumentException))]
1351                 public void AddCurve_Point_1 ()
1352                 {
1353                         GraphicsPath gp = new GraphicsPath ();
1354                         gp.AddCurve (new Point[1] { new Point (1, 1) });
1355                 }
1356
1357                 [Test]
1358                 public void AddCurve_Point_2 ()
1359                 {
1360                         GraphicsPath gp = new GraphicsPath ();
1361                         gp.AddCurve (new Point[2] { new Point (1, 1), new Point (2, 2) });
1362                         CheckCurve (gp);
1363                         // note: GdipAddPathCurveI allows adding a "curve" with only 2 points (a.k.a. a line ;-)
1364                         gp.Dispose ();
1365                 }
1366
1367                 [Test]
1368                 public void AddCurve_Point_2_Tension ()
1369                 {
1370                         GraphicsPath gp = new GraphicsPath ();
1371                         gp.AddCurve (new Point[2] { new Point (1, 1), new Point (2, 2) }, 1.0f);
1372                         CheckCurve (gp);
1373                         // note: GdipAddPathCurve2I allows adding a "curve" with only 2 points (a.k.a. a line ;-)
1374                         gp.Dispose ();
1375                 }
1376
1377                 [Test]
1378                 [ExpectedException (typeof (ArgumentException))]
1379                 public void AddCurve3_Point_2 ()
1380                 {
1381                         GraphicsPath gp = new GraphicsPath ();
1382                         gp.AddCurve (new Point[2] { new Point (1, 1), new Point (2, 2) }, 0, 2, 0.5f);
1383                         // adding only two points isn't supported by GdipAddCurve3I
1384                 }
1385
1386                 [Test]
1387                 [ExpectedException (typeof (ArgumentNullException))]
1388                 public void AddCurve_PointF_Null ()
1389                 {
1390                         new GraphicsPath ().AddCurve ((PointF[]) null);
1391                 }
1392
1393                 [Test]
1394                 [ExpectedException (typeof (ArgumentException))]
1395                 public void AddCurve_PointF_0 ()
1396                 {
1397                         GraphicsPath gp = new GraphicsPath ();
1398                         gp.AddCurve (new PointF[0]);
1399                 }
1400
1401                 [Test]
1402                 [ExpectedException (typeof (ArgumentException))]
1403                 public void AddCurve_PointF_1 ()
1404                 {
1405                         GraphicsPath gp = new GraphicsPath ();
1406                         gp.AddCurve (new PointF[1] { new PointF (1f, 1f) });
1407                 }
1408
1409                 [Test]
1410                 public void AddCurve_PointF_2 ()
1411                 {
1412                         GraphicsPath gp = new GraphicsPath ();
1413                         gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) });
1414                         CheckCurve (gp);
1415                         // note: GdipAddPathCurve allows adding a "curve" with only 2 points (a.k.a. a line ;-)
1416                         gp.Dispose ();
1417                 }
1418
1419                 [Test]
1420                 public void AddCurve_PoinFt_2_Tension ()
1421                 {
1422                         GraphicsPath gp = new GraphicsPath ();
1423                         gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) }, 1.0f);
1424                         CheckCurve (gp);
1425                         // note: GdipAddPathCurve2 allows adding a "curve" with only 2 points (a.k.a. a line ;-)
1426                         gp.Dispose ();
1427                 }
1428
1429                 [Test]
1430                 [ExpectedException (typeof (ArgumentException))]
1431                 public void AddCurve3_PointF_2 ()
1432                 {
1433                         GraphicsPath gp = new GraphicsPath ();
1434                         gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) }, 0, 2, 0.5f);
1435                         // adding only two points isn't supported by GdipAddCurve3
1436                 }
1437
1438                 [Test]
1439                 public void AddCurve_LargeTension ()
1440                 {
1441                         GraphicsPath gp = new GraphicsPath ();
1442                         gp.AddCurve (new PointF[3] { new PointF (1f, 1f), new PointF (0f, 20f), new PointF (20f, 0f) }, 0, 2, Single.MaxValue);
1443                         Assert.AreEqual (7, gp.PointCount, "PointCount");
1444                         gp.Dispose ();
1445                 }
1446
1447                 [Test]
1448                 [ExpectedException (typeof (ArgumentException))]
1449                 public void AddCurve_ZeroSegments ()
1450                 {
1451                         GraphicsPath gp = new GraphicsPath ();
1452                         gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) }, 0, 0, 0.5f);
1453                 }
1454
1455                 [Test]
1456                 [ExpectedException (typeof (ArgumentException))]
1457                 public void AddCurve_NegativeSegments ()
1458                 {
1459                         GraphicsPath gp = new GraphicsPath ();
1460                         gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new PointF (2f, 2f) }, 0, -1, 0.5f);
1461                 }
1462
1463                 [Test]
1464                 [ExpectedException (typeof (ArgumentException))]
1465                 public void AddCurve_OffsetTooLarge ()
1466                 {
1467                         GraphicsPath gp = new GraphicsPath ();
1468                         gp.AddCurve (new PointF[3] { new PointF (1f, 1f), new PointF (0f, 20f), new PointF (20f, 0f) }, 1, 2, 0.5f);
1469                 }
1470
1471                 [Test]
1472                 public void AddCurve_Offset ()
1473                 {
1474                         GraphicsPath gp = new GraphicsPath ();
1475                         gp.AddCurve (new PointF[4] { new PointF (1f, 1f), new PointF (0f, 20f), new PointF (20f, 0f), new PointF (0f, 10f) }, 1, 2, 0.5f);
1476                         Assert.AreEqual (7, gp.PointCount, "PointCount");
1477                         gp.Dispose ();
1478                 }
1479
1480                 [Test]
1481                 public void AddCurve_SamePoint ()
1482                 {
1483                         Point [] points = new Point [2] { new Point (1, 1), new Point (1, 1) };
1484                         GraphicsPath gp = new GraphicsPath ();
1485                         gp.AddCurve (points);
1486                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
1487                         gp.AddCurve (points);
1488                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
1489                 }
1490
1491                 [Test]
1492                 public void AddCurve_SamePointF ()
1493                 {
1494                         PointF [] points = new PointF [2] { new PointF (1f, 1f), new PointF (1f, 1f) };
1495                         GraphicsPath gp = new GraphicsPath ();
1496                         gp.AddCurve (points);
1497                         Assert.AreEqual (4, gp.PointCount, "1-PointCount");
1498                         gp.AddCurve (points);
1499                         Assert.AreEqual (7, gp.PointCount, "2-PointCount");
1500                 }
1501
1502                 [Test]
1503                 public void AddCurve ()
1504                 {
1505                         PointF [] points = new PointF [] {
1506                                 new PointF (37f, 185f),
1507                                 new PointF (99f, 185f),
1508                                 new PointF (161f, 159f),
1509                                 new PointF (223f, 185f),
1510                                 new PointF (285f, 54f),
1511                         };
1512                         int[] count = { 4, 7, 10, 13 };
1513
1514                         using (GraphicsPath gp = new GraphicsPath ()) {
1515                                 for (int i = 0; i < points.Length - 1; i++) {
1516                                         gp.AddCurve (points, i, 1, 0.5f);
1517                                         // all non-curves points are compressed expect the first one (positioning)
1518                                         Assert.AreEqual (count [i], gp.PointCount, i.ToString ());
1519                                 }
1520
1521                                 Assert.AreEqual (0, gp.PathData.Types [0], "Types[0]");
1522                                 Assert.AreEqual (37f, gp.PathData.Points [0].X, 0.001, "Points[0].X");
1523                                 Assert.AreEqual (185f, gp.PathData.Points [1].Y, 0.001, "Points[0].Y");
1524                                 Assert.AreEqual (3, gp.PathData.Types [1], "Types[1]");
1525                                 Assert.AreEqual (47.3334f, gp.PathData.Points [1].X, 0.001, "Points[1].X");
1526                                 Assert.AreEqual (185f, gp.PathData.Points [1].Y, 0.001, "Points[1].Y");
1527                                 Assert.AreEqual (3, gp.PathData.Types [2], "Types[2]");
1528                                 Assert.AreEqual (78.33333f, gp.PathData.Points [2].X, 0.001, "Points[2].X");
1529                                 Assert.AreEqual (189.3333f, gp.PathData.Points [2].Y, 0.001, "Points[2].Y");
1530                                 Assert.AreEqual (3, gp.PathData.Types [3], "Types[3]");
1531                                 Assert.AreEqual (99f, gp.PathData.Points [3].X, 0.001, "Points[3].X");
1532                                 Assert.AreEqual (185f, gp.PathData.Points [3].Y, 0.001, "Points[3].Y");
1533                                 Assert.AreEqual (3, gp.PathData.Types [4], "Types[4]");
1534                                 Assert.AreEqual (119.6667f, gp.PathData.Points [4].X, 0.001, "Points[4].X");
1535                                 Assert.AreEqual (180.6667f, gp.PathData.Points [4].Y, 0.001, "Points[4].Y");
1536                                 Assert.AreEqual (3, gp.PathData.Types [5], "Types[5]");
1537                                 Assert.AreEqual (140.3333f, gp.PathData.Points [5].X, 0.001, "Points[5].X");
1538                                 Assert.AreEqual (159f, gp.PathData.Points [5].Y, 0.001, "Points[5].Y");
1539                                 Assert.AreEqual (3, gp.PathData.Types [6], "Types[6]");
1540                                 Assert.AreEqual (161f, gp.PathData.Points [6].X, 0.001, "Points[6].X");
1541                                 Assert.AreEqual (159f, gp.PathData.Points [6].Y, 0.001, "Points[6].Y");
1542                                 Assert.AreEqual (3, gp.PathData.Types [7], "Types[7]");
1543                                 Assert.AreEqual (181.6667f, gp.PathData.Points [7].X, 0.001, "Points[7].X");
1544                                 Assert.AreEqual (159f, gp.PathData.Points [7].Y, 0.001, "Points[7].Y");
1545                                 Assert.AreEqual (3, gp.PathData.Types [8], "Types[8]");
1546                                 Assert.AreEqual (202.3333f, gp.PathData.Points [8].X, 0.001, "Points[8].X");
1547                                 Assert.AreEqual (202.5f, gp.PathData.Points [8].Y, 0.001, "Points[8].Y");
1548                                 Assert.AreEqual (3, gp.PathData.Types [9], "Types[9]");
1549                                 Assert.AreEqual (223f, gp.PathData.Points [9].X, 0.001, "Points[9].X");
1550                                 Assert.AreEqual (185f, gp.PathData.Points [9].Y, 0.001, "Points[9].Y");
1551                                 Assert.AreEqual (3, gp.PathData.Types [10], "Types[10]");
1552                                 Assert.AreEqual (243.6667f, gp.PathData.Points [10].X, 0.001, "Points[10].X");
1553                                 Assert.AreEqual (167.5f, gp.PathData.Points [10].Y, 0.001, "Points[10].Y");
1554                                 Assert.AreEqual (3, gp.PathData.Types [11], "Types[11]");
1555                                 Assert.AreEqual (274.6667f, gp.PathData.Points [11].X, 0.001, "Points[11].X");
1556                                 Assert.AreEqual (75.83334f, gp.PathData.Points [11].Y, 0.001, "Points[11].Y");
1557                                 Assert.AreEqual (3, gp.PathData.Types [12], "Types[12]");
1558                                 Assert.AreEqual (285f, gp.PathData.Points [12].X, 0.001, "Points[12].X");
1559                                 Assert.AreEqual (54f, gp.PathData.Points [12].Y, 0.001, "Points[12].Y");
1560                         }
1561                 }
1562
1563                 private FontFamily GetFontFamily ()
1564                 {
1565                         try {
1566                                 return FontFamily.GenericMonospace;
1567                         }
1568                         catch (ArgumentException) {
1569                                 Assert.Ignore ("GenericMonospace FontFamily couldn't be found");
1570                                 return null;
1571                         }
1572                 }
1573
1574                 [Test]
1575                 [ExpectedException (typeof (NullReferenceException))]
1576                 public void AddString_NullString ()
1577                 {
1578                         GraphicsPath gp = new GraphicsPath ();
1579                         FontFamily ff = GetFontFamily ();
1580                         gp.AddString (null, ff, 0, 10, new Point (10, 10), StringFormat.GenericDefault);
1581                 }
1582
1583                 [Test]
1584                 public void AddString_EmptyString ()
1585                 {
1586                         GraphicsPath gp = new GraphicsPath ();
1587                         FontFamily ff = GetFontFamily ();
1588                         gp.AddString (String.Empty, ff, 0, 10, new Point (10, 10), StringFormat.GenericDefault);
1589                         Assert.AreEqual (0, gp.PointCount, "PointCount");
1590                 }
1591
1592                 [Test]
1593                 [ExpectedException (typeof (ArgumentException))]
1594                 public void AddString_NullFontFamily ()
1595                 {
1596                         GraphicsPath gp = new GraphicsPath ();
1597                         gp.AddString ("mono", null, 0, 10, new Point (10, 10), StringFormat.GenericDefault);
1598                 }
1599
1600                 [Test]
1601                 public void AddString_NegativeSize ()
1602                 {
1603                         GraphicsPath gp = new GraphicsPath ();
1604                         FontFamily ff = GetFontFamily ();
1605                         gp.AddString ("mono", ff, 0, -10, new Point (10, 10), StringFormat.GenericDefault);
1606                         Assert.IsTrue (gp.PointCount > 0, "PointCount");
1607                 }
1608
1609                 [Test]
1610                 [Category ("NotWorking")] // StringFormat not yet supported in libgdiplus
1611                 public void AddString_StringFormat ()
1612                 {
1613                         FontFamily ff = GetFontFamily ();
1614                         // null maps to ?
1615                         GraphicsPath gp1 = new GraphicsPath ();
1616                         gp1.AddString ("mono", ff, 0, 10, new RectangleF (10, 10, 10, 10), null);
1617
1618                         // StringFormat.GenericDefault
1619                         GraphicsPath gp2 = new GraphicsPath ();
1620                         gp2.AddString ("mono", ff, 0, 10, new RectangleF (10, 10, 10, 10), StringFormat.GenericDefault);
1621                         Assert.AreEqual (gp1.PointCount, gp2.PointCount, "GenericDefault");
1622
1623                         // StringFormat.GenericTypographic
1624                         GraphicsPath gp3 = new GraphicsPath ();
1625                         gp3.AddString ("mono", ff, 0, 10, new RectangleF (10, 10, 10, 10), StringFormat.GenericTypographic);
1626                         Assert.IsFalse (gp1.PointCount == gp3.PointCount, "GenericTypographic");
1627                 }
1628
1629                 [Test]
1630                 public void GetBounds_Empty_Empty ()
1631                 {
1632                         GraphicsPath gp = new GraphicsPath ();
1633                         RectangleF rect = gp.GetBounds ();
1634                         Assert.AreEqual (0.0f, rect.X, "Bounds.X");
1635                         Assert.AreEqual (0.0f, rect.Y, "Bounds.Y");
1636                         Assert.AreEqual (0.0f, rect.Width, "Bounds.Width");
1637                         Assert.AreEqual (0.0f, rect.Height, "Bounds.Height");
1638                 }
1639
1640                 private void CheckRectangleBounds (RectangleF rect)
1641                 {
1642                         Assert.AreEqual (1.0f, rect.X, "Bounds.X");
1643                         Assert.AreEqual (1.0f, rect.Y, "Bounds.Y");
1644                         Assert.AreEqual (2.0f, rect.Width, "Bounds.Width");
1645                         Assert.AreEqual (2.0f, rect.Height, "Bounds.Height");
1646                 }
1647
1648                 [Test]
1649                 public void GetBounds_Empty_Rectangle ()
1650                 {
1651                         GraphicsPath gp = new GraphicsPath ();
1652                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
1653                         CheckRectangleBounds (gp.GetBounds ());
1654                 }
1655
1656                 [Test]
1657                 public void GetBounds_Null_Rectangle ()
1658                 {
1659                         GraphicsPath gp = new GraphicsPath ();
1660                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
1661                         CheckRectangleBounds (gp.GetBounds (null));
1662                 }
1663
1664                 [Test]
1665                 public void GetBounds_MatrixEmpty_Rectangle ()
1666                 {
1667                         GraphicsPath gp = new GraphicsPath ();
1668                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
1669                         CheckRectangleBounds (gp.GetBounds (new Matrix ()));
1670                 }
1671
1672                 [Test]
1673                 public void GetBounds_NullNull_Rectangle ()
1674                 {
1675                         GraphicsPath gp = new GraphicsPath ();
1676                         gp.AddRectangle (new Rectangle (1, 1, 2, 2));
1677                         CheckRectangleBounds (gp.GetBounds (null, null));
1678                 }
1679
1680                 [Test]
1681                 [Category ("NotWorking")] // can't/wont duplicate the lack of precision
1682                 public void GetBounds_WithPen ()
1683                 {
1684                         Rectangle rect = new Rectangle (1, 1, 2, 2);
1685                         Pen p = new Pen (Color.Aqua, 0);
1686                         GraphicsPath gp = new GraphicsPath ();
1687                         gp.AddRectangle (rect);
1688
1689                         RectangleF bounds = gp.GetBounds (null, p);
1690                         // those bounds doesn't make any sense (even visually)
1691                         // probably null gets mis-interpreted ???
1692                         Assert.AreEqual (-6.09999943f, bounds.X, "NullMatrix.Bounds.X");
1693                         Assert.AreEqual (-6.09999943f, bounds.Y, "NullMatrix.Bounds.Y");
1694                         Assert.AreEqual (16.1999989f, bounds.Width, "NullMatrix.Bounds.Width");
1695                         Assert.AreEqual (16.1999989f, bounds.Height, "NullMatrix.Bounds.Height");
1696
1697                         Matrix m = new Matrix ();
1698                         bounds = gp.GetBounds (m, p);
1699                         Assert.AreEqual (-0.419999957f, bounds.X, "EmptyMatrix.Bounds.X");
1700                         Assert.AreEqual (-0.419999957f, bounds.Y, "EmptyMatrix.Bounds.Y");
1701                         Assert.AreEqual (4.83999968f, bounds.Width, "EmptyMatrix.Bounds.Width");
1702                         Assert.AreEqual (4.83999968f, bounds.Height, "EmptyMatrix.Bounds.Height");
1703                         // visually we can see the bounds just a pixel bigger than the rectangle
1704
1705                         gp = new GraphicsPath ();
1706                         gp.AddRectangle (rect);
1707                         gp.Widen (p);
1708                         bounds = gp.GetBounds (null);
1709                         Assert.AreEqual (0.499999523f, bounds.X, "WidenNullMatrix.Bounds.X");
1710                         Assert.AreEqual (0.499999523f, bounds.Y, "WidenNullMatrix.Bounds.Y");
1711                         Assert.AreEqual (3.000001f, bounds.Width, "WidenNullMatrix.Bounds.Width");
1712                         Assert.AreEqual (3.000001f, bounds.Height, "WidenNullMatrix.Bounds.Height");
1713
1714                         bounds = gp.GetBounds (m);
1715                         Assert.AreEqual (0.499999523f, bounds.X, "WidenEmptyMatrix.Bounds.X");
1716                         Assert.AreEqual (0.499999523f, bounds.Y, "WidenEmptyMatrix.Bounds.Y");
1717                         Assert.AreEqual (3.000001f, bounds.Width, "WidenEmptyMatrix.Bounds.Width");
1718                         Assert.AreEqual (3.000001f, bounds.Height, "WidenEmptyMatrix.Bounds.Height");
1719                 }
1720
1721                 private void CheckPieBounds (RectangleF rect)
1722                 {
1723                         Assert.AreEqual (60.0f, rect.X, 1, "Bounds.X");
1724                         Assert.AreEqual (60.0f, rect.Y, 1, "Bounds.Y");
1725                         Assert.AreEqual (43.3f, rect.Width, 1, "Bounds.Width");
1726                         Assert.AreEqual (48.3f, rect.Height, 1, "Bounds.Height");
1727                 }
1728
1729                 [Test]
1730                 public void GetBounds_Empty_Pie ()
1731                 {
1732                         GraphicsPath gp = new GraphicsPath ();
1733                         gp.AddPie (10, 10, 100, 100, 30, 45);
1734                         CheckPieBounds (gp.GetBounds ());
1735                         gp.Dispose ();
1736                 }
1737
1738                 [Test]
1739                 public void GetBounds_Null_Pie ()
1740                 {
1741                         GraphicsPath gp = new GraphicsPath ();
1742                         gp.AddPie (10, 10, 100, 100, 30, 45);
1743                         CheckPieBounds (gp.GetBounds (null));
1744                         gp.Dispose ();
1745                 }
1746
1747                 [Test]
1748                 public void GetBounds_MatrixEmpty_Pie ()
1749                 {
1750                         GraphicsPath gp = new GraphicsPath ();
1751                         gp.AddPie (10, 10, 100, 100, 30, 45);
1752                         CheckPieBounds (gp.GetBounds (new Matrix ()));
1753                         gp.Dispose ();
1754                 }
1755
1756                 [Test]
1757                 public void GetBounds_NullNull_Pie ()
1758                 {
1759                         GraphicsPath gp = new GraphicsPath ();
1760                         gp.AddPie (10, 10, 100, 100, 30, 45);
1761                         CheckPieBounds (gp.GetBounds (null, null));
1762                         gp.Dispose ();
1763                 }
1764
1765                 [Test]
1766                 public void GetBounds_Empty_ClosedCurve ()
1767                 {
1768                         GraphicsPath gp = new GraphicsPath ();
1769                         gp.AddClosedCurve (new Point[4] { new Point (20, 100), new Point (70, 10),
1770                                 new Point (130, 200), new Point (180, 100) });
1771 #if false
1772                         // so far from reality that it's totally useless
1773                         Assert.AreEqual (1.666666f, rect.X, 0.00001, "Bounds.X");
1774                         Assert.AreEqual (-6.66666f, rect.Y, 1, "Bounds.Y");
1775                         Assert.AreEqual (196.6666f, rect.Width, 1, "Bounds.Width");
1776                         Assert.AreEqual (221.6666f, rect.Height, 1, "Bounds.Height");
1777 #endif
1778                         gp.Dispose ();
1779                 }
1780
1781                 [Test]
1782                 [ExpectedException (typeof (ArgumentNullException))]
1783                 public void Transform_Null ()
1784                 {
1785                         new GraphicsPath ().Transform (null);
1786                 }
1787                 [Test]
1788                 public void Transform_Empty ()
1789                 {
1790                         // no points in path and no exception
1791                         new GraphicsPath ().Transform (new Matrix ());
1792                 }
1793
1794                 private void ComparePaths (GraphicsPath expected, GraphicsPath actual)
1795                 {
1796                         Assert.AreEqual (expected.PointCount, actual.PointCount, "PointCount");
1797                         for (int i = 0; i < expected.PointCount; i++) {
1798                                 Assert.AreEqual (expected.PathPoints[i], actual.PathPoints[i], "PathPoints-" + i.ToString ());
1799                                 Assert.AreEqual (expected.PathTypes[i], actual.PathTypes[i], "PathTypes-" + i.ToString ());
1800                         }
1801                 }
1802
1803                 private void CompareFlats (GraphicsPath flat, GraphicsPath original)
1804                 {
1805                         Assert.IsTrue (flat.PointCount >= original.PointCount, "PointCount");
1806                         for (int i = 0; i < flat.PointCount; i++) {
1807                                 Assert.IsTrue (flat.PathTypes[i] != 3, "PathTypes-" + i.ToString ());
1808                         }
1809                 }
1810
1811                 [Test]
1812                 public void Flatten_Empty ()
1813                 {
1814                         GraphicsPath path = new GraphicsPath ();
1815                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1816                         // this is a no-op as there's nothing in the path
1817                         path.Flatten ();
1818                         ComparePaths (path, clone);
1819                 }
1820
1821                 [Test]
1822                 public void Flatten_Null ()
1823                 {
1824                         GraphicsPath path = new GraphicsPath ();
1825                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1826                         // this is a no-op as there's nothing in the path
1827                         // an no matrix to apply
1828                         path.Flatten (null);
1829                         ComparePaths (path, clone);
1830                 }
1831
1832                 [Test]
1833                 public void Flatten_NullFloat ()
1834                 {
1835                         GraphicsPath path = new GraphicsPath ();
1836                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1837                         // this is a no-op as there's nothing in the path
1838                         // an no matrix to apply
1839                         path.Flatten (null, 1f);
1840                         ComparePaths (path, clone);
1841                 }
1842
1843                 [Test]
1844                 public void Flatten_Arc ()
1845                 {
1846                         GraphicsPath path = new GraphicsPath ();
1847                         path.AddArc (0f, 0f, 100f, 100f, 30, 30);
1848                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1849                         path.Flatten ();
1850                         CompareFlats (path, clone);
1851                 }
1852
1853                 [Test]
1854                 public void Flatten_Bezier ()
1855                 {
1856                         GraphicsPath path = new GraphicsPath ();
1857                         path.AddBezier (0, 0, 100, 100, 30, 30, 60, 60);
1858                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1859                         path.Flatten ();
1860                         CompareFlats (path, clone);
1861                 }
1862
1863                 [Test]
1864                 public void Flatten_ClosedCurve ()
1865                 {
1866                         GraphicsPath path = new GraphicsPath ();
1867                         path.AddClosedCurve (new Point[4] {
1868                                 new Point (0, 0), new Point (40, 20),
1869                                 new Point (20, 40), new Point (40, 40)
1870                                 });
1871                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1872                         path.Flatten ();
1873                         CompareFlats (path, clone);
1874                 }
1875
1876                 [Test]
1877                 public void Flatten_Curve ()
1878                 {
1879                         GraphicsPath path = new GraphicsPath ();
1880                         path.AddCurve (new Point[4] {
1881                                 new Point (0, 0), new Point (40, 20),
1882                                 new Point (20, 40), new Point (40, 40)
1883                                 });
1884                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1885                         path.Flatten ();
1886                         CompareFlats (path, clone);
1887                 }
1888
1889                 [Test]
1890                 public void Flatten_Ellipse ()
1891                 {
1892                         GraphicsPath path = new GraphicsPath ();
1893                         path.AddEllipse (10f, 10f, 100f, 100f);
1894                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1895                         path.Flatten ();
1896                         CompareFlats (path, clone);
1897                 }
1898
1899                 [Test]
1900                 public void Flatten_Line ()
1901                 {
1902                         GraphicsPath path = new GraphicsPath ();
1903                         path.AddLine (10f, 10f, 100f, 100f);
1904                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1905                         path.Flatten ();
1906                         ComparePaths (path, clone);
1907                 }
1908
1909                 [Test]
1910                 public void Flatten_Pie ()
1911                 {
1912                         GraphicsPath path = new GraphicsPath ();
1913                         path.AddPie (0, 0, 100, 100, 30, 30);
1914                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1915                         path.Flatten ();
1916                         CompareFlats (path, clone);
1917                 }
1918
1919                 [Test]
1920                 public void Flatten_Polygon ()
1921                 {
1922                         GraphicsPath path = new GraphicsPath ();
1923                         path.AddPolygon (new Point[4] {
1924                                 new Point (0, 0), new Point (10, 10),
1925                                 new Point (20, 20), new Point (40, 40)
1926                                 });
1927                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1928                         path.Flatten ();
1929                         ComparePaths (path, clone);
1930                 }
1931
1932                 [Test]
1933                 public void Flatten_Rectangle ()
1934                 {
1935                         GraphicsPath path = new GraphicsPath ();
1936                         path.AddRectangle (new Rectangle (0, 0, 100, 100));
1937                         GraphicsPath clone = (GraphicsPath) path.Clone ();
1938                         path.Flatten ();
1939                         ComparePaths (path, clone);
1940                 }
1941
1942                 private void CheckWrap (GraphicsPath path)
1943                 {
1944                         Assert.AreEqual (3, path.PointCount, "Count");
1945
1946                         PointF[] pts = path.PathPoints;
1947                         Assert.AreEqual (0, pts[0].X, 1e-30, "0.X");
1948                         Assert.AreEqual (0, pts[0].Y, 1e-30, "0.Y");
1949                         Assert.AreEqual (0, pts[1].X, 1e-30, "1.X");
1950                         Assert.AreEqual (0, pts[1].Y, 1e-30, "1.Y");
1951                         Assert.AreEqual (0, pts[2].X, 1e-30, "2.X");
1952                         Assert.AreEqual (0, pts[2].Y, 1e-30, "2.Y");
1953
1954                         byte[] types = path.PathTypes;
1955                         Assert.AreEqual (0, types[0], "0");
1956                         Assert.AreEqual (1, types[1], "1");
1957                         Assert.AreEqual (129, types[2], "2");
1958                 }
1959
1960                 private void CheckWrapNaN (GraphicsPath path, bool closed)
1961                 {
1962                         Assert.AreEqual (3, path.PointCount, "Count");
1963
1964                         PointF[] pts = path.PathPoints;
1965                         Assert.AreEqual (Single.NaN, pts[0].X, "0.X");
1966                         Assert.AreEqual (Single.NaN, pts[0].Y, "0.Y");
1967                         Assert.AreEqual (Single.NaN, pts[1].X, "1.X");
1968                         Assert.AreEqual (Single.NaN, pts[1].Y, "1.Y");
1969                         Assert.AreEqual (Single.NaN, pts[2].X, "2.X");
1970                         Assert.AreEqual (Single.NaN, pts[2].Y, "2.Y");
1971
1972                         byte[] types = path.PathTypes;
1973                         Assert.AreEqual (0, types[0], "0");
1974                         Assert.AreEqual (1, types[1], "1");
1975                         Assert.AreEqual (closed ? 129 : 1, types[2], "2");
1976                 }
1977
1978                 [Test]
1979                 [ExpectedException (typeof (ArgumentNullException))]
1980                 public void Warp_Null ()
1981                 {
1982                         new GraphicsPath ().Warp (null, new RectangleF ());
1983                 }
1984
1985                 [Test]
1986                 [ExpectedException (typeof (ArgumentException))]
1987                 public void Warp_NoPoints ()
1988                 {
1989                         new GraphicsPath ().Warp (new PointF[0], new RectangleF ());
1990                 }
1991
1992                 [Test]
1993                 public void Wrap_NoPoint ()
1994                 {
1995                         using (GraphicsPath gp = new GraphicsPath ()) {
1996                                 Assert.AreEqual (0, gp.PointCount, "PointCount-1");
1997
1998                                 PointF[] pts = new PointF[1] { new PointF (0, 0) };
1999                                 RectangleF r = new RectangleF (10, 20, 30, 40);
2000                                 gp.Warp (pts, r, new Matrix ());
2001                                 Assert.AreEqual (0, gp.PointCount, "PointCount-2");
2002                         }
2003                 }
2004
2005                 [Test]
2006                 [Category ("NotWorking")]
2007                 public void Wrap_SinglePoint ()
2008                 {
2009                         using (GraphicsPath gp = new GraphicsPath ()) {
2010                                 gp.AddLines (new Point[1] { new Point (1, 1) });
2011                                 // Special case - a line with a single point is valid
2012                                 Assert.AreEqual (1, gp.PointCount, "PointCount-1");
2013
2014                                 PointF[] pts = new PointF[1] { new PointF (0, 0) };
2015                                 RectangleF r = new RectangleF (10, 20, 30, 40);
2016                                 gp.Warp (pts, r, new Matrix ());
2017                                 Assert.AreEqual (0, gp.PointCount, "PointCount-2");
2018                         }
2019                 }
2020
2021                 [Test]
2022                 [Category ("NotWorking")]
2023                 public void Wrap_Line ()
2024                 {
2025                         using (GraphicsPath gp = new GraphicsPath ()) {
2026                                 gp.AddLine (new Point (1, 1), new Point (20, 20));
2027                                 Assert.AreEqual (2, gp.PointCount, "PointCount-1");
2028
2029                                 PointF[] pts = new PointF[1] { new PointF (0, 0) };
2030                                 RectangleF r = new RectangleF (10, 20, 30, 40);
2031                                 gp.Warp (pts, r, new Matrix ());
2032                                 Assert.AreEqual (2, gp.PointCount, "PointCount-2");
2033                         }
2034                 }
2035
2036                 [Test]
2037                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2038                 public void Warp_NullMatrix ()
2039                 {
2040                         PointF[] pts = new PointF[1] { new PointF (0,0) };
2041                         GraphicsPath path = new GraphicsPath ();
2042                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2043                         RectangleF r = new RectangleF (10, 20, 30, 40);
2044                         path.Warp (pts, r, null);
2045                         CheckWrap (path);
2046                 }
2047
2048                 [Test]
2049                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2050                 public void Warp_EmptyMatrix ()
2051                 {
2052                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2053                         GraphicsPath path = new GraphicsPath ();
2054                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2055                         RectangleF r = new RectangleF (10, 20, 30, 40);
2056                         path.Warp (pts, r, new Matrix ());
2057                         CheckWrap (path);
2058                 }
2059
2060                 [Test]
2061                 [Category ("NotWorking")]
2062                 public void Warp_Rectangle_Empty ()
2063                 {
2064                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2065                         GraphicsPath path = new GraphicsPath ();
2066                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2067                         path.Warp (pts, new RectangleF (), null);
2068                         CheckWrapNaN (path, true);
2069                 }
2070
2071                 [Test]
2072                 [Category ("NotWorking")]
2073                 public void Warp_Rectangle_NegativeWidthHeight ()
2074                 {
2075                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2076                         GraphicsPath path = new GraphicsPath ();
2077                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2078                         RectangleF r = new RectangleF (10, 20, -30, -40);
2079                         path.Warp (pts, r, null);
2080                         Assert.AreEqual (3, path.PointCount, "Count");
2081
2082                         pts = path.PathPoints;
2083                         Assert.AreEqual (1.131355e-39, pts[0].X, 1e40, "0.X");
2084                         Assert.AreEqual (-2.0240637E-33, pts[0].Y, 1e40, "0.Y");
2085                         Assert.AreEqual (1.070131E-39, pts[1].X, 1e40, "1.X");
2086                         Assert.AreEqual (-2.02406389E-33, pts[1].Y, 1e40, "1.Y");
2087                         Assert.AreEqual (3.669146E-40, pts[2].X, 1e40, "2.X");
2088                         Assert.AreEqual (-6.746879E-34, pts[2].Y, 1e40, "2.Y");
2089                         byte[] types = path.PathTypes;
2090                         Assert.AreEqual (0, types[0], "0");
2091                         Assert.AreEqual (1, types[1], "1");
2092                         Assert.AreEqual (129, types[2], "2");
2093                 }
2094
2095                 [Test]
2096                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2097                 public void Warp_Matrix_NonInvertible ()
2098                 {
2099                         Matrix matrix = new Matrix (123, 24, 82, 16, 47, 30);
2100                         Assert.IsFalse (matrix.IsInvertible, "!IsInvertible");
2101                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2102                         GraphicsPath path = new GraphicsPath ();
2103                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2104                         RectangleF r = new RectangleF (10, 20, 30, 40);
2105                         path.Warp (pts, r, matrix);
2106
2107                         Assert.AreEqual (3, path.PointCount, "Count");
2108                         pts = path.PathPoints;
2109                         Assert.AreEqual (47, pts[0].X, "0.X");
2110                         Assert.AreEqual (30, pts[0].Y, "0.Y");
2111                         Assert.AreEqual (47, pts[1].X, "1.X");
2112                         Assert.AreEqual (30, pts[1].Y, "1.Y");
2113                         Assert.AreEqual (47, pts[2].X, "2.X");
2114                         Assert.AreEqual (30, pts[2].Y, "2.Y");
2115                         byte[] types = path.PathTypes;
2116                         Assert.AreEqual (0, types[0], "0");
2117                         Assert.AreEqual (1, types[1], "1");
2118                         Assert.AreEqual (129, types[2], "2");
2119                 }
2120
2121                 [Test]
2122                 [Category ("NotWorking")]
2123                 public void Warp_Bilinear ()
2124                 {
2125                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2126                         GraphicsPath path = new GraphicsPath ();
2127                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2128                         RectangleF r = new RectangleF (10, 20, 30, 40);
2129                         path.Warp (pts, r, new Matrix (), WarpMode.Bilinear);
2130                         // note that the last point is no more closed
2131                         CheckWrapNaN (path, false);
2132                 }
2133
2134                 [Test]
2135                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2136                 public void Warp_Perspective ()
2137                 {
2138                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2139                         GraphicsPath path = new GraphicsPath ();
2140                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2141                         RectangleF r = new RectangleF (10, 20, 30, 40);
2142                         path.Warp (pts, r, new Matrix (), WarpMode.Perspective);
2143                         CheckWrap (path);
2144                 }
2145
2146                 [Test]
2147                 public void Warp_Invalid ()
2148                 {
2149                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2150                         GraphicsPath path = new GraphicsPath ();
2151                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2152                         RectangleF r = new RectangleF (10, 20, 30, 40);
2153                         path.Warp (pts, r, new Matrix (), (WarpMode) Int32.MinValue);
2154                         Assert.AreEqual (0, path.PointCount, "Count");
2155                 }
2156
2157                 [Test]
2158                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2159                 public void Warp_Flatness_Negative ()
2160                 {
2161                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2162                         GraphicsPath path = new GraphicsPath ();
2163                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2164                         RectangleF r = new RectangleF (10, 20, 30, 40);
2165                         path.Warp (pts, r, new Matrix (), WarpMode.Perspective, -1f);
2166                         CheckWrap (path);
2167                 }
2168
2169                 [Test]
2170                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2171                 public void Warp_Flatness_OverOne ()
2172                 {
2173                         PointF[] pts = new PointF[1] { new PointF (0, 0) };
2174                         GraphicsPath path = new GraphicsPath ();
2175                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2176                         RectangleF r = new RectangleF (10, 20, 30, 40);
2177                         path.Warp (pts, r, new Matrix (), WarpMode.Perspective, 2.0f);
2178                         CheckWrap (path);
2179                 }
2180
2181                 [Test]
2182                 public void SetMarkers_EmptyPath ()
2183                 {
2184                         new GraphicsPath ().SetMarkers ();
2185                 }
2186
2187                 [Test]
2188                 public void ClearMarkers_EmptyPath ()
2189                 {
2190                         new GraphicsPath ().ClearMarkers ();
2191                 }
2192
2193                 [Test]
2194                 public void CloseFigure_EmptyPath ()
2195                 {
2196                         new GraphicsPath ().CloseFigure ();
2197                 }
2198
2199                 [Test]
2200                 public void CloseAllFigures_EmptyPath ()
2201                 {
2202                         new GraphicsPath ().CloseAllFigures ();
2203                 }
2204
2205                 [Test]
2206                 public void StartClose_AddArc ()
2207                 {
2208                         GraphicsPath path = new GraphicsPath ();
2209                         path.AddLine (1, 1, 2, 2);
2210                         path.AddArc (10, 10, 100, 100, 90, 180);
2211                         path.AddLine (10, 10, 20, 20);
2212                         byte[] types = path.PathTypes;
2213                         // check first types
2214                         Assert.AreEqual (0, types[0], "start/Line");
2215                         Assert.AreEqual (1, types[2], "start/Arc");
2216                         // check last types
2217                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Arc");
2218                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2219                 }
2220
2221                 [Test]
2222                 public void StartClose_AddBezier ()
2223                 {
2224                         GraphicsPath path = new GraphicsPath ();
2225                         path.AddLine (1, 1, 2, 2);
2226                         path.AddBezier (10, 10, 100, 100, 20, 20, 200, 200);
2227                         path.AddLine (10, 10, 20, 20);
2228                         byte[] types = path.PathTypes;
2229                         // check first types
2230                         Assert.AreEqual (0, types[0], "start/Line");
2231                         Assert.AreEqual (1, types[2], "start/Bezier");
2232                         // check last types
2233                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Bezier");
2234                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2235                 }
2236
2237                 [Test]
2238                 public void StartClose_AddBeziers ()
2239                 {
2240                         GraphicsPath path = new GraphicsPath ();
2241                         path.AddLine (1, 1, 2, 2);
2242                         path.AddBeziers (new Point[7] { new Point (10, 10),
2243                                 new Point (20, 10), new Point (20, 20), new Point (30, 20),
2244                                 new Point (40, 40), new Point (50, 40), new Point (50, 50)
2245                         });
2246                         path.AddLine (10, 10, 20, 20);
2247                         byte[] types = path.PathTypes;
2248                         // check first types
2249                         Assert.AreEqual (0, types[0], "start/Line");
2250                         Assert.AreEqual (1, types[2], "start/Bezier");
2251                         // check last types
2252                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Bezier");
2253                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2254                 }
2255
2256                 [Test]
2257                 public void StartClose_AddClosedCurve ()
2258                 {
2259                         GraphicsPath path = new GraphicsPath ();
2260                         path.AddLine (1, 1, 2, 2);
2261                         path.AddClosedCurve (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
2262                         path.AddLine (10, 10, 20, 20);
2263                         byte[] types = path.PathTypes;
2264                         // check first types
2265                         Assert.AreEqual (0, types[0], "start/Line");
2266                         Assert.AreEqual (0, types[2], "start/ClosedCurve");
2267                         // check last types
2268                         Assert.AreEqual (131, types[path.PointCount - 3], "end/ClosedCurve");
2269                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line3");
2270                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line3");
2271                 }
2272
2273                 [Test]
2274                 public void StartClose_AddCurve ()
2275                 {
2276                         GraphicsPath path = new GraphicsPath ();
2277                         path.AddLine (1, 1, 2, 2);
2278                         path.AddCurve (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
2279                         path.AddLine (10, 10, 20, 20);
2280                         byte[] types = path.PathTypes;
2281                         // check first types
2282                         Assert.AreEqual (0, types[0], "start/Line");
2283                         Assert.AreEqual (1, types[2], "start/Curve");
2284                         // check last types
2285                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Curve");
2286                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2287                 }
2288
2289                 [Test]
2290                 public void StartClose_AddEllipse ()
2291                 {
2292                         GraphicsPath path = new GraphicsPath ();
2293                         path.AddLine (1, 1, 2, 2);
2294                         path.AddEllipse (10, 10, 100, 100);
2295                         path.AddLine (10, 10, 20, 20);
2296                         byte[] types = path.PathTypes;
2297                         // check first types
2298                         Assert.AreEqual (0, types[0], "start/Line");
2299                         Assert.AreEqual (0, types[2], "start/Ellipse");
2300                         // check last types
2301                         Assert.AreEqual (131, types[path.PointCount - 3], "end/Ellipse");
2302                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line3");
2303                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line3");
2304                 }
2305
2306                 [Test]
2307                 public void StartClose_AddLine ()
2308                 {
2309                         GraphicsPath path = new GraphicsPath ();
2310                         path.AddLine (1, 1, 2, 2);
2311                         path.AddLine (5, 5, 10, 10);
2312                         path.AddLine (10, 10, 20, 20);
2313                         byte[] types = path.PathTypes;
2314                         // check first types
2315                         Assert.AreEqual (0, types[0], "start/Line");
2316                         Assert.AreEqual (1, types[2], "start/Line2");
2317                         // check last types
2318                         Assert.AreEqual (1, types[path.PointCount - 3], "end/Line2");
2319                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2320                 }
2321
2322                 [Test]
2323                 public void StartClose_AddLines ()
2324                 {
2325                         GraphicsPath path = new GraphicsPath ();
2326                         path.AddLine (1, 1, 2, 2);
2327                         path.AddLines (new Point[4] { new Point (10, 10), new Point (20, 10), new Point (20, 20), new Point (30, 20) });
2328                         path.AddLine (10, 10, 20, 20);
2329                         byte[] types = path.PathTypes;
2330                         // check first types
2331                         Assert.AreEqual (0, types[0], "start/Line");
2332                         Assert.AreEqual (1, types[2], "start/Lines");
2333                         // check last types
2334                         Assert.AreEqual (1, types[path.PointCount - 3], "end/Lines");
2335                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2336                 }
2337
2338                 [Test]
2339                 public void StartClose_AddPath_Connect ()
2340                 {
2341                         GraphicsPath inner = new GraphicsPath ();
2342                         inner.AddArc (10, 10, 100, 100, 90, 180);
2343                         GraphicsPath path = new GraphicsPath ();
2344                         path.AddLine (1, 1, 2, 2);
2345                         path.AddPath (inner, true);
2346                         path.AddLine (10, 10, 20, 20);
2347                         byte[] types = path.PathTypes;
2348                         // check first types
2349                         Assert.AreEqual (0, types[0], "start/Line");
2350                         Assert.AreEqual (1, types[2], "start/Path");
2351                         // check last types
2352                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Path");
2353                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2354                 }
2355
2356                 [Test]
2357                 public void StartClose_AddPath_NoConnect ()
2358                 {
2359                         GraphicsPath inner = new GraphicsPath ();
2360                         inner.AddArc (10, 10, 100, 100, 90, 180);
2361                         GraphicsPath path = new GraphicsPath ();
2362                         path.AddLine (1, 1, 2, 2);
2363                         path.AddPath (inner, false);
2364                         path.AddLine (10, 10, 20, 20);
2365                         byte[] types = path.PathTypes;
2366                         // check first types
2367                         Assert.AreEqual (0, types[0], "start/Line");
2368                         Assert.AreEqual (0, types[2], "start/Path");
2369                         // check last types
2370                         Assert.AreEqual (3, types[path.PointCount - 3], "end/Path");
2371                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line");
2372                 }
2373
2374                 [Test]
2375                 public void StartClose_AddPie ()
2376                 {
2377                         GraphicsPath path = new GraphicsPath ();
2378                         path.AddLine (1, 1, 2, 2);
2379                         path.AddPie (10, 10, 10, 10, 90, 180);
2380                         path.AddLine (10, 10, 20, 20);
2381                         byte[] types = path.PathTypes;
2382                         // check first types
2383                         Assert.AreEqual (0, types[0], "start/Line");
2384                         Assert.AreEqual (0, types[2], "start/Pie");
2385                         // check last types
2386                         // libgdiplus draws pie by ending with a line (not a curve) section
2387                         Assert.IsTrue ((types[path.PointCount - 3] & 128) == 128, "end/Pie");
2388                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line2");
2389                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line2");
2390                 }
2391
2392                 [Test]
2393                 public void StartClose_AddPolygon ()
2394                 {
2395                         GraphicsPath path = new GraphicsPath ();
2396                         path.AddLine (1, 1, 2, 2);
2397                         path.AddPolygon (new Point[3] { new Point (1, 1), new Point (2, 2), new Point (3, 3) });
2398                         path.AddLine (10, 10, 20, 20);
2399                         byte[] types = path.PathTypes;
2400                         // check first types
2401                         Assert.AreEqual (0, types[0], "start/Line");
2402                         Assert.AreEqual (0, types[2], "start/Polygon");
2403                         // check last types
2404                         Assert.AreEqual (129, types[path.PointCount - 3], "end/Polygon");
2405                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line2");
2406                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line2");
2407                 }
2408
2409                 [Test]
2410                 public void StartClose_AddRectangle ()
2411                 {
2412                         GraphicsPath path = new GraphicsPath ();
2413                         path.AddLine (1, 1, 2, 2);
2414                         path.AddRectangle (new RectangleF (10, 10, 20, 20));
2415                         path.AddLine (10, 10, 20, 20);
2416                         byte[] types = path.PathTypes;
2417                         // check first types
2418                         Assert.AreEqual (0, types[0], "start/Line");
2419                         Assert.AreEqual (0, types[2], "start/Rectangle");
2420                         // check last types
2421                         Assert.AreEqual (129, types[path.PointCount - 3], "end/Rectangle");
2422                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line2");
2423                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line2");
2424                 }
2425
2426                 [Test]
2427                 public void StartClose_AddRectangles ()
2428                 {
2429                         GraphicsPath path = new GraphicsPath ();
2430                         path.AddLine (1, 1, 2, 2);
2431                         path.AddRectangles (new RectangleF[2] {
2432                                 new RectangleF (10, 10, 20, 20),
2433                                 new RectangleF (20, 20, 10, 10) });
2434                         path.AddLine (10, 10, 20, 20);
2435                         byte[] types = path.PathTypes;
2436                         // check first types
2437                         Assert.AreEqual (0, types[0], "start/Line");
2438                         Assert.AreEqual (0, types[2], "start/Rectangles");
2439                         // check last types
2440                         Assert.AreEqual (129, types[path.PointCount - 3], "end/Rectangles");
2441                         Assert.AreEqual (0, types[path.PointCount - 2], "start/Line2");
2442                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line2");
2443                 }
2444
2445                 [Test]
2446                 [Category ("NotWorking")]
2447                 public void StartClose_AddString ()
2448                 {
2449                         GraphicsPath path = new GraphicsPath ();
2450                         path.AddLine (1, 1, 2, 2);
2451                         path.AddString ("mono", FontFamily.GenericMonospace, 0, 10, new Point (20,20), StringFormat.GenericDefault);
2452                         path.AddLine (10, 10, 20, 20);
2453                         byte[] types = path.PathTypes;
2454                         // check first types
2455                         Assert.AreEqual (0, types[0], "start/Line");
2456                         Assert.AreEqual (0, types[2], "start/String");
2457                         // check last types
2458                         Assert.AreEqual (163, types[path.PointCount - 3], "end/String");
2459                         Assert.AreEqual (1, types[path.PointCount - 2], "start/Line2");
2460                         Assert.AreEqual (1, types[path.PointCount - 1], "end/Line2");
2461                 }
2462
2463                 [Test]
2464                 [ExpectedException (typeof (ArgumentNullException))]
2465                 public void Widen_Pen_Null ()
2466                 {
2467                         new GraphicsPath ().Widen (null);
2468                 }
2469
2470                 [Test]
2471                 [Category ("NotWorking")]
2472                 public void Widen_Pen ()
2473                 {
2474                         Pen pen = new Pen (Color.Blue);
2475                         GraphicsPath path = new GraphicsPath ();
2476                         path.AddRectangle (new Rectangle (1, 1, 2, 2));
2477                         Assert.AreEqual (4, path.PointCount, "Count-1");
2478                         path.Widen (pen);
2479                         Assert.AreEqual (12, path.PointCount, "Count-2");
2480
2481                         PointF[] pts = path.PathPoints;
2482                         Assert.AreEqual (0.5, pts[0].X, 0.25, "0.X");
2483                         Assert.AreEqual (0.5, pts[0].Y, 0.25, "0.Y");
2484                         Assert.AreEqual (3.5, pts[1].X, 0.25, "1.X");
2485                         Assert.AreEqual (0.5, pts[1].Y, 0.25, "1.Y");
2486                         Assert.AreEqual (3.5, pts[2].X, 0.25, "2.X");
2487                         Assert.AreEqual (3.5, pts[2].Y, 0.25, "2.Y");
2488                         Assert.AreEqual (0.5, pts[3].X, 0.25, "3.X");
2489                         Assert.AreEqual (3.5, pts[3].Y, 0.25, "3.Y");
2490                         Assert.AreEqual (1.5, pts[4].X, 0.25, "4.X");
2491                         Assert.AreEqual (3.0, pts[4].Y, 0.25, "4.Y");
2492                         Assert.AreEqual (1.0, pts[5].X, 0.25, "5.X");
2493                         Assert.AreEqual (2.5, pts[5].Y, 0.25, "5.Y");
2494                         Assert.AreEqual (3.0, pts[6].X, 0.25, "6.X");
2495                         Assert.AreEqual (2.5, pts[6].Y, 0.25, "6.Y");
2496                         Assert.AreEqual (2.5, pts[7].X, 0.25, "7.X");
2497                         Assert.AreEqual (3.0, pts[7].Y, 0.25, "7.Y");
2498                         Assert.AreEqual (2.5, pts[8].X, 0.25, "8.X");
2499                         Assert.AreEqual (1.0, pts[8].Y, 0.25, "8.Y");
2500                         Assert.AreEqual (3.0, pts[9].X, 0.25, "9.X");
2501                         Assert.AreEqual (1.5, pts[9].Y, 0.25, "9.Y");
2502                         Assert.AreEqual (1.0, pts[10].X, 0.25, "10.X");
2503                         Assert.AreEqual (1.5, pts[10].Y, 0.25, "10.Y");
2504                         Assert.AreEqual (1.5, pts[11].X, 0.25, "11.X");
2505                         Assert.AreEqual (1.0, pts[11].Y, 0.25, "11.Y");
2506
2507                         byte[] types = path.PathTypes;
2508                         Assert.AreEqual (0, types[0], "0");
2509                         Assert.AreEqual (1, types[1], "1");
2510                         Assert.AreEqual (1, types[2], "2");
2511                         Assert.AreEqual (129, types[3], "3");
2512                         Assert.AreEqual (0, types[4], "4");
2513                         Assert.AreEqual (1, types[5], "5");
2514                         Assert.AreEqual (1, types[6], "6");
2515                         Assert.AreEqual (1, types[7], "7");
2516                         Assert.AreEqual (1, types[8], "8");
2517                         Assert.AreEqual (1, types[9], "9");
2518                         Assert.AreEqual (1, types[10], "10");
2519                         Assert.AreEqual (129, types[11], "11");
2520                 }
2521
2522                 [Test]
2523                 [ExpectedException (typeof (ArgumentNullException))]
2524                 public void Widen_Pen_Null_Matrix ()
2525                 {
2526                         new GraphicsPath ().Widen (null, new Matrix ());
2527                 }
2528
2529                 [Test]
2530                 public void Widen_NoPoint ()
2531                 {
2532                         using (GraphicsPath gp = new GraphicsPath ()) {
2533                                 Assert.AreEqual (0, gp.PointCount, "PointCount-1");
2534                                 Pen pen = new Pen (Color.Blue);
2535                                 gp.Widen (pen);
2536                                 Assert.AreEqual (0, gp.PointCount, "PointCount-2");
2537                         }
2538                 }
2539
2540                 [Test]
2541                 [ExpectedException (typeof (OutOfMemoryException))]
2542                 public void Widen_SinglePoint ()
2543                 {
2544                         using (GraphicsPath gp = new GraphicsPath ()) {
2545                                 gp.AddLines (new Point[1] { new Point (1, 1) });
2546                                 // Special case - a line with a single point is valid
2547                                 Assert.AreEqual (1, gp.PointCount, "PointCount");
2548                                 gp.Widen (Pens.Red);
2549                                 // oops ;-)
2550                         }
2551                 }
2552
2553                 private void CheckWiden3 (GraphicsPath path)
2554                 {
2555                         PointF[] pts = path.PathPoints;
2556                         Assert.AreEqual (4.2, pts[0].X, 0.25, "0.X");
2557                         Assert.AreEqual (4.5, pts[0].Y, 0.25, "0.Y");
2558                         Assert.AreEqual (15.8, pts[1].X, 0.25, "1.X");
2559                         Assert.AreEqual (4.5, pts[1].Y, 0.25, "1.Y");
2560                         Assert.AreEqual (10.0, pts[2].X, 0.25, "2.X");
2561                         Assert.AreEqual (16.1, pts[2].Y, 0.25, "2.Y");
2562                         Assert.AreEqual (10.4, pts[3].X, 0.25, "3.X");
2563                         Assert.AreEqual (14.8, pts[3].Y, 0.25, "3.Y");
2564                         Assert.AreEqual (9.6, pts[4].X, 0.25, "4.X");
2565                         Assert.AreEqual (14.8, pts[4].Y, 0.25, "4.Y");
2566                         Assert.AreEqual (14.6, pts[5].X, 0.25, "7.X");
2567                         Assert.AreEqual (4.8, pts[5].Y, 0.25, "7.Y");
2568                         Assert.AreEqual (15.0, pts[6].X, 0.25, "5.X");
2569                         Assert.AreEqual (5.5, pts[6].Y, 0.25, "5.Y");
2570                         Assert.AreEqual (5.0, pts[7].X, 0.25, "6.X");
2571                         Assert.AreEqual (5.5, pts[7].Y, 0.25, "6.Y");
2572                         Assert.AreEqual (5.4, pts[8].X, 0.25, "8.X");
2573                         Assert.AreEqual (4.8, pts[8].Y, 0.25, "8.Y");
2574
2575                         byte[] types = path.PathTypes;
2576                         Assert.AreEqual (0, types[0], "0");
2577                         Assert.AreEqual (1, types[1], "1");
2578                         Assert.AreEqual (129, types[2], "2");
2579                         Assert.AreEqual (0, types[3], "3");
2580                         Assert.AreEqual (1, types[4], "4");
2581                         Assert.AreEqual (1, types[5], "5");
2582                         Assert.AreEqual (1, types[6], "6");
2583                         Assert.AreEqual (1, types[7], "7");
2584                         Assert.AreEqual (129, types[8], "8");
2585                 }
2586
2587                 [Test]
2588                 [Category ("NotWorking")]
2589                 public void Widen_Pen_Matrix_Null ()
2590                 {
2591                         Pen pen = new Pen (Color.Blue);
2592                         GraphicsPath path = new GraphicsPath ();
2593                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2594                         path.Widen (pen, null);
2595                         Assert.AreEqual (9, path.PointCount, "Count");
2596                         CheckWiden3 (path);
2597                 }
2598
2599                 [Test]
2600                 [Category ("NotWorking")]
2601                 public void Widen_Pen_Matrix_Empty ()
2602                 {
2603                         Pen pen = new Pen (Color.Blue);
2604                         GraphicsPath path = new GraphicsPath ();
2605                         path.AddPolygon (new Point[3] { new Point (5, 5), new Point (15, 5), new Point (10, 15) });
2606                         path.Widen (pen, new Matrix ());
2607                         Assert.AreEqual (9, path.PointCount, "Count");
2608                         CheckWiden3 (path);
2609                 }
2610
2611                 [Test]
2612                 [Ignore ("results aren't always constant and differs from 1.x and 2.0")]
2613                 public void Widen_Pen_Matrix_NonInvertible ()
2614                 {
2615                         Matrix matrix = new Matrix (123, 24, 82, 16, 47, 30);
2616                         Assert.IsFalse (matrix.IsInvertible, "!IsInvertible");
2617                         GraphicsPath path = new GraphicsPath ();
2618                         path.Widen (new Pen (Color.Blue), matrix);
2619                         Assert.AreEqual (0, path.PointCount, "Points");
2620                 }
2621
2622                 private void CheckWidenedBounds (string message, GraphicsPath gp, Matrix m)
2623                 {
2624                         RectangleF bounds = gp.GetBounds (m);
2625                         Assert.AreEqual (0.5f, bounds.X, 0.00001f, message + ".Bounds.X");
2626                         Assert.AreEqual (0.5f, bounds.Y, 0.00001f, message + ".Bounds.Y");
2627                         Assert.AreEqual (3.0f, bounds.Width, 0.00001f, message + ".Bounds.Width");
2628                         Assert.AreEqual (3.0f, bounds.Height, 0.00001f, message + ".Bounds.Height");
2629                 }
2630
2631                 [Test]
2632                 [Category ("NotWorking")]
2633                 public void Widen_Pen_SmallWidth ()
2634                 {
2635                         Matrix m = new Matrix ();
2636                         Rectangle rect = new Rectangle (1, 1, 2, 2);
2637
2638                         // pen's smaller than 1.0 (width) are "promoted" to 1
2639                         Pen p = new Pen (Color.Aqua, 0);
2640                         GraphicsPath gp = new GraphicsPath ();
2641                         gp.AddRectangle (rect);
2642                         gp.Widen (p);
2643                         CheckWidenedBounds ("Width == 0, Null matrix", gp, null);
2644                         CheckWidenedBounds ("Width == 0, Empty matrix", gp, m);
2645
2646                         p.Width = 0.5f;
2647                         gp = new GraphicsPath ();
2648                         gp.AddRectangle (rect);
2649                         gp.Widen (p);
2650                         CheckWidenedBounds ("Width == 0.5, Null matrix", gp, null);
2651                         CheckWidenedBounds ("Width == 0.5, Empty matrix", gp, m);
2652
2653                         p.Width = 1.0f;
2654                         gp = new GraphicsPath ();
2655                         gp.AddRectangle (rect);
2656                         gp.Widen (p);
2657                         CheckWidenedBounds ("Width == 1.0, Null matrix", gp, null);
2658                         CheckWidenedBounds ("Width == 1.0, Empty matrix", gp, m);
2659
2660                         p.Width = 1.1f;
2661                         gp = new GraphicsPath ();
2662                         gp.AddRectangle (rect);
2663                         gp.Widen (p);
2664                         RectangleF bounds = gp.GetBounds (m);
2665                         Assert.AreEqual (0.45f, bounds.X, 0.00001f, "1.1.Bounds.X");
2666                         Assert.AreEqual (0.45f, bounds.Y, 0.00001f, "1.1.Bounds.Y");
2667                         Assert.AreEqual (3.10f, bounds.Width, 0.00001f, "1.1.Bounds.Width");
2668                         Assert.AreEqual (3.10f, bounds.Height, 0.00001f, "1.1.Bounds.Height");
2669                 }
2670
2671                 [Test]
2672                 [ExpectedException (typeof (ArgumentNullException))]
2673                 public void IsOutlineVisible_IntNull ()
2674                 {
2675                         new GraphicsPath ().IsOutlineVisible (1, 1, null);
2676                 }
2677
2678                 [Test]
2679                 [ExpectedException (typeof (ArgumentNullException))]
2680                 public void IsOutlineVisible_FloatNull ()
2681                 {
2682                         new GraphicsPath ().IsOutlineVisible (1.0f, 1.0f, null);
2683                 }
2684
2685                 [Test]
2686                 [ExpectedException (typeof (ArgumentNullException))]
2687                 public void IsOutlineVisible_PointNull ()
2688                 {
2689                         new GraphicsPath ().IsOutlineVisible (new Point (), null);
2690                 }
2691
2692                 [Test]
2693                 [ExpectedException (typeof (ArgumentNullException))]
2694                 public void IsOutlineVisible_PointFNull ()
2695                 {
2696                         new GraphicsPath ().IsOutlineVisible (new PointF (), null);
2697                 }
2698
2699                 private void IsOutlineVisible_Line (Graphics graphics)
2700                 {
2701                         Pen p2 = new Pen (Color.Red, 3.0f);
2702                         using (GraphicsPath gp = new GraphicsPath ()) {
2703                                 gp.AddLine (10, 1, 14, 1);
2704                                 Assert.IsTrue (gp.IsOutlineVisible (10, 1, Pens.Red, graphics), "Int1");
2705                                 Assert.IsTrue (gp.IsOutlineVisible (10, 2, p2, graphics), "Int2");
2706                                 Assert.IsFalse (gp.IsOutlineVisible (10, 2, Pens.Red, graphics), "Int3");
2707
2708                                 Assert.IsTrue (gp.IsOutlineVisible (11.0f, 1.0f, Pens.Red, graphics), "Float1");
2709                                 Assert.IsTrue (gp.IsOutlineVisible (11.0f, 1.0f, p2, graphics), "Float2");
2710                                 Assert.IsFalse (gp.IsOutlineVisible (11.0f, 2.0f, Pens.Red, graphics), "Float3");
2711
2712                                 Point pt = new Point (12, 2);
2713                                 Assert.IsFalse (gp.IsOutlineVisible (pt, Pens.Red, graphics), "Point1");
2714                                 Assert.IsTrue (gp.IsOutlineVisible (pt, p2, graphics), "Point2");
2715                                 pt.Y = 1;
2716                                 Assert.IsTrue (gp.IsOutlineVisible (pt, Pens.Red, graphics), "Point3");
2717
2718                                 PointF pf = new PointF (13.0f, 2.0f);
2719                                 Assert.IsFalse (gp.IsOutlineVisible (pf, Pens.Red, graphics), "PointF1");
2720                                 Assert.IsTrue (gp.IsOutlineVisible (pf, p2, graphics), "PointF2");
2721                                 pf.Y = 1;
2722                                 Assert.IsTrue (gp.IsOutlineVisible (pf, Pens.Red, graphics), "PointF3");
2723                         }
2724                         p2.Dispose ();
2725                 }
2726
2727                 [Test]
2728                 public void IsOutlineVisible_Line_WithoutGraphics ()
2729                 {
2730                         IsOutlineVisible_Line (null);
2731                 }
2732
2733                 [Test]
2734                 public void IsOutlineVisible_Line_WithGraphics_Inside ()
2735                 {
2736                         using (Bitmap bitmap = new Bitmap (20, 20)) {
2737                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2738                                         IsOutlineVisible_Line (g);
2739                                 }
2740                         }
2741                 }
2742
2743                 [Test]
2744                 public void IsOutlineVisible_Line_WithGraphics_Outside ()
2745                 {
2746                         using (Bitmap bitmap = new Bitmap (5, 5)) {
2747                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2748                                         IsOutlineVisible_Line (g);
2749                                 }
2750                                 // graphics "seems" ignored as the line is outside the bitmap!
2751                         }
2752                 }
2753
2754                 // docs ways the point is in world coordinates and that the graphics transform
2755                 // should be applied
2756
2757                 [Test]
2758                 public void IsOutlineVisible_Line_WithGraphics_Transform ()
2759                 {
2760                         using (Bitmap bitmap = new Bitmap (20, 20)) {
2761                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2762                                         g.Transform = new Matrix (2, 0, 0, 2, 50, -50);
2763                                         IsOutlineVisible_Line (g);
2764                                 }
2765                                 // graphics still "seems" ignored (Transform)
2766                         }
2767                 }
2768
2769                 [Test]
2770                 public void IsOutlineVisible_Line_WithGraphics_PageUnit ()
2771                 {
2772                         using (Bitmap bitmap = new Bitmap (20, 20)) {
2773                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2774                                         g.PageUnit = GraphicsUnit.Millimeter;
2775                                         IsOutlineVisible_Line (g);
2776                                 }
2777                                 // graphics still "seems" ignored (PageUnit)
2778                         }
2779                 }
2780
2781                 [Test]
2782                 public void IsOutlineVisible_Line_WithGraphics_PageScale ()
2783                 {
2784                         using (Bitmap bitmap = new Bitmap (20, 20)) {
2785                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2786                                         g.PageScale = 2.0f;
2787                                         IsOutlineVisible_Line (g);
2788                                 }
2789                                 // graphics still "seems" ignored (PageScale)
2790                         }
2791                 }
2792
2793                 [Test]
2794                 [Category ("NotWorking")]
2795                 public void IsOutlineVisible_Line_WithGraphics ()
2796                 {
2797                         using (Bitmap bitmap = new Bitmap (20, 20)) {
2798                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2799                                         g.Transform = new Matrix (2, 0, 0, 2, 50, -50);
2800                                         g.PageUnit = GraphicsUnit.Millimeter;
2801                                         g.PageScale = 2.0f;
2802                                         using (GraphicsPath gp = new GraphicsPath ()) {
2803                                                 gp.AddLine (10, 1, 14, 1);
2804                                                 Assert.IsFalse (gp.IsOutlineVisible (10, 1, Pens.Red, g), "Int1");
2805                                         }
2806                                 }
2807                                 // graphics ISN'T ignored (Transform+PageUnit+PageScale)
2808                         }
2809                 }
2810
2811                 [Test]
2812                 [Category ("NotWorking")] // looks buggy - reported to MS as FDBK50868
2813                 public void IsOutlineVisible_Line_End ()
2814                 {
2815                         // horizontal line
2816                         using (GraphicsPath gp = new GraphicsPath ()) {
2817                                 gp.AddLine (10, 1, 14, 1);
2818                                 Assert.IsFalse (gp.IsOutlineVisible (14, 1, Pens.Red, null), "Int1h");
2819                                 Assert.IsFalse (gp.IsOutlineVisible (13.5f, 1.0f, Pens.Red, null), "Float1h");
2820                                 Assert.IsTrue (gp.IsOutlineVisible (13.4f, 1.0f, Pens.Red, null), "Float2h");
2821                                 Assert.IsFalse (gp.IsOutlineVisible (new Point (14, 1), Pens.Red, null), "Point1h");
2822                                 Assert.IsFalse (gp.IsOutlineVisible (new PointF (13.5f, 1.0f), Pens.Red, null), "PointF1h");
2823                                 Assert.IsTrue (gp.IsOutlineVisible (new PointF (13.49f, 1.0f), Pens.Red, null), "PointF2h");
2824                         }
2825                         // vertical line
2826                         using (GraphicsPath gp = new GraphicsPath ()) {
2827                                 gp.AddLine (1, 10, 1, 14);
2828                                 Assert.IsFalse (gp.IsOutlineVisible (1, 14, Pens.Red, null), "Int1v");
2829                                 Assert.IsFalse (gp.IsOutlineVisible (1.0f, 13.5f, Pens.Red, null), "Float1v");
2830                                 Assert.IsTrue (gp.IsOutlineVisible (1.0f, 13.4f, Pens.Red, null), "Float2v");
2831                                 Assert.IsFalse (gp.IsOutlineVisible (new Point (1, 14), Pens.Red, null), "Point1v");
2832                                 Assert.IsFalse (gp.IsOutlineVisible (new PointF (1.0f, 13.5f), Pens.Red, null), "PointF1v");
2833                                 Assert.IsTrue (gp.IsOutlineVisible (new PointF (1.0f, 13.49f), Pens.Red, null), "PointF2v");
2834                         }
2835                 }
2836
2837                 private void IsOutlineVisible_Rectangle (Graphics graphics)
2838                 {
2839                         Pen p2 = new Pen (Color.Red, 3.0f);
2840                         using (GraphicsPath gp = new GraphicsPath ()) {
2841                                 gp.AddRectangle (new Rectangle (10, 10, 20, 20));
2842                                 Assert.IsTrue (gp.IsOutlineVisible (10, 10, Pens.Red, graphics), "Int1");
2843                                 Assert.IsTrue (gp.IsOutlineVisible (10, 11, p2, graphics), "Int2");
2844                                 Assert.IsFalse (gp.IsOutlineVisible (11, 11, Pens.Red, graphics), "Int3");
2845
2846                                 Assert.IsTrue (gp.IsOutlineVisible (11.0f, 10.0f, Pens.Red, graphics), "Float1");
2847                                 Assert.IsTrue (gp.IsOutlineVisible (11.0f, 11.0f, p2, graphics), "Float2");
2848                                 Assert.IsFalse (gp.IsOutlineVisible (11.0f, 11.0f, Pens.Red, graphics), "Float3");
2849
2850                                 Point pt = new Point (15, 10);
2851                                 Assert.IsTrue (gp.IsOutlineVisible (pt, Pens.Red, graphics), "Point1");
2852                                 Assert.IsTrue (gp.IsOutlineVisible (pt, p2, graphics), "Point2");
2853                                 pt.Y = 15;
2854                                 Assert.IsFalse (gp.IsOutlineVisible (pt, Pens.Red, graphics), "Point3");
2855
2856                                 PointF pf = new PointF (29.0f, 29.0f);
2857                                 Assert.IsFalse (gp.IsOutlineVisible (pf, Pens.Red, graphics), "PointF1");
2858                                 Assert.IsTrue (gp.IsOutlineVisible (pf, p2, graphics), "PointF2");
2859                                 pf.Y = 31.0f;
2860                                 Assert.IsTrue (gp.IsOutlineVisible (pf, p2, graphics), "PointF3");
2861                         }
2862                         p2.Dispose ();
2863                 }
2864
2865                 [Test]
2866                 public void IsOutlineVisible_Rectangle_WithoutGraphics ()
2867                 {
2868                         IsOutlineVisible_Rectangle (null);
2869                 }
2870
2871                 private void IsVisible_Rectangle (Graphics graphics)
2872                 {
2873                         using (GraphicsPath gp = new GraphicsPath ()) {
2874                                 gp.AddRectangle (new Rectangle (10, 10, 20, 20));
2875                                 Assert.IsFalse (gp.IsVisible (9, 9, graphics), "Int0");
2876                                 Assert.IsTrue (gp.IsVisible (10, 10, graphics), "Int1");
2877                                 Assert.IsTrue (gp.IsVisible (20, 20, graphics), "Int2");
2878                                 Assert.IsTrue (gp.IsVisible (29, 29, graphics), "Int3");
2879                                 Assert.IsFalse (gp.IsVisible (30, 29, graphics), "Int4");
2880                                 Assert.IsFalse (gp.IsVisible (29, 30, graphics), "Int5");
2881                                 Assert.IsFalse (gp.IsVisible (30, 30, graphics), "Int6");
2882
2883                                 Assert.IsFalse (gp.IsVisible (9.4f, 9.4f, graphics), "Float0");
2884                                 Assert.IsTrue (gp.IsVisible (9.5f, 9.5f, graphics), "Float1");
2885                                 Assert.IsTrue (gp.IsVisible (10f, 10f, graphics), "Float2");
2886                                 Assert.IsTrue (gp.IsVisible (20f, 20f, graphics), "Float3");
2887                                 // the next diff is too close, so this fails with libgdiplus/cairo
2888                                 //Assert.IsTrue (gp.IsVisible (29.4f, 29.4f, graphics), "Float4");
2889                                 Assert.IsFalse (gp.IsVisible (29.5f, 29.5f, graphics), "Float5");
2890                                 Assert.IsFalse (gp.IsVisible (29.5f, 29.4f, graphics), "Float6");
2891                                 Assert.IsFalse (gp.IsVisible (29.4f, 29.5f, graphics), "Float7");
2892                         }
2893                 }
2894
2895                 [Test]
2896                 public void IsVisible_Rectangle_WithoutGraphics ()
2897                 {
2898                         IsVisible_Rectangle (null);
2899                 }
2900
2901                 [Test]
2902                 public void IsVisible_Rectangle_WithGraphics ()
2903                 {
2904                         using (Bitmap bitmap = new Bitmap (40, 40)) {
2905                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2906                                         IsVisible_Rectangle (g);
2907                                 }
2908                         }
2909                 }
2910
2911                 // bug #325502 has shown that ellipse didn't work with earlier code
2912                 private void IsVisible_Ellipse (Graphics graphics)
2913                 {
2914                         using (GraphicsPath gp = new GraphicsPath ()) {
2915                                 gp.AddEllipse (new Rectangle (10, 10, 20, 20));
2916                                 Assert.IsFalse (gp.IsVisible (10, 10, graphics), "Int1");
2917                                 Assert.IsTrue (gp.IsVisible (20, 20, graphics), "Int2");
2918                                 Assert.IsFalse (gp.IsVisible (29, 29, graphics), "Int3");
2919
2920                                 Assert.IsFalse (gp.IsVisible (10f, 10f, graphics), "Float2");
2921                                 Assert.IsTrue (gp.IsVisible (20f, 20f, graphics), "Float3");
2922                                 Assert.IsFalse (gp.IsVisible (29.4f, 29.4f, graphics), "Float4");
2923                         }
2924                 }
2925
2926                 [Test]
2927                 public void IsVisible_Ellipse_WithoutGraphics ()
2928                 {
2929                         IsVisible_Ellipse (null);
2930                 }
2931
2932                 [Test]
2933                 public void IsVisible_Ellipse_WithGraphics ()
2934                 {
2935                         using (Bitmap bitmap = new Bitmap (40, 40)) {
2936                                 using (Graphics g = Graphics.FromImage (bitmap)) {
2937                                         IsVisible_Ellipse (g);
2938                                 }
2939                         }
2940                 }
2941
2942                 // Reverse simple test cases
2943
2944                 private void Reverse (GraphicsPath gp)
2945                 {
2946                         PointF[] bp = gp.PathPoints;
2947                         byte[] bt = gp.PathTypes;
2948
2949                         gp.Reverse ();
2950                         PointF[] ap = gp.PathPoints;
2951                         byte[] at = gp.PathTypes;
2952
2953                         int count = gp.PointCount;
2954                         Assert.AreEqual (bp.Length, count, "PointCount");
2955                         for (int i = 0; i < count; i++) {
2956                                 Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
2957                                 Assert.AreEqual (bt[i], at[i], "Type" + i.ToString ());
2958                         }
2959                 }
2960
2961                 [Test]
2962                 public void Reverse_Arc ()
2963                 {
2964                         using (GraphicsPath gp = new GraphicsPath ()) {
2965                                 gp.AddArc (1f, 1f, 2f, 2f, Pi4, Pi4);
2966                                 Reverse (gp);
2967                         }
2968                 }
2969
2970                 [Test]
2971                 public void Reverse_Bezier ()
2972                 {
2973                         using (GraphicsPath gp = new GraphicsPath ()) {
2974                                 gp.AddBezier (1, 2, 3, 4, 5, 6, 7, 8);
2975                                 Reverse (gp);
2976                         }
2977                 }
2978
2979                 [Test]
2980                 public void Reverse_Beziers ()
2981                 {
2982                         using (GraphicsPath gp = new GraphicsPath ()) {
2983                                 Point[] beziers = new Point[] { new Point (1,2), new Point (3,4), new Point (5,6),
2984                                         new Point (7,8), new Point (9,10), new Point (11,12), new Point (13,14) };
2985                                 gp.AddBeziers (beziers);
2986                                 Reverse (gp);
2987                         }
2988                 }
2989
2990                 [Test]
2991                 public void Reverse_ClosedCurve ()
2992                 {
2993                         using (GraphicsPath gp = new GraphicsPath ()) {
2994                                 Point[] beziers = new Point[] { new Point (1,2), new Point (3,4), new Point (5,6),
2995                                         new Point (7,8), new Point (9,10), new Point (11,12), new Point (13,14) };
2996                                 gp.AddClosedCurve (beziers);
2997                                 Reverse (gp);
2998                         }
2999                 }
3000
3001                 [Test]
3002                 public void Reverse_Curve ()
3003                 {
3004                         using (GraphicsPath gp = new GraphicsPath ()) {
3005                                 Point[] beziers = new Point[] { new Point (1,2), new Point (3,4), new Point (5,6),
3006                                         new Point (7,8), new Point (9,10), new Point (11,12), new Point (13,14) };
3007                                 gp.AddCurve (beziers);
3008                                 Reverse (gp);
3009                         }
3010                 }
3011
3012                 [Test]
3013                 public void Reverse_Ellipse ()
3014                 {
3015                         using (GraphicsPath gp = new GraphicsPath ()) {
3016                                 gp.AddEllipse (1, 2, 3, 4);
3017                                 Reverse (gp);
3018                         }
3019                 }
3020
3021                 [Test]
3022                 public void Reverse_Line ()
3023                 {
3024                         using (GraphicsPath gp = new GraphicsPath ()) {
3025                                 gp.AddLine (1, 2, 3, 4);
3026                                 Reverse (gp);
3027                         }
3028                 }
3029
3030                 [Test]
3031                 public void Reverse_Line_Closed ()
3032                 {
3033                         using (GraphicsPath gp = new GraphicsPath ()) {
3034                                 gp.AddLine (1, 2, 3, 4);
3035                                 gp.CloseFigure ();
3036                                 Reverse (gp);
3037                         }
3038                 }
3039
3040                 [Test]
3041                 public void Reverse_Lines ()
3042                 {
3043                         using (GraphicsPath gp = new GraphicsPath ()) {
3044                                 Point[] points = new Point[] { new Point (1,2), new Point (3,4), new Point (5,6),
3045                                         new Point (7,8), new Point (9,10), new Point (11,12), new Point (13,14) };
3046                                 gp.AddLines (points);
3047                                 Reverse (gp);
3048                         }
3049                 }
3050
3051                 [Test]
3052                 public void Reverse_Polygon ()
3053                 {
3054                         using (GraphicsPath gp = new GraphicsPath ()) {
3055                                 Point[] points = new Point[] { new Point (1,2), new Point (3,4), new Point (5,6),
3056                                         new Point (7,8), new Point (9,10), new Point (11,12), new Point (13,14) };
3057                                 gp.AddPolygon (points);
3058                                 Reverse (gp);
3059                         }
3060                 }
3061
3062                 [Test]
3063                 public void Reverse_Rectangle ()
3064                 {
3065                         using (GraphicsPath gp = new GraphicsPath ()) {
3066                                 gp.AddRectangle (new Rectangle (1,2,3,4));
3067                                 Reverse (gp);
3068                         }
3069                 }
3070
3071                 [Test]
3072                 public void Reverse_Rectangles ()
3073                 {
3074                         using (GraphicsPath gp = new GraphicsPath ()) {
3075                                 Rectangle[] rects = new Rectangle[] { new Rectangle (1, 2, 3, 4), new Rectangle (5, 6, 7, 8) };
3076                                 gp.AddRectangles (rects);
3077                                 Reverse (gp);
3078                         }
3079                 }
3080
3081                 // Reverse complex test cases
3082
3083                 [Test]
3084                 [Category ("NotWorking")] // the output differs from GDI+ and libgdiplus
3085                 public void Reverse_Pie ()
3086                 {
3087                         using (GraphicsPath gp = new GraphicsPath ()) {
3088                                 gp.AddPie (1, 2, 3, 4, 10, 20);
3089                                 PointF[] bp = gp.PathPoints;
3090                                 byte[] expected = new byte[] { 0, 3, 3, 3, 129 };
3091
3092                                 gp.Reverse ();
3093                                 PointF[] ap = gp.PathPoints;
3094                                 byte[] at = gp.PathTypes;
3095                                 int count = gp.PointCount;
3096                                 Assert.AreEqual (bp.Length, count, "PointCount");
3097                                 for (int i = 0; i < count; i++) {
3098                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3099                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3100                                 }
3101                         }
3102                 }
3103
3104                 [Test]
3105                 public void Reverse_Path ()
3106                 {
3107                         using (GraphicsPath gp = new GraphicsPath ()) {
3108                                 GraphicsPath path = new GraphicsPath ();
3109                                 path.AddArc (1f, 1f, 2f, 2f, Pi4, Pi4);
3110                                 path.AddLine (1, 2, 3, 4);
3111                                 gp.AddPath (path, true);
3112                                 PointF[] bp = gp.PathPoints;
3113                                 byte[] expected = new byte[] { 0, 1, 1, 3, 3, 3 };
3114
3115                                 gp.Reverse ();
3116                                 PointF[] ap = gp.PathPoints;
3117                                 byte[] at = gp.PathTypes;
3118
3119                                 int count = gp.PointCount;
3120                                 Assert.AreEqual (bp.Length, count, "PointCount");
3121                                 for (int i = 0; i < count; i++) {
3122                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3123                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3124                                 }
3125                         }
3126                 }
3127
3128                 [Test]
3129                 public void Reverse_Path_2 ()
3130                 {
3131                         using (GraphicsPath gp = new GraphicsPath ()) {
3132                                 gp.AddEllipse (50, 51, 50, 100);
3133                                 gp.AddRectangle (new Rectangle (200, 201, 60, 61));
3134                                 PointF[] bp = gp.PathPoints;
3135                                 byte[] expected = new byte[] { 0, 1, 1, 129, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 131 };
3136
3137                                 gp.Reverse ();
3138                                 PointF[] ap = gp.PathPoints;
3139                                 byte[] at = gp.PathTypes;
3140
3141                                 int count = gp.PointCount;
3142                                 Assert.AreEqual (bp.Length, count, "PointCount");
3143                                 for (int i = 0; i < count; i++) {
3144                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3145                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3146                                 }
3147                         }
3148                 }
3149
3150                 [Test]
3151                 [Category ("NotWorking")] // the output differs from GDI+ and libgdiplus
3152                 public void Reverse_String ()
3153                 {
3154                         using (GraphicsPath gp = new GraphicsPath ()) {
3155                                 FontFamily ff = GetFontFamily ();
3156                                 gp.AddString ("Mono::", ff, 0, 10, new Point (10, 10), StringFormat.GenericDefault);
3157                                 PointF[] bp = gp.PathPoints;
3158                                 byte[] expected = new byte[] { 0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,129,0,3,3,3,
3159                                         3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,161,0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,
3160                                         3,3,3,3,3,3,3,129,0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,161,0,3,3,3,3,3,
3161                                         3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,131,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
3162                                         163,0,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,
3163                                         1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,
3164                                         3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,161,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,131,
3165                                         0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,163,0,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,
3166                                         3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,
3167                                         1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,1,129 };
3168
3169                                 gp.Reverse ();
3170                                 PointF[] ap = gp.PathPoints;
3171                                 byte[] at = gp.PathTypes;
3172
3173                                 int count = gp.PointCount;
3174                                 Assert.AreEqual (bp.Length, count, "PointCount");
3175                                 for (int i = 0; i < count; i++) {
3176                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3177                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3178                                 }
3179                         }
3180                 }
3181
3182                 [Test]
3183                 public void Reverse_Marker ()
3184                 {
3185                         using (GraphicsPath gp = new GraphicsPath ()) {
3186                                 gp.AddRectangle (new Rectangle (200, 201, 60, 61));
3187                                 gp.SetMarkers ();
3188                                 PointF[] bp = gp.PathPoints;
3189                                 byte[] expected = new byte[] { 0, 1, 1, 129 };
3190
3191                                 gp.Reverse ();
3192                                 PointF[] ap = gp.PathPoints;
3193                                 byte[] at = gp.PathTypes;
3194
3195                                 int count = gp.PointCount;
3196                                 Assert.AreEqual (bp.Length, count, "PointCount");
3197                                 for (int i = 0; i < count; i++) {
3198                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3199                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3200                                 }
3201                         }
3202                 }
3203
3204                 [Test]
3205                 public void Reverse_Subpath_Marker ()
3206                 {
3207                         using (GraphicsPath gp = new GraphicsPath ()) {
3208                                 gp.AddLine (0, 1, 2, 3);
3209                                 gp.SetMarkers ();
3210                                 gp.CloseFigure ();
3211                                 gp.AddBezier (5, 6, 7, 8, 9, 10, 11, 12);
3212                                 gp.CloseFigure ();
3213                                 PointF[] bp = gp.PathPoints;
3214                                 byte[] expected = new byte[] { 0, 3, 3, 163, 0, 129 };
3215
3216                                 gp.Reverse ();
3217                                 PointF[] ap = gp.PathPoints;
3218                                 byte[] at = gp.PathTypes;
3219
3220                                 int count = gp.PointCount;
3221                                 Assert.AreEqual (bp.Length, count, "PointCount");
3222                                 for (int i = 0; i < count; i++) {
3223                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3224                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3225                                 }
3226                         }
3227                 }
3228
3229                 [Test]
3230                 public void Reverse_Subpath_Marker_2 ()
3231                 {
3232                         using (GraphicsPath gp = new GraphicsPath ()) {
3233                                 gp.AddLine (0, 1, 2, 3);
3234                                 gp.SetMarkers ();
3235                                 gp.StartFigure ();
3236                                 gp.AddLine (20, 21, 22, 23);
3237                                 gp.AddBezier (5, 6, 7, 8, 9, 10, 11, 12);
3238                                 PointF[] bp = gp.PathPoints;
3239                                 byte[] expected = new byte[] { 0, 3, 3, 3, 1, 33, 0, 1 };
3240
3241                                 gp.Reverse ();
3242                                 PointF[] ap = gp.PathPoints;
3243                                 byte[] at = gp.PathTypes;
3244
3245                                 int count = gp.PointCount;
3246                                 Assert.AreEqual (bp.Length, count, "PointCount");
3247                                 for (int i = 0; i < count; i++) {
3248                                         Assert.AreEqual (bp[i], ap[count - i - 1], "Point" + i.ToString ());
3249                                         Assert.AreEqual (expected[i], at[i], "Type" + i.ToString ());
3250                                 }
3251                         }
3252                 }
3253
3254                 [Test]
3255                 public void bug413461 ()
3256                 {
3257                         int dX = 520;
3258                         int dY = 320;
3259                         Point[] expected_points = new Point [] {
3260                                 new Point(dX-64, dY-24),//start
3261                                 new Point(dX-59, dY-34),//focal point 1
3262                                 new Point(dX-52, dY-54),//focal point 2
3263                                 new Point(dX-18, dY-66),//top
3264                                 new Point(dX-34, dY-47),//focal point 1
3265                                 new Point(dX-43, dY-27),//focal point 2
3266                                 new Point(dX-44, dY-8),//end
3267                                 };
3268                         byte[] expected_types = new byte [] {
3269                                 (byte)PathPointType.Start,
3270                                 (byte)PathPointType.Bezier,
3271                                 (byte)PathPointType.Bezier,
3272                                 (byte)PathPointType.Bezier,
3273                                 (byte)PathPointType.Bezier,
3274                                 (byte)PathPointType.Bezier,
3275                                 (byte)PathPointType.Bezier };
3276                         using (GraphicsPath path = new GraphicsPath (expected_points, expected_types)) {
3277                                 Assert.AreEqual (7, path.PointCount, "PathCount");
3278                                 byte [] actual_types = path.PathTypes;
3279                                 Assert.AreEqual (expected_types [0], actual_types [0], "types-0");
3280                                 Assert.AreEqual (expected_types [1], actual_types [1], "types-1");
3281                                 Assert.AreEqual (expected_types [2], actual_types [2], "types-2");
3282                                 Assert.AreEqual (expected_types [3], actual_types [3], "types-3");
3283                                 Assert.AreEqual (expected_types [4], actual_types [4], "types-4");
3284                                 Assert.AreEqual (expected_types [5], actual_types [5], "types-5");
3285                                 // path is filled like closed but this does not show on the type
3286                                 Assert.AreEqual (expected_types [6], actual_types [6], "types-6");
3287                         }
3288                 }
3289         }
3290 }