test/hotspot/jtreg/vmTestbase/vm/share/options/OptionsSetup.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package vm.share.options;

 import java.util.Map;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.Iterator;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.io.PrintStream;
 import nsk.share.TestBug;
 import nsk.share.log.LogSupport;

 class OptionsSetup {
     private LogSupport log = new LogSupport();
     private boolean verbose = true;
     private Object test;
     private String[] args;
     private OptionHandler unknownOptionHandler;

     private int argIndex = 0;
     private Map<String, OptionDefinition> optionDefs = new LinkedHashMap<String, OptionDefinition>(); // Use LinkedHashMap to ensure order of options
     private List<OptionDefinition> unconfiguredOptionsList = new ArrayList<OptionDefinition>();
     private List<OptionDefinition> unconfiguredOptionList = new ArrayList<OptionDefinition>();
     private Map<String, Object> optionValues = new LinkedHashMap<String, Object>();

     public OptionsSetup(Object test, String[] args, OptionHandler unknownOptionHandler) {
         this.test = test;
         this.args = args;
         this.unknownOptionHandler = unknownOptionHandler;
         log.setDebugEnabled(verbose);
     }

     public void run() {
         searchAnnotations(test, null);
         while (argIndex < args.length) {
             process1Arg();
         }
         setDefaultValues();
         checkMandatoryOptions();
         if (unconfiguredOptionsList.size() > 0) {
             for (OptionDefinition optDef : unconfiguredOptionsList)
                 log.info("Unconfigured option: " + optDef);
             throw new TestBug("Some options are unconfigured");
         }
     }

     private void checkMandatoryOptions() {
         for (Map.Entry<String, OptionDefinition> e : optionDefs.entrySet()) {
             String name = e.getKey();
             OptionDefinition optDef = e.getValue();
             if (optDef.getDefaultValue() == null && !optionValues.containsKey(name))
                 throw new TestBug("Mandatory option is not specified: -" + name);
         }
     }

     private void setDefaultValues() {
         for (Iterator<OptionDefinition> it = unconfiguredOptionList.iterator(); it.hasNext(); ) {
             OptionDefinition optDef = it.next();
             String value = optDef.getDefaultValue();
             if (value == null)
                 continue;
             setOptionValue(optDef, value);
             it.remove();
             if (unconfiguredOptionsList.contains(optDef))
                 unconfiguredOptionsList.remove(optDef);
         }

         for (Iterator<OptionDefinition> it = unconfiguredOptionsList.iterator(); it.hasNext(); ) {
             OptionDefinition optDef = it.next();
             if (optionsAnnotation(optDef.getOwner(), optDef.getField(), null, optDef, true))
                 it.remove();
         }
     }

     private void process1Arg() {
         String arg = args[argIndex++];
         //log.debug("Processing argument: " + arg);
         if (!arg.startsWith("-")) {
             processUnknownArg(arg);
             return;
         }
         String opt = arg.substring(1);
         String value = null;
         int i = opt.indexOf('=');
         if (i != -1) {
             value = opt.substring(i + 1);
             opt = opt.substring(0, i);
         }
         if (opt.equals("help")) {
             printHelp();
             throw new TestBug("-help was specified");
         }
         if (!optionDefs.containsKey(opt)) {
             if (value == null && argIndex < args.length)
                 value = args[argIndex++];
             // We need to try to resolve default values of all unconfigured fields because one of them may potentially have this option
             setDefaultValues();
             if (!optionDefs.containsKey(opt)) {
                 processUnknownOpt(opt, value);
                 return;
             }
         }
         OptionDefinition optDef = optionDefs.get(opt);
         Field f = optDef.getField();
         // Handle boolean omitted value
         if (value == null && (argIndex >= args.length || args[argIndex].startsWith("-"))) {
             if (f.getType() == boolean.class || f.getType() == Boolean.class) {
                 value = "true";
             }
         }
         if (value == null) {
             if (argIndex >= args.length)
                 throw new TestBug("Missing value for option -" + opt);
             value = args[argIndex++];
         }
         setOptionValue(optDef, value);
         if (unconfiguredOptionList.contains(optDef)){
             unconfiguredOptionList.remove(optDef);
         }
     }

     private void setOptionValue(OptionDefinition optDef, String value) {
         Object ovalue = null;
         if (optDef.hasFactory()) {
             ovalue = optDef.getFactory().getObject(value);
         } else {
             ovalue = PrimitiveParser.parse(value, optDef.getField().getType());
         }
         optionValues.put(optDef.getName(), ovalue);
         try {
             Field f = optDef.getField();
             Object o = optDef.getOwner();
             f.set(o, ovalue);
             if (f.isAnnotationPresent(Options.class)) {
                 if (!optionsAnnotation(o, f, optDef.getPrefix(), optDef, false))
                     throw new TestBug("Unexpected (bug in framework?): optionsAnnotation returned null: " + optDef);
                 if (unconfiguredOptionsList.contains(optDef))
                     unconfiguredOptionsList.remove(optDef);
             }
         } catch (IllegalArgumentException e) {
             throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
         } catch (IllegalAccessException e) {
             throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
         }
     }

     private void processUnknownArg(String arg) {
         if (unknownOptionHandler != null)
             unknownOptionHandler.argument(arg);
         else
             throw new TestBug("Invalid argument: " + arg);
     }

     private void processUnknownOpt(String opt, String value) {
         if (unknownOptionHandler != null)
             unknownOptionHandler.option(opt, value);
         else
             throw new TestBug("Invalid option: '" + opt + "', value: '" + value + "'");
     }

     private void searchAnnotations(Object o, String prefix) {
         Class<?> cl0 = o.getClass();
         //log.debug("Looking for annotations for object " + o + ", class " + cl0);
         List<Class> classes = new LinkedList<Class>();
         while (cl0.getSuperclass() != null) {
             classes.add(0, cl0); // Add to the beginning to ensure the option order is from superclass to subclass
             cl0 = cl0.getSuperclass();
         }
         for (Class<?> cl : classes) {
             for (Field f : cl.getDeclaredFields()) {
                 OptionDefinition optDef = null;
                 if (f.isAnnotationPresent(Option.class)) {
                     optDef = optionAnnotation(o, f, prefix);
                     if (optDef != null) {
                         unconfiguredOptionList.add(optDef);
                     }
                 }
                 if (f.isAnnotationPresent(Options.class)) {
                     if (!optionsAnnotation(o, f, prefix, optDef, false)) {
                         if (!unconfiguredOptionsList.contains(optDef))
                             unconfiguredOptionsList.add(optDef);
                     }
                 }
             }
         }
     }

     private boolean optionsAnnotation(Object o, Field f, String prefix, OptionDefinition optDef, boolean useDefault) {
         if (Modifier.isStatic(f.getModifiers()))
             throw new OptionError("@Options annotation is not allowed at static field", optDef);
         if (!Object.class.isAssignableFrom(f.getDeclaringClass()))
             throw new OptionError("@Options annotation is only allowed on object types", optDef);
         //log.debug("Processing @Options annotation: object " + o + ", field " + f + ", prefix " + prefix);
         Object v = null;
         try {
             f.setAccessible(true);
             v = f.get(o);
         } catch (IllegalAccessException e) {
             throw new OptionError("Exception getting value of field ", e, optDef);
         }
         if (v == null) {
             if (optDef == null)
                 throw new OptionError("Value of field is null and no @Option annotation is present", optDef);
             if (!optDef.hasFactory())
                 throw new OptionError("Value of field is null and no @Option annotation does not have factory", optDef);
             if (useDefault) {
                 setOptionValue(optDef, optDef.getDefaultValue());
                 try {
                     v = f.get(o);
                 } catch (IllegalAccessException e) {
                     throw new OptionError("Exception getting value of field ", e, optDef);
                 }
             }
             if (v == null) {
                 // We cannot setup it right away, so it is stored until value is set
                 return false;
             } else
                 return true; // setOption Value already searched annotations
         }
         Options opts = f.getAnnotation(Options.class);
         String vprefix = opts.prefix();
         if (vprefix.equals(Options.defPrefix))
             vprefix = null;
         if (vprefix != null) {
             if (prefix != null)
                 prefix = prefix + "." + vprefix;
             else
                 prefix = vprefix;
         }
         searchAnnotations(v, prefix);
         return true;
     }

     private OptionDefinition optionAnnotation(Object o, Field f, String prefix) {
         //log.debug("Processing @Option annotation: object " + o + ", field " + f + ", prefix " + prefix);
         f.setAccessible(true);
         Option opt = f.getAnnotation(Option.class);
         String name = opt.name();
         if (name.equals(Option.defName))
             name = f.getName();  // option name defaults to field name
         if (prefix != null)
             name = prefix + "." + name;
         if (optionDefs.containsKey(name))
             throw new TestBug("Option is already defined: " + name);
         String defaultValue = opt.default_value();
         if (defaultValue.equals(Option.defDefaultValue))
             defaultValue = null; // default value defaults to null
         String description = opt.description();
         if (description.equals(Option.defDescription))
             description = null;
         if (description == null) {
             if (name.equals("log") || name.endsWith(".log")) {
                 try {
                     f.set(o, log);
                 } catch (IllegalAccessException e) {
                     throw new TestBug("Exception setting log field of " + o, e);
                 }
                 return null;
             } else
                 throw new TestBug("@Option annotation should always have description set: " + name + ", field: " + f);
         }
         Class<? extends OptionObjectFactory> factory = opt.factory();
         //log.debug("Factory: " + factory);
         if (factory.equals(OptionObjectFactory.class))
             factory = null;
         OptionDefinition optDef = new OptionDefinition(
                 prefix,
                 name,
                 description,
                 defaultValue,
                 factory,
                 f,
                 o
         );
         optionDefs.put(name, optDef);
         //log.debug("Added option definition: " + optDef);
         return optDef;
     }

     private void printHelp() {
         PrintStream out = System.out;
         out.println(" Supported options:");
         out.println("    -help");
         out.println("          Show this help screen");
         for (Map.Entry<String, OptionDefinition> entry : optionDefs.entrySet()) {
             String opt = entry.getKey();
             OptionDefinition optDef = entry.getValue();
             out.println("    -" + opt + " <" + optDef.getPlaceHolder() + ">");
             out.print("          " + optDef.getDescription() + " ");
             if (optDef.getDefaultValue() != null) {
                 out.println("(default: " + optDef.getDefaultValue() + ")");
             } else {
                 out.println("(mandatory)");
             }
             if (optDef.hasFactory()) {
                 OptionObjectFactory factory = optDef.getFactory();
                 for (String key : factory.getPossibleValues()) {
                     out.println("             " + key + ": " + factory.getParameterDescription(key));
                 }
             }
         }
     }
 }
	/*
	* Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package vm.share.options;

	import java.util.Map;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.ArrayList;
	import java.util.LinkedList;
	import java.util.Iterator;
	import java.lang.reflect.Field;
	import java.lang.reflect.Modifier;
	import java.io.PrintStream;
	import nsk.share.TestBug;
	import nsk.share.log.LogSupport;

	class OptionsSetup {
	private LogSupport log = new LogSupport();
	private boolean verbose = true;
	private Object test;
	private String[] args;
	private OptionHandler unknownOptionHandler;

	private int argIndex = 0;
	private Map<String, OptionDefinition> optionDefs = new LinkedHashMap<String, OptionDefinition>(); // Use LinkedHashMap to ensure order of options
	private List<OptionDefinition> unconfiguredOptionsList = new ArrayList<OptionDefinition>();
	private List<OptionDefinition> unconfiguredOptionList = new ArrayList<OptionDefinition>();
	private Map<String, Object> optionValues = new LinkedHashMap<String, Object>();

	public OptionsSetup(Object test, String[] args, OptionHandler unknownOptionHandler) {
	this.test = test;
	this.args = args;
	this.unknownOptionHandler = unknownOptionHandler;
	log.setDebugEnabled(verbose);
	}

	public void run() {
	searchAnnotations(test, null);
	while (argIndex < args.length) {
	process1Arg();
	}
	setDefaultValues();
	checkMandatoryOptions();
	if (unconfiguredOptionsList.size() > 0) {
	for (OptionDefinition optDef : unconfiguredOptionsList)
	log.info("Unconfigured option: " + optDef);
	throw new TestBug("Some options are unconfigured");
	}
	}

	private void checkMandatoryOptions() {
	for (Map.Entry<String, OptionDefinition> e : optionDefs.entrySet()) {
	String name = e.getKey();
	OptionDefinition optDef = e.getValue();
	if (optDef.getDefaultValue() == null && !optionValues.containsKey(name))
	throw new TestBug("Mandatory option is not specified: -" + name);
	}
	}

	private void setDefaultValues() {
	for (Iterator<OptionDefinition> it = unconfiguredOptionList.iterator(); it.hasNext(); ) {
	OptionDefinition optDef = it.next();
	String value = optDef.getDefaultValue();
	if (value == null)
	continue;
	setOptionValue(optDef, value);
	it.remove();
	if (unconfiguredOptionsList.contains(optDef))
	unconfiguredOptionsList.remove(optDef);
	}

	for (Iterator<OptionDefinition> it = unconfiguredOptionsList.iterator(); it.hasNext(); ) {
	OptionDefinition optDef = it.next();
	if (optionsAnnotation(optDef.getOwner(), optDef.getField(), null, optDef, true))
	it.remove();
	}
	}

	private void process1Arg() {
	String arg = args[argIndex++];
	//log.debug("Processing argument: " + arg);
	if (!arg.startsWith("-")) {
	processUnknownArg(arg);
	return;
	}
	String opt = arg.substring(1);
	String value = null;
	int i = opt.indexOf('=');
	if (i != -1) {
	value = opt.substring(i + 1);
	opt = opt.substring(0, i);
	}
	if (opt.equals("help")) {
	printHelp();
	throw new TestBug("-help was specified");
	}
	if (!optionDefs.containsKey(opt)) {
	if (value == null && argIndex < args.length)
	value = args[argIndex++];
	// We need to try to resolve default values of all unconfigured fields because one of them may potentially have this option
	setDefaultValues();
	if (!optionDefs.containsKey(opt)) {
	processUnknownOpt(opt, value);
	return;
	}
	}
	OptionDefinition optDef = optionDefs.get(opt);
	Field f = optDef.getField();
	// Handle boolean omitted value
	if (value == null && (argIndex >= args.length \|\| args[argIndex].startsWith("-"))) {
	if (f.getType() == boolean.class \|\| f.getType() == Boolean.class) {
	value = "true";
	}
	}
	if (value == null) {
	if (argIndex >= args.length)
	throw new TestBug("Missing value for option -" + opt);
	value = args[argIndex++];
	}
	setOptionValue(optDef, value);
	if (unconfiguredOptionList.contains(optDef)){
	unconfiguredOptionList.remove(optDef);
	}
	}

	private void setOptionValue(OptionDefinition optDef, String value) {
	Object ovalue = null;
	if (optDef.hasFactory()) {
	ovalue = optDef.getFactory().getObject(value);
	} else {
	ovalue = PrimitiveParser.parse(value, optDef.getField().getType());
	}
	optionValues.put(optDef.getName(), ovalue);
	try {
	Field f = optDef.getField();
	Object o = optDef.getOwner();
	f.set(o, ovalue);
	if (f.isAnnotationPresent(Options.class)) {
	if (!optionsAnnotation(o, f, optDef.getPrefix(), optDef, false))
	throw new TestBug("Unexpected (bug in framework?): optionsAnnotation returned null: " + optDef);
	if (unconfiguredOptionsList.contains(optDef))
	unconfiguredOptionsList.remove(optDef);
	}
	} catch (IllegalArgumentException e) {
	throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
	} catch (IllegalAccessException e) {
	throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
	}
	}

	private void processUnknownArg(String arg) {
	if (unknownOptionHandler != null)
	unknownOptionHandler.argument(arg);
	else
	throw new TestBug("Invalid argument: " + arg);
	}

	private void processUnknownOpt(String opt, String value) {
	if (unknownOptionHandler != null)
	unknownOptionHandler.option(opt, value);
	else
	throw new TestBug("Invalid option: '" + opt + "', value: '" + value + "'");
	}

	private void searchAnnotations(Object o, String prefix) {
	Class<?> cl0 = o.getClass();
	//log.debug("Looking for annotations for object " + o + ", class " + cl0);
	List<Class> classes = new LinkedList<Class>();
	while (cl0.getSuperclass() != null) {
	classes.add(0, cl0); // Add to the beginning to ensure the option order is from superclass to subclass
	cl0 = cl0.getSuperclass();
	}
	for (Class<?> cl : classes) {
	for (Field f : cl.getDeclaredFields()) {
	OptionDefinition optDef = null;
	if (f.isAnnotationPresent(Option.class)) {
	optDef = optionAnnotation(o, f, prefix);
	if (optDef != null) {
	unconfiguredOptionList.add(optDef);
	}
	}
	if (f.isAnnotationPresent(Options.class)) {
	if (!optionsAnnotation(o, f, prefix, optDef, false)) {
	if (!unconfiguredOptionsList.contains(optDef))
	unconfiguredOptionsList.add(optDef);
	}
	}
	}
	}
	}

	private boolean optionsAnnotation(Object o, Field f, String prefix, OptionDefinition optDef, boolean useDefault) {
	if (Modifier.isStatic(f.getModifiers()))
	throw new OptionError("@Options annotation is not allowed at static field", optDef);
	if (!Object.class.isAssignableFrom(f.getDeclaringClass()))
	throw new OptionError("@Options annotation is only allowed on object types", optDef);
	//log.debug("Processing @Options annotation: object " + o + ", field " + f + ", prefix " + prefix);
	Object v = null;
	try {
	f.setAccessible(true);
	v = f.get(o);
	} catch (IllegalAccessException e) {
	throw new OptionError("Exception getting value of field ", e, optDef);
	}
	if (v == null) {
	if (optDef == null)
	throw new OptionError("Value of field is null and no @Option annotation is present", optDef);
	if (!optDef.hasFactory())
	throw new OptionError("Value of field is null and no @Option annotation does not have factory", optDef);
	if (useDefault) {
	setOptionValue(optDef, optDef.getDefaultValue());
	try {
	v = f.get(o);
	} catch (IllegalAccessException e) {
	throw new OptionError("Exception getting value of field ", e, optDef);
	}
	}
	if (v == null) {
	// We cannot setup it right away, so it is stored until value is set
	return false;
	} else
	return true; // setOption Value already searched annotations
	}
	Options opts = f.getAnnotation(Options.class);
	String vprefix = opts.prefix();
	if (vprefix.equals(Options.defPrefix))
	vprefix = null;
	if (vprefix != null) {
	if (prefix != null)
	prefix = prefix + "." + vprefix;
	else
	prefix = vprefix;
	}
	searchAnnotations(v, prefix);
	return true;
	}

	private OptionDefinition optionAnnotation(Object o, Field f, String prefix) {
	//log.debug("Processing @Option annotation: object " + o + ", field " + f + ", prefix " + prefix);
	f.setAccessible(true);
	Option opt = f.getAnnotation(Option.class);
	String name = opt.name();
	if (name.equals(Option.defName))
	name = f.getName(); // option name defaults to field name
	if (prefix != null)
	name = prefix + "." + name;
	if (optionDefs.containsKey(name))
	throw new TestBug("Option is already defined: " + name);
	String defaultValue = opt.default_value();
	if (defaultValue.equals(Option.defDefaultValue))
	defaultValue = null; // default value defaults to null
	String description = opt.description();
	if (description.equals(Option.defDescription))
	description = null;
	if (description == null) {
	if (name.equals("log") \|\| name.endsWith(".log")) {
	try {
	f.set(o, log);
	} catch (IllegalAccessException e) {
	throw new TestBug("Exception setting log field of " + o, e);
	}
	return null;
	} else
	throw new TestBug("@Option annotation should always have description set: " + name + ", field: " + f);
	}
	Class<? extends OptionObjectFactory> factory = opt.factory();
	//log.debug("Factory: " + factory);
	if (factory.equals(OptionObjectFactory.class))
	factory = null;
	OptionDefinition optDef = new OptionDefinition(
	prefix,
	name,
	description,
	defaultValue,
	factory,
	f,
	o
	);
	optionDefs.put(name, optDef);
	//log.debug("Added option definition: " + optDef);
	return optDef;
	}

	private void printHelp() {
	PrintStream out = System.out;
	out.println(" Supported options:");
	out.println(" -help");
	out.println(" Show this help screen");
	for (Map.Entry<String, OptionDefinition> entry : optionDefs.entrySet()) {
	String opt = entry.getKey();
	OptionDefinition optDef = entry.getValue();
	out.println(" -" + opt + " <" + optDef.getPlaceHolder() + ">");
	out.print(" " + optDef.getDescription() + " ");
	if (optDef.getDefaultValue() != null) {
	out.println("(default: " + optDef.getDefaultValue() + ")");
	} else {
	out.println("(mandatory)");
	}
	if (optDef.hasFactory()) {
	OptionObjectFactory factory = optDef.getFactory();
	for (String key : factory.getPossibleValues()) {
	out.println(" " + key + ": " + factory.getParameterDescription(key));
	}
	}
	}
	}
	}