test/Tizen.NUI.Devel.Tests.Ubuntu/nunit.framework/Assert/Assert.Comparisons.cs

   1 // ***********************************************************************
   2 // Copyright (c) 2014 Charlie Poole
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 // ***********************************************************************
  23
  24 using System;
  25
  26 namespace NUnit.Framework
  27 {
  28     public partial class Assert
  29     {
  30         #region Greater
  31
  32         #region Ints
  33
  34         /// <summary>
  35         /// Verifies that the first int is greater than the second
  36         /// int. If it is not, then an
  37         /// <see cref="AssertionException"/> is thrown.
  38         /// </summary>
  39         /// <param name="arg1">The first value, expected to be greater</param>
  40         /// <param name="arg2">The second value, expected to be less</param>
  41         /// <param name="message">The message to display in case of failure</param>
  42         /// <param name="args">Array of objects to be used in formatting the message</param>
  43         public static void Greater(int arg1, int arg2, string message, params object[] args)
  44         {
  45             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
  46         }
  47
  48         /// <summary>
  49         /// Verifies that the first int is greater than the second
  50         /// int. If it is not, then an
  51         /// <see cref="AssertionException"/> is thrown.
  52         /// </summary>
  53         /// <param name="arg1">The first value, expected to be greater</param>
  54         /// <param name="arg2">The second value, expected to be less</param>
  55         public static void Greater(int arg1, int arg2)
  56         {
  57             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
  58         }
  59
  60         #endregion
  61
  62         #region Unsigned Ints
  63
  64         /// <summary>
  65         /// Verifies that the first value is greater than the second
  66         /// value. If it is not, then an
  67         /// <see cref="AssertionException"/> is thrown.
  68         /// </summary>
  69         /// <param name="arg1">The first value, expected to be greater</param>
  70         /// <param name="arg2">The second value, expected to be less</param>
  71         /// <param name="message">The message to display in case of failure</param>
  72         /// <param name="args">Array of objects to be used in formatting the message</param>
  73         //[CLSCompliant(false)]
  74         public static void Greater(uint arg1, uint arg2, string message, params object[] args)
  75         {
  76             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
  77         }
  78
  79         /// <summary>
  80         /// Verifies that the first value is greater than the second
  81         /// value. If it is not, then an
  82         /// <see cref="AssertionException"/> is thrown.
  83         /// </summary>
  84         /// <param name="arg1">The first value, expected to be greater</param>
  85         /// <param name="arg2">The second value, expected to be less</param>
  86         //[CLSCompliant(false)]
  87         public static void Greater(uint arg1, uint arg2)
  88         {
  89             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
  90         }
  91
  92         #endregion
  93
  94         #region Longs
  95
  96         /// <summary>
  97         /// Verifies that the first value is greater than the second
  98         /// value. If it is not, then an
  99         /// <see cref="AssertionException"/> is thrown.
 100         /// </summary>
 101         /// <param name="arg1">The first value, expected to be greater</param>
 102         /// <param name="arg2">The second value, expected to be less</param>
 103         /// <param name="message">The message to display in case of failure</param>
 104         /// <param name="args">Array of objects to be used in formatting the message</param>
 105         public static void Greater(long arg1, long arg2, string message, params object[] args)
 106         {
 107             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 108         }
 109
 110         /// <summary>
 111         /// Verifies that the first value is greater than the second
 112         /// value. If it is not, then an
 113         /// <see cref="AssertionException"/> is thrown.
 114         /// </summary>
 115         /// <param name="arg1">The first value, expected to be greater</param>
 116         /// <param name="arg2">The second value, expected to be less</param>
 117         public static void Greater(long arg1, long arg2)
 118         {
 119             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 120         }
 121
 122         #endregion
 123
 124         #region Unsigned Longs
 125
 126         /// <summary>
 127         /// Verifies that the first value is greater than the second
 128         /// value. If it is not, then an
 129         /// <see cref="AssertionException"/> is thrown.
 130         /// </summary>
 131         /// <param name="arg1">The first value, expected to be greater</param>
 132         /// <param name="arg2">The second value, expected to be less</param>
 133         /// <param name="message">The message to display in case of failure</param>
 134         /// <param name="args">Array of objects to be used in formatting the message</param>
 135         //[CLSCompliant(false)]
 136         public static void Greater(ulong arg1, ulong arg2, string message, params object[] args)
 137         {
 138             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 139         }
 140
 141         /// <summary>
 142         /// Verifies that the first value is greater than the second
 143         /// value. If it is not, then an
 144         /// <see cref="AssertionException"/> is thrown.
 145         /// </summary>
 146         /// <param name="arg1">The first value, expected to be greater</param>
 147         /// <param name="arg2">The second value, expected to be less</param>
 148         //[CLSCompliant(false)]
 149         public static void Greater(ulong arg1, ulong arg2)
 150         {
 151             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 152         }
 153
 154         #endregion
 155
 156         #region Decimals
 157
 158         /// <summary>
 159         /// Verifies that the first value is greater than the second
 160         /// value. If it is not, then an
 161         /// <see cref="AssertionException"/> is thrown.
 162         /// </summary>
 163         /// <param name="arg1">The first value, expected to be greater</param>
 164         /// <param name="arg2">The second value, expected to be less</param>
 165         /// <param name="message">The message to display in case of failure</param>
 166         /// <param name="args">Array of objects to be used in formatting the message</param>
 167         public static void Greater(decimal arg1, decimal arg2, string message, params object[] args)
 168         {
 169             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 170         }
 171
 172         /// <summary>
 173         /// Verifies that the first value is greater than the second
 174         /// value. If it is not, then an
 175         /// <see cref="AssertionException"/> is thrown.
 176         /// </summary>
 177         /// <param name="arg1">The first value, expected to be greater</param>
 178         /// <param name="arg2">The second value, expected to be less</param>
 179         public static void Greater(decimal arg1, decimal arg2)
 180         {
 181             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 182         }
 183
 184         #endregion
 185
 186         #region Doubles
 187
 188         /// <summary>
 189         /// Verifies that the first value is greater than the second
 190         /// value. If it is not, then an
 191         /// <see cref="AssertionException"/> is thrown.
 192         /// </summary>
 193         /// <param name="arg1">The first value, expected to be greater</param>
 194         /// <param name="arg2">The second value, expected to be less</param>
 195         /// <param name="message">The message to display in case of failure</param>
 196         /// <param name="args">Array of objects to be used in formatting the message</param>
 197         public static void Greater(double arg1, double arg2, string message, params object[] args)
 198         {
 199             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 200         }
 201
 202         /// <summary>
 203         /// Verifies that the first value is greater than the second
 204         /// value. If it is not, then an
 205         /// <see cref="AssertionException"/> is thrown.
 206         /// </summary>
 207         /// <param name="arg1">The first value, expected to be greater</param>
 208         /// <param name="arg2">The second value, expected to be less</param>
 209         public static void Greater(double arg1, double arg2)
 210         {
 211             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 212         }
 213
 214         #endregion
 215
 216         #region Floats
 217
 218         /// <summary>
 219         /// Verifies that the first value is greater than the second
 220         /// value. If it is not, then an
 221         /// <see cref="AssertionException"/> is thrown.
 222         /// </summary>
 223         /// <param name="arg1">The first value, expected to be greater</param>
 224         /// <param name="arg2">The second value, expected to be less</param>
 225         /// <param name="message">The message to display in case of failure</param>
 226         /// <param name="args">Array of objects to be used in formatting the message</param>
 227         public static void Greater(float arg1, float arg2, string message, params object[] args)
 228         {
 229             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 230         }
 231
 232         /// <summary>
 233         /// Verifies that the first value is greater than the second
 234         /// value. If it is not, then an
 235         /// <see cref="AssertionException"/> is thrown.
 236         /// </summary>
 237         /// <param name="arg1">The first value, expected to be greater</param>
 238         /// <param name="arg2">The second value, expected to be less</param>
 239         public static void Greater(float arg1, float arg2)
 240         {
 241             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 242         }
 243
 244         #endregion
 245
 246         #region IComparables
 247
 248         /// <summary>
 249         /// Verifies that the first value is greater than the second
 250         /// value. If it is not, then an
 251         /// <see cref="AssertionException"/> is thrown.
 252         /// </summary>
 253         /// <param name="arg1">The first value, expected to be greater</param>
 254         /// <param name="arg2">The second value, expected to be less</param>
 255         /// <param name="message">The message to display in case of failure</param>
 256         /// <param name="args">Array of objects to be used in formatting the message</param>
 257         public static void Greater(IComparable arg1, IComparable arg2, string message, params object[] args)
 258         {
 259             Assert.That(arg1, Is.GreaterThan(arg2), message, args);
 260         }
 261
 262         /// <summary>
 263         /// Verifies that the first value is greater than the second
 264         /// value. If it is not, then an
 265         /// <see cref="AssertionException"/> is thrown.
 266         /// </summary>
 267         /// <param name="arg1">The first value, expected to be greater</param>
 268         /// <param name="arg2">The second value, expected to be less</param>
 269         public static void Greater(IComparable arg1, IComparable arg2)
 270         {
 271             Assert.That(arg1, Is.GreaterThan(arg2), null, null);
 272         }
 273
 274         #endregion
 275
 276         #endregion
 277
 278         #region Less
 279
 280         #region Ints
 281
 282         /// <summary>
 283         /// Verifies that the first value is less than the second
 284         /// value. If it is not, then an
 285         /// <see cref="AssertionException"/> is thrown.
 286         /// </summary>
 287         /// <param name="arg1">The first value, expected to be less</param>
 288         /// <param name="arg2">The second value, expected to be greater</param>
 289         /// <param name="message">The message to display in case of failure</param>
 290         /// <param name="args">Array of objects to be used in formatting the message</param>
 291         public static void Less(int arg1, int arg2, string message, params object[] args)
 292         {
 293             Assert.That(arg1, Is.LessThan(arg2), message, args);
 294         }
 295
 296         /// <summary>
 297         /// Verifies that the first value is less than the second
 298         /// value. If it is not, then an
 299         /// <see cref="AssertionException"/> is thrown.
 300         /// </summary>
 301         /// <param name="arg1">The first value, expected to be less</param>
 302         /// <param name="arg2">The second value, expected to be greater</param>
 303         public static void Less(int arg1, int arg2)
 304         {
 305             Assert.That(arg1, Is.LessThan(arg2), null, null);
 306         }
 307
 308         #endregion
 309
 310         #region Unsigned Ints
 311
 312         /// <summary>
 313         /// Verifies that the first value is less than the second
 314         /// value. If it is not, then an
 315         /// <see cref="AssertionException"/> is thrown.
 316         /// </summary>
 317         /// <param name="arg1">The first value, expected to be less</param>
 318         /// <param name="arg2">The second value, expected to be greater</param>
 319         /// <param name="message">The message to display in case of failure</param>
 320         /// <param name="args">Array of objects to be used in formatting the message</param>
 321         //[CLSCompliant(false)]
 322         public static void Less(uint arg1, uint arg2, string message, params object[] args)
 323         {
 324             Assert.That(arg1, Is.LessThan(arg2), message, args);
 325         }
 326
 327         /// <summary>
 328         /// Verifies that the first value is less than the second
 329         /// value. If it is not, then an
 330         /// <see cref="AssertionException"/> is thrown.
 331         /// </summary>
 332         /// <param name="arg1">The first value, expected to be less</param>
 333         /// <param name="arg2">The second value, expected to be greater</param>
 334         //[CLSCompliant(false)]
 335         public static void Less(uint arg1, uint arg2)
 336         {
 337             Assert.That(arg1, Is.LessThan(arg2), null, null);
 338         }
 339
 340         #endregion
 341
 342         #region Longs
 343
 344         /// <summary>
 345         /// Verifies that the first value is less than the second
 346         /// value. If it is not, then an
 347         /// <see cref="AssertionException"/> is thrown.
 348         /// </summary>
 349         /// <param name="arg1">The first value, expected to be less</param>
 350         /// <param name="arg2">The second value, expected to be greater</param>
 351         /// <param name="message">The message to display in case of failure</param>
 352         /// <param name="args">Array of objects to be used in formatting the message</param>
 353         public static void Less(long arg1, long arg2, string message, params object[] args)
 354         {
 355             Assert.That(arg1, Is.LessThan(arg2), message, args);
 356         }
 357
 358         /// <summary>
 359         /// Verifies that the first value is less than the second
 360         /// value. If it is not, then an
 361         /// <see cref="AssertionException"/> is thrown.
 362         /// </summary>
 363         /// <param name="arg1">The first value, expected to be less</param>
 364         /// <param name="arg2">The second value, expected to be greater</param>
 365         public static void Less(long arg1, long arg2)
 366         {
 367             Assert.That(arg1, Is.LessThan(arg2), null, null);
 368         }
 369
 370         #endregion
 371
 372         #region Unsigned Longs
 373
 374         /// <summary>
 375         /// Verifies that the first value is less than the second
 376         /// value. If it is not, then an
 377         /// <see cref="AssertionException"/> is thrown.
 378         /// </summary>
 379         /// <param name="arg1">The first value, expected to be less</param>
 380         /// <param name="arg2">The second value, expected to be greater</param>
 381         /// <param name="message">The message to display in case of failure</param>
 382         /// <param name="args">Array of objects to be used in formatting the message</param>
 383         //[CLSCompliant(false)]
 384         public static void Less(ulong arg1, ulong arg2, string message, params object[] args)
 385         {
 386             Assert.That(arg1, Is.LessThan(arg2), message, args);
 387         }
 388
 389         /// <summary>
 390         /// Verifies that the first value is less than the second
 391         /// value. If it is not, then an
 392         /// <see cref="AssertionException"/> is thrown.
 393         /// </summary>
 394         /// <param name="arg1">The first value, expected to be less</param>
 395         /// <param name="arg2">The second value, expected to be greater</param>
 396         //[CLSCompliant(false)]
 397         public static void Less(ulong arg1, ulong arg2)
 398         {
 399             Assert.That(arg1, Is.LessThan(arg2), null, null);
 400         }
 401
 402         #endregion
 403
 404         #region Decimals
 405
 406         /// <summary>
 407         /// Verifies that the first value is less than the second
 408         /// value. If it is not, then an
 409         /// <see cref="AssertionException"/> is thrown.
 410         /// </summary>
 411         /// <param name="arg1">The first value, expected to be less</param>
 412         /// <param name="arg2">The second value, expected to be greater</param>
 413         /// <param name="message">The message to display in case of failure</param>
 414         /// <param name="args">Array of objects to be used in formatting the message</param>
 415         public static void Less(decimal arg1, decimal arg2, string message, params object[] args)
 416         {
 417             Assert.That(arg1, Is.LessThan(arg2), message, args);
 418         }
 419
 420         /// <summary>
 421         /// Verifies that the first value is less than the second
 422         /// value. If it is not, then an
 423         /// <see cref="AssertionException"/> is thrown.
 424         /// </summary>
 425         /// <param name="arg1">The first value, expected to be less</param>
 426         /// <param name="arg2">The second value, expected to be greater</param>
 427         public static void Less(decimal arg1, decimal arg2)
 428         {
 429             Assert.That(arg1, Is.LessThan(arg2), null, null);
 430         }
 431
 432         #endregion
 433
 434         #region Doubles
 435
 436         /// <summary>
 437         /// Verifies that the first value is less than the second
 438         /// value. If it is not, then an
 439         /// <see cref="AssertionException"/> is thrown.
 440         /// </summary>
 441         /// <param name="arg1">The first value, expected to be less</param>
 442         /// <param name="arg2">The second value, expected to be greater</param>
 443         /// <param name="message">The message to display in case of failure</param>
 444         /// <param name="args">Array of objects to be used in formatting the message</param>
 445         public static void Less(double arg1, double arg2, string message, params object[] args)
 446         {
 447             Assert.That(arg1, Is.LessThan(arg2), message, args);
 448         }
 449
 450         /// <summary>
 451         /// Verifies that the first value is less than the second
 452         /// value. If it is not, then an
 453         /// <see cref="AssertionException"/> is thrown.
 454         /// </summary>
 455         /// <param name="arg1">The first value, expected to be less</param>
 456         /// <param name="arg2">The second value, expected to be greater</param>
 457         public static void Less(double arg1, double arg2)
 458         {
 459             Assert.That(arg1, Is.LessThan(arg2), null, null);
 460         }
 461
 462         #endregion
 463
 464         #region Floats
 465
 466         /// <summary>
 467         /// Verifies that the first value is less than the second
 468         /// value. If it is not, then an
 469         /// <see cref="AssertionException"/> is thrown.
 470         /// </summary>
 471         /// <param name="arg1">The first value, expected to be less</param>
 472         /// <param name="arg2">The second value, expected to be greater</param>
 473         /// <param name="message">The message to display in case of failure</param>
 474         /// <param name="args">Array of objects to be used in formatting the message</param>
 475         public static void Less(float arg1, float arg2, string message, params object[] args)
 476         {
 477             Assert.That(arg1, Is.LessThan(arg2), message, args);
 478         }
 479
 480         /// <summary>
 481         /// Verifies that the first value is less than the second
 482         /// value. If it is not, then an
 483         /// <see cref="AssertionException"/> is thrown.
 484         /// </summary>
 485         /// <param name="arg1">The first value, expected to be less</param>
 486         /// <param name="arg2">The second value, expected to be greater</param>
 487         public static void Less(float arg1, float arg2)
 488         {
 489             Assert.That(arg1, Is.LessThan(arg2), null, null);
 490         }
 491
 492         #endregion
 493
 494         #region IComparables
 495
 496         /// <summary>
 497         /// Verifies that the first value is less than the second
 498         /// value. If it is not, then an
 499         /// <see cref="AssertionException"/> is thrown.
 500         /// </summary>
 501         /// <param name="arg1">The first value, expected to be less</param>
 502         /// <param name="arg2">The second value, expected to be greater</param>
 503         /// <param name="message">The message to display in case of failure</param>
 504         /// <param name="args">Array of objects to be used in formatting the message</param>
 505         public static void Less(IComparable arg1, IComparable arg2, string message, params object[] args)
 506         {
 507             Assert.That(arg1, Is.LessThan(arg2), message, args);
 508         }
 509
 510         /// <summary>
 511         /// Verifies that the first value is less than the second
 512         /// value. If it is not, then an
 513         /// <see cref="AssertionException"/> is thrown.
 514         /// </summary>
 515         /// <param name="arg1">The first value, expected to be less</param>
 516         /// <param name="arg2">The second value, expected to be greater</param>
 517         public static void Less(IComparable arg1, IComparable arg2)
 518         {
 519             Assert.That(arg1, Is.LessThan(arg2), null, null);
 520         }
 521
 522         #endregion
 523
 524         #endregion
 525
 526         #region GreaterOrEqual
 527
 528         #region Ints
 529
 530         /// <summary>
 531         /// Verifies that the first value is greater than or equal to the second
 532         /// value. If it is not, then an
 533         /// <see cref="AssertionException"/> is thrown.
 534         /// </summary>
 535         /// <param name="arg1">The first value, expected to be greater</param>
 536         /// <param name="arg2">The second value, expected to be less</param>
 537         /// <param name="message">The message to display in case of failure</param>
 538         /// <param name="args">Array of objects to be used in formatting the message</param>
 539         public static void GreaterOrEqual(int arg1, int arg2, string message, params object[] args)
 540         {
 541             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 542         }
 543
 544         /// <summary>
 545         /// Verifies that the first value is greater than or equal to the second
 546         /// value. If it is not, then an
 547         /// <see cref="AssertionException"/> is thrown.
 548         /// </summary>
 549         /// <param name="arg1">The first value, expected to be greater</param>
 550         /// <param name="arg2">The second value, expected to be less</param>
 551         public static void GreaterOrEqual(int arg1, int arg2)
 552         {
 553             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 554         }
 555
 556         #endregion
 557
 558         #region Unsigned Ints
 559
 560         /// <summary>
 561         /// Verifies that the first value is greater than or equal to the second
 562         /// value. If it is not, then an
 563         /// <see cref="AssertionException"/> is thrown.
 564         /// </summary>
 565         /// <param name="arg1">The first value, expected to be greater</param>
 566         /// <param name="arg2">The second value, expected to be less</param>
 567         /// <param name="message">The message to display in case of failure</param>
 568         /// <param name="args">Array of objects to be used in formatting the message</param>
 569         //[CLSCompliant(false)]
 570         public static void GreaterOrEqual(uint arg1, uint arg2, string message, params object[] args)
 571         {
 572             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 573         }
 574
 575         /// <summary>
 576         /// Verifies that the first value is greater than or equal to the second
 577         /// value. If it is not, then an
 578         /// <see cref="AssertionException"/> is thrown.
 579         /// </summary>
 580         /// <param name="arg1">The first value, expected to be greater</param>
 581         /// <param name="arg2">The second value, expected to be less</param>
 582         //[CLSCompliant(false)]
 583         public static void GreaterOrEqual(uint arg1, uint arg2)
 584         {
 585             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 586         }
 587
 588         #endregion
 589
 590         #region Longs
 591
 592         /// <summary>
 593         /// Verifies that the first value is greater than or equal to the second
 594         /// value. If it is not, then an
 595         /// <see cref="AssertionException"/> is thrown.
 596         /// </summary>
 597         /// <param name="arg1">The first value, expected to be greater</param>
 598         /// <param name="arg2">The second value, expected to be less</param>
 599         /// <param name="message">The message to display in case of failure</param>
 600         /// <param name="args">Array of objects to be used in formatting the message</param>
 601         public static void GreaterOrEqual(long arg1, long arg2, string message, params object[] args)
 602         {
 603             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 604         }
 605
 606         /// <summary>
 607         /// Verifies that the first value is greater than or equal to the second
 608         /// value. If it is not, then an
 609         /// <see cref="AssertionException"/> is thrown.
 610         /// </summary>
 611         /// <param name="arg1">The first value, expected to be greater</param>
 612         /// <param name="arg2">The second value, expected to be less</param>
 613         public static void GreaterOrEqual(long arg1, long arg2)
 614         {
 615             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 616         }
 617
 618         #endregion
 619
 620         #region Unsigned Longs
 621
 622         /// <summary>
 623         /// Verifies that the first value is greater than or equal to the second
 624         /// value. If it is not, then an
 625         /// <see cref="AssertionException"/> is thrown.
 626         /// </summary>
 627         /// <param name="arg1">The first value, expected to be greater</param>
 628         /// <param name="arg2">The second value, expected to be less</param>
 629         /// <param name="message">The message to display in case of failure</param>
 630         /// <param name="args">Array of objects to be used in formatting the message</param>
 631         //[CLSCompliant(false)]
 632         public static void GreaterOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
 633         {
 634             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 635         }
 636
 637         /// <summary>
 638         /// Verifies that the first value is greater than or equal to the second
 639         /// value. If it is not, then an
 640         /// <see cref="AssertionException"/> is thrown.
 641         /// </summary>
 642         /// <param name="arg1">The first value, expected to be greater</param>
 643         /// <param name="arg2">The second value, expected to be less</param>
 644         //[CLSCompliant(false)]
 645         public static void GreaterOrEqual(ulong arg1, ulong arg2)
 646         {
 647             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 648         }
 649
 650         #endregion
 651
 652         #region Decimals
 653
 654         /// <summary>
 655         /// Verifies that the first value is greater than or equal to the second
 656         /// value. If it is not, then an
 657         /// <see cref="AssertionException"/> is thrown.
 658         /// </summary>
 659         /// <param name="arg1">The first value, expected to be greater</param>
 660         /// <param name="arg2">The second value, expected to be less</param>
 661         /// <param name="message">The message to display in case of failure</param>
 662         /// <param name="args">Array of objects to be used in formatting the message</param>
 663         public static void GreaterOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
 664         {
 665             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 666         }
 667
 668         /// <summary>
 669         /// Verifies that the first value is greater than or equal to the second
 670         /// value. If it is not, then an
 671         /// <see cref="AssertionException"/> is thrown.
 672         /// </summary>
 673         /// <param name="arg1">The first value, expected to be greater</param>
 674         /// <param name="arg2">The second value, expected to be less</param>
 675         public static void GreaterOrEqual(decimal arg1, decimal arg2)
 676         {
 677             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 678         }
 679
 680         #endregion
 681
 682         #region Doubles
 683
 684         /// <summary>
 685         /// Verifies that the first value is greater than or equal to the second
 686         /// value. If it is not, then an
 687         /// <see cref="AssertionException"/> is thrown.
 688         /// </summary>
 689         /// <param name="arg1">The first value, expected to be greater</param>
 690         /// <param name="arg2">The second value, expected to be less</param>
 691         /// <param name="message">The message to display in case of failure</param>
 692         /// <param name="args">Array of objects to be used in formatting the message</param>
 693         public static void GreaterOrEqual(double arg1, double arg2, string message, params object[] args)
 694         {
 695             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 696         }
 697
 698         /// <summary>
 699         /// Verifies that the first value is greater than or equal to the second
 700         /// value. If it is not, then an
 701         /// <see cref="AssertionException"/> is thrown.
 702         /// </summary>
 703         /// <param name="arg1">The first value, expected to be greater</param>
 704         /// <param name="arg2">The second value, expected to be less</param>
 705         public static void GreaterOrEqual(double arg1, double arg2)
 706         {
 707             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 708         }
 709
 710         #endregion
 711
 712         #region Floats
 713
 714         /// <summary>
 715         /// Verifies that the first value is greater than or equal to the second
 716         /// value. If it is not, then an
 717         /// <see cref="AssertionException"/> is thrown.
 718         /// </summary>
 719         /// <param name="arg1">The first value, expected to be greater</param>
 720         /// <param name="arg2">The second value, expected to be less</param>
 721         /// <param name="message">The message to display in case of failure</param>
 722         /// <param name="args">Array of objects to be used in formatting the message</param>
 723         public static void GreaterOrEqual(float arg1, float arg2, string message, params object[] args)
 724         {
 725             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 726         }
 727
 728         /// <summary>
 729         /// Verifies that the first value is greater than or equal to the second
 730         /// value. If it is not, then an
 731         /// <see cref="AssertionException"/> is thrown.
 732         /// </summary>
 733         /// <param name="arg1">The first value, expected to be greater</param>
 734         /// <param name="arg2">The second value, expected to be less</param>
 735         public static void GreaterOrEqual(float arg1, float arg2)
 736         {
 737             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 738         }
 739
 740         #endregion
 741
 742         #region IComparables
 743
 744         /// <summary>
 745         /// Verifies that the first value is greater than or equal to the second
 746         /// value. If it is not, then an
 747         /// <see cref="AssertionException"/> is thrown.
 748         /// </summary>
 749         /// <param name="arg1">The first value, expected to be greater</param>
 750         /// <param name="arg2">The second value, expected to be less</param>
 751         /// <param name="message">The message to display in case of failure</param>
 752         /// <param name="args">Array of objects to be used in formatting the message</param>
 753         public static void GreaterOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
 754         {
 755             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), message, args);
 756         }
 757
 758         /// <summary>
 759         /// Verifies that the first value is greater than or equal to the second
 760         /// value. If it is not, then an
 761         /// <see cref="AssertionException"/> is thrown.
 762         /// </summary>
 763         /// <param name="arg1">The first value, expected to be greater</param>
 764         /// <param name="arg2">The second value, expected to be less</param>
 765         public static void GreaterOrEqual(IComparable arg1, IComparable arg2)
 766         {
 767             Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), null, null);
 768         }
 769
 770         #endregion
 771
 772         #endregion
 773
 774         #region LessOrEqual
 775
 776         #region Ints
 777
 778         /// <summary>
 779         /// Verifies that the first value is less than or equal to the second
 780         /// value. If it is not, then an
 781         /// <see cref="AssertionException"/> is thrown.
 782         /// </summary>
 783         /// <param name="arg1">The first value, expected to be less</param>
 784         /// <param name="arg2">The second value, expected to be greater</param>
 785         /// <param name="message">The message to display in case of failure</param>
 786         /// <param name="args">Array of objects to be used in formatting the message</param>
 787         public static void LessOrEqual(int arg1, int arg2, string message, params object[] args)
 788         {
 789             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 790         }
 791
 792         /// <summary>
 793         /// Verifies that the first value is less than or equal to the second
 794         /// value. If it is not, then an
 795         /// <see cref="AssertionException"/> is thrown.
 796         /// </summary>
 797         /// <param name="arg1">The first value, expected to be less</param>
 798         /// <param name="arg2">The second value, expected to be greater</param>
 799         public static void LessOrEqual(int arg1, int arg2)
 800         {
 801             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 802         }
 803
 804         #endregion
 805
 806         #region Unsigned Ints
 807
 808         /// <summary>
 809         /// Verifies that the first value is less than or equal to the second
 810         /// value. If it is not, then an
 811         /// <see cref="AssertionException"/> is thrown.
 812         /// </summary>
 813         /// <param name="arg1">The first value, expected to be less</param>
 814         /// <param name="arg2">The second value, expected to be greater</param>
 815         /// <param name="message">The message to display in case of failure</param>
 816         /// <param name="args">Array of objects to be used in formatting the message</param>
 817         //[CLSCompliant(false)]
 818         public static void LessOrEqual(uint arg1, uint arg2, string message, params object[] args)
 819         {
 820             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 821         }
 822
 823         /// <summary>
 824         /// Verifies that the first value is less than or equal to the second
 825         /// value. If it is not, then an
 826         /// <see cref="AssertionException"/> is thrown.
 827         /// </summary>
 828         /// <param name="arg1">The first value, expected to be less</param>
 829         /// <param name="arg2">The second value, expected to be greater</param>
 830         //[CLSCompliant(false)]
 831         public static void LessOrEqual(uint arg1, uint arg2)
 832         {
 833             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 834         }
 835
 836         #endregion
 837
 838         #region Longs
 839
 840         /// <summary>
 841         /// Verifies that the first value is less than or equal to the second
 842         /// value. If it is not, then an
 843         /// <see cref="AssertionException"/> is thrown.
 844         /// </summary>
 845         /// <param name="arg1">The first value, expected to be less</param>
 846         /// <param name="arg2">The second value, expected to be greater</param>
 847         /// <param name="message">The message to display in case of failure</param>
 848         /// <param name="args">Array of objects to be used in formatting the message</param>
 849         public static void LessOrEqual(long arg1, long arg2, string message, params object[] args)
 850         {
 851             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 852         }
 853
 854         /// <summary>
 855         /// Verifies that the first value is less than or equal to the second
 856         /// value. If it is not, then an
 857         /// <see cref="AssertionException"/> is thrown.
 858         /// </summary>
 859         /// <param name="arg1">The first value, expected to be less</param>
 860         /// <param name="arg2">The second value, expected to be greater</param>
 861         public static void LessOrEqual(long arg1, long arg2)
 862         {
 863             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 864         }
 865
 866         #endregion
 867
 868         #region Unsigned Longs
 869
 870         /// <summary>
 871         /// Verifies that the first value is less than or equal to the second
 872         /// value. If it is not, then an
 873         /// <see cref="AssertionException"/> is thrown.
 874         /// </summary>
 875         /// <param name="arg1">The first value, expected to be less</param>
 876         /// <param name="arg2">The second value, expected to be greater</param>
 877         /// <param name="message">The message to display in case of failure</param>
 878         /// <param name="args">Array of objects to be used in formatting the message</param>
 879         //[CLSCompliant(false)]
 880         public static void LessOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
 881         {
 882             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 883         }
 884
 885         /// <summary>
 886         /// Verifies that the first value is less than or equal to the second
 887         /// value. If it is not, then an
 888         /// <see cref="AssertionException"/> is thrown.
 889         /// </summary>
 890         /// <param name="arg1">The first value, expected to be less</param>
 891         /// <param name="arg2">The second value, expected to be greater</param>
 892         //[CLSCompliant(false)]
 893         public static void LessOrEqual(ulong arg1, ulong arg2)
 894         {
 895             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 896         }
 897
 898         #endregion
 899
 900         #region Decimals
 901
 902         /// <summary>
 903         /// Verifies that the first value is less than or equal to the second
 904         /// value. If it is not, then an
 905         /// <see cref="AssertionException"/> is thrown.
 906         /// </summary>
 907         /// <param name="arg1">The first value, expected to be less</param>
 908         /// <param name="arg2">The second value, expected to be greater</param>
 909         /// <param name="message">The message to display in case of failure</param>
 910         /// <param name="args">Array of objects to be used in formatting the message</param>
 911         public static void LessOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
 912         {
 913             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 914         }
 915
 916         /// <summary>
 917         /// Verifies that the first value is less than or equal to the second
 918         /// value. If it is not, then an
 919         /// <see cref="AssertionException"/> is thrown.
 920         /// </summary>
 921         /// <param name="arg1">The first value, expected to be less</param>
 922         /// <param name="arg2">The second value, expected to be greater</param>
 923         public static void LessOrEqual(decimal arg1, decimal arg2)
 924         {
 925             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 926         }
 927
 928         #endregion
 929
 930         #region Doubles
 931
 932         /// <summary>
 933         /// Verifies that the first value is less than or equal to the second
 934         /// value. If it is not, then an
 935         /// <see cref="AssertionException"/> is thrown.
 936         /// </summary>
 937         /// <param name="arg1">The first value, expected to be less</param>
 938         /// <param name="arg2">The second value, expected to be greater</param>
 939         /// <param name="message">The message to display in case of failure</param>
 940         /// <param name="args">Array of objects to be used in formatting the message</param>
 941         public static void LessOrEqual(double arg1, double arg2, string message, params object[] args)
 942         {
 943             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 944         }
 945
 946         /// <summary>
 947         /// Verifies that the first value is less than or equal to the second
 948         /// value. If it is not, then an
 949         /// <see cref="AssertionException"/> is thrown.
 950         /// </summary>
 951         /// <param name="arg1">The first value, expected to be less</param>
 952         /// <param name="arg2">The second value, expected to be greater</param>
 953         public static void LessOrEqual(double arg1, double arg2)
 954         {
 955             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 956         }
 957
 958         #endregion
 959
 960         #region Floats
 961
 962         /// <summary>
 963         /// Verifies that the first value is less than or equal to the second
 964         /// value. If it is not, then an
 965         /// <see cref="AssertionException"/> is thrown.
 966         /// </summary>
 967         /// <param name="arg1">The first value, expected to be less</param>
 968         /// <param name="arg2">The second value, expected to be greater</param>
 969         /// <param name="message">The message to display in case of failure</param>
 970         /// <param name="args">Array of objects to be used in formatting the message</param>
 971         public static void LessOrEqual(float arg1, float arg2, string message, params object[] args)
 972         {
 973             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
 974         }
 975
 976         /// <summary>
 977         /// Verifies that the first value is less than or equal to the second
 978         /// value. If it is not, then an
 979         /// <see cref="AssertionException"/> is thrown.
 980         /// </summary>
 981         /// <param name="arg1">The first value, expected to be less</param>
 982         /// <param name="arg2">The second value, expected to be greater</param>
 983         public static void LessOrEqual(float arg1, float arg2)
 984         {
 985             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
 986         }
 987
 988         #endregion
 989
 990         #region IComparables
 991
 992         /// <summary>
 993         /// Verifies that the first value is less than or equal to the second
 994         /// value. If it is not, then an
 995         /// <see cref="AssertionException"/> is thrown.
 996         /// </summary>
 997         /// <param name="arg1">The first value, expected to be less</param>
 998         /// <param name="arg2">The second value, expected to be greater</param>
 999         /// <param name="message">The message to display in case of failure</param>
1000         /// <param name="args">Array of objects to be used in formatting the message</param>
1001         public static void LessOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
1002         {
1003             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), message, args);
1004         }
1005
1006         /// <summary>
1007         /// Verifies that the first value is less than or equal to the second
1008         /// value. If it is not, then an
1009         /// <see cref="AssertionException"/> is thrown.
1010         /// </summary>
1011         /// <param name="arg1">The first value, expected to be less</param>
1012         /// <param name="arg2">The second value, expected to be greater</param>
1013         public static void LessOrEqual(IComparable arg1, IComparable arg2)
1014         {
1015             Assert.That(arg1, Is.LessThanOrEqualTo(arg2), null, null);
1016         }
1017
1018         #endregion
1019
1020         #endregion
1021     }
1022 }