1 /*
2 * Copyright (c) 2015, 2016, 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 jdk.Version.
27 * @bug 8072379
28 */
29
30 import java.lang.reflect.InvocationTargetException;
31 import java.lang.reflect.Method;
32 import java.math.BigInteger;
33 import java.util.stream.Collectors;
34 import java.util.Arrays;
35 import java.util.ArrayList;
36 import java.util.List;
37 import java.util.Optional;
38
39 import jdk.Version;
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(), opt(), 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 current()
120 testCurrent();
121
122 //// Test for equals{IgnoreOpt}?(), hashCode(), compareTo{IgnoreOpt}?()
123 // compare: after "<" == -1, equal == 0, before ">" == 1
124 // v0 v1 eq eqNO cmp cmpNO
125 testEHC("9", "9", true, true, 0, 0);
126
127 testEHC("8", "9", false, false, -1, -1);
128 testEHC("9", "10", false, false, -1, -1);
129 testEHC("9", "8", false, false, 1, 1);
130
131 // $OPT comparison
132 testEHC("9", "9+-oink", false, true, -1, 0);
133 testEHC("9+-ribbit", "9+-moo", false, true, 1, 0);
134 testEHC("9-quack+3-ribbit",
135 "9-quack+3-moo", false, true, 1, 0);
136 testEHC("9.1+7", "9.1+7-moo-baa-la", false, true, -1, 0);
137
138 // numeric vs. non-numeric $PRE
139 testEHC("9.1.1.2-2a", "9.1.1.2-12", false, false, 1, 1);
140 testEHC("9.1.1.2-12", "9.1.1.2-4", false, false, 1, 1);
141
142 testEHC("27.16", "27.16+120", false, false, 1, 1);
143 testEHC("10", "10-ea", false, false, 1, 1);
144 testEHC("10.1+1", "10.1-ea+1", false, false, 1, 1);
145 testEHC("10.0.1+22", "10.0.1+21", false, false, 1, 1);
146
147 // numeric vs. non-numeric $PRE
148 testEHC("9.1.1.2-12", "9.1.1.2-a2", false, false, -1, -1);
149 testEHC("9.1.1.2-1", "9.1.1.2-4", false, false, -1, -1);
150
151 testEHC("9-internal", "9", false, false, -1, -1);
152 testEHC("9-ea+120", "9+120", false, false, -1, -1);
153 testEHC("9-ea+120", "9+120", false, false, -1, -1);
154 testEHC("9+101", "9", false, false, -1, -1);
155 testEHC("9+101", "9+102", false, false, -1, -1);
156 testEHC("1.9-ea", "9-ea", false, false, -1, -1);
157
158 if (fail != 0)
159 throw new RuntimeException((fail + pass) + " tests: "
160 + fail + " failure(s), first", first);
161 else
162 out.println("all " + (fail + pass) + " tests passed");
163
164 }
165
166 private static void test(String s, Integer major, Integer minor,
167 Integer sec, String pre, Integer build,
168 String opt)
169 {
170 Version v = testParse(s);
171
172 testStr(v.toString(), s);
173
174 testInt(v.major(), major);
175 testInt(v.minor(), minor);
176 testInt(v.security(), sec);
177 testStr((v.pre().isPresent() ? v.pre().get() : ""), pre);
178 testInt((v.build().isPresent() ? v.build().get() : 0), build);
179 testStr((v.optional().isPresent() ? v.optional().get() : ""), opt);
180
181 testVersion(v.version(), s);
182 }
183
184 private static Version testParse(String s) {
185 Version v = Version.parse(s);
186 pass();
187 return v;
188 }
189
190 private static void testInt(int got, int exp) {
191 if (got != exp) {
192 fail("testInt()", Integer.toString(exp), Integer.toString(got));
193 } else {
194 pass();
195 }
196 }
197
198 private static void testStr(String got, String exp) {
199 if (!got.equals(exp)) {
200 fail("testStr()", exp, got);
201 } else {
202 pass();
203 }
204 }
205
206 private static void tryCatch(String s, Class<? extends Throwable> ex) {
207 Throwable t = null;
208 try {
209 Version.parse(s);
210 } catch (Throwable x) {
211 if (ex.isAssignableFrom(x.getClass())) {
212 t = x;
213 } else
214 x.printStackTrace();
215 }
216 if ((t == null) && (ex != null))
217 fail(s, ex);
218 else
219 pass();
220 }
221
222 private static void testCurrent() {
223 Version current = Version.current();
224 String javaVer = System.getProperty("java.version");
225
226 // java.version == $VNUM(\-$PRE)
227 String [] ver = javaVer.split("-");
228 List<Integer> javaVerVNum
229 = Arrays.stream(ver[0].split("\\."))
230 .map(v -> Integer.parseInt(v))
231 .collect(Collectors.toList());
232 if (!javaVerVNum.equals(current.version())) {
233 fail("testCurrent() version()", javaVerVNum.toString(),
234 current.version().toString());
235 } else {
236 pass();
237 }
238
239 Optional<String> javaVerPre
240 = (ver.length == 2)
241 ? Optional.ofNullable(ver[1])
242 : Optional.empty();
243 if (!javaVerPre.equals(current.pre())) {
244 fail("testCurrent() pre()", javaVerPre.toString(),
245 current.pre().toString());
246 } else {
247 pass();
248 }
249
250 testEHC(current.toString(), javaVer, true, true, 0, 0);
251 }
252
253 private static void testVersion(List<Integer> vnum, String s) {
254 List<Integer> svnum = new ArrayList<Integer>();
255 StringBuilder sb = new StringBuilder();
256 for (int i = 0; i < s.length(); i++) {
257 Character c = s.charAt(i);
258 if (Character.isDigit(c)) {
259 sb.append(c);
260 } else {
261 svnum.add(Integer.parseInt(sb.toString()));
262 sb = new StringBuilder();
263 if (c == '+' || c == '-') {
264 break;
265 }
266 }
267 }
268 if (sb.length() > 0) {
269 svnum.add(Integer.parseInt(sb.toString()));
270 }
271
272 if (!svnum.equals(vnum)) {
273 fail("testVersion() equals()", svnum.toString(), vnum.toString());
274 } else {
275 pass();
276 }
277 }
278
279 private static void testEHC(String s0, String s1, boolean eq, boolean eqNO,
280 int cmp, int cmpNO)
281 {
282 Version v0 = Version.parse(s0);
283 Version v1 = Version.parse(s1);
284
285 testEquals(v0, v1, eq);
286 testEqualsNO(v0, v1, eqNO);
287
288 testHashCode(v0, v1, eq);
289
290 testCompare(v0, v1, cmp);
291 testCompareNO(v0, v1, cmpNO);
292 }
293
294 private static void testEqualsNO(Version v0, Version v1, boolean eq) {
295 if ((eq && !v0.equalsIgnoreOpt(v1))
296 || (!eq && v0.equalsIgnoreOpt(v1))) {
297 fail("equalsIgnoreOpt() " + Boolean.toString(eq),
298 v0.toString(), v1.toString());
299 } else {
300 pass();
301 }
302 }
303
304 private static void testEquals(Version v0, Version v1, boolean eq) {
305 if ((eq && !v0.equals(v1)) || (!eq && v0.equals(v1))) {
306 fail("equals() " + Boolean.toString(eq),
307 v0.toString(), v1.toString());
308 } else {
309 pass();
310 }
311 }
312
313 private static void testHashCode(Version v0, Version v1, boolean eq) {
314 int h0 = v0.hashCode();
315 int h1 = v1.hashCode();
316 if (eq) {
317 testInt(h0, h1);
318 } else if (h0 == h1) {
319 fail(String.format("hashCode() %s", h0),
320 Integer.toString(h0),
321 Integer.toString(h1));
322 } else { // !eq && (h0 != h1)
323 pass();
324 }
325 }
326
327 private static void testCompareNO(Version v0, Version v1, int compare)
328 {
329 try {
330 Method m = VERSION.getMethod("compareToIgnoreOpt", VERSION);
331 int cmp = (int) m.invoke(v0, v1);
332 checkCompare(v0, v1, compare, cmp);
333 } catch (IllegalAccessException | InvocationTargetException |
334 NoSuchMethodException ex) {
335 fail(String.format("compareToIgnoreOpt() invocation: %s",
336 ex.getClass()),
337 null);
338 }
339 }
340
341 private static void testCompare(Version v0, Version v1, int compare) {
342 try {
343 Method m = VERSION.getMethod("compareTo", VERSION);
344 int cmp = (int) m.invoke(v0, v1);
345 checkCompare(v0, v1, compare, cmp);
346 } catch (IllegalAccessException | InvocationTargetException |
347 NoSuchMethodException ex) {
348 fail(String.format("compareTo() invocation: %s", ex.getClass()),
349 null);
350 }
351 }
352
353 private static void checkCompare(Version v0, Version v1,
354 int compare, int cmp)
355 {
356 if (((cmp == 0) && (compare == 0))
357 || (compare == (cmp / Math.abs(cmp == 0 ? 1 : cmp)))) {
358 pass();
359 } else {
360 fail(String.format("compare() (cmp = %s) (compare = %s)",
361 cmp, compare),
362 v0.toString(), v1.toString());
363 }
364 }
365
366 private static int fail = 0;
367 private static int pass = 0;
368
369 private static Throwable first;
370
371 static void pass() {
372 pass++;
373 }
374
375 static void fail(String fs, Class ex) {
376 String s = "'" + fs + "'";
377 if (ex != null)
378 s += ": " + ex.getName() + " not thrown";
379 if (first == null)
380 setFirst(s);
381 System.err.println("FAILED: " + s);
382 fail++;
383 }
384
385 static void fail(String t, String exp, String got) {
386 String s = t + ": Expected '" + exp + "', got '" + got + "'";
387 if (first == null)
388 setFirst(s);
389 System.err.println("FAILED: " + s);
390 fail++;
391 }
392
393 private static void setFirst(String s) {
394 try {
395 throw new RuntimeException(s);
396 } catch (RuntimeException x) {
397 first = x;
398 }
399 }
400 }