1 /*

     2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import static com.oracle.java.testlibrary.Asserts.*;

    25 

    26 /* @test

    27  * @summary Tests the different assertions in the Assert class

    28  * @library /testlibrary

    29  */

    30 public class AssertsTest {

    31     private static class Foo implements Comparable<Foo> {

    32         final int id;

    33         public Foo(int id) {

    34             this.id = id;

    35         }

    36 

    37         public int compareTo(Foo f) {

    38             return new Integer(id).compareTo(new Integer(f.id));

    39         }

    40     }

    41 

    42     public static void main(String[] args) throws Exception {

    43         testLessThan();

    44         testLessThanOrEqual();

    45         testEquals();

    46         testGreaterThanOrEqual();

    47         testGreaterThan();

    48         testNotEquals();

    49         testNull();

    50         testNotNull();

    51         testTrue();

    52         testFalse();

    53     }

    54 

    55     private static void testLessThan() throws Exception {

    56         expectPass(Assertion.LT, 1, 2);

    57 

    58         expectFail(Assertion.LT, 2, 2);

    59         expectFail(Assertion.LT, 2, 1);

    60         expectFail(Assertion.LT, null, 2);

    61         expectFail(Assertion.LT, 2, null);

    62     }

    63 

    64     private static void testLessThanOrEqual() throws Exception {

    65         expectPass(Assertion.LTE, 1, 2);

    66         expectPass(Assertion.LTE, 2, 2);

    67 

    68         expectFail(Assertion.LTE, 3, 2);

    69         expectFail(Assertion.LTE, null, 2);

    70         expectFail(Assertion.LTE, 2, null);

    71     }

    72 

    73     private static void testEquals() throws Exception {

    74         expectPass(Assertion.EQ, 1, 1);

    75         expectPass(Assertion.EQ, null, null);

    76 

    77         Foo f1 = new Foo(1);

    78         expectPass(Assertion.EQ, f1, f1);

    79 

    80         Foo f2 = new Foo(1);

    81         expectFail(Assertion.EQ, f1, f2);

    82         expectFail(Assertion.LTE, null, 2);

    83         expectFail(Assertion.LTE, 2, null);

    84     }

    85 

    86     private static void testGreaterThanOrEqual() throws Exception {

    87         expectPass(Assertion.GTE, 1, 1);

    88         expectPass(Assertion.GTE, 2, 1);

    89 

    90         expectFail(Assertion.GTE, 1, 2);

    91         expectFail(Assertion.GTE, null, 2);

    92         expectFail(Assertion.GTE, 2, null);

    93     }

    94 

    95     private static void testGreaterThan() throws Exception {

    96         expectPass(Assertion.GT, 2, 1);

    97 

    98         expectFail(Assertion.GT, 1, 1);

    99         expectFail(Assertion.GT, 1, 2);

   100         expectFail(Assertion.GT, null, 2);

   101         expectFail(Assertion.GT, 2, null);

   102     }

   103 

   104     private static void testNotEquals() throws Exception {

   105         expectPass(Assertion.NE, null, 1);

   106         expectPass(Assertion.NE, 1, null);

   107 

   108         Foo f1 = new Foo(1);

   109         Foo f2 = new Foo(1);

   110         expectPass(Assertion.NE, f1, f2);

   111 

   112         expectFail(Assertion.NE, null, null);

   113         expectFail(Assertion.NE, f1, f1);

   114         expectFail(Assertion.NE, 1, 1);

   115     }

   116 

   117     private static void testNull() throws Exception {

   118         expectPass(Assertion.NULL, null);

   119 

   120         expectFail(Assertion.NULL, 1);

   121     }

   122 

   123     private static void testNotNull() throws Exception {

   124         expectPass(Assertion.NOTNULL, 1);

   125 

   126         expectFail(Assertion.NOTNULL, null);

   127     }

   128 

   129     private static void testTrue() throws Exception {

   130         expectPass(Assertion.TRUE, true);

   131 

   132         expectFail(Assertion.TRUE, false);

   133     }

   134 

   135     private static void testFalse() throws Exception {

   136         expectPass(Assertion.FALSE, false);

   137 

   138         expectFail(Assertion.FALSE, true);

   139     }

   140 

   141     private static <T extends Comparable<T>> void expectPass(Assertion assertion, T ... args)

   142         throws Exception {

   143         Assertion.run(assertion, args);

   144     }

   145 

   146     private static <T extends Comparable<T>> void expectFail(Assertion assertion, T ... args)

   147         throws Exception {

   148         try {

   149             Assertion.run(assertion, args);

   150         } catch (RuntimeException e) {

   151             return;

   152         }

   153         throw new Exception("Expected " + Assertion.format(assertion, (Object[]) args) +

   154                             " to throw a RuntimeException");

   155     }

   156 

   157 }

   158 

   159 enum Assertion {

   160     LT, LTE, EQ, GTE, GT, NE, NULL, NOTNULL, FALSE, TRUE;

   161 

   162     public static <T extends Comparable<T>> void run(Assertion assertion, T ... args) {

   163         String msg = "Expected " + format(assertion, args) + " to pass";

   164         switch (assertion) {

   165             case LT:

   166                 assertLessThan(args[0], args[1], msg);

   167                 break;

   168             case LTE:

   169                 assertLessThanOrEqual(args[0], args[1], msg);

   170                 break;

   171             case EQ:

   172                 assertEquals(args[0], args[1], msg);

   173                 break;

   174             case GTE:

   175                 assertGreaterThanOrEqual(args[0], args[1], msg);

   176                 break;

   177             case GT:

   178                 assertGreaterThan(args[0], args[1], msg);

   179                 break;

   180             case NE:

   181                 assertNotEquals(args[0], args[1], msg);

   182                 break;

   183             case NULL:

   184                 assertNull(args == null ? args : args[0], msg);

   185                 break;

   186             case NOTNULL:

   187                 assertNotNull(args == null ? args : args[0], msg);

   188                 break;

   189             case FALSE:

   190                 assertFalse((Boolean) args[0], msg);

   191                 break;

   192             case TRUE:

   193                 assertTrue((Boolean) args[0], msg);

   194                 break;

   195             default:

   196                 // do nothing

   197         }

   198     }

   199 

   200     public static String format(Assertion assertion, Object ... args) {

   201         switch (assertion) {

   202             case LT:

   203                 return asString("assertLessThan", args);

   204             case LTE:

   205                 return asString("assertLessThanOrEqual", args);

   206             case EQ:

   207                 return asString("assertEquals", args);

   208             case GTE:

   209                 return asString("assertGreaterThanOrEquals", args);

   210             case GT:

   211                 return asString("assertGreaterThan", args);

   212             case NE:

   213                 return asString("assertNotEquals", args);

   214             case NULL:

   215                 return asString("assertNull", args);

   216             case NOTNULL:

   217                 return asString("assertNotNull", args);

   218             case FALSE:

   219                 return asString("assertFalse", args);

   220             case TRUE:

   221                 return asString("assertTrue", args);

   222             default:

   223                 return "";

   224         }

   225     }

   226 

   227     private static String asString(String assertion, Object ... args) {

   228         if (args == null) {

   229             return String.format("%s(null)", assertion);

   230         }

   231         if (args.length == 1) {

   232             return String.format("%s(%s)", assertion, args[0]);

   233         } else {

   234             return String.format("%s(%s, %s)", assertion, args[0], args[1]);

   235         }

   236     }

   237 }