Author: spouliot
Date: 2006-01-13 15:05:00 -0500 (Fri, 13 Jan 2006)
New Revision: 55544
Modified:
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/ChangeLog
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/GraphicsPathTest.cs
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/PathDataTest.cs
Log:
2006-01-13 Sebastien Pouliot <[EMAIL PROTECTED]>
* GraphicsPathTest.cs: New. Added multiple test cases to check null
handling and how the points are generated for the Add* methods.
* PathDataTest.cs: New. Added clone test case.
Modified: trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/ChangeLog
===================================================================
--- trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/ChangeLog
2006-01-13 20:04:49 UTC (rev 55543)
+++ trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/ChangeLog
2006-01-13 20:05:00 UTC (rev 55544)
@@ -1,3 +1,9 @@
+2006-01-13 Sebastien Pouliot <[EMAIL PROTECTED]>
+
+ * GraphicsPathTest.cs: New. Added multiple test cases to check null
+ handling and how the points are generated for the Add* methods.
+ * PathDataTest.cs: New. Added clone test case.
+
2006-01-12 Sebastien Pouliot <[EMAIL PROTECTED]>
* GraphicsPathTest.cs: New. Basic test cases for empty path and
Modified:
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/GraphicsPathTest.cs
===================================================================
---
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/GraphicsPathTest.cs
2006-01-13 20:04:49 UTC (rev 55543)
+++
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/GraphicsPathTest.cs
2006-01-13 20:05:00 UTC (rev 55544)
@@ -27,6 +27,8 @@
//
using System;
+using SC = System.ComponentModel;
+using System.Drawing;
using System.Drawing.Drawing2D;
using System.Security.Permissions;
using NUnit.Framework;
@@ -37,21 +39,74 @@
[SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
public class GraphicsPathTest {
+ private const float Pi4 = (float) (Math.PI / 4);
+
private void CheckEmpty (string prefix, GraphicsPath gp)
{
- Assert.AreEqual (FillMode.Alternate, gp.FillMode,
"FillMode");
Assert.AreEqual (0, gp.PathData.Points.Length,
"PathData.Points");
Assert.AreEqual (0, gp.PathData.Types.Length,
"PathData.Types");
Assert.AreEqual (0, gp.PointCount, prefix +
"PointCount");
}
[Test]
+ public void Constructor_InvalidFillMode ()
+ {
+ GraphicsPath gp = new GraphicsPath ((FillMode)
Int32.MinValue);
+ Assert.AreEqual (Int32.MinValue, (int) gp.FillMode,
"FillMode");
+ CheckEmpty ("InvalidFillMode.", gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void Constructor_Point_Null_Byte ()
+ {
+ new GraphicsPath ((Point[]) null, new byte[1]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void Constructor_Point_Byte_Null ()
+ {
+ new GraphicsPath (new Point[1], null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Constructor_Point_Byte_LengthMismatch ()
+ {
+ new GraphicsPath (new Point[1], new byte [2]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void Constructor_PointF_Null_Byte ()
+ {
+ new GraphicsPath ((PointF[])null, new byte [1]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void Constructor_PointF_Byte_Null ()
+ {
+ new GraphicsPath ( new PointF[1], null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Constructor_PointF_Byte_LengthMismatch ()
+ {
+ new GraphicsPath (new PointF[2], new byte [1]);
+ }
+
+ [Test]
public void GraphicsPath_Empty ()
{
GraphicsPath gp = new GraphicsPath ();
+ Assert.AreEqual (FillMode.Alternate, gp.FillMode,
"Empty.FillMode");
CheckEmpty ("Empty.", gp);
GraphicsPath clone = (GraphicsPath) gp.Clone ();
+ Assert.AreEqual (FillMode.Alternate, gp.FillMode,
"Clone.FillMode");
CheckEmpty ("Clone.", gp);
}
@@ -68,5 +123,877 @@
{
Assert.IsNull (new GraphicsPath ().PathTypes);
}
+
+ [Test]
+ [ExpectedException (typeof (SC.InvalidEnumArgumentException))]
+ public void FillMode_Invalid ()
+ {
+ // constructor accept an invalid FillMode
+ GraphicsPath gp = new GraphicsPath ((FillMode)
Int32.MaxValue);
+ Assert.AreEqual (Int32.MaxValue, (int) gp.FillMode,
"MaxValue");
+ // but you can't set the FillMode property to an
invalid value ;-)
+ gp.FillMode = (FillMode) Int32.MaxValue;
+ }
+
+ [Test]
+ public void PathData_CannotChange ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangle (new Rectangle (1, 1, 2, 2));
+
+ Assert.AreEqual (1f, gp.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, gp.PathData.Points[0].Y,
"Points[0].Y");
+
+ // now try to change the first point
+ gp.PathData.Points[0] = new Point (0, 0);
+ // the changes isn't reflected in the property
+ Assert.AreEqual (1f, gp.PathData.Points[0].X,
"Points[0].X-1");
+ Assert.AreEqual (1f, gp.PathData.Points[0].Y,
"Points[0].Y-1");
+ }
+
+ [Test]
+ public void PathPoints_CannotChange ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangle (new Rectangle (1, 1, 2, 2));
+
+ Assert.AreEqual (1f, gp.PathPoints[0].X,
"PathPoints[0].X");
+ Assert.AreEqual (1f, gp.PathPoints[0].Y,
"PathPoints[0].Y");
+
+ // now try to change the first point
+ gp.PathPoints[0] = new Point (0, 0);
+ // the changes isn't reflected in the property
+ Assert.AreEqual (1f, gp.PathPoints[0].X,
"PathPoints[0].X-1");
+ Assert.AreEqual (1f, gp.PathPoints[0].Y,
"PathPoints[0].Y-1");
+ }
+
+ [Test]
+ public void PathTypes_CannotChange ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangle (new Rectangle (1, 1, 2, 2));
+
+ Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
+
+ // now try to change the first type
+ gp.PathTypes[0] = 1;
+ // the changes isn't reflected in the property
+ Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]-1");
+ }
+
+ private void CheckArc (GraphicsPath path)
+ {
+ Assert.AreEqual (4, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathData.Points.Length,
"PathData");
+
+ Assert.AreEqual (2.999906f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (2.013707f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (2.999843f, path.PathData.Points[1].X,
"Points[1].X");
+ Assert.AreEqual (2.018276f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
+ Assert.AreEqual (2.99974918f,
path.PathData.Points[2].X, "Points[2].X");
+ Assert.AreEqual (2.02284455f, path.PathPoints[2].Y,
"Points[2].Y");
+ Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
+ Assert.AreEqual (2.999624f, path.PathData.Points[3].X,
"Points[3].X");
+ Assert.AreEqual (2.027412f, path.PathPoints[3].Y,
"Points[3].Y");
+ Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
+ }
+
+ [Test]
+ public void AddArc_Rectangle ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddArc (new Rectangle (1, 1, 2, 2), Pi4, Pi4);
+ CheckArc (gp);
+ }
+
+ [Test]
+ public void AddArc_RectangleF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddArc (new RectangleF (1f, 1f, 2f, 2f), Pi4, Pi4);
+ CheckArc (gp);
+ }
+
+ [Test]
+ public void AddArc_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddArc (1, 1, 2, 2, Pi4, Pi4);
+ CheckArc (gp);
+ }
+
+ [Test]
+ public void AddArc_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddArc (1f, 1f, 2f, 2f, Pi4, Pi4);
+ CheckArc (gp);
+ }
+
+ private void CheckBezier (GraphicsPath path)
+ {
+ Assert.AreEqual (4, path.PointCount, "PointCount");
+ Assert.AreEqual (4, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathData.Points.Length,
"PathData");
+
+ Assert.AreEqual (1f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (2f, path.PathData.Points[1].X,
"Points[1].X");
+ Assert.AreEqual (2f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
+ Assert.AreEqual (3f, path.PathData.Points[2].X,
"Points[2].X");
+ Assert.AreEqual (3f, path.PathPoints[2].Y,
"Points[2].Y");
+ Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
+ Assert.AreEqual (4f, path.PathData.Points[3].X,
"Points[3].X");
+ Assert.AreEqual (4f, path.PathPoints[3].Y,
"Points[3].Y");
+ Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
+ }
+
+ [Test]
+ public void AddBezier_Point ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBezier (new Point (1, 1), new Point (2, 2), new
Point (3, 3), new Point (4, 4));
+ CheckBezier (gp);
+ }
+
+ [Test]
+ public void AddBezier_PointF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBezier (new PointF (1f, 1f), new PointF (2f, 2f),
new PointF (3f, 3f), new PointF (4f, 4f));
+ CheckBezier (gp);
+ }
+
+ [Test]
+ public void AddBezier_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBezier (1, 1, 2, 2, 3, 3, 4, 4);
+ CheckBezier (gp);
+ }
+
+ [Test]
+ public void AddBezier_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBezier (1f, 1f, 2f, 2f, 3f, 3f, 4f, 4f);
+ CheckBezier (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddBeziers_Point_Null ()
+ {
+ new GraphicsPath ().AddBeziers ((Point[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddBeziers_3_Points ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBeziers (new Point[3] { new Point (1, 1), new
Point (2, 2), new Point (3, 3) });
+ }
+
+ [Test]
+ public void AddBeziers_Point ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBeziers (new Point[4] { new Point (1, 1), new
Point (2, 2), new Point (3, 3), new Point (4, 4) });
+ CheckBezier (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddBeziers_PointF_Null ()
+ {
+ new GraphicsPath ().AddBeziers ((PointF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddBeziers_3_PointFs ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBeziers (new PointF[3] { new PointF (1f, 1f), new
PointF (2f, 2f), new PointF (3f, 3f) });
+ }
+
+ [Test]
+ public void AddBeziers_PointF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddBeziers (new PointF[4] { new PointF (1f, 1f), new
PointF (2f, 2f), new PointF (3f, 3f), new PointF (4f, 4f) });
+ CheckBezier (gp);
+ }
+
+ private void CheckEllipse (GraphicsPath path)
+ {
+ Assert.AreEqual (13, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (13, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (13, path.PathData.Points.Length,
"PathData");
+#if false
+ // GetBounds (well GdipGetPathWorldBounds) isn't
implemented
+ RectangleF rect = path.GetBounds ();
+ Assert.AreEqual (1f, rect.X, "Bounds.X");
+ Assert.AreEqual (1f, rect.Y, "Bounds.Y");
+ Assert.AreEqual (2f, rect.Width, "Bounds.Width");
+ Assert.AreEqual (2f, rect.Height, "Bounds.Height");
+#endif
+ Assert.AreEqual (0, path.PathData.Types[0],
"PathData.Types[0]");
+ for (int i = 1; i < 12; i++)
+ Assert.AreEqual (3, path.PathTypes[i],
"PathTypes" + i.ToString ());
+ Assert.AreEqual (131, path.PathData.Types[12],
"PathData.Types[12]");
+ }
+
+ [Test]
+ public void AddEllipse_Rectangle ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddEllipse (new Rectangle (1, 1, 2, 2));
+ CheckEllipse (gp);
+ }
+
+ [Test]
+ public void AddEllipse_RectangleF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddEllipse (new RectangleF (1f, 1f, 2f, 2f));
+ CheckEllipse (gp);
+ }
+
+ [Test]
+ public void AddEllipse_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddEllipse (1, 1, 2, 2);
+ CheckEllipse (gp);
+ }
+
+ [Test]
+ public void AddEllipse_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddEllipse (1f, 1f, 2f, 2f);
+ CheckEllipse (gp);
+ }
+
+ private void CheckLine (GraphicsPath path)
+ {
+ Assert.AreEqual (2, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (2, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (2, path.PathData.Points.Length,
"PathData");
+
+ Assert.AreEqual (1f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (2f, path.PathData.Points[1].X,
"Points[1].X");
+ Assert.AreEqual (2f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
+ }
+
+ [Test]
+ public void AddLine_Point ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLine (new Point (1, 1), new Point (2, 2));
+ CheckLine (gp);
+ }
+
+ [Test]
+ public void AddLine_PointF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLine (new PointF (1f, 1f), new PointF (2f, 2f));
+ CheckLine (gp);
+ }
+
+ [Test]
+ public void AddLine_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLine (1, 1, 2, 2);
+ CheckLine (gp);
+ }
+
+ [Test]
+ public void AddLine_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLine (1f, 1f, 2f, 2f);
+ CheckLine (gp);
+ }
+
+ [Test]
+ public void AddLine_SamePoint ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLine (new Point (1, 1), new Point (1, 1));
+ Assert.AreEqual (2, gp.PointCount, "PointCount");
+ Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
+ Assert.AreEqual (1, gp.PathTypes[1], "PathTypes[1]");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddLines_Point_Null ()
+ {
+ new GraphicsPath ().AddLines ((Point[])null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddLines_Point_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new Point[0]);
+ CheckLine (gp);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void AddLines_Point_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new Point[1] { new Point (1, 1) });
+ // Special case - a line with a single point is valid
+ Assert.AreEqual (1, gp.PointCount, "PointCount");
+ Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
+ }
+
+ [Test]
+ public void AddLines_Point ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new Point[2] { new Point (1, 1), new Point
(2, 2) });
+ CheckLine (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddLines_PointF_Null ()
+ {
+ new GraphicsPath ().AddLines ((PointF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddLines_PointF_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new PointF[0]);
+ CheckLine (gp);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void AddLines_PointF_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new PointF[1] { new PointF (1f, 1f) });
+ // Special case - a line with a single point is valid
+ Assert.AreEqual (1, gp.PointCount, "PointCount");
+ Assert.AreEqual (0, gp.PathTypes[0], "PathTypes[0]");
+ }
+
+ [Test]
+ public void AddLines_PointF ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddLines (new PointF[2] { new PointF (1f, 1f), new
PointF (2f, 2f) });
+ CheckLine (gp);
+ }
+
+ private void CheckPie (GraphicsPath path)
+ {
+ // the number of points generated for a Pie isn't the
same between Mono and MS
+#if false
+ Assert.AreEqual (5, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (5, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (5, path.PathData.Points.Length,
"PathData");
+
+ // GetBounds (well GdipGetPathWorldBounds) isn't
implemented
+ RectangleF rect = path.GetBounds ();
+ Assert.AreEqual (2f, rect.X, "Bounds.X");
+ Assert.AreEqual (2f, rect.Y, "Bounds.Y");
+ Assert.AreEqual (0.9999058f, rect.Width,
"Bounds.Width");
+ Assert.AreEqual (0.0274119377f, rect.Height,
"Bounds.Height");
+
+ Assert.AreEqual (2f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (2f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (2.99990582f,
path.PathData.Points[1].X, "Points[1].X");
+ Assert.AreEqual (2.01370716f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
+ Assert.AreEqual (2.99984312f,
path.PathData.Points[2].X, "Points[2].X");
+ Assert.AreEqual (2.018276f, path.PathPoints[2].Y,
"Points[2].Y");
+ Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
+ Assert.AreEqual (2.99974918f,
path.PathData.Points[3].X, "Points[2].X");
+ Assert.AreEqual (2.02284455f, path.PathPoints[3].Y,
"Points[2].Y");
+ Assert.AreEqual (3, path.PathData.Types[3], "Types[2]");
+ Assert.AreEqual (2.999624f, path.PathData.Points[4].X,
"Points[3].X");
+ Assert.AreEqual (2.027412f, path.PathPoints[4].Y,
"Points[3].Y");
+ Assert.AreEqual (131, path.PathTypes[4], "Types[3]");
+#endif
+ }
+
+ [Test]
+ public void AddPie_Rect ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPie (new Rectangle (1, 1, 2, 2), Pi4, Pi4);
+ CheckPie (gp);
+ }
+
+ [Test]
+ public void AddPie_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPie (1, 1, 2, 2, Pi4, Pi4);
+ CheckPie (gp);
+ }
+
+ [Test]
+ public void AddPie_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPie (1f, 1f, 2f, 2f, Pi4, Pi4);
+ CheckPie (gp);
+ }
+
+ private void CheckPolygon (GraphicsPath path)
+ {
+ // an extra point is generated by Mono (libgdiplus)
+#if false
+ Assert.AreEqual (3, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (3, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (3, path.PathData.Points.Length,
"PathData");
+
+ // GetBounds (well GdipGetPathWorldBounds) isn't
implemented
+ RectangleF rect = path.GetBounds ();
+ Assert.AreEqual (1f, rect.X, "Bounds.X");
+ Assert.AreEqual (1f, rect.Y, "Bounds.Y");
+ Assert.AreEqual (2f, rect.Width, "Bounds.Width");
+ Assert.AreEqual (2f, rect.Height, "Bounds.Height");
+#endif
+ Assert.AreEqual (1f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (2f, path.PathData.Points[1].X,
"Points[1].X");
+ Assert.AreEqual (2f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
+ Assert.AreEqual (3f, path.PathData.Points[2].X,
"Points[2].X");
+ Assert.AreEqual (3f, path.PathPoints[2].Y,
"Points[2].Y");
+ // the extra point change the type of the last point
+#if false
+ Assert.AreEqual (129, path.PathData.Types[2],
"Types[2]");
+#endif
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddPolygon_Point_Null ()
+ {
+ new GraphicsPath ().AddPolygon ((Point[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_Point_Empty ()
+ {
+ new GraphicsPath ().AddPolygon (new Point[0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_Point_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new Point[1] { new Point (1, 1) });
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_Point_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new Point[2] { new Point (1, 1), new
Point (2, 2) });
+ }
+
+ [Test]
+ public void AddPolygon_Point_3 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new Point[3] { new Point (1, 1), new
Point (2, 2), new Point (3, 3) });
+ CheckPolygon (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddPolygon_PointF_Null ()
+ {
+ new GraphicsPath ().AddPolygon ((PointF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_PointF_Empty ()
+ {
+ new GraphicsPath ().AddPolygon (new PointF[0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_PointF_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new PointF[1] { new PointF (1f, 1f) });
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddPolygon_PointF_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new PointF[2] { new PointF (1f, 1f), new
PointF (2f, 2f) });
+ }
+
+ [Test]
+ public void AddPolygon_PointF_3 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPolygon (new PointF[3] { new PointF (1f, 1f), new
PointF (2f, 2f), new PointF (3f, 3f) });
+ CheckPolygon (gp);
+ }
+
+ private void CheckRectangle (GraphicsPath path)
+ {
+ Assert.AreEqual (4, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathData.Points.Length,
"PathData");
+
+ Assert.AreEqual (1f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ Assert.AreEqual (3f, path.PathData.Points[1].X,
"Points[1].X");
+ Assert.AreEqual (1f, path.PathPoints[1].Y,
"Points[1].Y");
+ Assert.AreEqual (1, path.PathTypes[1], "Types[1]");
+ Assert.AreEqual (3f, path.PathData.Points[2].X,
"Points[2].X");
+ Assert.AreEqual (3f, path.PathPoints[2].Y,
"Points[2].Y");
+ Assert.AreEqual (1, path.PathData.Types[2], "Types[2]");
+ Assert.AreEqual (1f, path.PathData.Points[3].X,
"Points[3].X");
+ Assert.AreEqual (3f, path.PathPoints[3].Y,
"Points[3].Y");
+ Assert.AreEqual (129, path.PathTypes[3], "Types[3]");
+ }
+
+ [Test]
+ public void AddRectangle_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangle (new Rectangle (1, 1, 2, 2));
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ public void AddRectangle_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangle (new RectangleF (1f, 1f, 2f, 2f));
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddRectangles_Int_Null ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles ((Rectangle[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddRectangles_Int_Empty ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles (new Rectangle[0]);
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ public void AddRectangles_Int ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles (new Rectangle[1] { new Rectangle (1,
1, 2, 2) });
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddRectangles_Float_Null ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles ((RectangleF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddRectangles_Float_Empty ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles ( new RectangleF[0]);
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ public void AddRectangles_Float ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddRectangles (new RectangleF [1] { new RectangleF
(1f, 1f, 2f, 2f) });
+ CheckRectangle (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddPath_Null ()
+ {
+ new GraphicsPath ().AddPath (null, false);
+ }
+
+ [Test]
+ public void AddPath ()
+ {
+ GraphicsPath gpr = new GraphicsPath ();
+ gpr.AddRectangle (new Rectangle (1, 1, 2, 2));
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddPath (gpr, true);
+ CheckRectangle (gp);
+ }
+
+ private void CheckClosedCurve (GraphicsPath path)
+ {
+ Assert.AreEqual (10, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (10, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (10, path.PathData.Points.Length,
"PathData");
+#if false
+ // GetBounds (well GdipGetPathWorldBounds) isn't
implemented
+ RectangleF rect = path.GetBounds ();
+ Assert.AreEqual (0.8333333f, rect.X, "Bounds.X");
+ Assert.AreEqual (0.8333333f, rect.Y, "Bounds.Y");
+ Assert.AreEqual (2.33333278f, rect.Width,
"Bounds.Width");
+ Assert.AreEqual (2.33333278f, rect.Height,
"Bounds.Height");
+#endif
+ Assert.AreEqual (0, path.PathData.Types[0],
"PathData.Types[0]");
+ for (int i = 1; i < 9; i++)
+ Assert.AreEqual (3, path.PathTypes[i],
"PathTypes" + i.ToString ());
+ Assert.AreEqual (131, path.PathData.Types[9],
"PathData.Types[9]");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddClosedCurve_Point_Null ()
+ {
+ new GraphicsPath ().AddClosedCurve ((Point[])null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_Point_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new Point [0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_Point_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new Point[1] { new Point (1, 1) });
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_Point_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new Point[2] { new Point (1, 1), new
Point (2, 2) });
+ }
+
+ [Test]
+ public void AddClosedCurve_Point_3 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new Point[3] { new Point (1, 1), new
Point (2, 2), new Point (3, 3) });
+ CheckClosedCurve (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddClosedCurve_PointF_Null ()
+ {
+ new GraphicsPath ().AddClosedCurve ((PointF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_PointF_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new PointF[0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_PointF_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new PointF[1] { new PointF (1f, 1f)
});
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddClosedCurve_PointF_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new PointF[2] { new PointF (1f, 1f),
new PointF (2f, 2f) });
+ }
+
+ [Test]
+ public void AddClosedCurve_PointF_3 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddClosedCurve (new PointF[3] { new PointF (1f, 1f),
new PointF (2f, 2f), new PointF (3f, 3f) });
+ CheckClosedCurve (gp);
+ }
+
+ private void CheckCurve (GraphicsPath path)
+ {
+ Assert.AreEqual (4, path.PathPoints.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathTypes.Length,
"PathPoints");
+ Assert.AreEqual (4, path.PathData.Points.Length,
"PathData");
+#if false
+ // GetBounds (well GdipGetPathWorldBounds) isn't
implemented
+ RectangleF rect = path.GetBounds ();
+ Assert.AreEqual (1.0f, rect.X, "Bounds.X");
+ Assert.AreEqual (1.0f, rect.Y, "Bounds.Y");
+ Assert.AreEqual (1.0f, rect.Width, "Bounds.Width");
+ Assert.AreEqual (1.0f, rect.Height, "Bounds.Height");
+#endif
+ Assert.AreEqual (1f, path.PathData.Points[0].X,
"Points[0].X");
+ Assert.AreEqual (1f, path.PathPoints[0].Y,
"Points[0].Y");
+ Assert.AreEqual (0, path.PathData.Types[0], "Types[0]");
+ // Mono has wrong? results
+#if false
+ Assert.AreEqual (1.16666663f,
path.PathData.Points[1].X, "Points[1].X");
+ Assert.AreEqual (1.16666663f, path.PathPoints[1].Y,
"Points[1].Y");
+#endif
+ Assert.AreEqual (3, path.PathTypes[1], "Types[1]");
+ // Mono has wrong? results
+#if false
+ Assert.AreEqual (1.83333325f,
path.PathData.Points[2].X, "Points[2].X");
+ Assert.AreEqual (1.83333325f, path.PathPoints[2].Y,
"Points[2].Y");
+#endif
+ Assert.AreEqual (3, path.PathData.Types[2], "Types[2]");
+ Assert.AreEqual (2f, path.PathData.Points[3].X,
"Points[3].X");
+ Assert.AreEqual (2f, path.PathPoints[3].Y,
"Points[3].Y");
+ Assert.AreEqual (3, path.PathTypes[3], "Types[3]");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddCurve_Point_Null ()
+ {
+ new GraphicsPath ().AddCurve ((Point[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddCurve_Point_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new Point[0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddCurve_Point_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new Point[1] { new Point (1, 1) });
+ }
+
+ [Test]
+ public void AddCurve_Point_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new Point[2] { new Point (1, 1), new Point
(2, 2) });
+ CheckCurve (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void AddCurve_PointF_Null ()
+ {
+ new GraphicsPath ().AddCurve ((PointF[]) null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddCurve_PointF_0 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new PointF[0]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void AddCurve_PointF_1 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new PointF[1] { new PointF (1f, 1f) });
+ }
+
+ [Test]
+ public void AddCurve_PointF_2 ()
+ {
+ GraphicsPath gp = new GraphicsPath ();
+ gp.AddCurve (new PointF[2] { new PointF (1f, 1f), new
PointF (2f, 2f) });
+ CheckCurve (gp);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void Transform_Null ()
+ {
+ new GraphicsPath ().Transform (null);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void Flatten_Null ()
+ {
+ new GraphicsPath ().Flatten (null);
+ // no ArgumentNullException or NullReferenceException
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void Flatten_NullFloat ()
+ {
+ new GraphicsPath ().Flatten (null, 1f);
+ // no ArgumentNullException or NullReferenceException
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void Warp_Null ()
+ {
+ new GraphicsPath ().Warp (null, new RectangleF ());
+ }
}
}
Modified:
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/PathDataTest.cs
===================================================================
---
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/PathDataTest.cs
2006-01-13 20:04:49 UTC (rev 55543)
+++
trunk/mcs/class/System.Drawing/Test/System.Drawing.Drawing2D/PathDataTest.cs
2006-01-13 20:05:00 UTC (rev 55544)
@@ -65,5 +65,23 @@
Assert.AreEqual (2, data.Points.Length, "Points-2");
Assert.AreEqual (1, data.Types.Length, "Types-1");
}
+
+ [Test]
+ public void PathData_UnclonedProperties ()
+ {
+ PathData data = new PathData ();
+ data.Points = new PointF[1] { new PointF (1f, 1f) };
+ data.Types = new byte[1] { 1 };
+ Assert.AreEqual (1f, data.Points[0].X, "Points.X");
+ Assert.AreEqual (1f, data.Points[0].Y, "Points.Y");
+ Assert.AreEqual (1, data.Types[0], "Types");
+
+ data.Points[0] = new PointF (0f, 0f);
+ Assert.AreEqual (0f, data.Points[0].X, "Points.X.1");
+ Assert.AreEqual (0f, data.Points[0].Y, "Points.Y.1");
+
+ data.Types[0] = 0;
+ Assert.AreEqual (0, data.Types[0], "Types-1");
+ }
}
}
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
