You've already forked linux-packaging-mono
2198 lines
54 KiB
C#
2198 lines
54 KiB
C#
// Tests for System.Drawing.Pens.cs
|
|
//
|
|
// Author:
|
|
// Ravindra (rkumar@novell.com)
|
|
//
|
|
|
|
//
|
|
// Copyright (C) 2004 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
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Security.Permissions;
|
|
|
|
namespace MonoTests.System.Drawing
|
|
{
|
|
[TestFixture]
|
|
[SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
|
|
public class PensTest
|
|
{
|
|
[SetUp]
|
|
public void SetUp () { }
|
|
|
|
[TearDown]
|
|
public void TearDown () { }
|
|
|
|
[Test]
|
|
public void TestEquals ()
|
|
{
|
|
Pen pen1 = Pens.Blue;
|
|
Pen pen2 = Pens.Blue;
|
|
|
|
Assert.AreEqual (true, pen1.Equals (pen2), "Equals");
|
|
}
|
|
|
|
[Test]
|
|
public void TestAliceBlue ()
|
|
{
|
|
Pen pen = Pens.AliceBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P1#1");
|
|
Assert.AreEqual (pen.Color, Color.AliceBlue, "P1#2");
|
|
|
|
try {
|
|
pen.Color = Color.AliceBlue;
|
|
Assert.Fail ("P1#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P1#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestAntiqueWhite ()
|
|
{
|
|
Pen pen = Pens.AntiqueWhite;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P2#1");
|
|
Assert.AreEqual (pen.Color, Color.AntiqueWhite, "P2#2");
|
|
|
|
try {
|
|
pen.Color = Color.AntiqueWhite;
|
|
Assert.Fail ("P2#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P2#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestAqua ()
|
|
{
|
|
Pen pen = Pens.Aqua;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P3#1");
|
|
Assert.AreEqual (pen.Color, Color.Aqua, "P3#2");
|
|
|
|
try {
|
|
pen.Color = Color.Aqua;
|
|
Assert.Fail ("P3#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P3#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestAquamarine ()
|
|
{
|
|
Pen pen = Pens.Aquamarine;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P4#1");
|
|
Assert.AreEqual (pen.Color, Color.Aquamarine, "P4#2");
|
|
|
|
try {
|
|
pen.Color = Color.Aquamarine;
|
|
Assert.Fail ("P4#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P4#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestAzure ()
|
|
{
|
|
Pen pen = Pens.Azure;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P5#1");
|
|
Assert.AreEqual (pen.Color, Color.Azure, "P5#2");
|
|
|
|
try {
|
|
pen.Color = Color.Azure;
|
|
Assert.Fail ("P5#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P5#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBeige ()
|
|
{
|
|
Pen pen = Pens.Beige;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P6#1");
|
|
Assert.AreEqual (pen.Color, Color.Beige, "P6#2");
|
|
|
|
try {
|
|
pen.Color = Color.Beige;
|
|
Assert.Fail ("P6#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P6#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBisque ()
|
|
{
|
|
Pen pen = Pens.Bisque;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P7#1");
|
|
Assert.AreEqual (pen.Color, Color.Bisque, "P7#2");
|
|
|
|
try {
|
|
pen.Color = Color.Bisque;
|
|
Assert.Fail ("P7#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P7#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBlack ()
|
|
{
|
|
Pen pen = Pens.Black;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P8#1");
|
|
Assert.AreEqual (pen.Color, Color.Black, "P8#2");
|
|
|
|
try {
|
|
pen.Color = Color.Black;
|
|
Assert.Fail ("P8#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P8#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBlanchedAlmond ()
|
|
{
|
|
Pen pen = Pens.BlanchedAlmond;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P9#1");
|
|
Assert.AreEqual (pen.Color, Color.BlanchedAlmond, "P9#2");
|
|
|
|
try {
|
|
pen.Color = Color.BlanchedAlmond;
|
|
Assert.Fail ("P9#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P9#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBlue ()
|
|
{
|
|
Pen pen = Pens.Blue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P10#1");
|
|
Assert.AreEqual (pen.Color, Color.Blue, "P10#2");
|
|
|
|
try {
|
|
pen.Color = Color.Blue;
|
|
Assert.Fail ("P10#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P10#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBlueViolet ()
|
|
{
|
|
Pen pen = Pens.BlueViolet;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P11#1");
|
|
Assert.AreEqual (pen.Color, Color.BlueViolet, "P11#2");
|
|
|
|
try {
|
|
pen.Color = Color.BlueViolet;
|
|
Assert.Fail ("P11#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P11#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBrown ()
|
|
{
|
|
Pen pen = Pens.Brown;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P12#1");
|
|
Assert.AreEqual (pen.Color, Color.Brown, "P12#2");
|
|
|
|
try {
|
|
pen.Color = Color.Brown;
|
|
Assert.Fail ("P12#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P12#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBurlyWood ()
|
|
{
|
|
Pen pen = Pens.BurlyWood;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P13#1");
|
|
Assert.AreEqual (pen.Color, Color.BurlyWood, "P13#2");
|
|
|
|
try {
|
|
pen.Color = Color.BurlyWood;
|
|
Assert.Fail ("P13#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P13#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCadetBlue ()
|
|
{
|
|
Pen pen = Pens.CadetBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P14#1");
|
|
Assert.AreEqual (pen.Color, Color.CadetBlue, "P14#2");
|
|
|
|
try {
|
|
pen.Color = Color.CadetBlue;
|
|
Assert.Fail ("P14#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P14#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestChartreuse ()
|
|
{
|
|
Pen pen = Pens.Chartreuse;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P15#1");
|
|
Assert.AreEqual (pen.Color, Color.Chartreuse, "P15#2");
|
|
|
|
try {
|
|
pen.Color = Color.Chartreuse;
|
|
Assert.Fail ("P15#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P15#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestChocolate ()
|
|
{
|
|
Pen pen = Pens.Chocolate;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P16#1");
|
|
Assert.AreEqual (pen.Color, Color.Chocolate, "P16#2");
|
|
|
|
try {
|
|
pen.Color = Color.Chocolate;
|
|
Assert.Fail ("P16#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P16#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCoral ()
|
|
{
|
|
Pen pen = Pens.Coral;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P17#1");
|
|
Assert.AreEqual (pen.Color, Color.Coral, "P17#2");
|
|
|
|
try {
|
|
pen.Color = Color.Coral;
|
|
Assert.Fail ("P17#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P17#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCornflowerBlue ()
|
|
{
|
|
Pen pen = Pens.CornflowerBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P18#1");
|
|
Assert.AreEqual (pen.Color, Color.CornflowerBlue, "P18#2");
|
|
|
|
try {
|
|
pen.Color = Color.CornflowerBlue;
|
|
Assert.Fail ("P18#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P18#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCornsilk ()
|
|
{
|
|
Pen pen = Pens.Cornsilk;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P19#1");
|
|
Assert.AreEqual (pen.Color, Color.Cornsilk, "P19#2");
|
|
|
|
try {
|
|
pen.Color = Color.Cornsilk;
|
|
Assert.Fail ("P19#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P19#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCrimson ()
|
|
{
|
|
Pen pen = Pens.Crimson;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P20#1");
|
|
Assert.AreEqual (pen.Color, Color.Crimson, "P20#2");
|
|
|
|
try {
|
|
pen.Color = Color.Crimson;
|
|
Assert.Fail ("P20#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P20#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCyan ()
|
|
{
|
|
Pen pen = Pens.Cyan;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P21#1");
|
|
Assert.AreEqual (pen.Color, Color.Cyan, "P21#2");
|
|
|
|
try {
|
|
pen.Color = Color.Cyan;
|
|
Assert.Fail ("P21#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P21#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkBlue ()
|
|
{
|
|
Pen pen = Pens.DarkBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P22#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkBlue, "P22#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkBlue;
|
|
Assert.Fail ("P22#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P22#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkCyan ()
|
|
{
|
|
Pen pen = Pens.DarkCyan;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P23#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkCyan, "P23#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkCyan;
|
|
Assert.Fail ("P23#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P23#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkGoldenrod ()
|
|
{
|
|
Pen pen = Pens.DarkGoldenrod;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P24#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkGoldenrod, "P24#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkGoldenrod;
|
|
Assert.Fail ("P24#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P24#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkGray ()
|
|
{
|
|
Pen pen = Pens.DarkGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P25#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkGray, "P25#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkGray;
|
|
Assert.Fail ("P25#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P25#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkGreen ()
|
|
{
|
|
Pen pen = Pens.DarkGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P26#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkGreen, "P26#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkGreen;
|
|
Assert.Fail ("P26#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P26#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkKhaki ()
|
|
{
|
|
Pen pen = Pens.DarkKhaki;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P27#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkKhaki, "P27#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkKhaki;
|
|
Assert.Fail ("P27#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P27#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkMagenta ()
|
|
{
|
|
Pen pen = Pens.DarkMagenta;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P28#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkMagenta, "P28#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkMagenta;
|
|
Assert.Fail ("P28#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P28#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkOliveGreen ()
|
|
{
|
|
Pen pen = Pens.DarkOliveGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P29#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkOliveGreen, "P29#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkOliveGreen;
|
|
Assert.Fail ("P29#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P29#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkOrange ()
|
|
{
|
|
Pen pen = Pens.DarkOrange;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P30#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkOrange, "P30#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkOrange;
|
|
Assert.Fail ("P30#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P30#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkOrchid ()
|
|
{
|
|
Pen pen = Pens.DarkOrchid;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P31#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkOrchid, "P31#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkOrchid;
|
|
Assert.Fail ("P31#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P31#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkRed ()
|
|
{
|
|
Pen pen = Pens.DarkRed;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P32#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkRed, "P32#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkRed;
|
|
Assert.Fail ("P32#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P32#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkSalmon ()
|
|
{
|
|
Pen pen = Pens.DarkSalmon;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P33#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkSalmon, "P33#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkSalmon;
|
|
Assert.Fail ("P33#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P33#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkSeaGreen ()
|
|
{
|
|
Pen pen = Pens.DarkSeaGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P34#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkSeaGreen, "P34#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkSeaGreen;
|
|
Assert.Fail ("P34#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P34#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkSlateBlue ()
|
|
{
|
|
Pen pen = Pens.DarkSlateBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P35#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkSlateBlue, "P35#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkSlateBlue;
|
|
Assert.Fail ("P35#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P35#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkSlateGray ()
|
|
{
|
|
Pen pen = Pens.DarkSlateGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P36#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkSlateGray, "P36#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkSlateGray;
|
|
Assert.Fail ("P36#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P36#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkTurquoise ()
|
|
{
|
|
Pen pen = Pens.DarkTurquoise;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P37#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkTurquoise, "P37#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkTurquoise;
|
|
Assert.Fail ("P37#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P37#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDarkViolet ()
|
|
{
|
|
Pen pen = Pens.DarkViolet;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P38#1");
|
|
Assert.AreEqual (pen.Color, Color.DarkViolet, "P38#2");
|
|
|
|
try {
|
|
pen.Color = Color.DarkViolet;
|
|
Assert.Fail ("P38#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P38#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDeepPink ()
|
|
{
|
|
Pen pen = Pens.DeepPink;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P39#1");
|
|
Assert.AreEqual (pen.Color, Color.DeepPink, "P39#2");
|
|
|
|
try {
|
|
pen.Color = Color.DeepPink;
|
|
Assert.Fail ("P39#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P39#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDeepSkyBlue ()
|
|
{
|
|
Pen pen = Pens.DeepSkyBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P40#1");
|
|
Assert.AreEqual (pen.Color, Color.DeepSkyBlue, "P40#2");
|
|
|
|
try {
|
|
pen.Color = Color.DeepSkyBlue;
|
|
Assert.Fail ("P40#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P40#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDimGray ()
|
|
{
|
|
Pen pen = Pens.DimGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P41#1");
|
|
Assert.AreEqual (pen.Color, Color.DimGray, "P41#2");
|
|
|
|
try {
|
|
pen.Color = Color.DimGray;
|
|
Assert.Fail ("P41#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P41#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestDodgerBlue ()
|
|
{
|
|
Pen pen = Pens.DodgerBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P42#1");
|
|
Assert.AreEqual (pen.Color, Color.DodgerBlue, "P42#2");
|
|
|
|
try {
|
|
pen.Color = Color.DodgerBlue;
|
|
Assert.Fail ("P42#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P42#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestFirebrick ()
|
|
{
|
|
Pen pen = Pens.Firebrick;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P43#1");
|
|
Assert.AreEqual (pen.Color, Color.Firebrick, "P43#2");
|
|
|
|
try {
|
|
pen.Color = Color.Firebrick;
|
|
Assert.Fail ("P43#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P43#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestFloralWhite ()
|
|
{
|
|
Pen pen = Pens.FloralWhite;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P44#1");
|
|
Assert.AreEqual (pen.Color, Color.FloralWhite, "P44#2");
|
|
|
|
try {
|
|
pen.Color = Color.FloralWhite;
|
|
Assert.Fail ("P44#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P44#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestForestGreen ()
|
|
{
|
|
Pen pen = Pens.ForestGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P45#1");
|
|
Assert.AreEqual (pen.Color, Color.ForestGreen, "P45#2");
|
|
|
|
try {
|
|
pen.Color = Color.ForestGreen;
|
|
Assert.Fail ("P45#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P45#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestFuchsia ()
|
|
{
|
|
Pen pen = Pens.Fuchsia;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P46#1");
|
|
Assert.AreEqual (pen.Color, Color.Fuchsia, "P46#2");
|
|
|
|
try {
|
|
pen.Color = Color.Fuchsia;
|
|
Assert.Fail ("P46#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P46#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGainsboro ()
|
|
{
|
|
Pen pen = Pens.Gainsboro;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P47#1");
|
|
Assert.AreEqual (pen.Color, Color.Gainsboro, "P47#2");
|
|
|
|
try {
|
|
pen.Color = Color.Gainsboro;
|
|
Assert.Fail ("P47#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P47#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGhostWhite ()
|
|
{
|
|
Pen pen = Pens.GhostWhite;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P48#1");
|
|
Assert.AreEqual (pen.Color, Color.GhostWhite, "P48#2");
|
|
|
|
try {
|
|
pen.Color = Color.GhostWhite;
|
|
Assert.Fail ("P48#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P48#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGold ()
|
|
{
|
|
Pen pen = Pens.Gold;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P49#1");
|
|
Assert.AreEqual (pen.Color, Color.Gold, "P49#2");
|
|
|
|
try {
|
|
pen.Color = Color.Gold;
|
|
Assert.Fail ("P49#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P49#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGoldenrod ()
|
|
{
|
|
Pen pen = Pens.Goldenrod;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P50#1");
|
|
Assert.AreEqual (pen.Color, Color.Goldenrod, "P50#2");
|
|
|
|
try {
|
|
pen.Color = Color.Goldenrod;
|
|
Assert.Fail ("P50#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P50#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGray ()
|
|
{
|
|
Pen pen = Pens.Gray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P51#1");
|
|
Assert.AreEqual (pen.Color, Color.Gray, "P51#2");
|
|
|
|
try {
|
|
pen.Color = Color.Gray;
|
|
Assert.Fail ("P51#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P51#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGreen ()
|
|
{
|
|
Pen pen = Pens.Green;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P52#1");
|
|
Assert.AreEqual (pen.Color, Color.Green, "P52#2");
|
|
|
|
try {
|
|
pen.Color = Color.Green;
|
|
Assert.Fail ("P52#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P52#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGreenYellow ()
|
|
{
|
|
Pen pen = Pens.GreenYellow;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P53#1");
|
|
Assert.AreEqual (pen.Color, Color.GreenYellow, "P53#2");
|
|
|
|
try {
|
|
pen.Color = Color.GreenYellow;
|
|
Assert.Fail ("P53#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P53#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestHoneydew ()
|
|
{
|
|
Pen pen = Pens.Honeydew;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P54#1");
|
|
Assert.AreEqual (pen.Color, Color.Honeydew, "P54#2");
|
|
|
|
try {
|
|
pen.Color = Color.Honeydew;
|
|
Assert.Fail ("P54#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P54#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestHotPink ()
|
|
{
|
|
Pen pen = Pens.HotPink;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P55#1");
|
|
Assert.AreEqual (pen.Color, Color.HotPink, "P55#2");
|
|
|
|
try {
|
|
pen.Color = Color.HotPink;
|
|
Assert.Fail ("P55#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P55#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestIndianRed ()
|
|
{
|
|
Pen pen = Pens.IndianRed;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P56#1");
|
|
Assert.AreEqual (pen.Color, Color.IndianRed, "P56#2");
|
|
|
|
try {
|
|
pen.Color = Color.IndianRed;
|
|
Assert.Fail ("P56#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P56#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestIndigo ()
|
|
{
|
|
Pen pen = Pens.Indigo;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P57#1");
|
|
Assert.AreEqual (pen.Color, Color.Indigo, "P57#2");
|
|
|
|
try {
|
|
pen.Color = Color.Indigo;
|
|
Assert.Fail ("P57#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P57#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestIvory ()
|
|
{
|
|
Pen pen = Pens.Ivory;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P58#1");
|
|
Assert.AreEqual (pen.Color, Color.Ivory, "P58#2");
|
|
|
|
try {
|
|
pen.Color = Color.Ivory;
|
|
Assert.Fail ("P58#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P58#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestKhaki ()
|
|
{
|
|
Pen pen = Pens.Khaki;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P59#1");
|
|
Assert.AreEqual (pen.Color, Color.Khaki, "P59#2");
|
|
|
|
try {
|
|
pen.Color = Color.Khaki;
|
|
Assert.Fail ("P59#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P59#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLavender ()
|
|
{
|
|
Pen pen = Pens.Lavender;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P60#1");
|
|
Assert.AreEqual (pen.Color, Color.Lavender, "P60#2");
|
|
|
|
try {
|
|
pen.Color = Color.Lavender;
|
|
Assert.Fail ("P60#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P60#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLavenderBlush ()
|
|
{
|
|
Pen pen = Pens.LavenderBlush;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P61#1");
|
|
Assert.AreEqual (pen.Color, Color.LavenderBlush, "P61#2");
|
|
|
|
try {
|
|
pen.Color = Color.LavenderBlush;
|
|
Assert.Fail ("P61#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P61#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLawnGreen ()
|
|
{
|
|
Pen pen = Pens.LawnGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P62#1");
|
|
Assert.AreEqual (pen.Color, Color.LawnGreen, "P62#2");
|
|
|
|
try {
|
|
pen.Color = Color.LawnGreen;
|
|
Assert.Fail ("P62#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P62#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLemonChiffon ()
|
|
{
|
|
Pen pen = Pens.LemonChiffon;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P63#1");
|
|
Assert.AreEqual (pen.Color, Color.LemonChiffon, "P63#2");
|
|
|
|
try {
|
|
pen.Color = Color.LemonChiffon;
|
|
Assert.Fail ("P63#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P63#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightBlue ()
|
|
{
|
|
Pen pen = Pens.LightBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P64#1");
|
|
Assert.AreEqual (pen.Color, Color.LightBlue, "P64#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightBlue;
|
|
Assert.Fail ("P64#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P64#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightCoral ()
|
|
{
|
|
Pen pen = Pens.LightCoral;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P65#1");
|
|
Assert.AreEqual (pen.Color, Color.LightCoral, "P65#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightCoral;
|
|
Assert.Fail ("P65#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P65#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightCyan ()
|
|
{
|
|
Pen pen = Pens.LightCyan;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P66#1");
|
|
Assert.AreEqual (pen.Color, Color.LightCyan, "P66#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightCyan;
|
|
Assert.Fail ("P66#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P66#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightGoldenrodYellow ()
|
|
{
|
|
Pen pen = Pens.LightGoldenrodYellow;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P67#1");
|
|
Assert.AreEqual (pen.Color, Color.LightGoldenrodYellow, "P67#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightGoldenrodYellow;
|
|
Assert.Fail ("P67#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P67#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightGray ()
|
|
{
|
|
Pen pen = Pens.LightGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P68#1");
|
|
Assert.AreEqual (pen.Color, Color.LightGray, "P68#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightGray;
|
|
Assert.Fail ("P68#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P68#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightGreen ()
|
|
{
|
|
Pen pen = Pens.LightGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P69#1");
|
|
Assert.AreEqual (pen.Color, Color.LightGreen, "P69#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightGreen;
|
|
Assert.Fail ("P69#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P69#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightPink ()
|
|
{
|
|
Pen pen = Pens.LightPink;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P70#1");
|
|
Assert.AreEqual (pen.Color, Color.LightPink, "P70#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightPink;
|
|
Assert.Fail ("P70#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P70#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightSalmon ()
|
|
{
|
|
Pen pen = Pens.LightSalmon;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P71#1");
|
|
Assert.AreEqual (pen.Color, Color.LightSalmon, "P71#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightSalmon;
|
|
Assert.Fail ("P71#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P71#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightSeaGreen ()
|
|
{
|
|
Pen pen = Pens.LightSeaGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P72#1");
|
|
Assert.AreEqual (pen.Color, Color.LightSeaGreen, "P72#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightSeaGreen;
|
|
Assert.Fail ("P72#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P72#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightSkyBlue ()
|
|
{
|
|
Pen pen = Pens.LightSkyBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P73#1");
|
|
Assert.AreEqual (pen.Color, Color.LightSkyBlue, "P73#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightSkyBlue;
|
|
Assert.Fail ("P73#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P73#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightSlateGray ()
|
|
{
|
|
Pen pen = Pens.LightSlateGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P74#1");
|
|
Assert.AreEqual (pen.Color, Color.LightSlateGray, "P74#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightSlateGray;
|
|
Assert.Fail ("P74#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P74#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightSteelBlue ()
|
|
{
|
|
Pen pen = Pens.LightSteelBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P75#1");
|
|
Assert.AreEqual (pen.Color, Color.LightSteelBlue, "P75#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightSteelBlue;
|
|
Assert.Fail ("P75#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P75#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLightYellow ()
|
|
{
|
|
Pen pen = Pens.LightYellow;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P76#1");
|
|
Assert.AreEqual (pen.Color, Color.LightYellow, "P76#2");
|
|
|
|
try {
|
|
pen.Color = Color.LightYellow;
|
|
Assert.Fail ("P76#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P76#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLime ()
|
|
{
|
|
Pen pen = Pens.Lime;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P77#1");
|
|
Assert.AreEqual (pen.Color, Color.Lime, "P77#2");
|
|
|
|
try {
|
|
pen.Color = Color.Lime;
|
|
Assert.Fail ("P77#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P77#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLimeGreen ()
|
|
{
|
|
Pen pen = Pens.LimeGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P78#1");
|
|
Assert.AreEqual (pen.Color, Color.LimeGreen, "P78#2");
|
|
|
|
try {
|
|
pen.Color = Color.LimeGreen;
|
|
Assert.Fail ("P78#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P78#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestLinen ()
|
|
{
|
|
Pen pen = Pens.Linen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P79#1");
|
|
Assert.AreEqual (pen.Color, Color.Linen, "P79#2");
|
|
|
|
try {
|
|
pen.Color = Color.Linen;
|
|
Assert.Fail ("P79#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P79#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMagenta ()
|
|
{
|
|
Pen pen = Pens.Magenta;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P80#1");
|
|
Assert.AreEqual (pen.Color, Color.Magenta, "P80#2");
|
|
|
|
try {
|
|
pen.Color = Color.Magenta;
|
|
Assert.Fail ("P80#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P80#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMaroon ()
|
|
{
|
|
Pen pen = Pens.Maroon;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P81#1");
|
|
Assert.AreEqual (pen.Color, Color.Maroon, "P81#2");
|
|
|
|
try {
|
|
pen.Color = Color.Maroon;
|
|
Assert.Fail ("P81#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P81#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumAquamarine ()
|
|
{
|
|
Pen pen = Pens.MediumAquamarine;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P82#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumAquamarine, "P82#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumAquamarine;
|
|
Assert.Fail ("P82#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P82#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumBlue ()
|
|
{
|
|
Pen pen = Pens.MediumBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P83#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumBlue, "P83#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumBlue;
|
|
Assert.Fail ("P83#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P83#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumOrchid ()
|
|
{
|
|
Pen pen = Pens.MediumOrchid;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P84#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumOrchid, "P84#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumOrchid;
|
|
Assert.Fail ("P84#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P84#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumPurple ()
|
|
{
|
|
Pen pen = Pens.MediumPurple;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P85#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumPurple, "P85#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumPurple;
|
|
Assert.Fail ("P85#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P85#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumSeaGreen ()
|
|
{
|
|
Pen pen = Pens.MediumSeaGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P86#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumSeaGreen, "P86#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumSeaGreen;
|
|
Assert.Fail ("P86#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P86#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumSlateBlue ()
|
|
{
|
|
Pen pen = Pens.MediumSlateBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P87#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumSlateBlue, "P87#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumSlateBlue;
|
|
Assert.Fail ("P87#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P87#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumSpringGreen ()
|
|
{
|
|
Pen pen = Pens.MediumSpringGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P88#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumSpringGreen, "P88#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumSpringGreen;
|
|
Assert.Fail ("P88#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P88#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumTurquoise ()
|
|
{
|
|
Pen pen = Pens.MediumTurquoise;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P89#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumTurquoise, "P89#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumTurquoise;
|
|
Assert.Fail ("P89#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P89#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMediumVioletRed ()
|
|
{
|
|
Pen pen = Pens.MediumVioletRed;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P90#1");
|
|
Assert.AreEqual (pen.Color, Color.MediumVioletRed, "P90#2");
|
|
|
|
try {
|
|
pen.Color = Color.MediumVioletRed;
|
|
Assert.Fail ("P90#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P90#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMidnightBlue ()
|
|
{
|
|
Pen pen = Pens.MidnightBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P91#1");
|
|
Assert.AreEqual (pen.Color, Color.MidnightBlue, "P91#2");
|
|
|
|
try {
|
|
pen.Color = Color.MidnightBlue;
|
|
Assert.Fail ("P91#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P91#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMintCream ()
|
|
{
|
|
Pen pen = Pens.MintCream;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P92#1");
|
|
Assert.AreEqual (pen.Color, Color.MintCream, "P92#2");
|
|
|
|
try {
|
|
pen.Color = Color.MintCream;
|
|
Assert.Fail ("P92#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P92#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMistyRose ()
|
|
{
|
|
Pen pen = Pens.MistyRose;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P93#1");
|
|
Assert.AreEqual (pen.Color, Color.MistyRose, "P93#2");
|
|
|
|
try {
|
|
pen.Color = Color.MistyRose;
|
|
Assert.Fail ("P93#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P93#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMoccasin ()
|
|
{
|
|
Pen pen = Pens.Moccasin;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P94#1");
|
|
Assert.AreEqual (pen.Color, Color.Moccasin, "P94#2");
|
|
|
|
try {
|
|
pen.Color = Color.Moccasin;
|
|
Assert.Fail ("P94#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P94#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestNavajoWhite ()
|
|
{
|
|
Pen pen = Pens.NavajoWhite;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P95#1");
|
|
Assert.AreEqual (pen.Color, Color.NavajoWhite, "P95#2");
|
|
|
|
try {
|
|
pen.Color = Color.NavajoWhite;
|
|
Assert.Fail ("P95#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P95#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestNavy ()
|
|
{
|
|
Pen pen = Pens.Navy;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P96#1");
|
|
Assert.AreEqual (pen.Color, Color.Navy, "P96#2");
|
|
|
|
try {
|
|
pen.Color = Color.Navy;
|
|
Assert.Fail ("P96#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P96#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOldLace ()
|
|
{
|
|
Pen pen = Pens.OldLace;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P97#1");
|
|
Assert.AreEqual (pen.Color, Color.OldLace, "P97#2");
|
|
|
|
try {
|
|
pen.Color = Color.OldLace;
|
|
Assert.Fail ("P97#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P97#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOlive ()
|
|
{
|
|
Pen pen = Pens.Olive;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P98#1");
|
|
Assert.AreEqual (pen.Color, Color.Olive, "P98#2");
|
|
|
|
try {
|
|
pen.Color = Color.Olive;
|
|
Assert.Fail ("P98#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P98#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOliveDrab ()
|
|
{
|
|
Pen pen = Pens.OliveDrab;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P99#1");
|
|
Assert.AreEqual (pen.Color, Color.OliveDrab, "P99#2");
|
|
|
|
try {
|
|
pen.Color = Color.OliveDrab;
|
|
Assert.Fail ("P99#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P99#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOrange ()
|
|
{
|
|
Pen pen = Pens.Orange;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P100#1");
|
|
Assert.AreEqual (pen.Color, Color.Orange, "P100#2");
|
|
|
|
try {
|
|
pen.Color = Color.Orange;
|
|
Assert.Fail ("P100#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P100#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOrangeRed ()
|
|
{
|
|
Pen pen = Pens.OrangeRed;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P101#1");
|
|
Assert.AreEqual (pen.Color, Color.OrangeRed, "P101#2");
|
|
|
|
try {
|
|
pen.Color = Color.OrangeRed;
|
|
Assert.Fail ("P101#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P101#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestOrchid ()
|
|
{
|
|
Pen pen = Pens.Orchid;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P102#1");
|
|
Assert.AreEqual (pen.Color, Color.Orchid, "P102#2");
|
|
|
|
try {
|
|
pen.Color = Color.Orchid;
|
|
Assert.Fail ("P102#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P102#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPaleGoldenrod ()
|
|
{
|
|
Pen pen = Pens.PaleGoldenrod;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P103#1");
|
|
Assert.AreEqual (pen.Color, Color.PaleGoldenrod, "P103#2");
|
|
|
|
try {
|
|
pen.Color = Color.PaleGoldenrod;
|
|
Assert.Fail ("P103#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P103#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPaleGreen ()
|
|
{
|
|
Pen pen = Pens.PaleGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P104#1");
|
|
Assert.AreEqual (pen.Color, Color.PaleGreen, "P104#2");
|
|
|
|
try {
|
|
pen.Color = Color.PaleGreen;
|
|
Assert.Fail ("P104#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P104#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPaleTurquoise ()
|
|
{
|
|
Pen pen = Pens.PaleTurquoise;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P105#1");
|
|
Assert.AreEqual (pen.Color, Color.PaleTurquoise, "P105#2");
|
|
|
|
try {
|
|
pen.Color = Color.PaleTurquoise;
|
|
Assert.Fail ("P105#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P105#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPaleVioletRed ()
|
|
{
|
|
Pen pen = Pens.PaleVioletRed;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P106#1");
|
|
Assert.AreEqual (pen.Color, Color.PaleVioletRed, "P106#2");
|
|
|
|
try {
|
|
pen.Color = Color.PaleVioletRed;
|
|
Assert.Fail ("P106#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P106#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPapayaWhip ()
|
|
{
|
|
Pen pen = Pens.PapayaWhip;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P107#1");
|
|
Assert.AreEqual (pen.Color, Color.PapayaWhip, "P107#2");
|
|
|
|
try {
|
|
pen.Color = Color.PapayaWhip;
|
|
Assert.Fail ("P107#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P107#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPeachPuff ()
|
|
{
|
|
Pen pen = Pens.PeachPuff;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P108#1");
|
|
Assert.AreEqual (pen.Color, Color.PeachPuff, "P108#2");
|
|
|
|
try {
|
|
pen.Color = Color.PeachPuff;
|
|
Assert.Fail ("P108#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P108#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPeru ()
|
|
{
|
|
Pen pen = Pens.Peru;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P109#1");
|
|
Assert.AreEqual (pen.Color, Color.Peru, "P109#2");
|
|
|
|
try {
|
|
pen.Color = Color.Peru;
|
|
Assert.Fail ("P109#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P109#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPink ()
|
|
{
|
|
Pen pen = Pens.Pink;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P110#1");
|
|
Assert.AreEqual (pen.Color, Color.Pink, "P110#2");
|
|
|
|
try {
|
|
pen.Color = Color.Pink;
|
|
Assert.Fail ("P110#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P110#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPlum ()
|
|
{
|
|
Pen pen = Pens.Plum;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P111#1");
|
|
Assert.AreEqual (pen.Color, Color.Plum, "P111#2");
|
|
|
|
try {
|
|
pen.Color = Color.Plum;
|
|
Assert.Fail ("P111#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P111#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPowderBlue ()
|
|
{
|
|
Pen pen = Pens.PowderBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P112#1");
|
|
Assert.AreEqual (pen.Color, Color.PowderBlue, "P112#2");
|
|
|
|
try {
|
|
pen.Color = Color.PowderBlue;
|
|
Assert.Fail ("P112#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P112#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPurple ()
|
|
{
|
|
Pen pen = Pens.Purple;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P113#1");
|
|
Assert.AreEqual (pen.Color, Color.Purple, "P113#2");
|
|
|
|
try {
|
|
pen.Color = Color.Purple;
|
|
Assert.Fail ("P113#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P113#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestRed ()
|
|
{
|
|
Pen pen = Pens.Red;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P114#1");
|
|
Assert.AreEqual (pen.Color, Color.Red, "P114#2");
|
|
|
|
try {
|
|
pen.Color = Color.Red;
|
|
Assert.Fail ("P114#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P114#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestRosyBrown ()
|
|
{
|
|
Pen pen = Pens.RosyBrown;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P115#1");
|
|
Assert.AreEqual (pen.Color, Color.RosyBrown, "P115#2");
|
|
|
|
try {
|
|
pen.Color = Color.RosyBrown;
|
|
Assert.Fail ("P115#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P115#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestRoyalBlue ()
|
|
{
|
|
Pen pen = Pens.RoyalBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P116#1");
|
|
Assert.AreEqual (pen.Color, Color.RoyalBlue, "P116#2");
|
|
|
|
try {
|
|
pen.Color = Color.RoyalBlue;
|
|
Assert.Fail ("P116#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P116#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSaddleBrown ()
|
|
{
|
|
Pen pen = Pens.SaddleBrown;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P117#1");
|
|
Assert.AreEqual (pen.Color, Color.SaddleBrown, "P117#2");
|
|
|
|
try {
|
|
pen.Color = Color.SaddleBrown;
|
|
Assert.Fail ("P117#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P117#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSalmon ()
|
|
{
|
|
Pen pen = Pens.Salmon;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P118#1");
|
|
Assert.AreEqual (pen.Color, Color.Salmon, "P118#2");
|
|
|
|
try {
|
|
pen.Color = Color.Salmon;
|
|
Assert.Fail ("P118#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P118#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSandyBrown ()
|
|
{
|
|
Pen pen = Pens.SandyBrown;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P119#1");
|
|
Assert.AreEqual (pen.Color, Color.SandyBrown, "P119#2");
|
|
|
|
try {
|
|
pen.Color = Color.SandyBrown;
|
|
Assert.Fail ("P119#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P119#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSeaGreen ()
|
|
{
|
|
Pen pen = Pens.SeaGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P120#1");
|
|
Assert.AreEqual (pen.Color, Color.SeaGreen, "P120#2");
|
|
|
|
try {
|
|
pen.Color = Color.SeaGreen;
|
|
Assert.Fail ("P120#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P120#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSeaShell ()
|
|
{
|
|
Pen pen = Pens.SeaShell;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P121#1");
|
|
Assert.AreEqual (pen.Color, Color.SeaShell, "P121#2");
|
|
|
|
try {
|
|
pen.Color = Color.SeaShell;
|
|
Assert.Fail ("P121#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P121#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSienna ()
|
|
{
|
|
Pen pen = Pens.Sienna;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P122#1");
|
|
Assert.AreEqual (pen.Color, Color.Sienna, "P122#2");
|
|
|
|
try {
|
|
pen.Color = Color.Sienna;
|
|
Assert.Fail ("P122#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P122#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSilver ()
|
|
{
|
|
Pen pen = Pens.Silver;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P123#1");
|
|
Assert.AreEqual (pen.Color, Color.Silver, "P123#2");
|
|
|
|
try {
|
|
pen.Color = Color.Silver;
|
|
Assert.Fail ("P123#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P123#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSkyBlue ()
|
|
{
|
|
Pen pen = Pens.SkyBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P124#1");
|
|
Assert.AreEqual (pen.Color, Color.SkyBlue, "P124#2");
|
|
|
|
try {
|
|
pen.Color = Color.SkyBlue;
|
|
Assert.Fail ("P124#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P124#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSlateBlue ()
|
|
{
|
|
Pen pen = Pens.SlateBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P125#1");
|
|
Assert.AreEqual (pen.Color, Color.SlateBlue, "P125#2");
|
|
|
|
try {
|
|
pen.Color = Color.SlateBlue;
|
|
Assert.Fail ("P125#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P125#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSlateGray ()
|
|
{
|
|
Pen pen = Pens.SlateGray;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P126#1");
|
|
Assert.AreEqual (pen.Color, Color.SlateGray, "P126#2");
|
|
|
|
try {
|
|
pen.Color = Color.SlateGray;
|
|
Assert.Fail ("P126#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P126#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSnow ()
|
|
{
|
|
Pen pen = Pens.Snow;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P127#1");
|
|
Assert.AreEqual (pen.Color, Color.Snow, "P127#2");
|
|
|
|
try {
|
|
pen.Color = Color.Snow;
|
|
Assert.Fail ("P127#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P127#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSpringGreen ()
|
|
{
|
|
Pen pen = Pens.SpringGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P128#1");
|
|
Assert.AreEqual (pen.Color, Color.SpringGreen, "P128#2");
|
|
|
|
try {
|
|
pen.Color = Color.SpringGreen;
|
|
Assert.Fail ("P128#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P128#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestSteelBlue ()
|
|
{
|
|
Pen pen = Pens.SteelBlue;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P129#1");
|
|
Assert.AreEqual (pen.Color, Color.SteelBlue, "P129#2");
|
|
|
|
try {
|
|
pen.Color = Color.SteelBlue;
|
|
Assert.Fail ("P129#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P129#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestTan ()
|
|
{
|
|
Pen pen = Pens.Tan;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P130#1");
|
|
Assert.AreEqual (pen.Color, Color.Tan, "P130#2");
|
|
|
|
try {
|
|
pen.Color = Color.Tan;
|
|
Assert.Fail ("P130#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P130#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestTeal ()
|
|
{
|
|
Pen pen = Pens.Teal;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P131#1");
|
|
Assert.AreEqual (pen.Color, Color.Teal, "P131#2");
|
|
|
|
try {
|
|
pen.Color = Color.Teal;
|
|
Assert.Fail ("P131#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P131#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestThistle ()
|
|
{
|
|
Pen pen = Pens.Thistle;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P132#1");
|
|
Assert.AreEqual (pen.Color, Color.Thistle, "P132#2");
|
|
|
|
try {
|
|
pen.Color = Color.Thistle;
|
|
Assert.Fail ("P132#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P132#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestTomato ()
|
|
{
|
|
Pen pen = Pens.Tomato;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P133#1");
|
|
Assert.AreEqual (pen.Color, Color.Tomato, "P133#2");
|
|
|
|
try {
|
|
pen.Color = Color.Tomato;
|
|
Assert.Fail ("P133#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P133#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestTransparent ()
|
|
{
|
|
Pen pen = Pens.Transparent;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P134#1");
|
|
Assert.AreEqual (pen.Color, Color.Transparent, "P134#2");
|
|
|
|
try {
|
|
pen.Color = Color.Transparent;
|
|
Assert.Fail ("P134#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P134#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestTurquoise ()
|
|
{
|
|
Pen pen = Pens.Turquoise;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P135#1");
|
|
Assert.AreEqual (pen.Color, Color.Turquoise, "P135#2");
|
|
|
|
try {
|
|
pen.Color = Color.Turquoise;
|
|
Assert.Fail ("P135#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P135#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestViolet ()
|
|
{
|
|
Pen pen = Pens.Violet;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P136#1");
|
|
Assert.AreEqual (pen.Color, Color.Violet, "P136#2");
|
|
|
|
try {
|
|
pen.Color = Color.Violet;
|
|
Assert.Fail ("P136#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P136#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestWheat ()
|
|
{
|
|
Pen pen = Pens.Wheat;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P137#1");
|
|
Assert.AreEqual (pen.Color, Color.Wheat, "P137#2");
|
|
|
|
try {
|
|
pen.Color = Color.Wheat;
|
|
Assert.Fail ("P137#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P137#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestWhite ()
|
|
{
|
|
Pen pen = Pens.White;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P138#1");
|
|
Assert.AreEqual (pen.Color, Color.White, "P138#2");
|
|
|
|
try {
|
|
pen.Color = Color.White;
|
|
Assert.Fail ("P138#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P138#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestWhiteSmoke ()
|
|
{
|
|
Pen pen = Pens.WhiteSmoke;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P139#1");
|
|
Assert.AreEqual (pen.Color, Color.WhiteSmoke, "P139#2");
|
|
|
|
try {
|
|
pen.Color = Color.WhiteSmoke;
|
|
Assert.Fail ("P139#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P139#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestYellow ()
|
|
{
|
|
Pen pen = Pens.Yellow;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P140#1");
|
|
Assert.AreEqual (pen.Color, Color.Yellow, "P140#2");
|
|
|
|
try {
|
|
pen.Color = Color.Yellow;
|
|
Assert.Fail ("P140#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P140#3");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestYellowGreen ()
|
|
{
|
|
Pen pen = Pens.YellowGreen;
|
|
Assert.AreEqual (pen.PenType, PenType.SolidColor, "P141#1");
|
|
Assert.AreEqual (pen.Color, Color.YellowGreen, "P141#2");
|
|
|
|
try {
|
|
pen.Color = Color.YellowGreen;
|
|
Assert.Fail ("P141#3: must throw ArgumentException");
|
|
} catch (ArgumentException) {
|
|
Assert.IsTrue (true, "P141#3");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Following code was used to generate the test methods above
|
|
//
|
|
//Type type = typeof (Pens);
|
|
//PropertyInfo [] properties = type.GetProperties ();
|
|
//int count = 1;
|
|
//foreach (PropertyInfo property in properties) {
|
|
// Console.WriteLine();
|
|
// Console.WriteLine("\t\t[Test]");
|
|
// Console.WriteLine("\t\tpublic void Test" + property.Name + " ()");
|
|
// Console.WriteLine("\t\t{");
|
|
// Console.WriteLine("\t\t\tPen pen = Pens." + property.Name + ";");
|
|
// Console.WriteLine("\t\t\tAssertEquals (\"P" + count + "#1\", pen.PenType, PenType.SolidColor);");
|
|
// Console.WriteLine("\t\t\tAssertEquals (\"P" + count + "#2\", pen.Color, Color." + property.Name + ");\n");
|
|
//
|
|
// Console.WriteLine("\t\t\ttry {");
|
|
// Console.WriteLine("\t\t\t\tpen.Color = Color." + property.Name + ";");
|
|
// Console.WriteLine("\t\t\t\tAssert.Fail (\"P" + count + "#3: must throw ArgumentException\");");
|
|
// Console.WriteLine("\t\t\t} catch (ArgumentException) {");
|
|
// Console.WriteLine("\t\t\t\tAssert.IsTrue (\"P" + count + "#3\", true);");
|
|
// Console.WriteLine("\t\t\t}");
|
|
// Console.WriteLine("\t\t}");
|
|
// count++;
|
|
//}
|