// Authors:
// Sebastien Pouliot <sebastien@ximian.com>
//
-// Copyright (C) 2006 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2006, 2008 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
private void CheckDefaultMatrix (Matrix matrix)
{
float[] elements = matrix.Elements;
- Assert.AreEqual (1, elements[0], 0.1, "matrix.0");
- Assert.AreEqual (1, elements[1], 0.1, "matrix.1");
- Assert.AreEqual (-1, elements[2], 0.1, "matrix.2");
- Assert.AreEqual (1, elements[3], 0.1, "matrix.3");
- Assert.AreEqual (16, elements[4], "matrix.4");
- Assert.AreEqual (-16, elements[5], "matrix.5");
+ Assert.AreEqual (1.0f, elements[0], 0.1, "matrix.0");
+ Assert.AreEqual (1.0f, elements[1], 0.1, "matrix.1");
+ Assert.AreEqual (-1.0f, elements[2], 0.1, "matrix.2");
+ Assert.AreEqual (1.0f, elements[3], 0.1, "matrix.3");
+ Assert.AreEqual (16.0f, elements[4], 0.1, "matrix.4");
+ Assert.AreEqual (-16.0f, elements[5], 0.1, "matrix.5");
}
private void CheckBrushAt45 (LinearGradientBrush lgb)
CheckDefaultMatrix (lgb.Transform);
}
+ private void CheckMatrixAndRect (PointF pt1, PointF pt2, float[] testVals)
+ {
+ Matrix m;
+ RectangleF rect;
+
+ using (LinearGradientBrush b = new LinearGradientBrush (pt1, pt2, Color.Black, Color.White)) {
+ m = b.Transform;
+ rect = b.Rectangle;
+ }
+
+ Assert.AreEqual (testVals[0], m.Elements[0], 0.0001, "matrix.0");
+ Assert.AreEqual (testVals[1], m.Elements[1], 0.0001, "matrix.1");
+ Assert.AreEqual (testVals[2], m.Elements[2], 0.0001, "matrix.2");
+ Assert.AreEqual (testVals[3], m.Elements[3], 0.0001, "matrix.3");
+ Assert.AreEqual (testVals[4], m.Elements[4], 0.0001, "matrix.4");
+ Assert.AreEqual (testVals[5], m.Elements[5], 0.0001, "matrix.5");
+
+ Assert.AreEqual (testVals[6], rect.X, 0.0001, "rect.X");
+ Assert.AreEqual (testVals[7], rect.Y, 0.0001, "rect.Y");
+ Assert.AreEqual (testVals[8], rect.Width, 0.0001, "rect.Width");
+ Assert.AreEqual (testVals[9], rect.Height, 0.0001, "rect.Height");
+ }
+
+ private void CheckMatrixForScalableAngle (RectangleF rect, float angle, float[] testVals)
+ {
+ Matrix m;
+
+ using (LinearGradientBrush b = new LinearGradientBrush (rect, Color.Firebrick, Color.Lavender, angle, true)) {
+ m = b.Transform;
+ }
+
+ Assert.AreEqual (testVals[0], m.Elements[0], 0.0001, "matrix.0");
+ Assert.AreEqual (testVals[1], m.Elements[1], 0.0001, "matrix.1");
+ Assert.AreEqual (testVals[2], m.Elements[2], 0.0001, "matrix.2");
+ Assert.AreEqual (testVals[3], m.Elements[3], 0.0001, "matrix.3");
+ Assert.AreEqual (testVals[4], m.Elements[4], 0.0001, "matrix.4");
+ Assert.AreEqual (testVals[5], m.Elements[5], 0.0001, "matrix.5");
+ }
+
[Test]
public void Constructor_Point_Point_Color_Color ()
{
// can't set WrapMode.Clamp
}
+ [Test]
+ public void Constructor_Point_Point_Color_Color_1 ()
+ {
+ PointF pt1 = new Point (100, 200);
+ PointF pt2 = new Point (200, 200);
+ CheckMatrixAndRect (pt1, pt2, new float[] { 1, 0, 0, 1, 0, 0, 100, 150, 100, 100 });
+
+ pt1 = new Point (100, 200);
+ pt2 = new Point (0, 200);
+ CheckMatrixAndRect (pt1, pt2, new float[] { -1, 0, 0, -1, 100, 400, 0, 150, 100, 100 });
+
+ pt1 = new Point (100, 200);
+ pt2 = new Point (100, 300);
+ CheckMatrixAndRect (pt1, pt2, new float[] { 0, 1, -1, 0, 350, 150, 50, 200, 100, 100 });
+
+ pt1 = new Point (100, 200);
+ pt2 = new Point (100, 100);
+ CheckMatrixAndRect (pt1, pt2, new float[] { 0, -1, 1, 0, -50, 250, 50, 100, 100, 100 });
+
+ pt1 = new Point (100, 100);
+ pt2 = new Point (150, 225);
+ CheckMatrixAndRect (pt1, pt2, new float[] { 1, 2.5f, -0.6896552f, 0.2758622f, 112.069f, -194.8276f, 100, 100, 50, 125 });
+
+ pt1 = new Point (100, 100);
+ pt2 = new Point (55, 200);
+ CheckMatrixAndRect (pt1, pt2, new float[] { -1, 2.222222f, -0.7484408f, -0.3367983f, 267.2661f, 28.29753f, 55, 100, 45, 100 });
+
+ pt1 = new Point (100, 100);
+ pt2 = new Point (150, 60);
+ CheckMatrixAndRect (pt1, pt2, new float[] { 1, -0.8000001f, 0.9756095f, 1.219512f, -78.04876f, 82.43903f, 100, 60, 50, 40 });
+
+ pt1 = new Point (100, 100);
+ pt2 = new Point (27, 59);
+ CheckMatrixAndRect (pt1, pt2, new float[] { -1, -0.5616435f, 0.8539224f, -1.520399f, 59.11317f, 236.0361f, 27, 59, 73, 41 });
+ }
+
[Test]
public void Constructor_RectangleF_Color_Color_Single_0 ()
{
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
+ public void Constructor_Rectangle_InvalidWidthHeight ()
+ {
+ var emptyWidth = new Rectangle (0, 0, 0, 1);
+ var emptyHeight = new Rectangle (0, 0, 0, 1);
+
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyWidth, Color.Empty, Color.Empty, 1));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyHeight, Color.Empty, Color.Empty, 1));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyWidth, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyHeight, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
+ }
+
+ [Test]
+ public void Constructor_RectangleF_InvalidWidthHeight ()
+ {
+ var emptyWidth = new RectangleF (0, 0, 0, 1);
+ var emptyHeight = new RectangleF (0, 0, 0, 1);
+
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyWidth, Color.Empty, Color.Empty, 1));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyHeight, Color.Empty, Color.Empty, 1));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyWidth, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
+ Assert.Throws<ArgumentException>(() => new LinearGradientBrush (emptyHeight, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
+ }
+
+ [Test]
+ public void Constructor_LinearGradientMode_InvalidMode ()
+ {
+ var rect = new Rectangle (0, 0, 1, 1);
+ var rectf = new RectangleF (0, 0, 1, 1);
+
+ Assert.Throws<InvalidEnumArgumentException>(() => new LinearGradientBrush (rect, Color.Empty, Color.Empty, LinearGradientMode.Horizontal - 1));
+ Assert.Throws<InvalidEnumArgumentException>(() => new LinearGradientBrush (rectf, Color.Empty, Color.Empty, LinearGradientMode.Horizontal - 1));
+ Assert.Throws<InvalidEnumArgumentException>(() => new LinearGradientBrush (rect, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal + 1));
+ Assert.Throws<InvalidEnumArgumentException>(() => new LinearGradientBrush (rectf, Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal + 1));
+ }
+
+ [Test]
public void InterpolationColors_Colors_InvalidBlend ()
{
// default Blend doesn't allow getting this property
- Assert.IsNotNull (default_brush.InterpolationColors.Colors);
+ Assert.Throws<ArgumentException> (() => { var x = default_brush.InterpolationColors.Colors; });
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void InterpolationColors_Positions_InvalidBlend ()
{
// default Blend doesn't allow getting this property
- Assert.IsNotNull (default_brush.InterpolationColors.Positions);
+ Assert.Throws<ArgumentException> (() => { var x = default_brush.InterpolationColors.Positions; });
}
[Test]
- [ExpectedException (typeof (IndexOutOfRangeException))]
public void LinearColors_Empty ()
{
- default_brush.LinearColors = new Color[0];
+ Assert.Throws<IndexOutOfRangeException> (() => default_brush.LinearColors = new Color[0]);
}
[Test]
- [ExpectedException (typeof (IndexOutOfRangeException))]
public void LinearColors_One ()
{
- default_brush.LinearColors = new Color[1];
+ Assert.Throws<IndexOutOfRangeException> (() => default_brush.LinearColors = new Color[1]);
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentNullException))]
public void Transform_Null ()
{
- default_brush.Transform = null;
+ Assert.Throws<ArgumentNullException> (() => default_brush.Transform = null);
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void Transform_NonInvertible ()
{
- default_brush.Transform = new Matrix (123, 24, 82, 16, 47, 30);
+ Assert.Throws<ArgumentException> (() => default_brush.Transform = new Matrix (123, 24, 82, 16, 47, 30));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void WrapMode_Clamp ()
{
- default_brush.WrapMode = WrapMode.Clamp;
+ Assert.Throws<ArgumentException> (() => default_brush.WrapMode = WrapMode.Clamp);
}
[Test]
- [ExpectedException (typeof (InvalidEnumArgumentException))]
public void WrapMode_Invalid ()
{
- default_brush.WrapMode = (WrapMode) Int32.MinValue;
+ Assert.Throws<InvalidEnumArgumentException> (() => default_brush.WrapMode = (WrapMode) Int32.MinValue);
}
}
[Test]
- [ExpectedException (typeof (ArgumentNullException))]
public void MultiplyTransform1_Null ()
{
- default_brush.MultiplyTransform (null);
+ Assert.Throws<ArgumentNullException> (() => default_brush.MultiplyTransform (null));
}
[Test]
- [ExpectedException (typeof (ArgumentNullException))]
public void MultiplyTransform2_Null ()
{
- default_brush.MultiplyTransform (null, MatrixOrder.Append);
+ Assert.Throws<ArgumentNullException> (() => default_brush.MultiplyTransform (null, MatrixOrder.Append));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void MultiplyTransform_NonInvertible ()
{
Matrix noninvertible = new Matrix (123, 24, 82, 16, 47, 30);
- default_brush.MultiplyTransform (noninvertible);
+ Assert.Throws<ArgumentException> (() => default_brush.MultiplyTransform (noninvertible));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void RotateTransform_InvalidOrder ()
{
LinearGradientBrush lgb = new LinearGradientBrush (pt1, pt2, c1, c2);
- lgb.RotateTransform (720, (MatrixOrder) Int32.MinValue);
+ Assert.Throws<ArgumentException> (() => lgb.RotateTransform (720, (MatrixOrder) Int32.MinValue));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void ScaleTransform_InvalidOrder ()
{
LinearGradientBrush lgb = new LinearGradientBrush (pt1, pt2, c1, c2);
- lgb.ScaleTransform (1, 1, (MatrixOrder) Int32.MinValue);
+ Assert.Throws<ArgumentException> (() => lgb.ScaleTransform (1, 1, (MatrixOrder) Int32.MinValue));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetBlendTriangularShape_FocusTooSmall ()
{
- default_brush.SetBlendTriangularShape (-1);
+ Assert.Throws<ArgumentException> (() => default_brush.SetBlendTriangularShape (-1));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetBlendTriangularShape_FocusTooBig ()
{
- default_brush.SetBlendTriangularShape (1.01f);
+ Assert.Throws<ArgumentException> (() => default_brush.SetBlendTriangularShape (1.01f));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetBlendTriangularShape_ScaleTooSmall ()
{
- default_brush.SetBlendTriangularShape (1, -1);
+ Assert.Throws<ArgumentException> (() => default_brush.SetBlendTriangularShape (1, -1));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetBlendTriangularShape_ScaleTooBig ()
{
- default_brush.SetBlendTriangularShape (1, 1.01f);
+ Assert.Throws<ArgumentException> (() => default_brush.SetBlendTriangularShape (1, 1.01f));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetSigmaBellShape_FocusTooSmall ()
{
- default_brush.SetSigmaBellShape (-1);
+ Assert.Throws<ArgumentException> (() => default_brush.SetSigmaBellShape (-1));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetSigmaBellShape_FocusTooBig ()
{
- default_brush.SetSigmaBellShape (1.01f);
+ Assert.Throws<ArgumentException> (() => default_brush.SetSigmaBellShape (1.01f));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetSigmaBellShape_ScaleTooSmall ()
{
- default_brush.SetSigmaBellShape (1, -1);
+ Assert.Throws<ArgumentException> (() => default_brush.SetSigmaBellShape (1, -1));
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void SetSigmaBellShape_ScaleTooBig ()
{
- default_brush.SetSigmaBellShape (1, 1.01f);
+ Assert.Throws<ArgumentException> (() => default_brush.SetSigmaBellShape (1, 1.01f));
}
[Test]
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void TranslateTransform_InvalidOrder ()
{
LinearGradientBrush lgb = new LinearGradientBrush (pt1, pt2, c1, c2);
- lgb.TranslateTransform (1, 1, (MatrixOrder) Int32.MinValue);
+ Assert.Throws<ArgumentException> (() => lgb.TranslateTransform (1, 1, (MatrixOrder) Int32.MinValue));
}
[Test]
lgb.ResetTransform ();
Assert.AreEqual (lgb.Transform, clone, "Reset");
}
+
+ [Test]
+ public void Constructor_Rectangle_Angle_Scalable ()
+ {
+ CheckMatrixForScalableAngle (new RectangleF (0, 0, 10, 10), 15, new float[] { 1.183013f, 0.3169873f, -0.3169873f, 1.183012f, 0.6698728f, -2.5f });
+
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 15, new float[] { 1.183012f, 0.176104f, -0.5705772f, 1.183012f, 34.77311f, -28.76387f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 75, new float[] { 0.3169872f, 0.6572293f, -2.129423f, 0.3169873f, 232.2269f, 8.763878f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 95, new float[] { -0.09442029f, 0.599571f, -1.942611f, -0.09442017f, 247.2034f, 48.05788f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 150, new float[] { -1.183013f, 0.3794515f, -1.229423f, -1.183013f, 268.2269f, 157.0972f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 215, new float[] { -1.140856f, -0.4437979f, 1.437905f, -1.140856f, 38.34229f, 215.2576f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 50), 300, new float[] { 0.6830127f, -0.6572294f, 2.129422f, 0.6830124f, -157.2269f, 76.23613f });
+
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 15, new float[] { 1.183012f, 0.5283121f, -0.1901924f, 1.183012f, 11.95002f, -64.33012f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 75, new float[] { 0.3169872f, 1.971688f, -0.7098077f, 0.3169872f, 147.05f, -55.66987f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 95, new float[] { -0.09442029f, 1.798713f, -0.6475369f, -0.09442022f, 169.499f, 12.84323f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 150, new float[] { -1.183013f, 1.138354f, -0.4098077f, -1.183013f, 219.05f, 209.3301f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 215, new float[] { -1.140856f, -1.331394f, 0.4793016f, -1.140856f, 95.85849f, 388.8701f });
+ CheckMatrixForScalableAngle (new RectangleF (30, 60, 90, 150), 300, new float[] { 0.6830127f, -1.971688f, 0.7098075f, 0.6830125f, -72.04998f, 190.6699f });
+ }
+
+ [Test]
+ public void LinearColors_Null ()
+ {
+ Assert.Throws<NullReferenceException> (() => default_brush.LinearColors = null);
+ }
+
+ [Test]
+ public void InterpolationColors_Null ()
+ {
+ Assert.Throws<ArgumentException> (() => default_brush.InterpolationColors = null);
+ }
+
+ [Test]
+ public void Blend_Null ()
+ {
+ Assert.Throws<NullReferenceException> (() => default_brush.Blend = null);
+ }
+
+ [Test]
+ public void ZeroWidthRectangle ()
+ {
+ Rectangle r = new Rectangle (10, 10, 0, 10);
+ Assert.AreEqual (0, r.Width, "Width");
+ Assert.Throws<ArgumentException> (() => new LinearGradientBrush (r, Color.Red, Color.Blue, LinearGradientMode.Vertical));
+ }
+
+ [Test]
+ public void ZeroHeightRectangleF ()
+ {
+ RectangleF r = new RectangleF (10.0f, 10.0f, 10.0f, 0.0f);
+ Assert.AreEqual (0.0f, r.Height, "Height");
+ Assert.Throws<ArgumentException> (() => new LinearGradientBrush (r, Color.Red, Color.Blue, LinearGradientMode.Vertical));
+ }
}
}
projects / mono.git / blobdiff