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