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

   1 // Tests for System.Drawing.SizeF.cs
   2 //
   3 // Author: Ravindra (rkumar@novell.com)
   4 //
   5 //      Modified TestPoint.cs for testing SizeF.cs.
   6 //
   7 // Copyright (c) 2004 Novell, Inc.
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Drawing;
  13
  14 namespace MonoTests.System.Drawing
  15 {
  16         [TestFixture]
  17         public class SizeFTest : Assertion
  18         {
  19                 SizeF sz11_99;
  20                 SizeF sz11_0;
  21                 SizeF sz0_11;
  22
  23                 [TearDown]
  24                 public void TearDown () {}
  25
  26                 [SetUp]
  27                 public void SetUp ()
  28                 {
  29                         sz11_99 = new SizeF (1.1F, 9.9F);
  30                         sz11_0 = new SizeF (1.1F, 0F);
  31                         sz0_11 = new SizeF (0F, 1.1F);
  32                 }
  33
  34                 [Test]
  35                 public void TestConstructors ()
  36                 {
  37                         SizeF sz_wh = new SizeF (1.5F, 5.8F);
  38                         AssertEquals ("C#1", 1.5F, sz_wh.Width);
  39                         AssertEquals ("C#2", 5.8F, sz_wh.Height);
  40
  41                         SizeF sz_pf = new SizeF (new PointF (1.5F, 5.8F));
  42                         AssertEquals ("C#3", 1.5F, sz_pf.Width);
  43                         AssertEquals ("C#4", 5.8F, sz_pf.Height);
  44
  45                         SizeF sz_sz = new SizeF (sz_wh);
  46                         AssertEquals ("C#5", 1.5F, sz_sz.Width);
  47                         AssertEquals ("C#6", 5.8F, sz_sz.Height);
  48
  49                         AssertEquals ("C#7", sz_wh, sz_pf);
  50                         AssertEquals ("C#8", sz_pf, sz_sz);
  51                         AssertEquals ("C#9", sz_wh, sz_sz);
  52                 }
  53
  54                 [Test]
  55                 public void TestEmptyField ()
  56                 {
  57                         SizeF sz = new SizeF (0.0F, 0.0F);
  58                         AssertEquals ("EMP#1", sz, SizeF.Empty);
  59                 }
  60
  61                 [Test]
  62                 public void TestProperties ()
  63                 {
  64                         SizeF sz = new SizeF (0.0F, 0.0F);
  65
  66                         Assert ("P#1", sz.IsEmpty);
  67                         Assert ("P#2", ! sz11_99.IsEmpty);
  68                         AssertEquals ("P#3", 1.1F, sz11_0.Width);
  69                         AssertEquals ("P#4", 1.1F, sz0_11.Height);
  70                 }
  71
  72                 [Test]
  73                 public void TestEquals ()
  74                 {
  75                         AssertEquals ("EQ#1", sz11_99, sz11_99);
  76                         AssertEquals ("EQ#2", sz11_99, new SizeF (1.1F, 9.9F));
  77                         Assert ("EQ#3", ! sz11_99.Equals (sz11_0));
  78                         Assert ("EQ#4", ! sz11_99.Equals (sz0_11));
  79                         Assert ("EQ#5", ! sz11_0.Equals (sz0_11));
  80                 }
  81
  82                 [Test]
  83                 public void Test2PointF ()
  84                 {
  85                         PointF p1 = new PointF (1.1F, 9.9F);
  86                         PointF p2 = sz11_99.ToPointF ();
  87
  88                         AssertEquals ("2PF#1", p1, p2);
  89                 }
  90
  91                 [Test]
  92                 public void Test2Size ()
  93                 {
  94                         Size sz1 = new Size (1, 9);
  95                         Size sz2 = sz11_99.ToSize ();
  96
  97                         AssertEquals ("2SZ#1", sz1, sz2);
  98                 }
  99
 100
 101                 [Test]
 102                 public void TestAddition ()
 103                 {
 104                         AssertEquals ("ADD#1", sz11_99, sz11_0 + new SizeF (0.0F, 9.9F));
 105                         AssertEquals ("ADD#2", sz11_99, new SizeF (0.0F, 0.0F) + new SizeF (1.1F, 9.9F));
 106                 }
 107
 108                 [Test]
 109                 public void TestEqualityOp ()
 110                 {
 111                         Assert ("EOP#1", sz11_99 == sz11_99);
 112                         Assert ("EOP#2", sz11_99 == new SizeF (1.1F, 9.9F));
 113                         Assert ("EOP#3", ! (sz11_99 == sz11_0));
 114                         Assert ("EOP#4", ! (sz11_99 == sz0_11));
 115                         Assert ("EOP#5", ! (sz11_0 == sz0_11));
 116                 }
 117
 118                 [Test]
 119                 public void TestInequalityOp ()
 120                 {
 121                         Assert ("IOP#1", ! (sz11_99 != sz11_99));
 122                         Assert ("IOP#2", ! (sz11_99 != new SizeF (1.1F, 9.9F)));
 123                         Assert ("IOP#3", sz11_99 != sz11_0);
 124                         Assert ("IOP#4", sz11_99 != sz0_11);
 125                         Assert ("IOP#5", sz11_0 != sz0_11);
 126                 }
 127
 128                 [Test]
 129                 public void TestSubtraction ()
 130                 {
 131                         AssertEquals ("SUB#1", sz11_0, sz11_99 - new SizeF (0.0F, 9.9F));
 132                         AssertEquals ("SUB#2", sz0_11, new SizeF (1.1F, 1.1F) - new SizeF (1.1F, 0.0F));
 133                 }
 134
 135                 [Test]
 136                 public void TestSizeF2PointF ()
 137                 {
 138                         PointF pf1 = new PointF (1.1F, 9.9F);
 139                         PointF pf2 = (PointF) sz11_99;
 140
 141                         AssertEquals ("SF2PF#1", pf1, pf2);
 142                 }
 143         }
 144 }
 145