1 /*
   2  * Copyright (c) 2015, 2017, 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 /*
  25  * @test
  26  * @summary Unit test for java.lang.Runtime.Version.
  27  * @bug 8072379 8144062 8161236 8160956
  28  */
  29 
  30 import java.lang.reflect.InvocationTargetException;
  31 import java.lang.reflect.Method;
  32 import java.lang.Runtime.Version;
  33 import java.math.BigInteger;
  34 import java.util.stream.Collectors;
  35 import java.util.Arrays;
  36 import java.util.ArrayList;
  37 import java.util.List;
  38 import java.util.Optional;
  39 
  40 import static java.lang.System.out;
  41 
  42 public class Basic {
  43     private static final Class<? extends Throwable> IAE
  44         = IllegalArgumentException.class;
  45     private static final Class<? extends Throwable> NPE
  46         = NullPointerException.class;
  47     private static final Class<? extends Throwable> NFE
  48         = NumberFormatException.class;
  49     private static final Class<?> VERSION = Version.class;
  50 
  51     private static final BigInteger TOO_BIG
  52         = (BigInteger.valueOf(Integer.MAX_VALUE)).add(BigInteger.ONE);
  53     private static final String TOO_BIG_STR = TOO_BIG.toString();
  54 
  55     public static void main(String ... args) {
  56 
  57         //// Tests for parse(), major(), minor(), security(), pre(),
  58         //// build(), optional(), version(), toString()
  59         //   v                          M     m sec pre bld opt
  60 
  61         // $VNUM
  62         test("9",                       9,    0, 0, "", 0, "");
  63         test("9.1",                     9,    1, 0, "", 0, "");
  64         test("9.0.1",                   9,    0, 1, "", 0, "");
  65         test("404.1.2",                 404,  1, 2, "", 0, "");
  66         test("9.1.2.3",                 9,    1, 2, "", 0, "");
  67         test("1000.0.0.0.0.0.99999999", 1000, 0, 0, "", 0, "");
  68 
  69         tryCatch(null,    NPE);
  70         tryCatch("",      IAE);
  71         tryCatch("foo",   IAE);
  72         tryCatch("7a",    IAE);
  73         tryCatch("0",     IAE);
  74         tryCatch("09",    IAE);
  75         tryCatch("9.0",   IAE);
  76         tryCatch("9.0.",  IAE);
  77         tryCatch("1.9,1", IAE);
  78         tryCatch(TOO_BIG_STR, NFE);
  79 
  80         // $PRE
  81         test("9-ea",       9, 0, 0, "ea",       0, "");
  82         test("9-internal", 9, 0, 0, "internal", 0, "");
  83         test("9-0",        9, 0, 0, "0",        0, "");
  84         test("9.2.7-8",    9, 2, 7, "8",        0, "");
  85         test("1-ALL",      1, 0, 0, "ALL",      0, "");
  86         test("2.3.4.5-1a", 2, 3, 4, "1a",       0, "");
  87         test("1-" + TOO_BIG_STR, 1, 0, 0, TOO_BIG_STR, 0, "");
  88 
  89         tryCatch("9:-ea",     IAE);
  90         tryCatch("3.14159-",  IAE);
  91         tryCatch("3.14159-%", IAE);
  92 
  93         // $BUILD
  94         test("9+0",            9, 0,  0,  "",      0,       "");
  95         test("3.14+9999900",   3, 14, 0,  "",      9999900, "");
  96         test("9-pre+105",      9, 0,  0,  "pre",   105,     "");
  97         test("6.0.42-8beta+4", 6, 0,  42, "8beta", 4,       "");
  98 
  99         tryCatch("9+",     IAE);
 100         tryCatch("7+a",    IAE);
 101         tryCatch("9+00",   IAE);
 102         tryCatch("4.2+01", IAE);
 103         tryCatch("4.2+1a", IAE);
 104         tryCatch("1+" + TOO_BIG_STR, NFE);
 105 
 106         // $OPT
 107         test("9+-foo",          9,   0, 0, "",       0,  "foo");
 108         test("9-pre-opt",       9,   0, 0, "pre",    0,  "opt");
 109         test("42+---bar",       42,  0, 0, "",       0,  "--bar");
 110         test("2.91+-8061493-",  2,  91, 0, "",       0,  "8061493-");
 111         test("24+-foo.bar",     24,  0, 0, "",       0,  "foo.bar");
 112         test("9-ribbit+17-...", 9,   0, 0, "ribbit", 17, "...");
 113         test("7+1-" + TOO_BIG_STR, 7,0, 0, "",       1,  TOO_BIG_STR);
 114 
 115         tryCatch("9-pre+-opt", IAE);
 116         tryCatch("1.4142+-",   IAE);
 117         tryCatch("2.9979+-%",  IAE);
 118 
 119         //// Test for Runtime.version()
 120         testVersion();
 121 
 122         //// Test for equals{IgnoreOptional}?(), hashCode(),
 123         //// compareTo{IgnoreOptional}?()
 124         // compare: after "<" == -1, equal == 0, before ">" == 1
 125         //      v0            v1                  eq     eqNO  cmp  cmpNO
 126         testEHC("9",          "9",                true,  true,   0,    0);
 127 
 128         testEHC("8",          "9",                false, false, -1,   -1);
 129         testEHC("9",          "10",               false, false, -1,   -1);
 130         testEHC("9",          "8",                false, false,  1,    1);
 131 
 132         // $OPT comparison
 133         testEHC("9",          "9+-oink",          false, true,  -1,    0);
 134         testEHC("9+-ribbit",  "9+-moo",           false, true,   1,    0);
 135         testEHC("9-quack+3-ribbit",
 136                               "9-quack+3-moo",    false, true,   1,    0);
 137         testEHC("9.1+7",      "9.1+7-moo-baa-la", false, true,  -1,    0);
 138 
 139         // numeric vs. non-numeric $PRE
 140         testEHC("9.1.1.2-2a", "9.1.1.2-12",       false, false,  1,    1);
 141         testEHC("9.1.1.2-12", "9.1.1.2-4",        false, false,  1,    1);
 142 
 143         testEHC("27.16",      "27.16+120",        false, false, -1,   -1);
 144         testEHC("10",         "10-ea",            false, false,  1,    1);
 145         testEHC("10.1+1",     "10.1-ea+1",        false, false,  1,    1);
 146         testEHC("10.0.1+22",  "10.0.1+21",        false, false,  1,    1);
 147 
 148         // numeric vs. non-numeric $PRE
 149         testEHC("9.1.1.2-12", "9.1.1.2-a2",       false, false, -1,   -1);
 150         testEHC("9.1.1.2-1",  "9.1.1.2-4",        false, false, -1,   -1);
 151 
 152         testEHC("9-internal", "9",                false, false, -1,   -1);
 153         testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
 154         testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
 155         testEHC("9+101",      "9",                false, false,  1,    1);
 156         testEHC("9+101",      "9+102",            false, false, -1,   -1);
 157         testEHC("1.9-ea",     "9-ea",             false, false, -1,   -1);
 158 
 159         if (fail != 0)
 160             throw new RuntimeException((fail + pass) + " tests: "
 161                                        + fail + " failure(s), first", first);
 162         else
 163             out.println("all " + (fail + pass) + " tests passed");
 164 
 165     }
 166 
 167     private static void test(String s, Integer major, Integer minor,
 168                              Integer sec, String pre, Integer build,
 169                              String opt)
 170     {
 171         Version v = testParse(s);
 172 
 173         testStr(v.toString(), s);
 174 
 175         testInt(v.major(), major);
 176         testInt(v.minor(), minor);
 177         testInt(v.security(), sec);
 178         testStr((v.pre().isPresent() ? v.pre().get() : ""), pre);
 179         testInt((v.build().isPresent() ? v.build().get() : 0), build);
 180         testStr((v.optional().isPresent() ? v.optional().get() : ""), opt);
 181 
 182         testVersion(v.version(), s);
 183     }
 184 
 185     private static Version testParse(String s) {
 186         Version v = Version.parse(s);
 187         pass();
 188         return v;
 189     }
 190 
 191     private static void testInt(int got, int exp) {
 192         if (got != exp) {
 193             fail("testInt()", Integer.toString(exp), Integer.toString(got));
 194         } else {
 195             pass();
 196         }
 197      }
 198 
 199     private static void testStr(String got, String exp) {
 200         if (!got.equals(exp)) {
 201             fail("testStr()", exp, got);
 202         } else {
 203             pass();
 204         }
 205     }
 206 
 207     private static void tryCatch(String s, Class<? extends Throwable> ex) {
 208         Throwable t = null;
 209         try {
 210             Version.parse(s);
 211         } catch (Throwable x) {
 212             if (ex.isAssignableFrom(x.getClass())) {
 213                 t = x;
 214             } else
 215                 x.printStackTrace();
 216         }
 217         if ((t == null) && (ex != null))
 218             fail(s, ex);
 219         else
 220             pass();
 221     }
 222 
 223     private static void testVersion() {
 224         Version current = Runtime.version();
 225         String javaVer = System.getProperty("java.runtime.version");
 226 
 227         // java.runtime.version == $VNUM(\-$PRE)?(\+$BUILD)?(-$OPT)?
 228         String [] jv  = javaVer.split("\\+");
 229         String [] ver = jv[0].split("-");
 230         List<Integer> javaVerVNum
 231             = Arrays.stream(ver[0].split("\\."))
 232             .map(v -> Integer.parseInt(v))
 233             .collect(Collectors.toList());
 234         if (!javaVerVNum.equals(current.version())) {
 235             fail("Runtime.version()", javaVerVNum.toString(),
 236                  current.version().toString());
 237         } else {
 238             pass();
 239         }
 240 
 241         Optional<String> javaVerPre
 242             = (ver.length == 2)
 243             ? Optional.ofNullable(ver[1])
 244             : Optional.empty();
 245         if (!javaVerPre.equals(current.pre())) {
 246             fail("testCurrent() pre()", javaVerPre.toString(),
 247                  current.pre().toString());
 248         } else {
 249             pass();
 250         }
 251 
 252         testEHC(current.toString(), javaVer, true, true, 0, 0);
 253     }
 254 
 255     private static void testVersion(List<Integer> vnum, String s) {
 256         List<Integer> svnum = new ArrayList<Integer>();
 257         StringBuilder sb = new StringBuilder();
 258         for (int i = 0; i < s.length(); i++) {
 259             Character c = s.charAt(i);
 260             if (Character.isDigit(c)) {
 261                 sb.append(c);
 262             } else {
 263                 svnum.add(Integer.parseInt(sb.toString()));
 264                 sb = new StringBuilder();
 265                 if (c == '+' || c == '-') {
 266                     break;
 267                 }
 268             }
 269         }
 270         if (sb.length() > 0) {
 271             svnum.add(Integer.parseInt(sb.toString()));
 272         }
 273 
 274         if (!svnum.equals(vnum)) {
 275             fail("testVersion() equals()", svnum.toString(), vnum.toString());
 276         } else {
 277             pass();
 278         }
 279     }
 280 
 281     private static void testEHC(String s0, String s1, boolean eq, boolean eqNO,
 282                                 int cmp, int cmpNO)
 283     {
 284         Version v0 = Version.parse(s0);
 285         Version v1 = Version.parse(s1);
 286 
 287         testEquals(v0, v1, eq);
 288         testEqualsNO(v0, v1, eqNO);
 289 
 290         testHashCode(v0, v1, eq);
 291 
 292         testCompare(v0, v1, cmp);
 293         testCompareNO(v0, v1, cmpNO);
 294     }
 295 
 296     private static void testEqualsNO(Version v0, Version v1, boolean eq) {
 297         if ((eq && !v0.equalsIgnoreOptional(v1))
 298             || (!eq && v0.equalsIgnoreOptional(v1))) {
 299             fail("equalsIgnoreOptional() " + Boolean.toString(eq),
 300                  v0.toString(), v1.toString());
 301         } else {
 302             pass();
 303         }
 304     }
 305 
 306     private static void testEquals(Version v0, Version v1, boolean eq) {
 307         if ((eq && !v0.equals(v1)) || (!eq && v0.equals(v1))) {
 308             fail("equals() " + Boolean.toString(eq),
 309                  v0.toString(), v1.toString());
 310         } else {
 311             pass();
 312         }
 313     }
 314 
 315     private static void testHashCode(Version v0, Version v1, boolean eq) {
 316         int h0 = v0.hashCode();
 317         int h1 = v1.hashCode();
 318         if (eq) {
 319             testInt(h0, h1);
 320         } else if (h0 == h1) {
 321             fail(String.format("hashCode() %s", h0),
 322                  Integer.toString(h0),
 323                  Integer.toString(h1));
 324         } else { // !eq && (h0 != h1)
 325             pass();
 326         }
 327     }
 328 
 329     private static void testCompareNO(Version v0, Version v1, int compare)
 330     {
 331         try {
 332             Method m = VERSION.getMethod("compareToIgnoreOptional", VERSION);
 333             int cmp = (int) m.invoke(v0, v1);
 334             checkCompare(v0, v1, compare, cmp);
 335         } catch (IllegalAccessException | InvocationTargetException |
 336                  NoSuchMethodException ex) {
 337             fail(String.format("compareToIgnoreOptional() invocation: %s",
 338                                ex.getClass()),
 339                  null);
 340         }
 341     }
 342 
 343     private static void testCompare(Version v0, Version v1, int compare) {
 344         try {
 345             Method m = VERSION.getMethod("compareTo", VERSION);
 346             int cmp = (int) m.invoke(v0, v1);
 347             checkCompare(v0, v1, compare, cmp);
 348         } catch (IllegalAccessException | InvocationTargetException |
 349                  NoSuchMethodException ex) {
 350             fail(String.format("compareTo() invocation: %s", ex.getClass()),
 351                  null);
 352         }
 353     }
 354 
 355     private static void checkCompare(Version v0, Version v1,
 356                                      int compare, int cmp)
 357     {
 358         if (((cmp == 0) && (compare == 0))
 359             || (compare == (cmp / Math.abs(cmp == 0 ? 1 : cmp)))) {
 360             pass();
 361         } else {
 362             fail(String.format("compare() (cmp = %s) (compare = %s)",
 363                                cmp, compare),
 364                  v0.toString(), v1.toString());
 365         }
 366     }
 367 
 368     private static int fail = 0;
 369     private static int pass = 0;
 370 
 371     private static Throwable first;
 372 
 373     static void pass() {
 374         pass++;
 375     }
 376 
 377     static void fail(String fs, Class ex) {
 378         String s = "'" + fs + "'";
 379         if (ex != null)
 380             s += ": " + ex.getName() + " not thrown";
 381         if (first == null)
 382             setFirst(s);
 383         System.err.println("FAILED: " + s);
 384         fail++;
 385     }
 386 
 387     static void fail(String t, String exp, String got) {
 388         String s = t + ": Expected '" + exp + "', got '" + got + "'";
 389         if (first == null)
 390             setFirst(s);
 391         System.err.println("FAILED: " + s);
 392         fail++;
 393      }
 394 
 395     private static void setFirst(String s) {
 396         try {
 397             throw new RuntimeException(s);
 398         } catch (RuntimeException x) {
 399             first = x;
 400         }
 401     }
 402 }
--- EOF ---