1 /*
2 * Copyright (c) 2015, 2018, 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 package optionsvalidation;
24
25 import com.sun.tools.attach.VirtualMachine;
26 import com.sun.tools.attach.AttachOperationFailedException;
27 import java.util.ArrayList;
28 import java.util.Arrays;
29 import java.util.HashSet;
30 import java.util.List;
31 import java.util.Set;
32 import jdk.test.lib.management.DynamicVMOption;
33 import jdk.test.lib.process.OutputAnalyzer;
34 import jdk.test.lib.process.ProcessTools;
35 import jdk.test.lib.dcmd.CommandExecutor;
36 import jdk.test.lib.dcmd.JMXExecutor;
37 import jdk.test.lib.Platform;
38 import sun.tools.attach.HotSpotVirtualMachine;
39
40 import static optionsvalidation.JVMOptionsUtils.failedMessage;
41 import static optionsvalidation.JVMOptionsUtils.GCType;
42 import static optionsvalidation.JVMOptionsUtils.printOutputContent;
43 import static optionsvalidation.JVMOptionsUtils.VMType;
44
45 public abstract class JVMOption {
46
47 /**
48 * Executor for JCMD
49 */
50 private final static CommandExecutor executor = new JMXExecutor();
51
52 /**
53 * Name of the tested parameter
54 */
55 protected String name;
56
57 /**
58 * Range is defined for option inside VM
59 */
60 protected boolean withRange;
61
62 /**
63 * Test valid min range value and additional small values
64 */
65 protected boolean testMinRange;
66
67 /**
68 * Test valid max range value and additional big values
69 */
70 protected boolean testMaxRange;
71
72 private Set<Integer> allowedExitCodes;
73
74 /**
75 * Prepend string which added before testing option to the command line
76 */
77 private final List<String> prepend;
78 private final StringBuilder prependString;
79
80 protected JVMOption() {
81 this.prepend = new ArrayList<>();
82 prependString = new StringBuilder();
83 allowedExitCodes = new HashSet<>();
84 allowedExitCodes.add(0);
85 allowedExitCodes.add(1);
86 withRange = false;
87 testMinRange = true;
88 testMaxRange = true;
89 }
90
91 /**
92 * Create JVM Option with given type and name.
93 *
94 * @param type type: "intx", "size_t", "uintx", "uint64_t" or "double"
95 * @param name name of the option
96 * @return created JVMOption
97 */
98 static JVMOption createVMOption(String type, String name) {
99 JVMOption parameter;
100
101 switch (type) {
102 case "int":
103 case "intx":
104 case "size_t":
105 case "uint":
106 case "uintx":
107 case "uint64_t":
108 parameter = new IntJVMOption(name, type);
109 break;
110 case "double":
111 parameter = new DoubleJVMOption(name);
112 break;
113 default:
114 throw new Error("Expected only \"int\", \"intx\", \"size_t\", "
115 + "\"uint\", \"uintx\", \"uint64_t\", or \"double\" "
116 + "option types! Got " + type + " type!");
117 }
118
119 return parameter;
120 }
121
122 /**
123 * Add passed options to the prepend options of the option. Prepend options
124 * will be added before testing option to the command line.
125 *
126 * @param options array of prepend options
127 */
128 public final void addPrepend(String... options) {
129 String toAdd;
130
131 for (String option : options) {
132 if (option.startsWith("-")) {
133 toAdd = option;
134 } else {
135 /* Add "-" before parameter name */
136 toAdd = "-" + option;
137
138 }
139 prepend.add(toAdd);
140 prependString.append(toAdd).append(" ");
141 }
142 }
143
144 /**
145 * Get name of the option
146 *
147 * @return name of the option
148 */
149 final String getName() {
150 return name;
151 }
152
153 /**
154 * Mark this option as option which range is defined inside VM
155 */
156 final void optionWithRange() {
157 withRange = true;
158 }
159
160 /**
161 * Exclude testing of min range value for this option
162 */
163 public final void excludeTestMinRange() {
164 testMinRange = false;
165 }
166
167 /**
168 * Exclude testing of max range value for this option
169 */
170 public final void excludeTestMaxRange() {
171 testMaxRange = false;
172 }
173
174 public final void setAllowedExitCodes(Integer... allowedExitCodes) {
175 this.allowedExitCodes.addAll(Arrays.asList(allowedExitCodes));
176 }
177
178 /**
179 * Set new minimum option value
180 *
181 * @param min new minimum value
182 */
183 abstract void setMin(String min);
184
185 /**
186 * Get string with minimum value of the option
187 *
188 * @return string with minimum value of the option
189 */
190 abstract String getMin();
191
192 /**
193 * Set new maximum option value
194 *
195 * @param max new maximum value
196 */
197 abstract void setMax(String min);
198
199 /**
200 * Get string with maximum value of the option
201 *
202 * @return string with maximum value of the option
203 */
204 abstract String getMax();
205
206 /**
207 * Return list of strings with valid option values which used for testing
208 * using jcmd, attach and etc.
209 *
210 * @return list of strings which contain valid values for option
211 */
212 protected abstract List<String> getValidValues();
213
214 /**
215 * Return list of strings with invalid option values which used for testing
216 * using jcmd, attach and etc.
217 *
218 * @return list of strings which contain invalid values for option
219 */
220 protected abstract List<String> getInvalidValues();
221
222 /**
223 * Return expected error message for option with value "value" when it used
224 * on command line with passed value
225 *
226 * @param value option value
227 * @return expected error message
228 */
229 protected abstract String getErrorMessageCommandLine(String value);
230
231 /**
232 * Testing writeable option using DynamicVMOption isValidValue and
233 * isInvalidValue methods
234 *
235 * @return number of failed tests
236 */
237 public int testDynamic() {
238 DynamicVMOption option = new DynamicVMOption(name);
239 int failedTests = 0;
240 String origValue;
241
242 if (option.isWriteable()) {
243
244 System.out.println("Testing " + name + " option dynamically by DynamicVMOption");
245
246 origValue = option.getValue();
247
248 for (String value : getValidValues()) {
249 if (!option.isValidValue(value)) {
250 failedMessage(String.format("Option %s: Valid value \"%s\" is invalid", name, value));
251 failedTests++;
252 }
253 }
254
255 for (String value : getInvalidValues()) {
256 if (option.isValidValue(value)) {
257 failedMessage(String.format("Option %s: Invalid value \"%s\" is valid", name, value));
258 failedTests++;
259 }
260 }
261
262 option.setValue(origValue);
263 }
264
265 return failedTests;
266 }
267
268 /**
269 * Testing writeable option using Jcmd
270 *
271 * @return number of failed tests
272 */
273 public int testJcmd() {
274 DynamicVMOption option = new DynamicVMOption(name);
275 int failedTests = 0;
276 OutputAnalyzer out;
277 String origValue;
278
279 if (option.isWriteable()) {
280
281 System.out.println("Testing " + name + " option dynamically by jcmd");
282
283 origValue = option.getValue();
284
285 for (String value : getValidValues()) {
286 out = executor.execute(String.format("VM.set_flag %s %s", name, value), true);
287
288 if (out.getOutput().contains(name + " error")) {
289 failedMessage(String.format("Option %s: Can not change "
290 + "option to valid value \"%s\" via jcmd", name, value));
291 printOutputContent(out);
292 failedTests++;
293 }
294 }
295
296 for (String value : getInvalidValues()) {
297 out = executor.execute(String.format("VM.set_flag %s %s", name, value), true);
298
299 if (!out.getOutput().contains(name + " error")) {
300 failedMessage(String.format("Option %s: Error not reported for "
301 + "option when it chagned to invalid value \"%s\" via jcmd", name, value));
302 printOutputContent(out);
303 failedTests++;
304 }
305 }
306
307 option.setValue(origValue);
308 }
309
310 return failedTests;
311 }
312
313 private boolean setFlagAttach(HotSpotVirtualMachine vm, String flagName, String flagValue) throws Exception {
314 boolean result;
315
316 try {
317 vm.setFlag(flagName, flagValue);
318 result = true;
319 } catch (AttachOperationFailedException e) {
320 result = false;
321 }
322
323 return result;
324 }
325
326 /**
327 * Testing writeable option using attach method
328 *
329 * @return number of failed tests
330 * @throws Exception if an error occurred while attaching to the target JVM
331 */
332 public int testAttach() throws Exception {
333 DynamicVMOption option = new DynamicVMOption(name);
334 int failedTests = 0;
335 String origValue;
336
337 if (option.isWriteable()) {
338
339 System.out.println("Testing " + name + " option dynamically via attach");
340
341 origValue = option.getValue();
342
343 HotSpotVirtualMachine vm = (HotSpotVirtualMachine) VirtualMachine.attach(String.valueOf(ProcessTools.getProcessId()));
344
345 for (String value : getValidValues()) {
346 if (!setFlagAttach(vm, name, value)) {
347 failedMessage(String.format("Option %s: Can not change option to valid value \"%s\" via attach", name, value));
348 failedTests++;
349 }
350 }
351
352 for (String value : getInvalidValues()) {
353 if (setFlagAttach(vm, name, value)) {
354 failedMessage(String.format("Option %s: Option changed to invalid value \"%s\" via attach", name, value));
355 failedTests++;
356 }
357 }
358
359 vm.detach();
360
361 option.setValue(origValue);
362 }
363
364 return failedTests;
365 }
366
367 /**
368 * Run java with passed parameter and check the result depending on the
369 * 'valid' parameter
370 *
371 * @param param tested parameter passed to the JVM
372 * @param valid indicates whether the JVM should fail or not
373 * @return true - if test passed
374 * @throws Exception if java process can not be started
375 */
376 private boolean runJavaWithParam(String optionValue, boolean valid) throws Exception {
377 int exitCode = 0;
378 boolean result = true;
379 String errorMessage = null;
380 String explicitGC = null;
381 List<String> runJava = new ArrayList<>();
382 OutputAnalyzer out = null;
383
384 if (VMType != null) {
385 runJava.add(VMType);
386 }
387
388 // Run with a small heap to avoid excessive execution time
389 long max = Runtime.getRuntime().maxMemory() / 1024 / 1024;
390 if (max > 1024) {
391 runJava.add("-Xmx1024m");
392 }
393
394 if (Platform.isDebugBuild()) {
395 // Avoid excessive execution time.
396 runJava.add("-XX:-ZapUnusedHeapArea");
397 }
398
399 if (GCType != null &&
400 !(prepend.contains("-XX:+UseConcMarkSweepGC") ||
401 prepend.contains("-XX:+UseSerialGC") ||
402 prepend.contains("-XX:+UseParallelGC") ||
403 prepend.contains("-XX:+UseG1GC"))) {
404 explicitGC = GCType;
405 }
406
407 if (explicitGC != null) {
408 runJava.add(explicitGC);
409 }
410
411 runJava.addAll(prepend);
412 runJava.add(optionValue);
413 runJava.add(JVMStartup.class.getName());
414
415 out = new OutputAnalyzer(ProcessTools.createJavaProcessBuilder(runJava.toArray(new String[0])).start());
416
417 exitCode = out.getExitValue();
418 String exitCodeString = null;
419 if (exitCode != 0) {
420 exitCodeString = exitCode + " [0x" + Integer.toHexString(exitCode).toUpperCase() + "]";
421 }
422
423 if (out.getOutput().contains("A fatal error has been detected by the Java Runtime Environment")) {
424 /* Always consider "fatal error" in output as fail */
425 errorMessage = "JVM output reports a fatal error. JVM exited with code " + exitCodeString + "!";
426 } else if (out.getStderr().contains("Ignoring option " + name)) {
427 // Watch for newly obsoleted, but not yet removed, flags
428 System.out.println("SKIPPED: Ignoring test result for obsolete flag " + name);
429 } else if (valid == true) {
430 if (!allowedExitCodes.contains(exitCode)) {
431 errorMessage = "JVM exited with unexpected error code = " + exitCodeString;
432 } else if ((exitCode != 0) && (out.getOutput().isEmpty() == true)) {
433 errorMessage = "JVM exited with error(exitcode == " + exitCodeString + "), but with empty stdout and stderr. " +
434 "Description of error is needed!";
435 } else if (out.getOutput().contains("is outside the allowed range")) {
436 errorMessage = "JVM output contains \"is outside the allowed range\"";
437 }
438 } else {
439 // valid == false
440 String value = optionValue.substring(optionValue.lastIndexOf("=") + 1);
441 String errorMessageCommandLineValue = getErrorMessageCommandLine(value);
442 if (exitCode == 0) {
443 errorMessage = "JVM successfully exit";
444 } else if (exitCode != 1) {
445 errorMessage = "JVM exited with code " + exitCodeString + " which does not equal to 1";
446 } else if (!out.getOutput().contains(errorMessageCommandLineValue)) {
447 errorMessage = "JVM output does not contain expected output \"" + errorMessageCommandLineValue + "\"";
448 }
449 }
450
451 if (errorMessage != null) {
452 String fullOptionString = String.format("%s %s %s %s",
453 VMType == null ? "" : VMType, explicitGC == null ? "" : explicitGC, prependString.toString(), optionValue).trim().replaceAll(" +", " ");
454 failedMessage(name, fullOptionString, valid, errorMessage);
455 printOutputContent(out);
456 result = false;
457 }
458
459 System.out.println("");
460
461 return result;
462 }
463
464 /**
465 * Construct option string with passed value
466 *
467 * @param value parameter value
468 * @return string containing option with passed value
469 */
470 private String constructOption(String value) {
471 return "-XX:" + name + "=" + value;
472 }
473
474 /**
475 * Return list of strings which contain options with valid values which can
476 * be used for testing on command line
477 *
478 * @return list of strings which contain options with valid values
479 */
480 private List<String> getValidCommandLineOptions() {
481 List<String> validParameters = new ArrayList<>();
482
483 for (String value : getValidValues()) {
484 validParameters.add(constructOption(value));
485 }
486
487 return validParameters;
488 }
489
490 /**
491 * Return list of strings which contain options with invalid values which
492 * can be used for testing on command line
493 *
494 * @return list of strings which contain options with invalid values
495 */
496 private List<String> getInvalidCommandLineOptions() {
497 List<String> invalidParameters = new ArrayList<>();
498
499 for (String value : getInvalidValues()) {
500 invalidParameters.add(constructOption(value));
501 }
502
503 return invalidParameters;
504 }
505
506 /**
507 * Perform test of the parameter. Call java with valid option values and
508 * with invalid option values.
509 *
510 * @return number of failed tests
511 * @throws Exception if java process can not be started
512 */
513 public int testCommandLine() throws Exception {
514 ProcessBuilder pb;
515 int failed = 0;
516 List<String> optionValuesList;
517
518 optionValuesList = getValidCommandLineOptions();
519
520 if (optionValuesList.isEmpty() != true) {
521 System.out.println("Testing valid " + name + " values.");
522 for (String optionValid : optionValuesList) {
523 if (runJavaWithParam(optionValid, true) == false) {
524 failed++;
525 }
526 }
527 }
528
529 optionValuesList = getInvalidCommandLineOptions();
530
531 if (optionValuesList.isEmpty() != true) {
532 System.out.println("Testing invalid " + name + " values.");
533
534 for (String optionInvalid : optionValuesList) {
535 if (runJavaWithParam(optionInvalid, false) == false) {
536 failed++;
537 }
538 }
539 }
540
541 /* return number of failed tests for this option */
542 return failed;
543 }
544
545 }