mcs/nunit24/NUnitFramework/framework/Assert.cs

   1 // ****************************************************************\r
   2 // This is free software licensed under the NUnit license. You\r
   3 // may obtain a copy of the license as well as information regarding\r
   4 // copyright ownership at http://nunit.org/?p=license&r=2.4.\r
   5 // ****************************************************************\r
   6 \r
   7 using System;\r
   8 using System.Collections;\r
   9 using System.ComponentModel;\r
  10 using NUnit.Framework.Constraints;\r
  11 using NUnit.Framework.SyntaxHelpers;\r
  12 \r
  13 namespace NUnit.Framework\r
  14 {\r
  15         /// <summary>\r
  16         /// The Assert class contains a collection of static methods that\r
  17         /// implement the most common assertions used in NUnit.\r
  18         /// </summary>\r
  19         public class Assert\r
  20         {\r
  21                 #region Assert Counting\r
  22 \r
  23                 private static int counter = 0;\r
  24                 \r
  25                 /// <summary>\r
  26                 /// Gets the number of assertions executed so far and \r
  27                 /// resets the counter to zero.\r
  28                 /// </summary>\r
  29                 public static int Counter\r
  30                 {\r
  31                         get\r
  32                         {\r
  33                                 int cnt = counter;\r
  34                                 counter = 0;\r
  35                                 return cnt;\r
  36                         }\r
  37                 }\r
  38 \r
  39                 private static void IncrementAssertCount()\r
  40                 {\r
  41                         ++counter;\r
  42                 }\r
  43 \r
  44                 #endregion\r
  45 \r
  46                 #region Constructor\r
  47 \r
  48                 /// <summary>\r
  49                 /// We don't actually want any instances of this object, but some people\r
  50                 /// like to inherit from it to add other static methods. Hence, the\r
  51                 /// protected constructor disallows any instances of this object. \r
  52                 /// </summary>\r
  53                 protected Assert() {}\r
  54 \r
  55                 #endregion\r
  56 \r
  57                 #region Equals and ReferenceEquals\r
  58 \r
  59                 /// <summary>\r
  60                 /// The Equals method throws an AssertionException. This is done \r
  61                 /// to make sure there is no mistake by calling this function.\r
  62                 /// </summary>\r
  63                 /// <param name="a"></param>\r
  64                 /// <param name="b"></param>\r
  65                 [EditorBrowsable(EditorBrowsableState.Never)]\r
  66                 public static new bool Equals(object a, object b)\r
  67                 {\r
  68                         throw new AssertionException("Assert.Equals should not be used for Assertions");\r
  69                 }\r
  70 \r
  71                 /// <summary>\r
  72                 /// override the default ReferenceEquals to throw an AssertionException. This \r
  73                 /// implementation makes sure there is no mistake in calling this function \r
  74                 /// as part of Assert. \r
  75                 /// </summary>\r
  76                 /// <param name="a"></param>\r
  77                 /// <param name="b"></param>\r
  78                 public static new void ReferenceEquals(object a, object b)\r
  79                 {\r
  80                         throw new AssertionException("Assert.ReferenceEquals should not be used for Assertions");\r
  81                 }\r
  82 \r
  83                 #endregion\r
  84                                 \r
  85                 #region IsTrue\r
  86 \r
  87                 /// <summary>\r
  88                 /// Asserts that a condition is true. If the condition is false the method throws\r
  89                 /// an <see cref="AssertionException"/>.\r
  90                 /// </summary> \r
  91                 /// <param name="condition">The evaluated condition</param>\r
  92                 /// <param name="message">The message to display if the condition is false</param>\r
  93                 /// <param name="args">Arguments to be used in formatting the message</param>\r
  94                 static public void IsTrue(bool condition, string message, params object[] args) \r
  95                 {\r
  96             Assert.That(condition, Is.True, message, args);\r
  97                 }\r
  98     \r
  99                 /// <summary>\r
 100                 /// Asserts that a condition is true. If the condition is false the method throws\r
 101                 /// an <see cref="AssertionException"/>.\r
 102                 /// </summary>\r
 103                 /// <param name="condition">The evaluated condition</param>\r
 104                 /// <param name="message">The message to display if the condition is false</param>\r
 105                 static public void IsTrue(bool condition, string message) \r
 106                 {\r
 107                         Assert.IsTrue(condition, message, null);\r
 108                 }\r
 109 \r
 110                 /// <summary>\r
 111                 /// Asserts that a condition is true. If the condition is false the method throws\r
 112                 /// an <see cref="AssertionException"/>.\r
 113                 /// </summary>\r
 114                 /// <param name="condition">The evaluated condition</param>\r
 115                 static public void IsTrue(bool condition) \r
 116                 {\r
 117                         Assert.IsTrue(condition, null, null);\r
 118                 }\r
 119 \r
 120                 #endregion\r
 121 \r
 122                 #region IsFalse\r
 123 \r
 124                 /// <summary>\r
 125                 /// Asserts that a condition is false. If the condition is true the method throws\r
 126                 /// an <see cref="AssertionException"/>.\r
 127                 /// </summary>\r
 128                 /// <param name="condition">The evaluated condition</param>\r
 129                 /// <param name="message">The message to display if the condition is true</param>\r
 130                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 131                 static public void IsFalse(bool condition, string message, params object[] args) \r
 132                 {\r
 133             Assert.That(condition, Is.False, message, args);\r
 134                 }\r
 135                 \r
 136                 /// <summary>\r
 137                 /// Asserts that a condition is false. If the condition is true the method throws\r
 138                 /// an <see cref="AssertionException"/>.\r
 139                 /// </summary>\r
 140                 /// <param name="condition">The evaluated condition</param>\r
 141                 /// <param name="message">The message to display if the condition is true</param>\r
 142                 static public void IsFalse(bool condition, string message) \r
 143                 {\r
 144                         Assert.IsFalse( condition, message, null );\r
 145                 }\r
 146                 \r
 147                 /// <summary>\r
 148                 /// Asserts that a condition is false. If the condition is true the method throws\r
 149                 /// an <see cref="AssertionException"/>.\r
 150                 /// </summary>\r
 151                 /// <param name="condition">The evaluated condition</param>\r
 152                 static public void IsFalse(bool condition) \r
 153                 {\r
 154                         Assert.IsFalse(condition, string.Empty, null);\r
 155                 }\r
 156 \r
 157                 #endregion\r
 158 \r
 159                 #region IsNotNull\r
 160 \r
 161                 /// <summary>\r
 162                 /// Verifies that the object that is passed in is not equal to <code>null</code>\r
 163                 /// If the object is <code>null</code> then an <see cref="AssertionException"/>\r
 164                 /// is thrown.\r
 165                 /// </summary>\r
 166                 /// <param name="anObject">The object that is to be tested</param>\r
 167                 /// <param name="message">The message to be displayed when the object is null</param>\r
 168                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 169                 static public void IsNotNull(Object anObject, string message, params object[] args) \r
 170                 {\r
 171             Assert.That(anObject, Is.Not.Null, message, args);\r
 172                 }\r
 173 \r
 174                 /// <summary>\r
 175                 /// Verifies that the object that is passed in is not equal to <code>null</code>\r
 176                 /// If the object is <code>null</code> then an <see cref="AssertionException"/>\r
 177                 /// is thrown.\r
 178                 /// </summary>\r
 179                 /// <param name="anObject">The object that is to be tested</param>\r
 180                 /// <param name="message">The message to be displayed when the object is null</param>\r
 181                 static public void IsNotNull(Object anObject, string message) \r
 182                 {\r
 183                         Assert.IsNotNull(anObject, message, null);\r
 184                 }\r
 185     \r
 186                 /// <summary>\r
 187                 /// Verifies that the object that is passed in is not equal to <code>null</code>\r
 188                 /// If the object is <code>null</code> then an <see cref="AssertionException"/>\r
 189                 /// is thrown.\r
 190                 /// </summary>\r
 191                 /// <param name="anObject">The object that is to be tested</param>\r
 192                 static public void IsNotNull(Object anObject) \r
 193                 {\r
 194                         Assert.IsNotNull(anObject, string.Empty, null);\r
 195                 }\r
 196     \r
 197                 #endregion\r
 198                     \r
 199                 #region IsNull\r
 200 \r
 201                 /// <summary>\r
 202                 /// Verifies that the object that is passed in is equal to <code>null</code>\r
 203                 /// If the object is not <code>null</code> then an <see cref="AssertionException"/>\r
 204                 /// is thrown.\r
 205                 /// </summary>\r
 206                 /// <param name="anObject">The object that is to be tested</param>\r
 207                 /// <param name="message">The message to be displayed when the object is not null</param>\r
 208                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 209                 static public void IsNull(Object anObject, string message, params object[] args) \r
 210                 {\r
 211                         Assert.That( anObject, Is.Null, message, args );\r
 212                 }\r
 213 \r
 214                 /// <summary>\r
 215                 /// Verifies that the object that is passed in is equal to <code>null</code>\r
 216                 /// If the object is not <code>null</code> then an <see cref="AssertionException"/>\r
 217                 /// is thrown.\r
 218                 /// </summary>\r
 219                 /// <param name="anObject">The object that is to be tested</param>\r
 220                 /// <param name="message">The message to be displayed when the object is not null</param>\r
 221                 static public void IsNull(Object anObject, string message) \r
 222                 {\r
 223                         Assert.IsNull(anObject, message, null);\r
 224                 }\r
 225     \r
 226                 /// <summary>\r
 227                 /// Verifies that the object that is passed in is equal to <code>null</code>\r
 228                 /// If the object is not null <code>null</code> then an <see cref="AssertionException"/>\r
 229                 /// is thrown.\r
 230                 /// </summary>\r
 231                 /// <param name="anObject">The object that is to be tested</param>\r
 232                 static public void IsNull(Object anObject) \r
 233                 {\r
 234                         Assert.IsNull(anObject, string.Empty, null);\r
 235                 }\r
 236     \r
 237                 #endregion\r
 238 \r
 239                 #region IsNaN\r
 240 \r
 241                 /// <summary>\r
 242                 /// Verifies that the double is passed is an <code>NaN</code> value.\r
 243                 /// If the object is not <code>NaN</code> then an <see cref="AssertionException"/>\r
 244                 /// is thrown.\r
 245                 /// </summary>\r
 246                 /// <param name="aDouble">The value that is to be tested</param>\r
 247                 /// <param name="message">The message to be displayed when the object is not null</param>\r
 248                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 249                 static public void IsNaN(double aDouble, string message, params object[] args) \r
 250                 {\r
 251             Assert.That(aDouble, Is.NaN, message, args);\r
 252                 }\r
 253 \r
 254                 /// <summary>\r
 255                 /// Verifies that the double is passed is an <code>NaN</code> value.\r
 256                 /// If the object is not <code>NaN</code> then an <see cref="AssertionException"/>\r
 257                 /// is thrown.\r
 258                 /// </summary>\r
 259                 /// <param name="aDouble">The object that is to be tested</param>\r
 260                 /// <param name="message">The message to be displayed when the object is not null</param>\r
 261                 static public void IsNaN(double aDouble, string message) \r
 262                 {\r
 263                         Assert.IsNaN(aDouble, message, null);\r
 264                 }\r
 265     \r
 266                 /// <summary>\r
 267                 /// Verifies that the double is passed is an <code>NaN</code> value.\r
 268                 /// If the object is not <code>NaN</code> then an <see cref="AssertionException"/>\r
 269                 /// is thrown.\r
 270                 /// </summary>\r
 271                 /// <param name="aDouble">The object that is to be tested</param>\r
 272                 static public void IsNaN(double aDouble) \r
 273                 {\r
 274                         Assert.IsNaN(aDouble, string.Empty, null);\r
 275                 }\r
 276     \r
 277                 #endregion\r
 278 \r
 279                 #region IsEmpty\r
 280 \r
 281                 /// <summary>\r
 282                 /// Assert that a string is empty - that is equal to string.Empty\r
 283                 /// </summary>\r
 284                 /// <param name="aString">The string to be tested</param>\r
 285                 /// <param name="message">The message to be displayed on failure</param>\r
 286                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 287                 public static void IsEmpty( string aString, string message, params object[] args )\r
 288                 {\r
 289             Assert.That(aString, new EmptyStringConstraint(), message, args);\r
 290                 }\r
 291 \r
 292                 /// <summary>\r
 293                 /// Assert that a string is empty - that is equal to string.Emtpy\r
 294                 /// </summary>\r
 295                 /// <param name="aString">The string to be tested</param>\r
 296                 /// <param name="message">The message to be displayed on failure</param>\r
 297                 public static void IsEmpty( string aString, string message )\r
 298                 {\r
 299                         IsEmpty( aString, message, null );\r
 300                 }\r
 301 \r
 302                 /// <summary>\r
 303                 /// Assert that a string is empty - that is equal to string.Emtpy\r
 304                 /// </summary>\r
 305                 /// <param name="aString">The string to be tested</param>\r
 306                 public static void IsEmpty( string aString )\r
 307                 {\r
 308                         IsEmpty( aString, string.Empty, null );\r
 309                 }\r
 310 \r
 311                 /// <summary>\r
 312                 /// Assert that an array, list or other collection is empty\r
 313                 /// </summary>\r
 314                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 315                 /// <param name="message">The message to be displayed on failure</param>\r
 316                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 317                 public static void IsEmpty( ICollection collection, string message, params object[] args )\r
 318                 {\r
 319             Assert.That(collection, new EmptyCollectionConstraint(), message, args);\r
 320                 }\r
 321 \r
 322                 /// <summary>\r
 323                 /// Assert that an array, list or other collection is empty\r
 324                 /// </summary>\r
 325                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 326                 /// <param name="message">The message to be displayed on failure</param>\r
 327                 public static void IsEmpty( ICollection collection, string message )\r
 328                 {\r
 329                         IsEmpty( collection, message, null );\r
 330                 }\r
 331 \r
 332                 /// <summary>\r
 333                 /// Assert that an array,list or other collection is empty\r
 334                 /// </summary>\r
 335                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 336                 public static void IsEmpty( ICollection collection )\r
 337                 {\r
 338                         IsEmpty( collection, string.Empty, null );\r
 339                 }\r
 340                 #endregion\r
 341 \r
 342                 #region IsNotEmpty\r
 343                 /// <summary>\r
 344                 /// Assert that a string is not empty - that is not equal to string.Empty\r
 345                 /// </summary>\r
 346                 /// <param name="aString">The string to be tested</param>\r
 347                 /// <param name="message">The message to be displayed on failure</param>\r
 348                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 349                 public static void IsNotEmpty( string aString, string message, params object[] args )\r
 350                 {\r
 351             Assert.That(aString, Is.Not.Empty, message, args);\r
 352                 }\r
 353 \r
 354                 /// <summary>\r
 355                 /// Assert that a string is empty - that is equal to string.Emtpy\r
 356                 /// </summary>\r
 357                 /// <param name="aString">The string to be tested</param>\r
 358                 /// <param name="message">The message to be displayed on failure</param>\r
 359                 public static void IsNotEmpty( string aString, string message )\r
 360                 {\r
 361                         IsNotEmpty( aString, message, null );\r
 362                 }\r
 363 \r
 364                 /// <summary>\r
 365                 /// Assert that a string is empty - that is equal to string.Emtpy\r
 366                 /// </summary>\r
 367                 /// <param name="aString">The string to be tested</param>\r
 368                 public static void IsNotEmpty( string aString )\r
 369                 {\r
 370                         IsNotEmpty( aString, string.Empty, null );\r
 371                 }\r
 372 \r
 373                 /// <summary>\r
 374                 /// Assert that an array, list or other collection is empty\r
 375                 /// </summary>\r
 376                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 377                 /// <param name="message">The message to be displayed on failure</param>\r
 378                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 379                 public static void IsNotEmpty( ICollection collection, string message, params object[] args )\r
 380                 {\r
 381             Assert.That(collection, Is.Not.Empty, message, args);\r
 382                 }\r
 383 \r
 384                 /// <summary>\r
 385                 /// Assert that an array, list or other collection is empty\r
 386                 /// </summary>\r
 387                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 388                 /// <param name="message">The message to be displayed on failure</param>\r
 389                 public static void IsNotEmpty( ICollection collection, string message )\r
 390                 {\r
 391                         IsNotEmpty( collection, message, null );\r
 392                 }\r
 393 \r
 394                 /// <summary>\r
 395                 /// Assert that an array,list or other collection is empty\r
 396                 /// </summary>\r
 397                 /// <param name="collection">An array, list or other collection implementing ICollection</param>\r
 398                 public static void IsNotEmpty( ICollection collection )\r
 399                 {\r
 400                         IsNotEmpty( collection, string.Empty, null );\r
 401                 }\r
 402                 #endregion\r
 403 \r
 404                 #region IsAssignableFrom\r
 405                 /// <summary>\r
 406                 /// Asserts that an object may be assigned a  value of a given Type.\r
 407                 /// </summary>\r
 408                 /// <param name="expected">The expected Type.</param>\r
 409                 /// <param name="actual">The object under examination</param>\r
 410                 static public void IsAssignableFrom( System.Type expected, object actual )\r
 411                 {\r
 412                         IsAssignableFrom(expected, actual, "");\r
 413                 }\r
 414 \r
 415                 /// <summary>\r
 416                 /// Asserts that an object may be assigned a  value of a given Type.\r
 417                 /// </summary>\r
 418                 /// <param name="expected">The expected Type.</param>\r
 419                 /// <param name="actual">The object under examination</param>\r
 420                 /// <param name="message">The messge to display in case of failure</param>\r
 421                 static public void IsAssignableFrom( System.Type expected, object actual, string message )\r
 422                 {\r
 423                         IsAssignableFrom(expected, actual, message, null);\r
 424                 }\r
 425                 \r
 426                 /// <summary>\r
 427                 /// Asserts that an object may be assigned a  value of a given Type.\r
 428                 /// </summary>\r
 429                 /// <param name="expected">The expected Type.</param>\r
 430                 /// <param name="actual">The object under examination</param>\r
 431                 /// <param name="message">The message to display in case of failure</param>\r
 432                 /// <param name="args">Array of objects to be used in formatting the message</param>\r
 433                 static public void IsAssignableFrom( System.Type expected, object actual, string message, params object[] args )\r
 434                 {\r
 435             Assert.That(actual, Is.AssignableFrom(expected), message, args);\r
 436                 }\r
 437                 #endregion\r
 438                 \r
 439                 #region IsNotAssignableFrom\r
 440                 /// <summary>\r
 441                 /// Asserts that an object may not be assigned a  value of a given Type.\r
 442                 /// </summary>\r
 443                 /// <param name="expected">The expected Type.</param>\r
 444                 /// <param name="actual">The object under examination</param>\r
 445                 static public void IsNotAssignableFrom( System.Type expected, object actual )\r
 446                 {\r
 447                         IsNotAssignableFrom(expected, actual, "");\r
 448                 }\r
 449                 \r
 450                 /// <summary>\r
 451                 /// Asserts that an object may not be assigned a  value of a given Type.\r
 452                 /// </summary>\r
 453                 /// <param name="expected">The expected Type.</param>\r
 454                 /// <param name="actual">The object under examination</param>\r
 455                 /// <param name="message">The messge to display in case of failure</param>\r
 456                 static public void IsNotAssignableFrom( System.Type expected, object actual, string message )\r
 457                 {\r
 458                         IsNotAssignableFrom(expected, actual, message, null);\r
 459                 }\r
 460                 \r
 461                 /// <summary>\r
 462                 /// Asserts that an object may not be assigned a  value of a given Type.\r
 463                 /// </summary>\r
 464                 /// <param name="expected">The expected Type.</param>\r
 465                 /// <param name="actual">The object under examination</param>\r
 466                 /// <param name="message">The message to display in case of failure</param>\r
 467                 /// <param name="args">Array of objects to be used in formatting the message</param>\r
 468                 static public void IsNotAssignableFrom( System.Type expected, object actual, string message, params object[] args )\r
 469                 {\r
 470             Assert.That(actual, Is.Not.AssignableFrom(expected), message, args);\r
 471                 }\r
 472                 #endregion\r
 473                 \r
 474                 #region IsInstanceOfType\r
 475                 /// <summary>\r
 476                 /// Asserts that an object is an instance of a given type.\r
 477                 /// </summary>\r
 478                 /// <param name="expected">The expected Type</param>\r
 479                 /// <param name="actual">The object being examined</param>\r
 480                 public static void IsInstanceOfType( System.Type expected, object actual )\r
 481                 {\r
 482                         IsInstanceOfType( expected, actual, string.Empty, null );\r
 483                 }\r
 484 \r
 485                 /// <summary>\r
 486                 /// Asserts that an object is an instance of a given type.\r
 487                 /// </summary>\r
 488                 /// <param name="expected">The expected Type</param>\r
 489                 /// <param name="actual">The object being examined</param>\r
 490                 /// <param name="message">A message to display in case of failure</param>\r
 491                 public static void IsInstanceOfType( System.Type expected, object actual, string message )\r
 492                 {\r
 493                         IsInstanceOfType( expected, actual, message, null );\r
 494                 }\r
 495 \r
 496                 /// <summary>\r
 497                 /// Asserts that an object is an instance of a given type.\r
 498                 /// </summary>\r
 499                 /// <param name="expected">The expected Type</param>\r
 500                 /// <param name="actual">The object being examined</param>\r
 501                 /// <param name="message">A message to display in case of failure</param>\r
 502                 /// <param name="args">An array of objects to be used in formatting the message</param>\r
 503                 public static void IsInstanceOfType( System.Type expected, object actual, string message, params object[] args )\r
 504                 {\r
 505             Assert.That(actual, Is.InstanceOfType(expected), message, args);\r
 506                 }\r
 507                 #endregion\r
 508 \r
 509                 #region IsNotInstanceOfType\r
 510                 /// <summary>\r
 511                 /// Asserts that an object is not an instance of a given type.\r
 512                 /// </summary>\r
 513                 /// <param name="expected">The expected Type</param>\r
 514                 /// <param name="actual">The object being examined</param>\r
 515                 public static void IsNotInstanceOfType( System.Type expected, object actual )\r
 516                 {\r
 517                         IsNotInstanceOfType( expected, actual, string.Empty, null );\r
 518                 }\r
 519 \r
 520                 /// <summary>\r
 521                 /// Asserts that an object is not an instance of a given type.\r
 522                 /// </summary>\r
 523                 /// <param name="expected">The expected Type</param>\r
 524                 /// <param name="actual">The object being examined</param>\r
 525                 /// <param name="message">A message to display in case of failure</param>\r
 526                 public static void IsNotInstanceOfType( System.Type expected, object actual, string message )\r
 527                 {\r
 528                         IsNotInstanceOfType( expected, actual, message, null );\r
 529                 }\r
 530 \r
 531                 /// <summary>\r
 532                 /// Asserts that an object is not an instance of a given type.\r
 533                 /// </summary>\r
 534                 /// <param name="expected">The expected Type</param>\r
 535                 /// <param name="actual">The object being examined</param>\r
 536                 /// <param name="message">A message to display in case of failure</param>\r
 537                 /// <param name="args">An array of objects to be used in formatting the message</param>\r
 538                 public static void IsNotInstanceOfType( System.Type expected, object actual, string message, params object[] args )\r
 539                 {\r
 540             Assert.That(actual, Is.Not.InstanceOfType(expected), message, args);\r
 541                 }\r
 542                 #endregion\r
 543 \r
 544                 #region AreEqual\r
 545 \r
 546         #region Ints\r
 547 \r
 548         /// <summary>\r
 549         /// Verifies that two ints are equal. If they are not, then an \r
 550         /// <see cref="AssertionException"/> is thrown.\r
 551         /// </summary>\r
 552         /// <param name="expected">The expected value</param>\r
 553         /// <param name="actual">The actual value</param>\r
 554                 /// <param name="message">The message that will be displayed on failure</param>\r
 555                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 556                 static public void AreEqual(int expected,\r
 557             int actual, string message, params object[] args)\r
 558         {\r
 559             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 560         }\r
 561 \r
 562         /// <summary>\r
 563         /// Verifies that two ints are equal. If they are not, then an \r
 564         /// <see cref="AssertionException"/> is thrown.\r
 565         /// </summary>\r
 566         /// <param name="expected">The expected value</param>\r
 567         /// <param name="actual">The actual value</param>\r
 568         /// <param name="message">The message that will be displayed on failure</param>\r
 569         static public void AreEqual(int expected, int actual, string message)\r
 570         {\r
 571             Assert.AreEqual(expected, actual, message, null);\r
 572         }\r
 573 \r
 574         /// <summary>\r
 575         /// Verifies that two ints are equal. If they are not, then an \r
 576         /// <see cref="AssertionException"/> is thrown.\r
 577         /// </summary>\r
 578         /// <param name="expected">The expected value</param>\r
 579         /// <param name="actual">The actual value</param>\r
 580         static public void AreEqual(int expected, int actual)\r
 581         {\r
 582             Assert.AreEqual(expected, actual, string.Empty, null);\r
 583         }\r
 584 \r
 585         #endregion\r
 586 \r
 587         #region Longs\r
 588 \r
 589         /// <summary>\r
 590         /// Verifies that two longs are equal. If they are not, then an \r
 591         /// <see cref="AssertionException"/> is thrown.\r
 592         /// </summary>\r
 593         /// <param name="expected">The expected value</param>\r
 594         /// <param name="actual">The actual value</param>\r
 595         /// <param name="message">The message that will be displayed on failure</param>\r
 596         /// <param name="args">Arguments to be used in formatting the message</param>\r
 597         static public void AreEqual(long expected,\r
 598             long actual, string message, params object[] args)\r
 599         {\r
 600             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 601         }\r
 602 \r
 603         /// <summary>\r
 604         /// Verifies that two longs are equal. If they are not, then an \r
 605         /// <see cref="AssertionException"/> is thrown.\r
 606         /// </summary>\r
 607         /// <param name="expected">The expected value</param>\r
 608         /// <param name="actual">The actual value</param>\r
 609         /// <param name="message">The message that will be displayed on failure</param>\r
 610         static public void AreEqual(long expected, long actual, string message)\r
 611         {\r
 612             Assert.AreEqual(expected, actual, message, null);\r
 613         }\r
 614 \r
 615         /// <summary>\r
 616         /// Verifies that two longs are equal. If they are not, then an \r
 617         /// <see cref="AssertionException"/> is thrown.\r
 618         /// </summary>\r
 619         /// <param name="expected">The expected value</param>\r
 620         /// <param name="actual">The actual value</param>\r
 621         static public void AreEqual(long expected, long actual)\r
 622         {\r
 623             Assert.AreEqual(expected, actual, string.Empty, null);\r
 624         }\r
 625 \r
 626         #endregion\r
 627 \r
 628         #region UInts\r
 629 \r
 630         /// <summary>\r
 631         /// Verifies that two uints are equal. If they are not, then an \r
 632         /// <see cref="AssertionException"/> is thrown.\r
 633         /// </summary>\r
 634         /// <param name="expected">The expected value</param>\r
 635         /// <param name="actual">The actual value</param>\r
 636         /// <param name="message">The message that will be displayed on failure</param>\r
 637         /// <param name="args">Arguments to be used in formatting the message</param>\r
 638                 [CLSCompliant(false)]\r
 639                 static public void AreEqual(uint expected,\r
 640             uint actual, string message, params object[] args)\r
 641         {\r
 642             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 643         }\r
 644 \r
 645         /// <summary>\r
 646         /// Verifies that two uints are equal. If they are not, then an \r
 647         /// <see cref="AssertionException"/> is thrown.\r
 648         /// </summary>\r
 649         /// <param name="expected">The expected value</param>\r
 650         /// <param name="actual">The actual value</param>\r
 651         /// <param name="message">The message that will be displayed on failure</param>\r
 652                 [CLSCompliant(false)]\r
 653                 static public void AreEqual(uint expected, uint actual, string message)\r
 654         {\r
 655             Assert.AreEqual(expected, actual, message, null);\r
 656         }\r
 657 \r
 658         /// <summary>\r
 659         /// Verifies that two uints are equal. If they are not, then an \r
 660         /// <see cref="AssertionException"/> is thrown.\r
 661         /// </summary>\r
 662         /// <param name="expected">The expected value</param>\r
 663         /// <param name="actual">The actual value</param>\r
 664                 [CLSCompliant(false)]\r
 665                 static public void AreEqual(uint expected, uint actual)\r
 666         {\r
 667             Assert.AreEqual(expected, actual, string.Empty, null);\r
 668         }\r
 669 \r
 670         #endregion\r
 671 \r
 672         #region Ulongs\r
 673 \r
 674         /// <summary>\r
 675         /// Verifies that two ulongs are equal. If they are not, then an \r
 676         /// <see cref="AssertionException"/> is thrown.\r
 677         /// </summary>\r
 678         /// <param name="expected">The expected value</param>\r
 679         /// <param name="actual">The actual value</param>\r
 680         /// <param name="message">The message that will be displayed on failure</param>\r
 681         /// <param name="args">Arguments to be used in formatting the message</param>\r
 682                 [CLSCompliant(false)]\r
 683                 static public void AreEqual(ulong expected,\r
 684             ulong actual, string message, params object[] args)\r
 685         {\r
 686             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 687         }\r
 688 \r
 689         /// <summary>\r
 690         /// Verifies that two ulongs are equal. If they are not, then an \r
 691         /// <see cref="AssertionException"/> is thrown.\r
 692         /// </summary>\r
 693         /// <param name="expected">The expected value</param>\r
 694         /// <param name="actual">The actual value</param>\r
 695         /// <param name="message">The message that will be displayed on failure</param>\r
 696                 [CLSCompliant(false)]\r
 697                 static public void AreEqual(ulong expected, ulong actual, string message)\r
 698         {\r
 699             Assert.AreEqual(expected, actual, message, null);\r
 700         }\r
 701 \r
 702         /// <summary>\r
 703         /// Verifies that two ulongs are equal. If they are not, then an \r
 704         /// <see cref="AssertionException"/> is thrown.\r
 705         /// </summary>\r
 706         /// <param name="expected">The expected value</param>\r
 707         /// <param name="actual">The actual value</param>\r
 708                 [CLSCompliant(false)]\r
 709                 static public void AreEqual(ulong expected, ulong actual)\r
 710         {\r
 711             Assert.AreEqual(expected, actual, string.Empty, null);\r
 712         }\r
 713 \r
 714         #endregion\r
 715 \r
 716         #region Decimals\r
 717 \r
 718                 /// <summary>\r
 719                 /// Verifies that two decimals are equal. If they are not, then an \r
 720                 /// <see cref="AssertionException"/> is thrown.\r
 721                 /// </summary>\r
 722                 /// <param name="expected">The expected value</param>\r
 723                 /// <param name="actual">The actual value</param>\r
 724                 /// <param name="message">The message that will be displayed on failure</param>\r
 725                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 726                 static public void AreEqual(decimal expected, \r
 727                         decimal actual, string message, params object[] args) \r
 728                 {\r
 729             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 730         }\r
 731 \r
 732                 /// <summary>\r
 733                 /// Verifies that two decimal are equal. If they are not, then an \r
 734                 /// <see cref="AssertionException"/> is thrown.\r
 735                 /// </summary>\r
 736                 /// <param name="expected">The expected value</param>\r
 737                 /// <param name="actual">The actual value</param>\r
 738                 /// <param name="message">The message that will be displayed on failure</param>\r
 739                 static public void AreEqual(decimal expected, decimal actual, string message) \r
 740                 {\r
 741                         Assert.AreEqual( expected, actual, message, null );\r
 742                 }\r
 743 \r
 744                 /// <summary>\r
 745                 /// Verifies that two decimals are equal. If they are not, then an \r
 746                 /// <see cref="AssertionException"/> is thrown.\r
 747                 /// </summary>\r
 748                 /// <param name="expected">The expected value</param>\r
 749                 /// <param name="actual">The actual value</param>\r
 750                 static public void AreEqual(decimal expected, decimal actual ) \r
 751                 {\r
 752                         Assert.AreEqual( expected, actual, string.Empty, null );\r
 753                 }\r
 754 \r
 755                 #endregion\r
 756 \r
 757                 #region Doubles\r
 758 \r
 759                 /// <summary>\r
 760                 /// Verifies that two doubles are equal considering a delta. If the\r
 761                 /// expected value is infinity then the delta value is ignored. If \r
 762                 /// they are not equals then an <see cref="AssertionException"/> is\r
 763                 /// thrown.\r
 764                 /// </summary>\r
 765                 /// <param name="expected">The expected value</param>\r
 766                 /// <param name="actual">The actual value</param>\r
 767                 /// <param name="delta">The maximum acceptable difference between the\r
 768                 /// the expected and the actual</param>\r
 769                 /// <param name="message">The message that will be displayed on failure</param>\r
 770                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 771                 static public void AreEqual(double expected, \r
 772                         double actual, double delta, string message, params object[] args) \r
 773                 {\r
 774                         Constraint constraint = new EqualConstraint( expected );\r
 775                         if ( double.IsNaN(expected) || double.IsInfinity(expected) )\r
 776                                 Assert.That(actual, Is.EqualTo( expected ), message, args);\r
 777                         else\r
 778                                 Assert.That(actual, Is.EqualTo(expected).Within(delta), message, args);\r
 779         }\r
 780 \r
 781                 /// <summary>\r
 782                 /// Verifies that two doubles are equal considering a delta. If the\r
 783                 /// expected value is infinity then the delta value is ignored. If \r
 784                 /// they are not equals then an <see cref="AssertionException"/> is\r
 785                 /// thrown.\r
 786                 /// </summary>\r
 787                 /// <param name="expected">The expected value</param>\r
 788                 /// <param name="actual">The actual value</param>\r
 789                 /// <param name="delta">The maximum acceptable difference between the\r
 790                 /// the expected and the actual</param>\r
 791                 /// <param name="message">The message that will be displayed on failure</param>\r
 792                 static public void AreEqual(double expected, \r
 793                         double actual, double delta, string message) \r
 794                 {\r
 795                         Assert.AreEqual( expected, actual, delta, message, null );\r
 796                 }\r
 797 \r
 798                 /// <summary>\r
 799                 /// Verifies that two doubles are equal considering a delta. If the\r
 800                 /// expected value is infinity then the delta value is ignored. If \r
 801                 /// they are not equals then an <see cref="AssertionException"/> is\r
 802                 /// thrown.\r
 803                 /// </summary>\r
 804                 /// <param name="expected">The expected value</param>\r
 805                 /// <param name="actual">The actual value</param>\r
 806                 /// <param name="delta">The maximum acceptable difference between the\r
 807                 /// the expected and the actual</param>\r
 808                 static public void AreEqual(double expected, double actual, double delta) \r
 809                 {\r
 810                         Assert.AreEqual(expected, actual, delta, string.Empty, null);\r
 811                 }\r
 812 \r
 813                 #endregion\r
 814 \r
 815                 #region Floats\r
 816 \r
 817                 /// <summary>\r
 818                 /// Verifies that two floats are equal considering a delta. If the\r
 819                 /// expected value is infinity then the delta value is ignored. If \r
 820                 /// they are not equals then an <see cref="AssertionException"/> is\r
 821                 /// thrown.\r
 822                 /// </summary>\r
 823                 /// <param name="expected">The expected value</param>\r
 824                 /// <param name="actual">The actual value</param>\r
 825                 /// <param name="delta">The maximum acceptable difference between the\r
 826                 /// the expected and the actual</param>\r
 827                 /// <param name="message">The message displayed upon failure</param>\r
 828                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 829                 static public void AreEqual(float expected, \r
 830                         float actual, float delta, string message, params object[] args) \r
 831                 {\r
 832                         if (float.IsNaN(expected) || float.IsInfinity(expected))\r
 833                                 Assert.That(actual, Is.EqualTo( expected), message, args );\r
 834                         else\r
 835                                 Assert.That(actual, Is.EqualTo(expected).Within(delta), message, args);\r
 836                 }\r
 837 \r
 838                 /// <summary>\r
 839                 /// Verifies that two floats are equal considering a delta. If the\r
 840                 /// expected value is infinity then the delta value is ignored. If \r
 841                 /// they are not equals then an <see cref="AssertionException"/> is\r
 842                 /// thrown.\r
 843                 /// </summary>\r
 844                 /// <param name="expected">The expected value</param>\r
 845                 /// <param name="actual">The actual value</param>\r
 846                 /// <param name="delta">The maximum acceptable difference between the\r
 847                 /// the expected and the actual</param>\r
 848                 /// <param name="message">The message displayed upon failure</param>\r
 849                 static public void AreEqual(float expected, float actual, float delta, string message) \r
 850                 {\r
 851                         Assert.AreEqual(expected, actual, delta, message, null);\r
 852                 }\r
 853 \r
 854                 /// <summary>\r
 855                 /// Verifies that two floats are equal considering a delta. If the\r
 856                 /// expected value is infinity then the delta value is ignored. If \r
 857                 /// they are not equals then an <see cref="AssertionException"/> is\r
 858                 /// thrown.\r
 859                 /// </summary>\r
 860                 /// <param name="expected">The expected value</param>\r
 861                 /// <param name="actual">The actual value</param>\r
 862                 /// <param name="delta">The maximum acceptable difference between the\r
 863                 /// the expected and the actual</param>\r
 864                 static public void AreEqual(float expected, float actual, float delta) \r
 865                 {\r
 866                         Assert.AreEqual(expected, actual, delta, string.Empty, null);\r
 867                 }\r
 868 \r
 869                 #endregion\r
 870 \r
 871                 #region Objects\r
 872                 \r
 873                 /// <summary>\r
 874                 /// Verifies that two objects are equal.  Two objects are considered\r
 875                 /// equal if both are null, or if both have the same value.  All\r
 876                 /// non-numeric types are compared by using the <c>Equals</c> method.\r
 877                 /// Arrays are compared by comparing each element using the same rules.\r
 878                 /// If they are not equal an <see cref="AssertionException"/> is thrown.\r
 879                 /// </summary>\r
 880                 /// <param name="expected">The value that is expected</param>\r
 881                 /// <param name="actual">The actual value</param>\r
 882                 /// <param name="message">The message to display if objects are not equal</param>\r
 883                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 884                 static public void AreEqual(Object expected, Object actual, string message, params object[] args)\r
 885                 {\r
 886             Assert.That(actual, Is.EqualTo(expected), message, args);\r
 887         }\r
 888 \r
 889                 /// <summary>\r
 890                 /// Verifies that two objects are equal.  Two objects are considered\r
 891                 /// equal if both are null, or if both have the same value.  All\r
 892                 /// non-numeric types are compared by using the <c>Equals</c> method.\r
 893                 /// If they are not equal an <see cref="AssertionException"/> is thrown.\r
 894                 /// </summary>\r
 895                 /// <param name="expected">The value that is expected</param>\r
 896                 /// <param name="actual">The actual value</param>\r
 897                 /// <param name="message">The message to display if objects are not equal</param>\r
 898                 static public void AreEqual(Object expected, Object actual, string message) \r
 899                 {\r
 900                         Assert.AreEqual(expected, actual, message, null);\r
 901                 }\r
 902 \r
 903                 /// <summary>\r
 904                 /// Verifies that two objects are equal.  Two objects are considered\r
 905                 /// equal if both are null, or if both have the same value.  All\r
 906                 /// non-numeric types are compared by using the <c>Equals</c> method.\r
 907                 /// If they are not equal an <see cref="AssertionException"/> is thrown.\r
 908                 /// </summary>\r
 909                 /// <param name="expected">The value that is expected</param>\r
 910                 /// <param name="actual">The actual value</param>\r
 911                 static public void AreEqual(Object expected, Object actual) \r
 912                 {\r
 913                         Assert.AreEqual(expected, actual, string.Empty, null);\r
 914                 }\r
 915 \r
 916                 #endregion\r
 917 \r
 918                 #endregion\r
 919 \r
 920                 #region AreNotEqual\r
 921 \r
 922                 #region Objects\r
 923                 /// <summary>\r
 924                 /// Asserts that two objects are not equal. If they are equal\r
 925                 /// an <see cref="AssertionException"/> is thrown.\r
 926                 /// </summary>\r
 927                 /// <param name="expected">The expected object</param>\r
 928                 /// <param name="actual">The actual object</param>\r
 929                 /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
 930                 /// <param name="args">Arguments to be used in formatting the message</param>\r
 931                 static public void AreNotEqual( Object expected, Object actual, string message, params object[] args)\r
 932                 {\r
 933             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
 934         }\r
 935 \r
 936                 /// <summary>\r
 937                 /// Asserts that two objects are not equal. If they are equal\r
 938                 /// an <see cref="AssertionException"/> is thrown.\r
 939                 /// </summary>\r
 940                 /// <param name="expected">The expected object</param>\r
 941                 /// <param name="actual">The actual object</param>\r
 942                 /// <param name="message">The message to be displayed when the objects are the same</param>\r
 943                 static public void AreNotEqual(Object expected, Object actual, string message) \r
 944                 {\r
 945                         Assert.AreNotEqual(expected, actual, message, null);\r
 946                 }\r
 947    \r
 948                 /// <summary>\r
 949                 /// Asserts that two objects are not equal. If they are equal\r
 950                 /// an <see cref="AssertionException"/> is thrown.\r
 951                 /// </summary>\r
 952                 /// <param name="expected">The expected object</param>\r
 953                 /// <param name="actual">The actual object</param>\r
 954                 static public void AreNotEqual(Object expected, Object actual) \r
 955                 {\r
 956                         Assert.AreNotEqual(expected, actual, string.Empty, null);\r
 957                 }\r
 958    \r
 959                 #endregion\r
 960 \r
 961         #region Ints\r
 962         /// <summary>\r
 963         /// Asserts that two ints are not equal. If they are equal\r
 964         /// an <see cref="AssertionException"/> is thrown.\r
 965         /// </summary>\r
 966         /// <param name="expected">The expected object</param>\r
 967         /// <param name="actual">The actual object</param>\r
 968         /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
 969         /// <param name="args">Arguments to be used in formatting the message</param>\r
 970         static public void AreNotEqual(int expected, int actual, string message, params object[] args)\r
 971         {\r
 972             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
 973         }\r
 974 \r
 975         /// <summary>\r
 976         /// Asserts that two ints are not equal. If they are equal\r
 977         /// an <see cref="AssertionException"/> is thrown.\r
 978         /// </summary>\r
 979         /// <param name="expected">The expected object</param>\r
 980         /// <param name="actual">The actual object</param>\r
 981         /// <param name="message">The message to be displayed when the objects are the same</param>\r
 982         static public void AreNotEqual(int expected, int actual, string message)\r
 983         {\r
 984             Assert.AreNotEqual(expected, actual, message, null);\r
 985         }\r
 986 \r
 987         /// <summary>\r
 988         /// Asserts that two ints are not equal. If they are equal\r
 989         /// an <see cref="AssertionException"/> is thrown.\r
 990         /// </summary>\r
 991         /// <param name="expected">The expected object</param>\r
 992         /// <param name="actual">The actual object</param>\r
 993         static public void AreNotEqual(int expected, int actual)\r
 994         {\r
 995             Assert.AreNotEqual(expected, actual, string.Empty, null);\r
 996         }\r
 997         #endregion\r
 998 \r
 999         #region Longs\r
1000         /// <summary>\r
1001         /// Asserts that two longss are not equal. If they are equal\r
1002         /// an <see cref="AssertionException"/> is thrown.\r
1003         /// </summary>\r
1004         /// <param name="expected">The expected object</param>\r
1005         /// <param name="actual">The actual object</param>\r
1006         /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1007         /// <param name="args">Arguments to be used in formatting the message</param>\r
1008         static public void AreNotEqual(long expected, long actual, string message, params object[] args)\r
1009         {\r
1010             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1011         }\r
1012 \r
1013         /// <summary>\r
1014         /// Asserts that two longs are not equal. If they are equal\r
1015         /// an <see cref="AssertionException"/> is thrown.\r
1016         /// </summary>\r
1017         /// <param name="expected">The expected object</param>\r
1018         /// <param name="actual">The actual object</param>\r
1019         /// <param name="message">The message to be displayed when the objects are the same</param>\r
1020         static public void AreNotEqual(long expected, long actual, string message)\r
1021         {\r
1022             Assert.AreNotEqual(expected, actual, message, null);\r
1023         }\r
1024 \r
1025         /// <summary>\r
1026         /// Asserts that two longs are not equal. If they are equal\r
1027         /// an <see cref="AssertionException"/> is thrown.\r
1028         /// </summary>\r
1029         /// <param name="expected">The expected object</param>\r
1030         /// <param name="actual">The actual object</param>\r
1031         static public void AreNotEqual(long expected, long actual)\r
1032         {\r
1033             Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1034         }\r
1035         #endregion\r
1036 \r
1037         #region UInts\r
1038         /// <summary>\r
1039         /// Asserts that two uints are not equal. If they are equal\r
1040         /// an <see cref="AssertionException"/> is thrown.\r
1041         /// </summary>\r
1042         /// <param name="expected">The expected object</param>\r
1043         /// <param name="actual">The actual object</param>\r
1044         /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1045         /// <param name="args">Arguments to be used in formatting the message</param>\r
1046                 [CLSCompliant(false)]\r
1047                 static public void AreNotEqual(uint expected, uint actual, string message, params object[] args)\r
1048         {\r
1049             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1050         }\r
1051 \r
1052         /// <summary>\r
1053         /// Asserts that two uints are not equal. If they are equal\r
1054         /// an <see cref="AssertionException"/> is thrown.\r
1055         /// </summary>\r
1056         /// <param name="expected">The expected object</param>\r
1057         /// <param name="actual">The actual object</param>\r
1058         /// <param name="message">The message to be displayed when the objects are the same</param>\r
1059                 [CLSCompliant(false)]\r
1060                 static public void AreNotEqual(uint expected, uint actual, string message)\r
1061         {\r
1062             Assert.AreNotEqual(expected, actual, message, null);\r
1063         }\r
1064 \r
1065         /// <summary>\r
1066         /// Asserts that two uints are not equal. If they are equal\r
1067         /// an <see cref="AssertionException"/> is thrown.\r
1068         /// </summary>\r
1069         /// <param name="expected">The expected object</param>\r
1070         /// <param name="actual">The actual object</param>\r
1071                 [CLSCompliant(false)]\r
1072                 static public void AreNotEqual(uint expected, uint actual)\r
1073         {\r
1074             Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1075         }\r
1076         #endregion\r
1077 \r
1078         #region Ulongs\r
1079         /// <summary>\r
1080         /// Asserts that two ulongs are not equal. If they are equal\r
1081         /// an <see cref="AssertionException"/> is thrown.\r
1082         /// </summary>\r
1083         /// <param name="expected">The expected object</param>\r
1084         /// <param name="actual">The actual object</param>\r
1085         /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1086         /// <param name="args">Arguments to be used in formatting the message</param>\r
1087                 [CLSCompliant(false)]\r
1088                 static public void AreNotEqual(ulong expected, ulong actual, string message, params object[] args)\r
1089         {\r
1090             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1091         }\r
1092 \r
1093         /// <summary>\r
1094         /// Asserts that two ulongs are not equal. If they are equal\r
1095         /// an <see cref="AssertionException"/> is thrown.\r
1096         /// </summary>\r
1097         /// <param name="expected">The expected object</param>\r
1098         /// <param name="actual">The actual object</param>\r
1099         /// <param name="message">The message to be displayed when the objects are the same</param>\r
1100                 [CLSCompliant(false)]\r
1101                 static public void AreNotEqual(ulong expected, ulong actual, string message)\r
1102         {\r
1103             Assert.AreNotEqual(expected, actual, message, null);\r
1104         }\r
1105 \r
1106         /// <summary>\r
1107         /// Asserts that two ulong are not equal. If they are equal\r
1108         /// an <see cref="AssertionException"/> is thrown.\r
1109         /// </summary>\r
1110         /// <param name="expected">The expected object</param>\r
1111         /// <param name="actual">The actual object</param>\r
1112                 [CLSCompliant(false)]\r
1113                 static public void AreNotEqual(ulong expected, ulong actual)\r
1114         {\r
1115             Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1116         }\r
1117         #endregion\r
1118 \r
1119         #region Decimals\r
1120                 /// <summary>\r
1121                 /// Asserts that two decimals are not equal. If they are equal\r
1122                 /// an <see cref="AssertionException"/> is thrown.\r
1123                 /// </summary>\r
1124                 /// <param name="expected">The expected object</param>\r
1125                 /// <param name="actual">The actual object</param>\r
1126                 /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1127                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1128                 static public void AreNotEqual( decimal expected, decimal actual, string message, params object[] args)\r
1129                 {\r
1130             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1131         }\r
1132 \r
1133                 /// <summary>\r
1134                 /// Asserts that two decimals are not equal. If they are equal\r
1135                 /// an <see cref="AssertionException"/> is thrown.\r
1136                 /// </summary>\r
1137                 /// <param name="expected">The expected object</param>\r
1138                 /// <param name="actual">The actual object</param>\r
1139                 /// <param name="message">The message to be displayed when the objects are the same</param>\r
1140                 static public void AreNotEqual(decimal expected, decimal actual, string message) \r
1141                 {\r
1142                         Assert.AreNotEqual(expected, actual, message, null);\r
1143                 }\r
1144    \r
1145                 /// <summary>\r
1146                 /// Asserts that two decimals are not equal. If they are equal\r
1147                 /// an <see cref="AssertionException"/> is thrown.\r
1148                 /// </summary>\r
1149                 /// <param name="expected">The expected object</param>\r
1150                 /// <param name="actual">The actual object</param>\r
1151                 static public void AreNotEqual(decimal expected, decimal actual) \r
1152                 {\r
1153                         Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1154                 }\r
1155                 #endregion\r
1156 \r
1157                 #region Floats\r
1158                 /// <summary>\r
1159                 /// Asserts that two floats are not equal. If they are equal\r
1160                 /// an <see cref="AssertionException"/> is thrown.\r
1161                 /// </summary>\r
1162                 /// <param name="expected">The expected object</param>\r
1163                 /// <param name="actual">The actual object</param>\r
1164                 /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1165                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1166                 static public void AreNotEqual( float expected, float actual, string message, params object[] args)\r
1167                 {\r
1168             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1169                 }\r
1170 \r
1171                 /// <summary>\r
1172                 /// Asserts that two floats are not equal. If they are equal\r
1173                 /// an <see cref="AssertionException"/> is thrown.\r
1174                 /// </summary>\r
1175                 /// <param name="expected">The expected object</param>\r
1176                 /// <param name="actual">The actual object</param>\r
1177                 /// <param name="message">The message to be displayed when the objects are the same</param>\r
1178                 static public void AreNotEqual(float expected, float actual, string message) \r
1179                 {\r
1180                         Assert.AreNotEqual(expected, actual, message, null);\r
1181                 }\r
1182    \r
1183                 /// <summary>\r
1184                 /// Asserts that two floats are not equal. If they are equal\r
1185                 /// an <see cref="AssertionException"/> is thrown.\r
1186                 /// </summary>\r
1187                 /// <param name="expected">The expected object</param>\r
1188                 /// <param name="actual">The actual object</param>\r
1189                 static public void AreNotEqual(float expected, float actual) \r
1190                 {\r
1191                         Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1192                 }\r
1193                 #endregion\r
1194 \r
1195                 #region Doubles\r
1196                 /// <summary>\r
1197                 /// Asserts that two doubles are not equal. If they are equal\r
1198                 /// an <see cref="AssertionException"/> is thrown.\r
1199                 /// </summary>\r
1200                 /// <param name="expected">The expected object</param>\r
1201                 /// <param name="actual">The actual object</param>\r
1202                 /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1203                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1204                 static public void AreNotEqual( double expected, double actual, string message, params object[] args)\r
1205                 {\r
1206             Assert.That(actual, Is.Not.EqualTo(expected), message, args);\r
1207                 }\r
1208 \r
1209                 /// <summary>\r
1210                 /// Asserts that two doubles are not equal. If they are equal\r
1211                 /// an <see cref="AssertionException"/> is thrown.\r
1212                 /// </summary>\r
1213                 /// <param name="expected">The expected object</param>\r
1214                 /// <param name="actual">The actual object</param>\r
1215                 /// <param name="message">The message to be displayed when the objects are the same</param>\r
1216                 static public void AreNotEqual(double expected, double actual, string message) \r
1217                 {\r
1218                         Assert.AreNotEqual(expected, actual, message, null);\r
1219                 }\r
1220    \r
1221                 /// <summary>\r
1222                 /// Asserts that two doubles are not equal. If they are equal\r
1223                 /// an <see cref="AssertionException"/> is thrown.\r
1224                 /// </summary>\r
1225                 /// <param name="expected">The expected object</param>\r
1226                 /// <param name="actual">The actual object</param>\r
1227                 static public void AreNotEqual(double expected, double actual) \r
1228                 {\r
1229                         Assert.AreNotEqual(expected, actual, string.Empty, null);\r
1230                 }\r
1231                 #endregion\r
1232 \r
1233                 #endregion\r
1234 \r
1235                 #region AreSame\r
1236 \r
1237                 /// <summary>\r
1238                 /// Asserts that two objects refer to the same object. If they\r
1239                 /// are not the same an <see cref="AssertionException"/> is thrown.\r
1240                 /// </summary>\r
1241                 /// <param name="expected">The expected object</param>\r
1242                 /// <param name="actual">The actual object</param>\r
1243                 /// <param name="message">The message to be displayed when the two objects are not the same object.</param>\r
1244                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1245                 static public void AreSame(Object expected, Object actual, string message, params object[] args)\r
1246                 {\r
1247             Assert.That(actual, Is.SameAs(expected), message, args);\r
1248                 }\r
1249 \r
1250                 /// <summary>\r
1251                 /// Asserts that two objects refer to the same object. If they\r
1252                 /// are not the same an <see cref="AssertionException"/> is thrown.\r
1253                 /// </summary>\r
1254                 /// <param name="expected">The expected object</param>\r
1255                 /// <param name="actual">The actual object</param>\r
1256                 /// <param name="message">The message to be displayed when the object is null</param>\r
1257                 static public void AreSame(Object expected, Object actual, string message) \r
1258                 {\r
1259                         Assert.AreSame(expected, actual, message, null);\r
1260                 }\r
1261    \r
1262                 /// <summary>\r
1263                 /// Asserts that two objects refer to the same object. If they\r
1264                 /// are not the same an <see cref="AssertionException"/> is thrown.\r
1265                 /// </summary>\r
1266                 /// <param name="expected">The expected object</param>\r
1267                 /// <param name="actual">The actual object</param>\r
1268                 static public void AreSame(Object expected, Object actual) \r
1269                 {\r
1270                         Assert.AreSame(expected, actual, string.Empty, null);\r
1271                 }\r
1272    \r
1273                 #endregion\r
1274 \r
1275                 #region AreNotSame\r
1276 \r
1277                 /// <summary>\r
1278                 /// Asserts that two objects do not refer to the same object. If they\r
1279                 /// are the same an <see cref="AssertionException"/> is thrown.\r
1280                 /// </summary>\r
1281                 /// <param name="expected">The expected object</param>\r
1282                 /// <param name="actual">The actual object</param>\r
1283                 /// <param name="message">The message to be displayed when the two objects are the same object.</param>\r
1284                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1285                 static public void AreNotSame(Object expected, Object actual, string message, params object[] args)\r
1286                 {\r
1287             Assert.That(actual, Is.Not.SameAs(expected), message, args);\r
1288                 }\r
1289 \r
1290                 /// <summary>\r
1291                 /// Asserts that two objects do not refer to the same object. If they\r
1292                 /// are the same an <see cref="AssertionException"/> is thrown.\r
1293                 /// </summary>\r
1294                 /// <param name="expected">The expected object</param>\r
1295                 /// <param name="actual">The actual object</param>\r
1296                 /// <param name="message">The message to be displayed when the objects are the same</param>\r
1297                 static public void AreNotSame(Object expected, Object actual, string message) \r
1298                 {\r
1299                         Assert.AreNotSame(expected, actual, message, null);\r
1300                 }\r
1301    \r
1302                 /// <summary>\r
1303                 /// Asserts that two objects do not refer to the same object. If they\r
1304                 /// are the same an <see cref="AssertionException"/> is thrown.\r
1305                 /// </summary>\r
1306                 /// <param name="expected">The expected object</param>\r
1307                 /// <param name="actual">The actual object</param>\r
1308                 static public void AreNotSame(Object expected, Object actual) \r
1309                 {\r
1310                         Assert.AreNotSame(expected, actual, string.Empty, null);\r
1311                 }\r
1312    \r
1313                 #endregion\r
1314 \r
1315                 #region Greater\r
1316 \r
1317                 #region Ints\r
1318 \r
1319                 /// <summary>\r
1320                 /// Verifies that the first value is greater than the second\r
1321                 /// value. If they are not, then an\r
1322                 /// <see cref="AssertionException"/> is thrown. \r
1323                 /// </summary>\r
1324                 /// <param name="arg1">The first value, expected to be greater</param>\r
1325                 /// <param name="arg2">The second value, expected to be less</param>\r
1326                 /// <param name="message">The message that will be displayed on failure</param>\r
1327                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1328                 static public void Greater(int arg1, \r
1329                         int arg2, string message, params object[] args) \r
1330                 {\r
1331             Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1332                 }\r
1333 \r
1334                 /// <summary>\r
1335                 /// Verifies that the first value is greater than the second\r
1336                 /// value. If they are not, then an \r
1337                 /// <see cref="AssertionException"/> is thrown.\r
1338                 /// </summary>\r
1339                 /// <param name="arg1">The first value, expected to be greater</param>\r
1340                 /// <param name="arg2">The second value, expected to be less</param>\r
1341                 /// <param name="message">The message that will be displayed on failure</param>\r
1342                 static public void Greater(int arg1, int arg2, string message) \r
1343                 {\r
1344                         Assert.Greater( arg1, arg2, message, null );\r
1345                 }\r
1346 \r
1347                 /// <summary>\r
1348                 /// Verifies that the first value is greater than the second\r
1349                 /// value. If they are not, then an \r
1350                 /// <see cref="AssertionException"/> is thrown.\r
1351                 /// </summary>\r
1352                 /// <param name="arg1">The first value, expected to be greater</param>\r
1353                 /// <param name="arg2">The second value, expected to be less</param>\r
1354                 static public void Greater(int arg1, int arg2 ) \r
1355                 {\r
1356                         Assert.Greater( arg1, arg2, string.Empty, null );\r
1357                 }\r
1358 \r
1359                 #endregion\r
1360 \r
1361                 #region UInts\r
1362 \r
1363                 /// <summary>\r
1364                 /// Verifies that the first value is greater than the second\r
1365                 /// value. If they are not, then an \r
1366                 /// <see cref="AssertionException"/> is thrown.\r
1367                 /// </summary>\r
1368                 /// <param name="arg1">The first value, expected to be greater</param>\r
1369                 /// <param name="arg2">The second value, expected to be less</param>\r
1370                 /// <param name="message">The message that will be displayed on failure</param>\r
1371                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1372                 [CLSCompliant(false)]\r
1373                 static public void Greater(uint arg1, \r
1374                         uint arg2, string message, params object[] args) \r
1375                 {\r
1376                         Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1377                 }\r
1378 \r
1379                 /// <summary>\r
1380                 /// Verifies that the first value is greater than the second\r
1381                 /// value. If they are not, then an \r
1382                 /// <see cref="AssertionException"/> is thrown.\r
1383                 /// </summary>\r
1384                 /// <param name="arg1">The first value, expected to be greater</param>\r
1385                 /// <param name="arg2">The second value, expected to be less</param>\r
1386                 /// <param name="message">The message that will be displayed on failure</param>\r
1387                 [CLSCompliant(false)]\r
1388                 static public void Greater(uint arg1, uint arg2, string message) \r
1389                 {\r
1390                         Assert.Greater( arg1, arg2, message, null );\r
1391                 }\r
1392 \r
1393                 /// <summary>\r
1394                 /// Verifies that the first value is greater than the second\r
1395                 /// value. If they are not, then an \r
1396                 /// <see cref="AssertionException"/> is thrown.\r
1397                 /// </summary>\r
1398                 /// <param name="arg1">The first value, expected to be greater</param>\r
1399                 /// <param name="arg2">The second value, expected to be less</param>\r
1400                 [CLSCompliant(false)]\r
1401                 static public void Greater(uint arg1, uint arg2 ) \r
1402                 {\r
1403                         Assert.Greater( arg1, arg2, string.Empty, null );\r
1404                 }\r
1405 \r
1406                 #endregion\r
1407 \r
1408                 #region Longs\r
1409 \r
1410                 /// <summary>\r
1411                 /// Verifies that the first value is greater than the second\r
1412                 /// value. If they are not, then an \r
1413                 /// <see cref="AssertionException"/> is thrown.\r
1414                 /// </summary>\r
1415                 /// <param name="arg1">The first value, expected to be greater</param>\r
1416                 /// <param name="arg2">The second value, expected to be less</param>\r
1417                 /// <param name="message">The message that will be displayed on failure</param>\r
1418                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1419                 static public void Greater(long arg1, \r
1420                         long arg2, string message, params object[] args) \r
1421                 {\r
1422                         Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1423                 }\r
1424 \r
1425                 /// <summary>\r
1426                 /// Verifies that the first value is greater than the second\r
1427                 /// value. If they are not, then an \r
1428                 /// <see cref="AssertionException"/> is thrown.\r
1429                 /// </summary>\r
1430                 /// <param name="arg1">The first value, expected to be greater</param>\r
1431                 /// <param name="arg2">The second value, expected to be less</param>\r
1432                 /// <param name="message">The message that will be displayed on failure</param>\r
1433                 static public void Greater(long arg1, long arg2, string message) \r
1434                 {\r
1435                         Assert.Greater( arg1, arg2, message, null );\r
1436                 }\r
1437 \r
1438                 /// <summary>\r
1439                 /// Verifies that the first value is greater than the second\r
1440                 /// value. If they are not, then an \r
1441                 /// <see cref="AssertionException"/> is thrown.\r
1442                 /// </summary>\r
1443                 /// <param name="arg1">The first value, expected to be greater</param>\r
1444                 /// <param name="arg2">The second value, expected to be less</param>\r
1445                 static public void Greater(long arg1, long arg2 ) \r
1446                 {\r
1447                         Assert.Greater( arg1, arg2, string.Empty, null );\r
1448                 }\r
1449 \r
1450                 #endregion\r
1451 \r
1452                 #region ULongs\r
1453 \r
1454                 /// <summary>\r
1455                 /// Verifies that the first value is greater than the second\r
1456                 /// value. If they are not, then an \r
1457                 /// <see cref="AssertionException"/> is thrown.\r
1458                 /// </summary>\r
1459                 /// <param name="arg1">The first value, expected to be greater</param>\r
1460                 /// <param name="arg2">The second value, expected to be less</param>\r
1461                 /// <param name="message">The message that will be displayed on failure</param>\r
1462                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1463                 [CLSCompliant(false)]\r
1464                 static public void Greater(ulong arg1, \r
1465                         ulong arg2, string message, params object[] args) \r
1466                 {\r
1467                         Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1468                 }\r
1469 \r
1470                 /// <summary>\r
1471                 /// Verifies that the first value is greater than the second\r
1472                 /// value. If they are not, then an \r
1473                 /// <see cref="AssertionException"/> is thrown.\r
1474                 /// </summary>\r
1475                 /// <param name="arg1">The first value, expected to be greater</param>\r
1476                 /// <param name="arg2">The second value, expected to be less</param>\r
1477                 /// <param name="message">The message that will be displayed on failure</param>\r
1478                 [CLSCompliant(false)]\r
1479                 static public void Greater(ulong arg1, ulong arg2, string message) \r
1480                 {\r
1481                         Assert.Greater( arg1, arg2, message, null );\r
1482                 }\r
1483 \r
1484                 /// <summary>\r
1485                 /// Verifies that the first value is greater than the second\r
1486                 /// value. If they are not, then an \r
1487                 /// <see cref="AssertionException"/> is thrown.\r
1488                 /// </summary>\r
1489                 /// <param name="arg1">The first value, expected to be greater</param>\r
1490                 /// <param name="arg2">The second value, expected to be less</param>\r
1491                 [CLSCompliant(false)]\r
1492                 static public void Greater(ulong arg1, ulong arg2 ) \r
1493                 {\r
1494                         Assert.Greater( arg1, arg2, string.Empty, null );\r
1495                 }\r
1496 \r
1497                 #endregion\r
1498 \r
1499                 #region Decimals\r
1500 \r
1501                 /// <summary>\r
1502                 /// Verifies that the first value is greater than the second\r
1503                 /// value. If they are not, then an \r
1504                 /// <see cref="AssertionException"/> is thrown.\r
1505                 /// </summary>\r
1506                 /// <param name="arg1">The first value, expected to be greater</param>\r
1507                 /// <param name="arg2">The second value, expected to be less</param>\r
1508                 /// <param name="message">The message that will be displayed on failure</param>\r
1509                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1510                 static public void Greater(decimal arg1, \r
1511                         decimal arg2, string message, params object[] args) \r
1512                 {\r
1513             Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1514         }\r
1515 \r
1516                 /// <summary>\r
1517                 /// Verifies that the first value is greater than the second\r
1518                 /// value. If they are not, then an \r
1519                 /// <see cref="AssertionException"/> is thrown.\r
1520                 /// </summary>\r
1521                 /// <param name="arg1">The first value, expected to be greater</param>\r
1522                 /// <param name="arg2">The second value, expected to be less</param>\r
1523                 /// <param name="message">The message that will be displayed on failure</param>\r
1524                 static public void Greater(decimal arg1, decimal arg2, string message) \r
1525                 {\r
1526                         Assert.Greater( arg1, arg2, message, null );\r
1527                 }\r
1528 \r
1529                 /// <summary>\r
1530                 /// Verifies that the first value is greater than the second\r
1531                 /// value. If they are not, then an \r
1532                 /// <see cref="AssertionException"/> is thrown.\r
1533                 /// </summary>\r
1534                 /// <param name="arg1">The first value, expected to be greater</param>\r
1535                 /// <param name="arg2">The second value, expected to be less</param>\r
1536                 static public void Greater(decimal arg1, decimal arg2 ) \r
1537                 {\r
1538                         Assert.Greater( arg1, arg2, string.Empty, null );\r
1539                 }\r
1540 \r
1541                 #endregion\r
1542 \r
1543                 #region Doubles\r
1544 \r
1545                 /// <summary>\r
1546                 /// Verifies that the first value is greater than the second\r
1547                 /// value. If they are not, then an \r
1548                 /// <see cref="AssertionException"/> is thrown.\r
1549                 /// </summary>\r
1550                 /// <param name="arg1">The first value, expected to be greater</param>\r
1551                 /// <param name="arg2">The second value, expected to be less</param>\r
1552                 /// <param name="message">The message that will be displayed on failure</param>\r
1553                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1554                 static public void Greater(double arg1, \r
1555                         double arg2, string message, params object[] args) \r
1556                 {\r
1557             Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1558         }\r
1559 \r
1560                 /// <summary>\r
1561                 /// Verifies that the first value is greater than the second\r
1562                 /// value. If they are not, then an \r
1563                 /// <see cref="AssertionException"/> is thrown.\r
1564                 /// </summary>\r
1565                 /// <param name="arg1">The first value, expected to be greater</param>\r
1566                 /// <param name="arg2">The second value, expected to be less</param>\r
1567                 /// <param name="message">The message that will be displayed on failure</param>\r
1568                 static public void Greater(double arg1, \r
1569                         double arg2, string message) \r
1570                 {\r
1571                         Assert.Greater( arg1, arg2, message, null );\r
1572                 }\r
1573 \r
1574                 /// <summary>\r
1575                 /// Verifies that the first value is greater than the second\r
1576                 /// value. If they are not, then an \r
1577                 /// <see cref="AssertionException"/> is thrown.\r
1578                 /// </summary>\r
1579                 /// <param name="arg1">The first value, expected to be greater</param>\r
1580                 /// <param name="arg2">The second value, expected to be less</param>\r
1581                 static public void Greater(double arg1, double arg2) \r
1582                 {\r
1583                         Assert.Greater(arg1, arg2, string.Empty, null);\r
1584                 }\r
1585 \r
1586                 #endregion\r
1587 \r
1588                 #region Floats\r
1589 \r
1590                 /// <summary>\r
1591                 /// Verifies that the first value is greater than the second\r
1592                 /// value. If they are not, then an \r
1593                 /// <see cref="AssertionException"/> is thrown.\r
1594                 /// </summary>\r
1595                 /// <param name="arg1">The first value, expected to be greater</param>\r
1596                 /// <param name="arg2">The second value, expected to be less</param>\r
1597                 /// <param name="message">The message that will be displayed on failure</param>\r
1598                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1599                 static public void Greater(float arg1, \r
1600                         float arg2, string message, params object[] args) \r
1601                 {\r
1602             Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1603         }\r
1604 \r
1605                 /// <summary>\r
1606                 /// Verifies that the first value is greater than the second\r
1607                 /// value. If they are not, then an \r
1608                 /// <see cref="AssertionException"/> is thrown.\r
1609                 /// </summary>\r
1610                 /// <param name="arg1">The first value, expected to be greater</param>\r
1611                 /// <param name="arg2">The second value, expected to be less</param>\r
1612                 /// <param name="message">The message that will be displayed on failure</param>\r
1613                 static public void Greater(float arg1, float arg2, string message) \r
1614                 {\r
1615                         Assert.Greater(arg1, arg2, message, null);\r
1616                 }\r
1617 \r
1618                 /// <summary>\r
1619                 /// Verifies that the first value is greater than the second\r
1620                 /// value. If they are not, then an \r
1621                 /// <see cref="AssertionException"/> is thrown.\r
1622                 /// </summary>\r
1623                 /// <param name="arg1">The first value, expected to be greater</param>\r
1624                 /// <param name="arg2">The second value, expected to be less</param>\r
1625                 static public void Greater(float arg1, float arg2) \r
1626                 {\r
1627                         Assert.Greater(arg1, arg2, string.Empty, null);\r
1628                 }\r
1629 \r
1630                 #endregion\r
1631 \r
1632                 #region IComparables\r
1633 \r
1634                 /// <summary>\r
1635                 /// Verifies that the first value is greater than the second\r
1636                 /// value. If they are not, then an \r
1637                 /// <see cref="AssertionException"/> is thrown.\r
1638                 /// </summary>\r
1639                 /// <param name="arg1">The first value, expected to be greater</param>\r
1640                 /// <param name="arg2">The second value, expected to be less</param>\r
1641                 /// <param name="message">The message that will be displayed on failure</param>\r
1642                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1643                 static public void Greater(IComparable arg1, \r
1644                         IComparable arg2, string message, params object[] args) \r
1645                 {\r
1646             Assert.That(arg1, Is.GreaterThan(arg2), message, args);\r
1647         }\r
1648 \r
1649                 /// <summary>\r
1650                 /// Verifies that the first value is greater than the second\r
1651                 /// value. If they are not, then an \r
1652                 /// <see cref="AssertionException"/> is thrown.\r
1653                 /// </summary>\r
1654                 /// <param name="arg1">The first value, expected to be greater</param>\r
1655                 /// <param name="arg2">The second value, expected to be less</param>\r
1656                 /// <param name="message">The message that will be displayed on failure</param>\r
1657                 static public void Greater(IComparable arg1, IComparable arg2, string message) \r
1658                 {\r
1659                         Assert.Greater(arg1, arg2, message, null);\r
1660                 }\r
1661 \r
1662                 /// <summary>\r
1663                 /// Verifies that the first value is greater than the second\r
1664                 /// value. If they are not, then an \r
1665                 /// <see cref="AssertionException"/> is thrown.\r
1666                 /// </summary>\r
1667                 /// <param name="arg1">The first value, expected to be greater</param>\r
1668                 /// <param name="arg2">The second value, expected to be less</param>\r
1669                 static public void Greater(IComparable arg1, IComparable arg2) \r
1670                 {\r
1671                         Assert.Greater(arg1, arg2, string.Empty, null);\r
1672                 }\r
1673 \r
1674                 #endregion\r
1675 \r
1676                 #endregion\r
1677 \r
1678                 #region Less\r
1679 \r
1680                 #region Ints\r
1681 \r
1682                 /// <summary>\r
1683                 /// Verifies that the first value is less than the second\r
1684                 /// value. If it is not, then an \r
1685                 /// <see cref="AssertionException"/> is thrown.\r
1686                 /// </summary>\r
1687                 /// <param name="arg1">The first value, expected to be less</param>\r
1688                 /// <param name="arg2">The second value, expected to be greater</param>\r
1689                 /// <param name="message">The message that will be displayed on failure</param>\r
1690                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1691                 static public void Less(int arg1, int arg2, string message, params object[] args) \r
1692                 {\r
1693             Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1694         }\r
1695 \r
1696                 /// <summary>\r
1697                 /// Verifies that the first value is less than the second\r
1698                 /// value. If it is not, then an \r
1699                 /// <see cref="AssertionException"/> is thrown.\r
1700                 /// </summary>\r
1701                 /// <param name="arg1">The first value, expected to be less</param>\r
1702                 /// <param name="arg2">The second value, expected to be greater</param>\r
1703                 /// <param name="message">The message that will be displayed on failure</param>\r
1704                 static public void Less(int arg1, int arg2, string message) \r
1705                 {\r
1706                         Assert.Less(arg1, arg2, message, null);\r
1707                 }\r
1708 \r
1709                 /// <summary>\r
1710                 /// Verifies that the first value is less than the second\r
1711                 /// value. If it is not, then an \r
1712                 /// <see cref="AssertionException"/> is thrown.\r
1713                 /// </summary>\r
1714                 /// <param name="arg1">The first value, expected to be less</param>\r
1715                 /// <param name="arg2">The second value, expected to be greater</param>\r
1716                 static public void Less(int arg1, int arg2) \r
1717                 {\r
1718                         Assert.Less( arg1, arg2, string.Empty, null);\r
1719                 }\r
1720 \r
1721                 #endregion\r
1722 \r
1723                 #region UInts\r
1724 \r
1725                 /// <summary>\r
1726                 /// Verifies that the first value is less than the second\r
1727                 /// value. If it is not, then an \r
1728                 /// <see cref="AssertionException"/> is thrown.\r
1729                 /// </summary>\r
1730                 /// <param name="arg1">The first value, expected to be less</param>\r
1731                 /// <param name="arg2">The second value, expected to be greater</param>\r
1732                 /// <param name="message">The message that will be displayed on failure</param>\r
1733                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1734                 [CLSCompliant(false)]\r
1735                 static public void Less(uint arg1, uint arg2, string message, params object[] args) \r
1736                 {\r
1737                         Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1738                 }\r
1739 \r
1740                 /// <summary>\r
1741                 /// Verifies that the first value is less than the second\r
1742                 /// value. If it is not, then an \r
1743                 /// <see cref="AssertionException"/> is thrown.\r
1744                 /// </summary>\r
1745                 /// <param name="arg1">The first value, expected to be less</param>\r
1746                 /// <param name="arg2">The second value, expected to be greater</param>\r
1747                 /// <param name="message">The message that will be displayed on failure</param>\r
1748                 [CLSCompliant(false)]\r
1749                 static public void Less(uint arg1, uint arg2, string message) \r
1750                 {\r
1751                         Assert.Less(arg1, arg2, message, null);\r
1752                 }\r
1753 \r
1754                 /// <summary>\r
1755                 /// Verifies that the first value is less than the second\r
1756                 /// value. If it is not, then an \r
1757                 /// <see cref="AssertionException"/> is thrown.\r
1758                 /// </summary>\r
1759                 /// <param name="arg1">The first value, expected to be less</param>\r
1760                 /// <param name="arg2">The second value, expected to be greater</param>\r
1761                 [CLSCompliant(false)]\r
1762                 static public void Less(uint arg1, uint arg2) \r
1763                 {\r
1764                         Assert.Less( arg1, arg2, string.Empty, null);\r
1765                 }\r
1766 \r
1767                 #endregion\r
1768 \r
1769                 #region Longs\r
1770 \r
1771                 /// <summary>\r
1772                 /// Verifies that the first value is less than the second\r
1773                 /// value. If it is not, then an \r
1774                 /// <see cref="AssertionException"/> is thrown.\r
1775                 /// </summary>\r
1776                 /// <param name="arg1">The first value, expected to be less</param>\r
1777                 /// <param name="arg2">The second value, expected to be greater</param>\r
1778                 /// <param name="message">The message that will be displayed on failure</param>\r
1779                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1780                 static public void Less(long arg1, long arg2, string message, params object[] args) \r
1781                 {\r
1782                         Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1783                 }\r
1784 \r
1785                 /// <summary>\r
1786                 /// Verifies that the first value is less than the second\r
1787                 /// value. If it is not, then an \r
1788                 /// <see cref="AssertionException"/> is thrown.\r
1789                 /// </summary>\r
1790                 /// <param name="arg1">The first value, expected to be less</param>\r
1791                 /// <param name="arg2">The second value, expected to be greater</param>\r
1792                 /// <param name="message">The message that will be displayed on failure</param>\r
1793                 static public void Less(long arg1, long arg2, string message) \r
1794                 {\r
1795                         Assert.Less(arg1, arg2, message, null);\r
1796                 }\r
1797 \r
1798                 /// <summary>\r
1799                 /// Verifies that the first value is less than the second\r
1800                 /// value. If it is not, then an \r
1801                 /// <see cref="AssertionException"/> is thrown.\r
1802                 /// </summary>\r
1803                 /// <param name="arg1">The first value, expected to be less</param>\r
1804                 /// <param name="arg2">The second value, expected to be greater</param>\r
1805                 static public void Less(long arg1, long arg2) \r
1806                 {\r
1807                         Assert.Less( arg1, arg2, string.Empty, null);\r
1808                 }\r
1809 \r
1810                 #endregion\r
1811 \r
1812                 #region ULongs\r
1813 \r
1814                 /// <summary>\r
1815                 /// Verifies that the first value is less than the second\r
1816                 /// value. If it is not, then an \r
1817                 /// <see cref="AssertionException"/> is thrown.\r
1818                 /// </summary>\r
1819                 /// <param name="arg1">The first value, expected to be less</param>\r
1820                 /// <param name="arg2">The second value, expected to be greater</param>\r
1821                 /// <param name="message">The message that will be displayed on failure</param>\r
1822                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1823                 [CLSCompliant(false)]\r
1824                 static public void Less(ulong arg1, ulong arg2, string message, params object[] args) \r
1825                 {\r
1826                         Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1827                 }\r
1828 \r
1829                 /// <summary>\r
1830                 /// Verifies that the first value is less than the second\r
1831                 /// value. If it is not, then an \r
1832                 /// <see cref="AssertionException"/> is thrown.\r
1833                 /// </summary>\r
1834                 /// <param name="arg1">The first value, expected to be less</param>\r
1835                 /// <param name="arg2">The second value, expected to be greater</param>\r
1836                 /// <param name="message">The message that will be displayed on failure</param>\r
1837                 [CLSCompliant(false)]\r
1838                 static public void Less(ulong arg1, ulong arg2, string message) \r
1839                 {\r
1840                         Assert.Less(arg1, arg2, message, null);\r
1841                 }\r
1842 \r
1843                 /// <summary>\r
1844                 /// Verifies that the first value is less than the second\r
1845                 /// value. If it is not, then an \r
1846                 /// <see cref="AssertionException"/> is thrown.\r
1847                 /// </summary>\r
1848                 /// <param name="arg1">The first value, expected to be less</param>\r
1849                 /// <param name="arg2">The second value, expected to be greater</param>\r
1850                 [CLSCompliant(false)]\r
1851                 static public void Less(ulong arg1, ulong arg2) \r
1852                 {\r
1853                         Assert.Less( arg1, arg2, string.Empty, null);\r
1854                 }\r
1855 \r
1856                 #endregion\r
1857 \r
1858                 #region Decimals\r
1859 \r
1860                 /// <summary>\r
1861                 /// Verifies that the first value is less than the second\r
1862                 /// value. If it is not, then an \r
1863                 /// <see cref="AssertionException"/> is thrown.\r
1864                 /// </summary>\r
1865                 /// <param name="arg1">The first value, expected to be less</param>\r
1866                 /// <param name="arg2">The second value, expected to be greater</param>\r
1867                 /// <param name="message">The message that will be displayed on failure</param>\r
1868                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1869                 static public void Less(decimal arg1, decimal arg2, string message, params object[] args) \r
1870                 {\r
1871             Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1872         }\r
1873 \r
1874                 /// <summary>\r
1875                 /// Verifies that the first value is less than the second\r
1876                 /// value. If it is not, then an \r
1877                 /// <see cref="AssertionException"/> is thrown.\r
1878                 /// </summary>\r
1879                 /// <param name="arg1">The first value, expected to be less</param>\r
1880                 /// <param name="arg2">The second value, expected to be greater</param>\r
1881                 /// <param name="message">The message that will be displayed on failure</param>\r
1882                 static public void Less(decimal arg1, decimal arg2, string message) \r
1883                 {\r
1884                         Assert.Less(arg1, arg2, message, null);\r
1885                 }\r
1886 \r
1887                 /// <summary>\r
1888                 /// Verifies that the first value is less than the second\r
1889                 /// value. If it is not, then an \r
1890                 /// <see cref="AssertionException"/> is thrown.\r
1891                 /// </summary>\r
1892                 /// <param name="arg1">The first value, expected to be less</param>\r
1893                 /// <param name="arg2">The second value, expected to be greater</param>\r
1894                 static public void Less(decimal arg1, decimal arg2) \r
1895                 {\r
1896                         Assert.Less(arg1, arg2, string.Empty, null);\r
1897                 }\r
1898 \r
1899                 #endregion\r
1900 \r
1901                 #region Doubles\r
1902 \r
1903                 /// <summary>\r
1904                 /// Verifies that the first value is less than the second\r
1905                 /// value. If it is not, then an \r
1906                 /// <see cref="AssertionException"/> is thrown.\r
1907                 /// </summary>\r
1908                 /// <param name="arg1">The first value, expected to be less</param>\r
1909                 /// <param name="arg2">The second value, expected to be greater</param>\r
1910                 /// <param name="message">The message that will be displayed on failure</param>\r
1911                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1912                 static public void Less(double arg1, double arg2, string message, params object[] args) \r
1913                 {\r
1914             Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1915         }\r
1916 \r
1917                 /// <summary>\r
1918                 /// Verifies that the first value is less than the second\r
1919                 /// value. If it is not, then an \r
1920                 /// <see cref="AssertionException"/> is thrown.\r
1921                 /// </summary>\r
1922                 /// <param name="arg1">The first value, expected to be less</param>\r
1923                 /// <param name="arg2">The second value, expected to be greater</param>\r
1924                 /// <param name="message">The message that will be displayed on failure</param>\r
1925                 static public void Less(double arg1, double arg2, string message) \r
1926                 {\r
1927                         Assert.Less(arg1, arg2, message, null);\r
1928                 }\r
1929 \r
1930                 /// <summary>\r
1931                 /// Verifies that the first value is less than the second\r
1932                 /// value. If it is not, then an \r
1933                 /// <see cref="AssertionException"/> is thrown.\r
1934                 /// </summary>\r
1935                 /// <param name="arg1">The first value, expected to be less</param>\r
1936                 /// <param name="arg2">The second value, expected to be greater</param>\r
1937                 static public void Less(double arg1, double arg2) \r
1938                 {\r
1939                         Assert.Less(arg1, arg2, string.Empty, null);\r
1940                 }\r
1941 \r
1942                 #endregion\r
1943 \r
1944                 #region Floats\r
1945 \r
1946                 /// <summary>\r
1947                 /// Verifies that the first value is less than the second\r
1948                 /// value. If it is not, then an \r
1949                 /// <see cref="AssertionException"/> is thrown.\r
1950                 /// </summary>\r
1951                 /// <param name="arg1">The first value, expected to be less</param>\r
1952                 /// <param name="arg2">The second value, expected to be greater</param>\r
1953                 /// <param name="message">The message that will be displayed on failure</param>\r
1954                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1955                 static public void Less(float arg1, float arg2, string message, params object[] args) \r
1956                 {\r
1957             Assert.That(arg1, Is.LessThan(arg2), message, args);\r
1958         }\r
1959 \r
1960                 /// <summary>\r
1961                 /// Verifies that the first value is less than the second\r
1962                 /// value. If it is not, then an \r
1963                 /// <see cref="AssertionException"/> is thrown.\r
1964                 /// </summary>\r
1965                 /// <param name="arg1">The first value, expected to be less</param>\r
1966                 /// <param name="arg2">The second value, expected to be greater</param>\r
1967                 /// <param name="message">The message that will be displayed on failure</param>\r
1968                 static public void Less(float arg1, float arg2, string message) \r
1969                 {\r
1970                         Assert.Less(arg1, arg2, message, null);\r
1971                 }\r
1972 \r
1973                 /// <summary>\r
1974                 /// Verifies that the first value is less than the second\r
1975                 /// value. If it is not, then an \r
1976                 /// <see cref="AssertionException"/> is thrown.\r
1977                 /// </summary>\r
1978                 /// <param name="arg1">The first value, expected to be less</param>\r
1979                 /// <param name="arg2">The second value, expected to be greater</param>\r
1980                 static public void Less(float arg1, float arg2) \r
1981                 {\r
1982                         Assert.Less(arg1, arg2, string.Empty, null);\r
1983                 }\r
1984 \r
1985                 #endregion\r
1986 \r
1987                 #region IComparables\r
1988 \r
1989                 /// <summary>\r
1990                 /// Verifies that the first value is less than the second\r
1991                 /// value. If it is not, then an \r
1992                 /// <see cref="AssertionException"/> is thrown.\r
1993                 /// </summary>\r
1994                 /// <param name="arg1">The first value, expected to be less</param>\r
1995                 /// <param name="arg2">The second value, expected to be greater</param>\r
1996                 /// <param name="message">The message that will be displayed on failure</param>\r
1997                 /// <param name="args">Arguments to be used in formatting the message</param>\r
1998                 static public void Less(IComparable arg1, IComparable arg2, string message, params object[] args) \r
1999                 {\r
2000             Assert.That(arg1, Is.LessThan(arg2), message, args);\r
2001         }\r
2002 \r
2003                 /// <summary>\r
2004                 /// Verifies that the first value is less than the second\r
2005                 /// value. If it is not, then an \r
2006                 /// <see cref="AssertionException"/> is thrown.\r
2007                 /// </summary>\r
2008                 /// <param name="arg1">The first value, expected to be less</param>\r
2009                 /// <param name="arg2">The second value, expected to be greater</param>\r
2010                 /// <param name="message">The message that will be displayed on failure</param>\r
2011                 static public void Less(IComparable arg1, IComparable arg2, string message) \r
2012                 {\r
2013                         Assert.Less(arg1, arg2, message, null);\r
2014                 }\r
2015 \r
2016                 /// <summary>\r
2017                 /// Verifies that the first value is less than the second\r
2018                 /// value. If it is not, then an \r
2019                 /// <see cref="AssertionException"/> is thrown.\r
2020                 /// </summary>\r
2021                 /// <param name="arg1">The first value, expected to be less</param>\r
2022                 /// <param name="arg2">The second value, expected to be greater</param>\r
2023                 static public void Less(IComparable arg1, IComparable arg2) \r
2024                 {\r
2025                         Assert.Less(arg1, arg2, string.Empty, null);\r
2026                 }\r
2027 \r
2028                 #endregion\r
2029 \r
2030                 #endregion\r
2031 \r
2032                 #region Collection Containment\r
2033 \r
2034                 /// <summary>\r
2035                 /// Asserts that an object is contained in a list.\r
2036                 /// </summary>\r
2037                 /// <param name="expected">The expected object</param>\r
2038                 /// <param name="actual">The list to be examined</param>\r
2039                 /// <param name="message">The message to display in case of failure</param>\r
2040                 /// <param name="args">Arguments used in formatting the message</param>\r
2041                 static public void Contains( object expected, ICollection actual, string message, params object[] args )\r
2042                 {\r
2043             Assert.That(actual, new CollectionContainsConstraint(expected), message, args);\r
2044                 }\r
2045 \r
2046                 /// <summary>\r
2047                 /// Asserts that an object is contained in a list.\r
2048                 /// </summary>\r
2049                 /// <param name="expected">The expected object</param>\r
2050                 /// <param name="actual">The list to be examined</param>\r
2051                 /// <param name="message">The message to display in case of failure</param>\r
2052                 static public void Contains( object expected, ICollection actual, string message )\r
2053                 {\r
2054                         Contains( expected, actual, message, null );\r
2055                 }\r
2056 \r
2057                 /// <summary>\r
2058                 /// Asserts that an object is contained in a list.\r
2059                 /// </summary>\r
2060                 /// <param name="expected">The expected object</param>\r
2061                 /// <param name="actual">The list to be examined</param>\r
2062                 static public void Contains( object expected, ICollection actual )\r
2063                 {\r
2064                         Contains( expected, actual, string.Empty, null );\r
2065                 }\r
2066 \r
2067                 #endregion\r
2068                 \r
2069                 #region Fail\r
2070 \r
2071                 /// <summary>\r
2072                 /// Throws an <see cref="AssertionException"/> with the message and arguments \r
2073                 /// that are passed in. This is used by the other Assert functions. \r
2074                 /// </summary>\r
2075                 /// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>\r
2076                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2077                 static public void Fail(string message, params object[] args ) \r
2078                 {\r
2079                         if (message == null) message = string.Empty;\r
2080                         else if ( args != null && args.Length > 0 )\r
2081                                 message = string.Format( message, args );\r
2082 \r
2083                         throw new AssertionException(message);\r
2084                 }\r
2085 \r
2086                 /// <summary>\r
2087                 /// Throws an <see cref="AssertionException"/> with the message that is \r
2088                 /// passed in. This is used by the other Assert functions. \r
2089                 /// </summary>\r
2090                 /// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>\r
2091                 static public void Fail(string message) \r
2092                 {\r
2093                         Assert.Fail(message, null);\r
2094                 }\r
2095     \r
2096                 /// <summary>\r
2097                 /// Throws an <see cref="AssertionException"/>. \r
2098                 /// This is used by the other Assert functions. \r
2099                 /// </summary>\r
2100                 static public void Fail() \r
2101                 {\r
2102                         Assert.Fail(string.Empty, null);\r
2103                 }\r
2104 \r
2105                 #endregion \r
2106 \r
2107                 #region Ignore\r
2108 \r
2109                 /// <summary>\r
2110                 /// Throws an <see cref="IgnoreException"/> with the message and arguments \r
2111                 /// that are passed in.  This causes the test to be reported as ignored.\r
2112                 /// </summary>\r
2113                 /// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>\r
2114                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2115                 static public void Ignore( string message, params object[] args )\r
2116                 {\r
2117                         if (message == null) message = string.Empty;\r
2118                         else if ( args != null && args.Length > 0 )\r
2119                                 message = string.Format( message, args );\r
2120 \r
2121                         throw new IgnoreException(message);\r
2122                 }\r
2123 \r
2124                 /// <summary>\r
2125                 /// Throws an <see cref="IgnoreException"/> with the message that is \r
2126                 /// passed in. This causes the test to be reported as ignored. \r
2127                 /// </summary>\r
2128                 /// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>\r
2129                 static public void Ignore( string message )\r
2130                 {\r
2131                         Assert.Ignore( message, null );\r
2132                 }\r
2133     \r
2134                 /// <summary>\r
2135                 /// Throws an <see cref="IgnoreException"/>. \r
2136                 /// This causes the test to be reported as ignored. \r
2137                 /// </summary>\r
2138                 static public void Ignore()\r
2139                 {\r
2140                         Assert.Ignore( string.Empty, null );\r
2141                 }\r
2142     \r
2143                 #endregion\r
2144 \r
2145                 #region DoAssert\r
2146 \r
2147                 /// <summary>\r
2148                 /// NOTE: The use of asserters for extending NUnit has\r
2149                 /// now been replaced by the use of constraints. This\r
2150                 /// method is marked obsolete.\r
2151                 /// \r
2152                 /// Test the condition asserted by an asserter and throw\r
2153                 /// an assertion exception using provided message on failure.\r
2154                 /// </summary>\r
2155                 /// <param name="asserter">An object that implements IAsserter</param>\r
2156                 [Obsolete("Use Constraints rather than Asserters for new work")]\r
2157                 static public void DoAssert( IAsserter asserter )\r
2158                 {\r
2159                         Assert.IncrementAssertCount();\r
2160                         if ( !asserter.Test() )\r
2161                                 throw new AssertionException( asserter.Message );\r
2162                 }\r
2163 \r
2164                 #endregion\r
2165 \r
2166                 #region That\r
2167                 /// <summary>\r
2168                 /// Apply a constraint to an actual value, succeeding if the constraint\r
2169                 /// is satisfied and throwing an assertion exception on failure.\r
2170                 /// </summary>\r
2171                 /// <param name="constraint">A Constraint to be applied</param>\r
2172                 /// <param name="actual">The actual value to test</param>\r
2173                 static public void That( object actual, Constraint constraint )\r
2174                 {\r
2175                         Assert.That( actual, constraint, null, null );\r
2176                 }\r
2177 \r
2178                 /// <summary>\r
2179                 /// Apply a constraint to an actual value, succeedingt if the constraint\r
2180                 /// is satisfied and throwing an assertion exception on failure.\r
2181                 /// </summary>\r
2182                 /// <param name="constraint">A Constraint to be applied</param>\r
2183                 /// <param name="actual">The actual value to test</param>\r
2184                 /// <param name="message">The message that will be displayed on failure</param>\r
2185                 static public void That( object actual, Constraint constraint, string message )\r
2186                 {\r
2187                         Assert.That( actual, constraint, message, null );\r
2188                 }\r
2189 \r
2190                 /// <summary>\r
2191                 /// Apply a constraint to an actual value, succeedingt if the constraint\r
2192                 /// is satisfied and throwing an assertion exception on failure.\r
2193                 /// </summary>\r
2194                 /// <param name="constraint">A Constraint to be applied</param>\r
2195                 /// <param name="actual">The actual value to test</param>\r
2196                 /// <param name="message">The message that will be displayed on failure</param>\r
2197                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2198                 static public void That( object actual, Constraint constraint, string message, params object[] args )\r
2199                 {\r
2200                         Assert.IncrementAssertCount();\r
2201                         if ( !constraint.Matches( actual ) )\r
2202                         {\r
2203                                 MessageWriter writer = new TextMessageWriter( message, args );\r
2204                                 constraint.WriteMessageTo( writer );\r
2205                                 throw new AssertionException( writer.ToString() );\r
2206                         }\r
2207                 }\r
2208 \r
2209         /// <summary>\r
2210         /// Asserts that a condition is true. If the condition is false the method throws\r
2211         /// an <see cref="AssertionException"/>.\r
2212         /// </summary> \r
2213         /// <param name="condition">The evaluated condition</param>\r
2214         /// <param name="message">The message to display if the condition is false</param>\r
2215         /// <param name="args">Arguments to be used in formatting the message</param>\r
2216         static public void That(bool condition, string message, params object[] args)\r
2217         {\r
2218             Assert.That(condition, Is.True, message, args);\r
2219         }\r
2220 \r
2221         /// <summary>\r
2222         /// Asserts that a condition is true. If the condition is false the method throws\r
2223         /// an <see cref="AssertionException"/>.\r
2224         /// </summary>\r
2225         /// <param name="condition">The evaluated condition</param>\r
2226         /// <param name="message">The message to display if the condition is false</param>\r
2227         static public void That(bool condition, string message)\r
2228         {\r
2229             Assert.That(condition, Is.True, message, null);\r
2230         }\r
2231 \r
2232         /// <summary>\r
2233         /// Asserts that a condition is true. If the condition is false the method throws\r
2234         /// an <see cref="AssertionException"/>.\r
2235         /// </summary>\r
2236         /// <param name="condition">The evaluated condition</param>\r
2237         static public void That(bool condition)\r
2238         {\r
2239             Assert.That(condition, Is.True, null, null);\r
2240         }\r
2241         #endregion\r
2242 \r
2243                 #region GreaterOrEqual\r
2244 \r
2245                 #region Ints\r
2246 \r
2247                 /// <summary>\r
2248                 /// Verifies that the first value is greater than or equal to the second\r
2249                 /// value. If they are not, then an \r
2250                 /// <see cref="AssertionException"/> is thrown. \r
2251                 /// </summary>\r
2252                 /// <param name="arg1">The first value, expected to be greater</param>\r
2253                 /// <param name="arg2">The second value, expected to be less</param>\r
2254                 /// <param name="message">The message that will be displayed on failure</param>\r
2255                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2256                 static public void GreaterOrEqual(int arg1,\r
2257                     int arg2, string message, params object[] args)\r
2258                 {\r
2259             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2260         }\r
2261 \r
2262                 /// <summary>\r
2263                 /// Verifies that the first value is greater than or equal to the second\r
2264                 /// value. If they are not, then an \r
2265                 /// <see cref="AssertionException"/> is thrown.\r
2266                 /// </summary>\r
2267                 /// <param name="arg1">The first value, expected to be greater</param>\r
2268                 /// <param name="arg2">The second value, expected to be less</param>\r
2269                 /// <param name="message">The message that will be displayed on failure</param>\r
2270                 static public void GreaterOrEqual(int arg1, int arg2, string message)\r
2271                 {\r
2272                     Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2273                 }\r
2274 \r
2275                 /// <summary>\r
2276                 /// Verifies that the first value is greater than or equal to the second\r
2277                 /// value. If they are not, then an \r
2278                 /// <see cref="AssertionException"/> is thrown.\r
2279                 /// </summary>\r
2280                 /// <param name="arg1">The first value, expected to be greater</param>\r
2281                 /// <param name="arg2">The second value, expected to be less</param>\r
2282                 static public void GreaterOrEqual(int arg1, int arg2)\r
2283                 {\r
2284                     Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2285                 }\r
2286 \r
2287                 #endregion\r
2288 \r
2289                 #region UInts\r
2290 \r
2291                 /// <summary>\r
2292                 /// Verifies that the first value is greater than or equal to the second\r
2293                 /// value. If they are not, then an \r
2294                 /// <see cref="AssertionException"/> is thrown.\r
2295                 /// </summary>\r
2296                 /// <param name="arg1">The first value, expected to be greater</param>\r
2297                 /// <param name="arg2">The second value, expected to be less</param>\r
2298                 /// <param name="message">The message that will be displayed on failure</param>\r
2299                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2300                 [CLSCompliant(false)]\r
2301                 static public void GreaterOrEqual(uint arg1,\r
2302                         uint arg2, string message, params object[] args)\r
2303                 {\r
2304                         Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2305                 }\r
2306 \r
2307                 /// <summary>\r
2308                 /// Verifies that the first value is greater than or equal to the second\r
2309                 /// value. If they are not, then an \r
2310                 /// <see cref="AssertionException"/> is thrown.\r
2311                 /// </summary>\r
2312                 /// <param name="arg1">The first value, expected to be greater</param>\r
2313                 /// <param name="arg2">The second value, expected to be less</param>\r
2314                 /// <param name="message">The message that will be displayed on failure</param>\r
2315                 [CLSCompliant(false)]\r
2316                 static public void GreaterOrEqual(uint arg1, uint arg2, string message)\r
2317                 {\r
2318                         Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2319                 }\r
2320 \r
2321                 /// <summary>\r
2322                 /// Verifies that the first value is greater or equal to than the second\r
2323                 /// value. If they are not, then an \r
2324                 /// <see cref="AssertionException"/> is thrown.\r
2325                 /// </summary>\r
2326                 /// <param name="arg1">The first value, expected to be greater</param>\r
2327                 /// <param name="arg2">The second value, expected to be less</param>\r
2328                 [CLSCompliant(false)]\r
2329                 static public void GreaterOrEqual(uint arg1, uint arg2)\r
2330                 {\r
2331                         Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2332                 }\r
2333 \r
2334                 #endregion\r
2335 \r
2336                 #region Longs\r
2337 \r
2338                 /// <summary>\r
2339                 /// Verifies that the first value is greater than or equal to the second\r
2340                 /// value. If they are not, then an \r
2341                 /// <see cref="AssertionException"/> is thrown.\r
2342                 /// </summary>\r
2343                 /// <param name="arg1">The first value, expected to be greater</param>\r
2344                 /// <param name="arg2">The second value, expected to be less</param>\r
2345                 /// <param name="message">The message that will be displayed on failure</param>\r
2346                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2347                 static public void GreaterOrEqual(long arg1,\r
2348                         long arg2, string message, params object[] args)\r
2349                 {\r
2350                         Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2351                 }\r
2352 \r
2353                 /// <summary>\r
2354                 /// Verifies that the first value is greater than or equal to the second\r
2355                 /// value. If they are not, then an \r
2356                 /// <see cref="AssertionException"/> is thrown.\r
2357                 /// </summary>\r
2358                 /// <param name="arg1">The first value, expected to be greater</param>\r
2359                 /// <param name="arg2">The second value, expected to be less</param>\r
2360                 /// <param name="message">The message that will be displayed on failure</param>\r
2361                 static public void GreaterOrEqual(long arg1, long arg2, string message)\r
2362                 {\r
2363                         Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2364                 }\r
2365 \r
2366                 /// <summary>\r
2367                 /// Verifies that the first value is greater or equal to than the second\r
2368                 /// value. If they are not, then an \r
2369                 /// <see cref="AssertionException"/> is thrown.\r
2370                 /// </summary>\r
2371                 /// <param name="arg1">The first value, expected to be greater</param>\r
2372                 /// <param name="arg2">The second value, expected to be less</param>\r
2373                 static public void GreaterOrEqual(long arg1, long arg2)\r
2374                 {\r
2375                         Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2376                 }\r
2377 \r
2378                 #endregion\r
2379 \r
2380                 #region ULongs\r
2381 \r
2382                 /// <summary>\r
2383                 /// Verifies that the first value is greater than or equal to the second\r
2384                 /// value. If they are not, then an \r
2385                 /// <see cref="AssertionException"/> is thrown.\r
2386                 /// </summary>\r
2387                 /// <param name="arg1">The first value, expected to be greater</param>\r
2388                 /// <param name="arg2">The second value, expected to be less</param>\r
2389                 /// <param name="message">The message that will be displayed on failure</param>\r
2390                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2391                 [CLSCompliant(false)]\r
2392                 static public void GreaterOrEqual(ulong arg1,\r
2393                         ulong arg2, string message, params object[] args)\r
2394                 {\r
2395                         Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2396                 }\r
2397 \r
2398                 /// <summary>\r
2399                 /// Verifies that the first value is greater than or equal to the second\r
2400                 /// value. If they are not, then an \r
2401                 /// <see cref="AssertionException"/> is thrown.\r
2402                 /// </summary>\r
2403                 /// <param name="arg1">The first value, expected to be greater</param>\r
2404                 /// <param name="arg2">The second value, expected to be less</param>\r
2405                 /// <param name="message">The message that will be displayed on failure</param>\r
2406                 [CLSCompliant(false)]\r
2407                 static public void GreaterOrEqual(ulong arg1, ulong arg2, string message)\r
2408                 {\r
2409                         Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2410                 }\r
2411 \r
2412                 /// <summary>\r
2413                 /// Verifies that the first value is greater or equal to than the second\r
2414                 /// value. If they are not, then an \r
2415                 /// <see cref="AssertionException"/> is thrown.\r
2416                 /// </summary>\r
2417                 /// <param name="arg1">The first value, expected to be greater</param>\r
2418                 /// <param name="arg2">The second value, expected to be less</param>\r
2419                 [CLSCompliant(false)]\r
2420                 static public void GreaterOrEqual(ulong arg1, ulong arg2)\r
2421                 {\r
2422                         Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2423                 }\r
2424 \r
2425                 #endregion\r
2426 \r
2427                 #region Decimals\r
2428 \r
2429                 /// <summary>\r
2430                 /// Verifies that the first value is greater than or equal to the second\r
2431                 /// value. If they are not, then an \r
2432                 /// <see cref="AssertionException"/> is thrown.\r
2433                 /// </summary>\r
2434                 /// <param name="arg1">The first value, expected to be greater</param>\r
2435                 /// <param name="arg2">The second value, expected to be less</param>\r
2436                 /// <param name="message">The message that will be displayed on failure</param>\r
2437                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2438                 static public void GreaterOrEqual(decimal arg1,\r
2439                     decimal arg2, string message, params object[] args)\r
2440                 {\r
2441             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2442         }\r
2443 \r
2444                 /// <summary>\r
2445                 /// Verifies that the first value is greater than or equal to the second\r
2446                 /// value. If they are not, then an \r
2447                 /// <see cref="AssertionException"/> is thrown.\r
2448                 /// </summary>\r
2449                 /// <param name="arg1">The first value, expected to be greater</param>\r
2450                 /// <param name="arg2">The second value, expected to be less</param>\r
2451                 /// <param name="message">The message that will be displayed on failure</param>\r
2452                 static public void GreaterOrEqual(decimal arg1, decimal arg2, string message)\r
2453                 {\r
2454                     Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2455                 }\r
2456 \r
2457                 /// <summary>\r
2458                 /// Verifies that the first value is greater than or equal to the second\r
2459                 /// value. If they are not, then an \r
2460                 /// <see cref="AssertionException"/> is thrown.\r
2461                 /// </summary>\r
2462                 /// <param name="arg1">The first value, expected to be greater</param>\r
2463                 /// <param name="arg2">The second value, expected to be less</param>\r
2464                 static public void GreaterOrEqual(decimal arg1, decimal arg2)\r
2465                 {\r
2466                     Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2467                 }\r
2468 \r
2469                 #endregion\r
2470 \r
2471                 #region Doubles\r
2472 \r
2473                 /// <summary>\r
2474                 /// Verifies that the first value is greater than or equal to the second\r
2475                 /// value. If they are not, then an \r
2476                 /// <see cref="AssertionException"/> is thrown.\r
2477                 /// </summary>\r
2478                 /// <param name="arg1">The first value, expected to be greater</param>\r
2479                 /// <param name="arg2">The second value, expected to be less</param>\r
2480                 /// <param name="message">The message that will be displayed on failure</param>\r
2481                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2482                 static public void GreaterOrEqual(double arg1,\r
2483                     double arg2, string message, params object[] args)\r
2484                 {\r
2485             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2486         }\r
2487 \r
2488                 /// <summary>\r
2489                 /// Verifies that the first value is greater than or equal to the second\r
2490                 /// value. If they are not, then an \r
2491                 /// <see cref="AssertionException"/> is thrown.\r
2492                 /// </summary>\r
2493                 /// <param name="arg1">The first value, expected to be greater</param>\r
2494                 /// <param name="arg2">The second value, expected to be less</param>\r
2495                 /// <param name="message">The message that will be displayed on failure</param>\r
2496                 static public void GreaterOrEqual(double arg1,\r
2497                     double arg2, string message)\r
2498                 {\r
2499                     Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2500                 }\r
2501 \r
2502                 /// <summary>\r
2503                 /// Verifies that the first value is greater than or equal to the second\r
2504                 /// value. If they are not, then an \r
2505                 /// <see cref="AssertionException"/> is thrown.\r
2506                 /// </summary>\r
2507                 /// <param name="arg1">The first value, expected to be greater</param>\r
2508                 /// <param name="arg2">The second value, expected to be less</param>\r
2509                 static public void GreaterOrEqual(double arg1, double arg2)\r
2510                 {\r
2511                     Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2512                 }\r
2513 \r
2514                 #endregion\r
2515 \r
2516                 #region Floats\r
2517 \r
2518                 /// <summary>\r
2519                 /// Verifies that the first value is greater than or equal to the second\r
2520                 /// value. If they are not, then an \r
2521                 /// <see cref="AssertionException"/> is thrown.\r
2522                 /// </summary>\r
2523                 /// <param name="arg1">The first value, expected to be greater</param>\r
2524                 /// <param name="arg2">The second value, expected to be less</param>\r
2525                 /// <param name="message">The message that will be displayed on failure</param>\r
2526                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2527                 static public void GreaterOrEqual(float arg1,\r
2528                     float arg2, string message, params object[] args)\r
2529                 {\r
2530             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2531         }\r
2532 \r
2533                 /// <summary>\r
2534                 /// Verifies that the first value is greater than or equal to the second\r
2535                 /// value. If they are not, then an \r
2536                 /// <see cref="AssertionException"/> is thrown.\r
2537                 /// </summary>\r
2538                 /// <param name="arg1">The first value, expected to be greater</param>\r
2539                 /// <param name="arg2">The second value, expected to be less</param>\r
2540                 /// <param name="message">The message that will be displayed on failure</param>\r
2541                 static public void GreaterOrEqual(float arg1, float arg2, string message)\r
2542                 {\r
2543                     Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2544                 }\r
2545 \r
2546                 /// <summary>\r
2547                 /// Verifies that the first value is greater than or equal to the second\r
2548                 /// value. If they are not, then an \r
2549                 /// <see cref="AssertionException"/> is thrown.\r
2550                 /// </summary>\r
2551                 /// <param name="arg1">The first value, expected to be greater</param>\r
2552                 /// <param name="arg2">The second value, expected to be less</param>\r
2553                 static public void GreaterOrEqual(float arg1, float arg2)\r
2554                 {\r
2555                     Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2556                 }\r
2557 \r
2558                 #endregion\r
2559 \r
2560                 #region IComparables\r
2561 \r
2562                 /// <summary>\r
2563                 /// Verifies that the first value is greater than the second\r
2564                 /// value. If they are not, then an \r
2565                 /// <see cref="AssertionException"/> is thrown.\r
2566                 /// </summary>\r
2567                 /// <param name="arg1">The first value, expected to be greater</param>\r
2568                 /// <param name="arg2">The second value, expected to be less</param>\r
2569                 /// <param name="message">The message that will be displayed on failure</param>\r
2570                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2571                 static public void GreaterOrEqual(IComparable arg1,\r
2572                     IComparable arg2, string message, params object[] args)\r
2573                 {\r
2574             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);\r
2575         }\r
2576 \r
2577                 /// <summary>\r
2578                 /// Verifies that the first value is greater than the second\r
2579                 /// value. If they are not, then an \r
2580                 /// <see cref="AssertionException"/> is thrown.\r
2581                 /// </summary>\r
2582                 /// <param name="arg1">The first value, expected to be greater</param>\r
2583                 /// <param name="arg2">The second value, expected to be less</param>\r
2584                 /// <param name="message">The message that will be displayed on failure</param>\r
2585                 static public void GreaterOrEqual(IComparable arg1, IComparable arg2, string message)\r
2586                 {\r
2587                     Assert.GreaterOrEqual(arg1, arg2, message, null);\r
2588                 }\r
2589 \r
2590                 /// <summary>\r
2591                 /// Verifies that the first value is greater than the second\r
2592                 /// value. If they are not, then an \r
2593                 /// <see cref="AssertionException"/> is thrown.\r
2594                 /// </summary>\r
2595                 /// <param name="arg1">The first value, expected to be greater</param>\r
2596                 /// <param name="arg2">The second value, expected to be less</param>\r
2597                 static public void GreaterOrEqual(IComparable arg1, IComparable arg2)\r
2598                 {\r
2599                     Assert.GreaterOrEqual(arg1, arg2, string.Empty, null);\r
2600                 }\r
2601 \r
2602                 #endregion\r
2603 \r
2604                 #endregion\r
2605 \r
2606                 #region LessOrEqual\r
2607 \r
2608                 #region Ints\r
2609 \r
2610                 /// <summary>\r
2611                 /// Verifies that the first value is less than or equal to the second\r
2612                 /// value. If it is not, then an \r
2613                 /// <see cref="AssertionException"/> is thrown.\r
2614                 /// </summary>\r
2615                 /// <param name="arg1">The first value, expected to be less</param>\r
2616                 /// <param name="arg2">The second value, expected to be greater</param>\r
2617                 /// <param name="message">The message that will be displayed on failure</param>\r
2618                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2619                 static public void LessOrEqual(int arg1, int arg2, string message, params object[] args)\r
2620                 {\r
2621             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2622         }\r
2623 \r
2624                 /// <summary>\r
2625                 /// Verifies that the first value is less than or equal to the second\r
2626                 /// value. If it is not, then an \r
2627                 /// <see cref="AssertionException"/> is thrown.\r
2628                 /// </summary>\r
2629                 /// <param name="arg1">The first value, expected to be less</param>\r
2630                 /// <param name="arg2">The second value, expected to be greater</param>\r
2631                 /// <param name="message">The message that will be displayed on failure</param>\r
2632                 static public void LessOrEqual(int arg1, int arg2, string message)\r
2633                 {\r
2634                     Assert.LessOrEqual(arg1, arg2, message, null);\r
2635                 }\r
2636 \r
2637                 /// <summary>\r
2638                 /// Verifies that the first value is less than or equal to the second\r
2639                 /// value. If it is not, then an \r
2640                 /// <see cref="AssertionException"/> is thrown.\r
2641                 /// </summary>\r
2642                 /// <param name="arg1">The first value, expected to be less</param>\r
2643                 /// <param name="arg2">The second value, expected to be greater</param>\r
2644                 static public void LessOrEqual(int arg1, int arg2)\r
2645                 {\r
2646                     Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2647                 }\r
2648 \r
2649                 #endregion\r
2650 \r
2651                 #region UInts\r
2652 \r
2653                 /// <summary>\r
2654                 /// Verifies that the first value is less than or equal to the second\r
2655                 /// value. If it is not, then an \r
2656                 /// <see cref="AssertionException"/> is thrown.\r
2657                 /// </summary>\r
2658                 /// <param name="arg1">The first value, expected to be less</param>\r
2659                 /// <param name="arg2">The second value, expected to be greater</param>\r
2660                 /// <param name="message">The message that will be displayed on failure</param>\r
2661                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2662                 [CLSCompliant(false)]\r
2663                 static public void LessOrEqual(uint arg1, uint arg2, string message, params object[] args)\r
2664                 {\r
2665                         Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2666                 }\r
2667 \r
2668                 /// <summary>\r
2669                 /// Verifies that the first value is less than or equal to the second\r
2670                 /// value. If it is not, then an \r
2671                 /// <see cref="AssertionException"/> is thrown.\r
2672                 /// </summary>\r
2673                 /// <param name="arg1">The first value, expected to be less</param>\r
2674                 /// <param name="arg2">The second value, expected to be greater</param>\r
2675                 /// <param name="message">The message that will be displayed on failure</param>\r
2676                 [CLSCompliant(false)]\r
2677                 static public void LessOrEqual(uint arg1, uint arg2, string message)\r
2678                 {\r
2679                         Assert.LessOrEqual(arg1, arg2, message, null);\r
2680                 }\r
2681 \r
2682                 /// <summary>\r
2683                 /// Verifies that the first value is less than or equal to the second\r
2684                 /// value. If it is not, then an \r
2685                 /// <see cref="AssertionException"/> is thrown.\r
2686                 /// </summary>\r
2687                 /// <param name="arg1">The first value, expected to be less</param>\r
2688                 /// <param name="arg2">The second value, expected to be greater</param>\r
2689                 [CLSCompliant(false)]\r
2690                 static public void LessOrEqual(uint arg1, uint arg2)\r
2691                 {\r
2692                         Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2693                 }\r
2694 \r
2695                 #endregion\r
2696 \r
2697                 #region Longs\r
2698 \r
2699                 /// <summary>\r
2700                 /// Verifies that the first value is less than or equal to the second\r
2701                 /// value. If it is not, then an \r
2702                 /// <see cref="AssertionException"/> is thrown.\r
2703                 /// </summary>\r
2704                 /// <param name="arg1">The first value, expected to be less</param>\r
2705                 /// <param name="arg2">The second value, expected to be greater</param>\r
2706                 /// <param name="message">The message that will be displayed on failure</param>\r
2707                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2708                 static public void LessOrEqual(long arg1, long arg2, string message, params object[] args)\r
2709                 {\r
2710                         Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2711                 }\r
2712 \r
2713                 /// <summary>\r
2714                 /// Verifies that the first value is less than or equal to the second\r
2715                 /// value. If it is not, then an \r
2716                 /// <see cref="AssertionException"/> is thrown.\r
2717                 /// </summary>\r
2718                 /// <param name="arg1">The first value, expected to be less</param>\r
2719                 /// <param name="arg2">The second value, expected to be greater</param>\r
2720                 /// <param name="message">The message that will be displayed on failure</param>\r
2721                 static public void LessOrEqual(long arg1, long arg2, string message)\r
2722                 {\r
2723                         Assert.LessOrEqual(arg1, arg2, message, null);\r
2724                 }\r
2725 \r
2726                 /// <summary>\r
2727                 /// Verifies that the first value is less than or equal to the second\r
2728                 /// value. If it is not, then an \r
2729                 /// <see cref="AssertionException"/> is thrown.\r
2730                 /// </summary>\r
2731                 /// <param name="arg1">The first value, expected to be less</param>\r
2732                 /// <param name="arg2">The second value, expected to be greater</param>\r
2733                 static public void LessOrEqual(long arg1, long arg2)\r
2734                 {\r
2735                         Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2736                 }\r
2737 \r
2738                 #endregion\r
2739 \r
2740                 #region ULongs\r
2741 \r
2742                 /// <summary>\r
2743                 /// Verifies that the first value is less than or equal to the second\r
2744                 /// value. If it is not, then an \r
2745                 /// <see cref="AssertionException"/> is thrown.\r
2746                 /// </summary>\r
2747                 /// <param name="arg1">The first value, expected to be less</param>\r
2748                 /// <param name="arg2">The second value, expected to be greater</param>\r
2749                 /// <param name="message">The message that will be displayed on failure</param>\r
2750                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2751                 [CLSCompliant(false)]\r
2752                 static public void LessOrEqual(ulong arg1, ulong arg2, string message, params object[] args)\r
2753                 {\r
2754                         Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2755                 }\r
2756 \r
2757                 /// <summary>\r
2758                 /// Verifies that the first value is less than or equal to the second\r
2759                 /// value. If it is not, then an \r
2760                 /// <see cref="AssertionException"/> is thrown.\r
2761                 /// </summary>\r
2762                 /// <param name="arg1">The first value, expected to be less</param>\r
2763                 /// <param name="arg2">The second value, expected to be greater</param>\r
2764                 /// <param name="message">The message that will be displayed on failure</param>\r
2765                 [CLSCompliant(false)]\r
2766                 static public void LessOrEqual(ulong arg1, ulong arg2, string message)\r
2767                 {\r
2768                         Assert.LessOrEqual(arg1, arg2, message, null);\r
2769                 }\r
2770 \r
2771                 /// <summary>\r
2772                 /// Verifies that the first value is less than or equal to the second\r
2773                 /// value. If it is not, then an \r
2774                 /// <see cref="AssertionException"/> is thrown.\r
2775                 /// </summary>\r
2776                 /// <param name="arg1">The first value, expected to be less</param>\r
2777                 /// <param name="arg2">The second value, expected to be greater</param>\r
2778                 [CLSCompliant(false)]\r
2779                 static public void LessOrEqual(ulong arg1, ulong arg2)\r
2780                 {\r
2781                         Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2782                 }\r
2783 \r
2784                 #endregion\r
2785 \r
2786                 #region Decimals\r
2787 \r
2788                 /// <summary>\r
2789                 /// Verifies that the first value is less than or equal to the second\r
2790                 /// value. If it is not, then an \r
2791                 /// <see cref="AssertionException"/> is thrown.\r
2792                 /// </summary>\r
2793                 /// <param name="arg1">The first value, expected to be less</param>\r
2794                 /// <param name="arg2">The second value, expected to be greater</param>\r
2795                 /// <param name="message">The message that will be displayed on failure</param>\r
2796                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2797                 static public void LessOrEqual(decimal arg1, decimal arg2, string message, params object[] args)\r
2798                 {\r
2799             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2800         }\r
2801 \r
2802                 /// <summary>\r
2803                 /// Verifies that the first value is less than or equal to the second\r
2804                 /// value. If it is not, then an \r
2805                 /// <see cref="AssertionException"/> is thrown.\r
2806                 /// </summary>\r
2807                 /// <param name="arg1">The first value, expected to be less</param>\r
2808                 /// <param name="arg2">The second value, expected to be greater</param>\r
2809                 /// <param name="message">The message that will be displayed on failure</param>\r
2810                 static public void LessOrEqual(decimal arg1, decimal arg2, string message)\r
2811                 {\r
2812                     Assert.LessOrEqual(arg1, arg2, message, null);\r
2813                 }\r
2814 \r
2815                 /// <summary>\r
2816                 /// Verifies that the first value is less than or equal to the second\r
2817                 /// value. If it is not, then an \r
2818                 /// <see cref="AssertionException"/> is thrown.\r
2819                 /// </summary>\r
2820                 /// <param name="arg1">The first value, expected to be less</param>\r
2821                 /// <param name="arg2">The second value, expected to be greater</param>\r
2822                 static public void LessOrEqual(decimal arg1, decimal arg2)\r
2823                 {\r
2824                     Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2825                 }\r
2826 \r
2827                 #endregion\r
2828 \r
2829                 #region Doubles\r
2830 \r
2831                 /// <summary>\r
2832                 /// Verifies that the first value is less than or equal to the second\r
2833                 /// value. If it is not, then an \r
2834                 /// <see cref="AssertionException"/> is thrown.\r
2835                 /// </summary>\r
2836                 /// <param name="arg1">The first value, expected to be less</param>\r
2837                 /// <param name="arg2">The second value, expected to be greater</param>\r
2838                 /// <param name="message">The message that will be displayed on failure</param>\r
2839                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2840                 static public void LessOrEqual(double arg1, double arg2, string message, params object[] args)\r
2841                 {\r
2842             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2843         }\r
2844 \r
2845                 /// <summary>\r
2846                 /// Verifies that the first value is less than or equal to the second\r
2847                 /// value. If it is not, then an \r
2848                 /// <see cref="AssertionException"/> is thrown.\r
2849                 /// </summary>\r
2850                 /// <param name="arg1">The first value, expected to be less</param>\r
2851                 /// <param name="arg2">The second value, expected to be greater</param>\r
2852                 /// <param name="message">The message that will be displayed on failure</param>\r
2853                 static public void LessOrEqual(double arg1, double arg2, string message)\r
2854                 {\r
2855                     Assert.LessOrEqual(arg1, arg2, message, null);\r
2856                 }\r
2857 \r
2858                 /// <summary>\r
2859                 /// Verifies that the first value is less than or equal to the second\r
2860                 /// value. If it is not, then an \r
2861                 /// <see cref="AssertionException"/> is thrown.\r
2862                 /// </summary>\r
2863                 /// <param name="arg1">The first value, expected to be less</param>\r
2864                 /// <param name="arg2">The second value, expected to be greater</param>\r
2865                 static public void LessOrEqual(double arg1, double arg2)\r
2866                 {\r
2867                     Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2868                 }\r
2869 \r
2870                 #endregion\r
2871 \r
2872                 #region Floats\r
2873 \r
2874                 /// <summary>\r
2875                 /// Verifies that the first value is less than or equal to the second\r
2876                 /// value. If it is not, then an \r
2877                 /// <see cref="AssertionException"/> is thrown.\r
2878                 /// </summary>\r
2879                 /// <param name="arg1">The first value, expected to be less</param>\r
2880                 /// <param name="arg2">The second value, expected to be greater</param>\r
2881                 /// <param name="message">The message that will be displayed on failure</param>\r
2882                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2883                 static public void LessOrEqual(float arg1, float arg2, string message, params object[] args)\r
2884                 {\r
2885             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2886         }\r
2887 \r
2888                 /// <summary>\r
2889                 /// Verifies that the first value is less than or equal to the second\r
2890                 /// value. If it is not, then an \r
2891                 /// <see cref="AssertionException"/> is thrown.\r
2892                 /// </summary>\r
2893                 /// <param name="arg1">The first value, expected to be less</param>\r
2894                 /// <param name="arg2">The second value, expected to be greater</param>\r
2895                 /// <param name="message">The message that will be displayed on failure</param>\r
2896                 static public void LessOrEqual(float arg1, float arg2, string message)\r
2897                 {\r
2898                     Assert.LessOrEqual(arg1, arg2, message, null);\r
2899                 }\r
2900 \r
2901                 /// <summary>\r
2902                 /// Verifies that the first value is less than or equal to the second\r
2903                 /// value. If it is not, then an \r
2904                 /// <see cref="AssertionException"/> is thrown.\r
2905                 /// </summary>\r
2906                 /// <param name="arg1">The first value, expected to be less</param>\r
2907                 /// <param name="arg2">The second value, expected to be greater</param>\r
2908                 static public void LessOrEqual(float arg1, float arg2)\r
2909                 {\r
2910                     Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2911                 }\r
2912 \r
2913                 #endregion\r
2914 \r
2915                 #region IComparables\r
2916 \r
2917                 /// <summary>\r
2918                 /// Verifies that the first value is less than or equal to the second\r
2919                 /// value. If it is not, then an \r
2920                 /// <see cref="AssertionException"/> is thrown.\r
2921                 /// </summary>\r
2922                 /// <param name="arg1">The first value, expected to be less</param>\r
2923                 /// <param name="arg2">The second value, expected to be greater</param>\r
2924                 /// <param name="message">The message that will be displayed on failure</param>\r
2925                 /// <param name="args">Arguments to be used in formatting the message</param>\r
2926                 static public void LessOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)\r
2927                 {\r
2928             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);\r
2929         }\r
2930 \r
2931                 /// <summary>\r
2932                 /// Verifies that the first value is less than or equal to the second\r
2933                 /// value. If it is not, then an \r
2934                 /// <see cref="AssertionException"/> is thrown.\r
2935                 /// </summary>\r
2936                 /// <param name="arg1">The first value, expected to be less</param>\r
2937                 /// <param name="arg2">The second value, expected to be greater</param>\r
2938                 /// <param name="message">The message that will be displayed on failure</param>\r
2939                 static public void LessOrEqual(IComparable arg1, IComparable arg2, string message)\r
2940                 {\r
2941                     Assert.LessOrEqual(arg1, arg2, message, null);\r
2942                 }\r
2943 \r
2944                 /// <summary>\r
2945                 /// Verifies that the first value is less than or equal to the second\r
2946                 /// value. If it is not, then an \r
2947                 /// <see cref="AssertionException"/> is thrown.\r
2948                 /// </summary>\r
2949                 /// <param name="arg1">The first value, expected to be less</param>\r
2950                 /// <param name="arg2">The second value, expected to be greater</param>\r
2951                 static public void LessOrEqual(IComparable arg1, IComparable arg2)\r
2952                 {\r
2953                     Assert.LessOrEqual(arg1, arg2, string.Empty, null);\r
2954                 }\r
2955 \r
2956                 #endregion\r
2957 \r
2958         #endregion\r
2959         }\r
2960 }\r