mcs/class/WindowsBase/Test/System.Windows/RectTest.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Authors:
  23 //      Chris Toshok (toshok@ximian.com)
  24 //
  25
  26 using System;
  27 using System.Globalization;
  28 using System.Windows;
  29 using System.Windows.Media;
  30 using NUnit.Framework;
  31
  32 namespace MonoTests.System.Windows {
  33
  34         [TestFixture]
  35         public class RectTest
  36         {
  37                 [Test]
  38                 public void Ctor_Accessor ()
  39                 {
  40                         Rect r;
  41
  42                         r = new Rect (new Size (40, 50));
  43                         Assert.AreEqual (0, r.X);
  44                         Assert.AreEqual (0, r.Y);
  45                         Assert.AreEqual (40, r.Width);
  46                         Assert.AreEqual (50, r.Height);
  47                         Assert.AreEqual (0, r.Left);
  48                         Assert.AreEqual (0, r.Top);
  49                         Assert.AreEqual (40, r.Right);
  50                         Assert.AreEqual (50, r.Bottom);
  51                         Assert.AreEqual (new Point (0, 0), r.TopLeft);
  52                         Assert.AreEqual (new Point (40, 0), r.TopRight);
  53                         Assert.AreEqual (new Point (0, 50), r.BottomLeft);
  54                         Assert.AreEqual (new Point (40, 50), r.BottomRight);
  55                         Assert.AreEqual (new Point (0, 0), r.Location);
  56                         Assert.AreEqual (new Size (40, 50), r.Size);
  57
  58                         r = new Rect (new Point (4, 5), new Vector (20, 30));
  59                         Assert.AreEqual (4, r.X);
  60                         Assert.AreEqual (5, r.Y);
  61                         Assert.AreEqual (20, r.Width);
  62                         Assert.AreEqual (30, r.Height);
  63                         Assert.AreEqual (4, r.Left);
  64                         Assert.AreEqual (5, r.Top);
  65                         Assert.AreEqual (24, r.Right);
  66                         Assert.AreEqual (35, r.Bottom);
  67                         Assert.AreEqual (new Point (4, 5), r.TopLeft);
  68                         Assert.AreEqual (new Point (24, 5), r.TopRight);
  69                         Assert.AreEqual (new Point (4, 35), r.BottomLeft);
  70                         Assert.AreEqual (new Point (24, 35), r.BottomRight);
  71                         Assert.AreEqual (new Point (4, 5), r.Location);
  72                         Assert.AreEqual (new Size (20, 30), r.Size);
  73
  74                         r = new Rect (new Point (4, 5), new Point (20, 30));
  75                         Assert.AreEqual (4, r.X);
  76                         Assert.AreEqual (5, r.Y);
  77                         Assert.AreEqual (16, r.Width);
  78                         Assert.AreEqual (25, r.Height);
  79                         Assert.AreEqual (4, r.Left);
  80                         Assert.AreEqual (5, r.Top);
  81                         Assert.AreEqual (20, r.Right);
  82                         Assert.AreEqual (30, r.Bottom);
  83                         Assert.AreEqual (new Point (4, 5), r.TopLeft);
  84                         Assert.AreEqual (new Point (20, 5), r.TopRight);
  85                         Assert.AreEqual (new Point (4, 30), r.BottomLeft);
  86                         Assert.AreEqual (new Point (20, 30), r.BottomRight);
  87                         Assert.AreEqual (new Point (4, 5), r.Location);
  88                         Assert.AreEqual (new Size (16,25), r.Size);
  89
  90                         r = new Rect (new Point (20, 30), new Point (4, 5));
  91                         Assert.AreEqual (4, r.X);
  92                         Assert.AreEqual (5, r.Y);
  93                         Assert.AreEqual (16, r.Width);
  94                         Assert.AreEqual (25, r.Height);
  95                         Assert.AreEqual (4, r.Left);
  96                         Assert.AreEqual (5, r.Top);
  97                         Assert.AreEqual (20, r.Right);
  98                         Assert.AreEqual (30, r.Bottom);
  99                         Assert.AreEqual (new Point (4, 5), r.TopLeft);
 100                         Assert.AreEqual (new Point (20, 5), r.TopRight);
 101                         Assert.AreEqual (new Point (4, 30), r.BottomLeft);
 102                         Assert.AreEqual (new Point (20, 30), r.BottomRight);
 103                         Assert.AreEqual (new Point (4, 5), r.Location);
 104                         Assert.AreEqual (new Size (16,25), r.Size);
 105
 106                         r = new Rect (10, 15, 20, 30);
 107                         Assert.AreEqual (10, r.X);
 108                         Assert.AreEqual (15, r.Y);
 109                         Assert.AreEqual (20, r.Width);
 110                         Assert.AreEqual (30, r.Height);
 111                         Assert.AreEqual (10, r.Left);
 112                         Assert.AreEqual (15, r.Top);
 113                         Assert.AreEqual (30, r.Right);
 114                         Assert.AreEqual (45, r.Bottom);
 115                         Assert.AreEqual (new Point (10, 15), r.TopLeft);
 116                         Assert.AreEqual (new Point (30, 15), r.TopRight);
 117                         Assert.AreEqual (new Point (10, 45), r.BottomLeft);
 118                         Assert.AreEqual (new Point (30, 45), r.BottomRight);
 119                         Assert.AreEqual (new Point (10, 15), r.Location);
 120                         Assert.AreEqual (new Size (20, 30), r.Size);
 121
 122                         r = new Rect (new Point (10, 15), new Size (20, 30));
 123                         Assert.AreEqual (10, r.X);
 124                         Assert.AreEqual (15, r.Y);
 125                         Assert.AreEqual (20, r.Width);
 126                         Assert.AreEqual (30, r.Height);
 127                         Assert.AreEqual (10, r.Left);
 128                         Assert.AreEqual (15, r.Top);
 129                         Assert.AreEqual (30, r.Right);
 130                         Assert.AreEqual (45, r.Bottom);
 131                         Assert.AreEqual (new Point (10, 15), r.TopLeft);
 132                         Assert.AreEqual (new Point (30, 15), r.TopRight);
 133                         Assert.AreEqual (new Point (10, 45), r.BottomLeft);
 134                         Assert.AreEqual (new Point (30, 45), r.BottomRight);
 135                         Assert.AreEqual (new Point (10, 15), r.Location);
 136                         Assert.AreEqual (new Size (20, 30), r.Size);
 137                 }
 138
 139                 [Test]
 140                 [ExpectedException (typeof (ArgumentException))]
 141                 public void Ctor_NegativeWidth ()
 142                 {
 143                         new Rect (10, 10, -10, 10);
 144                 }
 145
 146                 [Test]
 147                 [ExpectedException (typeof (ArgumentException))]
 148                 public void Ctor_NegativeHeight ()
 149                 {
 150                         new Rect (10, 10, 10, -10);
 151                 }
 152
 153                 [Test]
 154                 public void Empty ()
 155                 {
 156                         Rect r = Rect.Empty;
 157                         Assert.AreEqual (Double.PositiveInfinity, r.X);
 158                         Assert.AreEqual (Double.PositiveInfinity, r.Y);
 159                         Assert.AreEqual (Double.NegativeInfinity, r.Width);
 160                         Assert.AreEqual (Double.NegativeInfinity, r.Height);
 161                 }
 162
 163                 [Test]
 164                 [ExpectedException (typeof (InvalidOperationException))]
 165                 public void ModifyEmpty_x ()
 166                 {
 167                         Rect r = Rect.Empty;
 168                         r.X = 5;
 169                 }
 170
 171                 [Test]
 172                 [ExpectedException (typeof (InvalidOperationException))]
 173                 public void ModifyEmpty_y ()
 174                 {
 175                         Rect r = Rect.Empty;
 176                         r.Y = 5;
 177                 }
 178
 179                 [Test]
 180                 [ExpectedException (typeof (InvalidOperationException))]
 181                 public void ModifyEmpty_width ()
 182                 {
 183                         Rect r = Rect.Empty;
 184                         r.Width = 5;
 185                 }
 186
 187                 [Test]
 188                 [ExpectedException (typeof (InvalidOperationException))]
 189                 public void ModifyEmpty_height ()
 190                 {
 191                         Rect r = Rect.Empty;
 192                         r.Height = 5;
 193                 }
 194
 195                 [Test]
 196                 [ExpectedException (typeof (InvalidOperationException))]
 197                 public void ModifyEmpty_negative_width ()
 198                 {
 199                         Rect r = Rect.Empty;
 200                         r.Width = -5;
 201                 }
 202
 203                 [Test]
 204                 [ExpectedException (typeof (InvalidOperationException))]
 205                 public void ModifyEmpty_negative_height ()
 206                 {
 207                         Rect r = Rect.Empty;
 208                         r.Height = -5;
 209                 }
 210
 211
 212                 [Test]
 213                 [ExpectedException (typeof (ArgumentException))]
 214                 public void Modify_negative_width ()
 215                 {
 216                         Rect r = new Rect (0, 0, 10, 10);
 217                         r.Width = -5;
 218                 }
 219
 220                 [Test]
 221                 [ExpectedException (typeof (ArgumentException))]
 222                 public void Modify_negative_height ()
 223                 {
 224                         Rect r = new Rect (0, 0, 10, 10);
 225                         r.Height = -5;
 226                 }
 227
 228                 [Test]
 229                 public void Empty_Size ()
 230                 {
 231                         Assert.AreEqual (Size.Empty, Rect.Empty.Size);
 232                 }
 233
 234                 [Test]
 235                 public void IsEmpty ()
 236                 {
 237                         Assert.IsTrue (Rect.Empty.IsEmpty);
 238                         Assert.IsFalse ((new Rect (5, 5, 5, 5)).IsEmpty);
 239                 }
 240
 241                 [Test]
 242                 public void Location ()
 243                 {
 244                         Rect r = new Rect (0, 0, 0, 0);
 245
 246                         r.Location = new Point (10, 15);
 247                         Assert.AreEqual (10, r.X);
 248                         Assert.AreEqual (15, r.Y);
 249                 }
 250
 251                 [Test]
 252                 public void RectSize ()
 253                 {
 254                         Rect r = new Rect (0, 0, 5, 5);
 255
 256                         r.Size = new Size (10, 15);
 257                         Assert.AreEqual (10, r.Width);
 258                         Assert.AreEqual (15, r.Height);
 259                 }
 260
 261                 [Test]
 262                 [SetCulture ("en-us")]
 263                 public void ToStringTest ()
 264                 {
 265                         Rect r = new Rect (1.0, 2.5, 3, 4);
 266
 267                         string expectedStringOutput = "1,2.5,3,4";
 268                         Assert.AreEqual (expectedStringOutput, r.ToString ());
 269                         Assert.AreEqual (expectedStringOutput, r.ToString (null));
 270                         Assert.AreEqual ("Empty", Rect.Empty.ToString ());
 271
 272                         // IFormattable.ToString
 273                         IFormattable rFormattable = r;
 274                         Assert.AreEqual (expectedStringOutput,
 275                                 rFormattable.ToString (null, null),
 276                                 "IFormattable.ToString with null format");
 277                         Assert.AreEqual (expectedStringOutput,
 278                                 rFormattable.ToString (string.Empty, null),
 279                                 "IFormattable.ToString with empty format");
 280                         Assert.AreEqual ("1.00,2.50,3.00,4.00",
 281                                 rFormattable.ToString ("N2", null),
 282                                 "IFormattable.ToString with N2 format");
 283                         Assert.AreEqual ("blah,blah,blah,blah",
 284                                 rFormattable.ToString ("blah", null),
 285                                 "IFormattable.ToString with blah format");
 286                         Assert.AreEqual (":,:,:,:",
 287                                 rFormattable.ToString (":", null),
 288                                 "IFormattable.ToString with : format");
 289                         Assert.AreEqual ("Empty",
 290                                 ((IFormattable) Rect.Empty).ToString ("blah", null),
 291                                 "IFormattable.ToString on Rect.Empty with blah format");
 292
 293                         foreach (CultureInfo culture in CultureInfo.GetCultures (CultureTypes.AllCultures)) {
 294                                 if (culture.IsNeutralCulture)
 295                                         continue;
 296                                 string separator = ",";
 297                                 if (culture.NumberFormat.NumberDecimalSeparator == separator)
 298                                         separator = ";";
 299                                 expectedStringOutput =
 300                                         1.ToString (culture) + separator +
 301                                         2.5.ToString (culture) + separator +
 302                                         3.ToString (culture) + separator +
 303                                         4.ToString (culture);
 304                                 Assert.AreEqual (expectedStringOutput,
 305                                         r.ToString (culture),
 306                                         "ToString with Culture: " + culture.Name);
 307                                 Assert.AreEqual ("Empty",
 308                                         Rect.Empty.ToString (culture),
 309                                         "ToString on Empty with Culture: " + culture.Name);
 310
 311                                 // IFormattable.ToString
 312                                 Assert.AreEqual (expectedStringOutput,
 313                                         rFormattable.ToString (null, culture),
 314                                         "IFormattable.ToString with null format with Culture: " + culture.Name);
 315                                 Assert.AreEqual (expectedStringOutput,
 316                                         rFormattable.ToString (string.Empty, culture),
 317                                         "IFormattable.ToString with empty format with Culture: " + culture.Name);
 318                                 expectedStringOutput =
 319                                         1.ToString ("N2", culture) + separator +
 320                                         2.5.ToString ("N2", culture) + separator +
 321                                         3.ToString ("N2", culture) + separator +
 322                                         4.ToString ("N2", culture);
 323                                 Assert.AreEqual (expectedStringOutput,
 324                                         rFormattable.ToString ("N2", culture),
 325                                         "IFormattable.ToString with N2 format with Culture: " + culture.Name);
 326                         }
 327                 }
 328
 329                 [Test]
 330                 public void ToString_FormatException ()
 331                 {
 332                         // This test does not currently work because
 333                         // String.Format does not throw all necessary exceptions
 334                         IFormattable rFormattable = new Rect (1.0, 2.5, 3, 4);
 335                         bool exceptionRaised = false;
 336                         try {
 337                                 rFormattable.ToString ("{", null);
 338                         } catch (FormatException) {
 339                                 exceptionRaised = true;
 340                         }
 341                         Assert.IsTrue (exceptionRaised, "Expected FormatException with IFormattable.ToString (\"{\", null)");
 342                 }
 343
 344                 [Test]
 345                 public void Parse ()
 346                 {
 347                         Rect r = Rect.Parse ("1 , 2, 3, 4");
 348                         Assert.AreEqual (new Rect (1, 2, 3, 4), r);
 349                 }
 350
 351                 [Test]
 352                 public void Parse2 ()
 353                 {
 354                         Rect r = Rect.Parse ("1 2 3 4");
 355                         Assert.AreEqual (new Rect (1, 2, 3, 4), r);
 356                 }
 357
 358                 [Test]
 359                 public void Parse3 ()
 360                 {
 361                         Rect r = Rect.Parse ("  1 2 3 4  ");
 362                         Assert.AreEqual (new Rect (1, 2, 3, 4), r);
 363                 }
 364
 365                 [Test]
 366                 public void ParseWithBothSeparators ()
 367                 {
 368                         Rect.Parse ("1.0, 3 2.0, 5.0");
 369                 }
 370
 371                 [Test]
 372                 [ExpectedException (typeof (ArgumentException))]
 373                 public void ParseNegative ()
 374                 {
 375                         Rect.Parse ("1, 2, -3, -4");
 376                 }
 377
 378                 [Test]
 379                 [ExpectedException (typeof (InvalidOperationException))] // "Premature string termination encountered."
 380                 public void Parse3Doubles ()
 381                 {
 382                         Rect.Parse ("1.0, 3, -5");
 383                 }
 384
 385                 [Test]
 386                 [ExpectedException (typeof (FormatException))]
 387                 public void ParseInvalidString1 ()
 388                 {
 389                         Rect.Parse ("1.0, 3, -x, 5.0");
 390                 }
 391
 392                 [Test]
 393                 [ExpectedException (typeof (InvalidOperationException))]
 394                 public void ParseInvalidString3 ()
 395                 {
 396                         Rect.Parse ("1.0, 3, 2.0, 5.0, 2");
 397                 }
 398
 399                 [Test]
 400                 [ExpectedException (typeof (FormatException))]
 401                 public void ParseInvalidString4 ()
 402                 {
 403                         Rect.Parse ("1.0-3, 2.0, 5.0, 2");
 404                 }
 405
 406                 [Test]
 407                 [ExpectedException (typeof (InvalidOperationException))]
 408                 public void ParseInvalidString5 ()
 409                 {
 410                         Rect.Parse ("1.0, 2.0, 5.0, 2,");
 411                 }
 412
 413                 [Test]
 414                 public void ParseInvalidString6 ()
 415                 {
 416                         Rect.Parse ("\n1.0, 2.0, 5.0, 2");
 417                 }
 418
 419                 [Test]
 420                 [ExpectedException (typeof (InvalidOperationException))]
 421                 public void ParseInvalidString7 ()
 422                 {
 423                         Rect r = Rect.Parse ("1,, 2, 3, 4");
 424                         Assert.AreEqual (new Rect (1, 2, 3, 4), r);
 425                 }
 426
 427                 [Test]
 428                 public void Equals ()
 429                 {
 430                         Rect r1 = new Rect (1, 2, 3, 4);
 431                         Rect r2 = r1;
 432
 433                         Assert.IsTrue (r1.Equals (r1));
 434
 435                         r2.X = 0;
 436                         Assert.IsFalse (r1.Equals (r2));
 437                         r2.X = r1.X;
 438
 439                         r2.Y = 0;
 440                         Assert.IsFalse (r1.Equals (r2));
 441                         r2.Y = r1.Y;
 442
 443                         r2.Width = 0;
 444                         Assert.IsFalse (r1.Equals (r2));
 445                         r2.Width = r1.Width;
 446
 447                         r2.Height = 0;
 448                         Assert.IsFalse (r1.Equals (r2));
 449                         r2.Height = r1.Height;
 450
 451                         Assert.IsFalse (r1.Equals (new object ()));
 452
 453                         r1 = Rect.Empty;
 454                         r2 = Rect.Empty;
 455
 456                         Assert.AreEqual (true, r1.Equals (r2));
 457                         Assert.AreEqual (true, r2.Equals (r1));
 458                 }
 459
 460                 [Test]
 461                 public void ContainsRect ()
 462                 {
 463                         Rect r = new Rect (0, 0, 50, 50);
 464
 465                         // fully contained
 466                         Assert.IsTrue (r.Contains (new Rect (10, 10, 10, 10)));
 467
 468                         // crosses top side
 469                         Assert.IsFalse (r.Contains (new Rect (5, -5, 10, 10)));
 470
 471                         // crosses right side
 472                         Assert.IsFalse (r.Contains (new Rect (5, 5, 50, 10)));
 473
 474                         // crosses bottom side
 475                         Assert.IsFalse (r.Contains (new Rect (5, 5, 10, 50)));
 476
 477                         // crosses left side
 478                         Assert.IsFalse (r.Contains (new Rect (-5, 5, 10, 10)));
 479
 480                         // completely outside (top)
 481                         Assert.IsFalse (r.Contains (new Rect (5, -5, 1, 1)));
 482
 483                         // completely outside (right)
 484                         Assert.IsFalse (r.Contains (new Rect (75, 5, 1, 1)));
 485
 486                         // completely outside (bottom)
 487                         Assert.IsFalse (r.Contains (new Rect (5, 75, 1, 1)));
 488
 489                         // completely outside (left)
 490                         Assert.IsFalse (r.Contains (new Rect (-25, 5, 1, 1)));
 491                 }
 492
 493                 [Test]
 494                 public void ContainsDoubles ()
 495                 {
 496                         Rect r = new Rect (0, 0, 50, 50);
 497
 498                         Assert.IsTrue (r.Contains (10, 10));
 499                         Assert.IsFalse (r.Contains (-5, -5));
 500                 }
 501
 502                 [Test]
 503                 public void ContainsPoint ()
 504                 {
 505                         Rect r = new Rect (0, 0, 50, 50);
 506
 507                         Assert.IsTrue (r.Contains (new Point (10, 10)));
 508                         Assert.IsFalse (r.Contains (new Point (-5, -5)));
 509                 }
 510
 511                 [Test]
 512                 public void Inflate ()
 513                 {
 514                         Rect r = Rect.Inflate (new Rect (0, 0, 20, 20), 10, 15);
 515                         Assert.AreEqual (new Rect (-10, -15, 40, 50), r);
 516
 517                         r = Rect.Inflate (new Rect (0, 0, 20, 20), new Size (10, 15));
 518                         Assert.AreEqual (new Rect (-10, -15, 40, 50), r);
 519
 520                         r = new Rect (0, 0, 20, 20);
 521                         r.Inflate (10, 15);
 522                         Assert.AreEqual (new Rect (-10, -15, 40, 50), r);
 523
 524                         r = new Rect (0, 0, 20, 20);
 525                         r.Inflate (new Size (10, 15));
 526                         Assert.AreEqual (new Rect (-10, -15, 40, 50), r);
 527                 }
 528
 529                 [Test]
 530                 public void IntersectsWith ()
 531                 {
 532                         Rect r = new Rect (0, 0, 50, 50);
 533
 534                         // fully contained
 535                         Assert.IsTrue (r.IntersectsWith (new Rect (10, 10, 10, 10)));
 536
 537                         // crosses top side
 538                         Assert.IsTrue (r.IntersectsWith (new Rect (5, -5, 10, 10)));
 539
 540                         // crosses right side
 541                         Assert.IsTrue (r.IntersectsWith (new Rect (5, 5, 50, 10)));
 542
 543                         // crosses bottom side
 544                         Assert.IsTrue (r.IntersectsWith (new Rect (5, 5, 10, 50)));
 545
 546                         // crosses left side
 547                         Assert.IsTrue (r.IntersectsWith (new Rect (-5, 5, 10, 10)));
 548
 549                         // completely outside (top)
 550                         Assert.IsFalse (r.IntersectsWith (new Rect (5, -5, 1, 1)));
 551
 552                         // completely outside (right)
 553                         Assert.IsFalse (r.IntersectsWith (new Rect (75, 5, 1, 1)));
 554
 555                         // completely outside (bottom)
 556                         Assert.IsFalse (r.IntersectsWith (new Rect (5, 75, 1, 1)));
 557
 558                         // completely outside (left)
 559                         Assert.IsFalse (r.IntersectsWith (new Rect (-25, 5, 1, 1)));
 560                 }
 561
 562                 [Test]
 563                 public void Intersect ()
 564                 {
 565                         Rect r;
 566
 567                         // fully contained
 568                         r = new Rect (0, 0, 50, 50);
 569                         r.Intersect (new Rect (10, 10, 10, 10));
 570                         Assert.AreEqual (new Rect (10, 10, 10, 10), r);
 571
 572                         // crosses top side
 573                         r = new Rect (0, 0, 50, 50);
 574                         r.Intersect (new Rect (5, -5, 10, 10));
 575                         Assert.AreEqual (new Rect (5, 0, 10, 5), r);
 576
 577                         // crosses right side
 578                         r = new Rect (0, 0, 50, 50);
 579                         r.Intersect (new Rect (5, 5, 50, 10));
 580                         Assert.AreEqual (new Rect (5, 5, 45, 10), r);
 581
 582                         // crosses bottom side
 583                         r = new Rect (0, 0, 50, 50);
 584                         r.Intersect (new Rect (5, 5, 10, 50));
 585                         Assert.AreEqual(new Rect(5, 5, 10, 45), r);
 586
 587                         // crosses left side
 588                         r = new Rect (0, 0, 50, 50);
 589                         r.Intersect (new Rect (-5, 5, 10, 10));
 590                         Assert.AreEqual(new Rect(0, 5, 5, 10), r);
 591
 592                         // completely outside (top)
 593                         r = new Rect (0, 0, 50, 50);
 594                         r.Intersect (new Rect (5, -5, 1, 1));
 595                         Assert.AreEqual (Rect.Empty, r);
 596
 597                         // completely outside (right)
 598                         r = new Rect (0, 0, 50, 50);
 599                         r.Intersect (new Rect (75, 5, 1, 1));
 600                         Assert.AreEqual (Rect.Empty, r);
 601
 602                         // completely outside (bottom)
 603                         r = new Rect (0, 0, 50, 50);
 604                         r.Intersect (new Rect (5, 75, 1, 1));
 605                         Assert.AreEqual (Rect.Empty, r);
 606
 607                         // completely outside (left)
 608                         r = new Rect (0, 0, 50, 50);
 609                         r.Intersect (new Rect (-25, 5, 1, 1));
 610                         Assert.AreEqual (Rect.Empty, r);
 611                 }
 612
 613                 [Test]
 614                 public void Union()
 615                 {
 616                         Rect r;
 617
 618                         // fully contained
 619                         r = new Rect(0, 0, 50, 50);
 620                         r.Union(new Rect(10, 10, 10, 10));
 621                         Assert.AreEqual(new Rect(0, 0, 50, 50), r);
 622
 623                         // crosses top side
 624                         r = new Rect(0, 0, 50, 50);
 625                         r.Union(new Rect(5, -5, 10, 10));
 626                         Assert.AreEqual(new Rect(0, -5, 50, 55), r);
 627
 628                         // crosses right side
 629                         r = new Rect(0, 0, 50, 50);
 630                         r.Union(new Rect(5, 5, 50, 10));
 631                         Assert.AreEqual(new Rect(0, 0, 55, 50), r);
 632
 633                         // crosses bottom side
 634                         r = new Rect(0, 0, 50, 50);
 635                         r.Union(new Rect(5, 5, 10, 50));
 636                         Assert.AreEqual(new Rect(0, 0, 50, 55), r);
 637
 638                         // crosses left side
 639                         r = new Rect(0, 0, 50, 50);
 640                         r.Union(new Rect(-5, 5, 10, 10));
 641                         Assert.AreEqual(new Rect(-5, 0, 55, 50), r);
 642
 643                         // completely outside (top)
 644                         r = new Rect(0, 0, 50, 50);
 645                         r.Union(new Rect(5, -5, 1, 1));
 646                         Assert.AreEqual(new Rect(0, -5, 50, 55), r);
 647
 648                         // completely outside (right)
 649                         r = new Rect(0, 0, 50, 50);
 650                         r.Union(new Rect(75, 5, 1, 1));
 651                         Assert.AreEqual(new Rect(0, 0, 76, 50), r);
 652
 653                         // completely outside (bottom)
 654                         r = new Rect(0, 0, 50, 50);
 655                         r.Union(new Rect(5, 75, 1, 1));
 656                         Assert.AreEqual(new Rect(0,0, 50, 76), r);
 657
 658                         // completely outside (left)
 659                         r = new Rect(0, 0, 50, 50);
 660                         r.Union(new Rect(-25, 5, 1, 1));
 661                         Assert.AreEqual(new Rect(-25, 0, 75, 50), r);
 662                 }
 663
 664                 [Test]
 665                 public void Equals_Operator ()
 666                 {
 667                         Rect r1 = new Rect (1, 2, 30, 30);
 668                         Rect r2 = new Rect (1, 2, 30, 30);
 669
 670                         Assert.AreEqual (true,  r1 == r2);
 671                         Assert.AreEqual (false, r1 != r2);
 672
 673                         r2 = new Rect (10, 20, 30, 30);
 674
 675                         Assert.AreEqual (false, r1 == r2);
 676                         Assert.AreEqual (true,  r1 != r2);
 677
 678                         r1 = Rect.Empty;
 679                         r2 = Rect.Empty;
 680
 681                         Assert.AreEqual (true, r1 == r2);
 682                         Assert.AreEqual (false, r1 != r2);
 683                 }
 684
 685         }
 686 }
 687