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

   1 // Tests for System.Drawing.Size.cs
   2 //
   3 // Author: Ravindra (rkumar@novell.com)
   4 //
   5
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29
  30 using NUnit.Framework;
  31 using System;
  32 using System.Drawing;
  33
  34 namespace MonoTests.System.Drawing
  35 {
  36         [TestFixture]
  37         public class SizeTest : Assertion
  38         {
  39                 Size sz1_1;
  40                 Size sz1_0;
  41                 Size sz0_1;
  42
  43                 [TearDown]
  44                 public void TearDown () {}
  45
  46                 [SetUp]
  47                 public void SetUp ()
  48                 {
  49                         sz1_1 = new Size (1, 1);
  50                         sz1_0 = new Size (1, 0);
  51                         sz0_1 = new Size (0, 1);
  52                 }
  53
  54                 [Test]
  55                 public void TestConstructors ()
  56                 {
  57                         Size sz_wh = new Size (1, 5);
  58                         AssertEquals ("C#1", 1, sz_wh.Width);
  59                         AssertEquals ("C#2", 5, sz_wh.Height);
  60
  61                         Size sz_pt = new Size (new Point (1, 5));
  62                         AssertEquals ("C#3", 1, sz_pt.Width);
  63                         AssertEquals ("C#4", 5, sz_pt.Height);
  64
  65                         AssertEquals ("C#5", sz_wh, sz_pt);
  66                 }
  67
  68                 [Test]
  69                 public void TestEmptyField ()
  70                 {
  71                         Size sz = new Size (0, 0);
  72                         AssertEquals ("EMP#1", sz, Size.Empty);
  73                 }
  74
  75                 [Test]
  76                 public void TestProperties ()
  77                 {
  78                         Size sz = new Size (0, 0);
  79
  80                         Assert ("P#1", sz.IsEmpty);
  81                         Assert ("P#2", ! sz1_1.IsEmpty);
  82                         AssertEquals ("P#3", 1, sz1_0.Width);
  83                         AssertEquals ("P#4", 1, sz0_1.Height);
  84                 }
  85
  86                 [Test]
  87                 public void TestCeiling ()
  88                 {
  89                         SizeF sf = new SizeF (0.5F, 0.6F);
  90                         AssertEquals ("CL#1", sz1_1, Size.Ceiling (sf));
  91
  92                         sf = new SizeF (1.0F, 1.0F);
  93                         AssertEquals ("CL#2", sz1_1, Size.Ceiling (sf));
  94                 }
  95
  96                 [Test]
  97                 public void TestEquals ()
  98                 {
  99                         AssertEquals ("EQ#1", sz1_1, sz1_1);
 100                         AssertEquals ("EQ#2", sz1_1, new Size (1, 1));
 101                         Assert ("EQ#3", ! sz1_1.Equals (sz1_0));
 102                         Assert ("EQ#4", ! sz1_1.Equals (sz0_1));
 103                         Assert ("EQ#5", ! sz1_0.Equals (sz0_1));
 104                 }
 105
 106                 [Test]
 107                 public void TestRound ()
 108                 {
 109                         SizeF sf = new SizeF (0.3F, 0.7F);
 110                         AssertEquals ("CL#1", sz0_1, Size.Round (sf));
 111
 112                         sf = new SizeF (0.6F, 0.6F);
 113                         AssertEquals ("CL#2", sz1_1, Size.Round (sf));
 114
 115                         sf = new SizeF (1.0F, 1.0F);
 116                         AssertEquals ("CL#3", sz1_1, Size.Round (sf));
 117                 }
 118
 119
 120                 [Test]
 121                 public void TestTruncate ()
 122                 {
 123                         SizeF sf = new SizeF (0.8f, 1.3f);
 124                         AssertEquals ("TR#1", sz0_1, Size.Truncate (sf));
 125
 126                         sf = new SizeF (1.9f, 1.9f);
 127                         AssertEquals ("TR#2", sz1_1, Size.Truncate (sf));
 128
 129                         sf = new SizeF (1.0f, 1.0f);
 130                         AssertEquals ("TR#3", sz1_1, Size.Truncate (sf));
 131                 }
 132
 133                 [Test]
 134                 public void TestAddition ()
 135                 {
 136                         AssertEquals ("ADD#1", sz1_1, sz1_0 + sz0_1);
 137                         AssertEquals ("ADD#2", sz1_1, sz1_1 + new Size (0, 0));
 138                 }
 139
 140                 [Test]
 141                 public void TestEqualityOp ()
 142                 {
 143                         Assert ("EOP#1", sz1_1 == sz1_1);
 144                         Assert ("EOP#2", sz1_1 == new Size (1, 1));
 145                         Assert ("EOP#3", ! (sz1_1 == sz1_0));
 146                         Assert ("EOP#4", ! (sz1_1 == sz0_1));
 147                         Assert ("EOP#5", ! (sz1_0 == sz0_1));
 148                 }
 149
 150                 [Test]
 151                 public void TestInequalityOp ()
 152                 {
 153                         Assert ("IOP#1", ! (sz1_1 != sz1_1));
 154                         Assert ("IOP#2", ! (sz1_1 != new Size (1, 1)));
 155                         Assert ("IOP#3", sz1_1 != sz1_0);
 156                         Assert ("IOP#4", sz1_1 != sz0_1);
 157                         Assert ("IOP#5", sz1_0 != sz0_1);
 158                 }
 159
 160                 [Test]
 161                 public void TestSubtraction ()
 162                 {
 163                         AssertEquals ("SUB#1", sz1_0, sz1_1 - sz0_1);
 164                         AssertEquals ("SUB#2", sz0_1, sz1_1 - sz1_0);
 165                 }
 166
 167                 [Test]
 168                 public void TestSize2Point ()
 169                 {
 170                         Point pt1 = new Point (1, 1);
 171                         Point pt2 = (Point) sz1_1;
 172
 173                         AssertEquals ("SZ2PT#1", pt1, pt2);
 174                 }
 175
 176                 [Test]
 177                 public void TestSize2SizeF ()
 178                 {
 179                         SizeF sf1 = new SizeF (1.0F, 1.0F);
 180                         SizeF sf2 = (SizeF) sz1_1;
 181
 182                         AssertEquals ("SZ2SF#1", sf1, sf2);
 183                 }
 184         }
 185 }
 186