test/hotspot/jtreg/vmTestbase/vm/mlvm/meth/share/TestTypes.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.mlvm.meth.share;

 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;

 import nsk.share.test.TestUtils;
 import vm.mlvm.share.Env;

 public class TestTypes {

     public static final Class<?>[] TYPES = {
         // void.class
         boolean.class, byte.class, char.class, short.class, int.class, long.class,
         float.class, double.class, Object.class, String.class
     };

     public static final Map<Class<?>, Class<?>> BOX_MAP = new HashMap<Class<?>, Class<?>>();
     public static final Map<Class<?>, Class<?>> UNBOX_MAP = new HashMap<Class<?>, Class<?>>();
     static {
         BOX_MAP.put(boolean.class, Boolean.class);
         BOX_MAP.put(byte.class, Byte.class);
         BOX_MAP.put(char.class, Character.class);
         BOX_MAP.put(short.class, Short.class);
         BOX_MAP.put(int.class, Integer.class);
         BOX_MAP.put(long.class, Long.class);
         BOX_MAP.put(float.class, Float.class);
         BOX_MAP.put(double.class, Double.class);

         for ( Entry<Class<?>, Class<?>> e : BOX_MAP.entrySet() ) {
             UNBOX_MAP.put(e.getValue(), e.getKey());
         }
     }

     public static final Class<?>[] PRIMITIVE_WIDENING_HIERARCHY = {
         byte.class, short.class, char.class, int.class, long.class, float.class, double.class
     };

     public static boolean isBoxedType(Class<?> type) {
         return BOX_MAP.values().contains(type);
     }

     private static void addPrimitiveAndBoxed(List<Class<?>> list, Class<?> type) {
         list.add(type);
         list.add(BOX_MAP.get(type));
     }

     /**
      * WPC = JLS 5.1.2 Widening Primitive Conversions
      * @param type
      * @return
      */
     private static void addWPCAssignableTypesFor(List<Class<?>> result, Class<?> type) {
         if ( type.equals(short.class) ) {
             addPrimitiveAndBoxed(result, byte.class);
         }

         if ( type.equals(int.class) || type.equals(long.class) || type.equals(float.class) || type.equals(double.class) ) {
             for ( int p = 0; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
                 Class<?> c = PRIMITIVE_WIDENING_HIERARCHY[p];
                 addPrimitiveAndBoxed(result, c);

                 if ( c.equals(type) )
                     break;
             }
         }
     }

     /**
      * NPC = JLS 5.1.3 Narrowing Primitive Conversions
      *     + JLS 5.1.4 Widening and Narrowing Primitive Conversions
      */
     private static void addNPCAssignableTypesFor(List<Class<?>> result, Class<?> type) {
         // JLS 5.1.4
         if ( type.equals(char.class) ) {
             addPrimitiveAndBoxed(result, byte.class);
         }

         // JLS 5.1.3
         int p = 0;
         for ( ; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
             if ( PRIMITIVE_WIDENING_HIERARCHY[p].equals(type) )
                 break;
         }

         for ( ; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
             addPrimitiveAndBoxed(result, PRIMITIVE_WIDENING_HIERARCHY[p]);
         }
     }

     public static Class<?>[] getAssignableTypesFor(Class<?> type) {
         if ( type.equals(void.class) )
             return new Class<?>[0];

         if ( type.isPrimitive() ) {
             List<Class<?>> result = new LinkedList<Class<?>>();
             addPrimitiveAndBoxed(result, type);
             addWPCAssignableTypesFor(result, type);
             return (Class<?>[]) result.toArray();
         }

         if ( type.equals(Object.class) )
             return new Class<?>[] { Object.class, String.class };

         if ( type.equals(String.class) )
             return new Class<?>[] { String.class };

         throw new IllegalArgumentException("Don't know how to handle type " + type);
     }

     public static Class<?>[] getExplicitlyCastTypesFor(Class<?> type) {
         return TYPES;
     }

     public static boolean canConvertType(Class<?> from, Class<?> to, boolean isRetType) {
         return (Boolean) convert(from, null, to, isRetType, true);
     }

     public static boolean canExplicitlyCastType(Class<?> from, Class<?> to, boolean isRetType) {
         return true; // TODO: can use explicitCaseArguments() to convert "from" to "to"
     }

     /** convert an argument according to the rules defined in MethodHandles.convertArguments() */
     public static Argument convertArgument(Argument from, Class<?> toType, boolean isRetType) throws ClassCastException {
         Class<?> fromType = from.getType();

         if ( fromType.equals(toType) )
             return from;

         Object toValue = convert(fromType, from.getValue(), toType, isRetType, false);
         return new Argument(toType, toValue, from.isPreserved(), from.getTag());
     }

     /** convert an argument according to the rules defined in MethodHandles.convertArguments() */
     private static Object convert(Class<?> fromType, Object fromValue, Class<?> toType, boolean isRetType, boolean dryRun) {
         if ( ! dryRun ) {
             if ( ! fromType.isPrimitive() )
                 TestUtils.assertTrue(fromType.isAssignableFrom(fromValue.getClass()), "fromType " + fromType + " is not assignable from the type of fromValue " + fromValue);
             else
                 TestUtils.assertTrue(BOX_MAP.get(fromType).isAssignableFrom(fromValue.getClass()), "Boxed fromType " + fromType + " is not assignable from the type of fromValue " + fromValue);
         }

         // JLS 5.1.1 Identity conversion
         if ( fromType.equals(toType) )
             return dryRun ? Boolean.TRUE : fromValue;

         Class<?> exactFromType = fromValue.getClass();

         Throwable cause = null;

         try {
             if ( isRetType ) {
                 // If the return type T1 is void, any returned value is discarded
                 if ( toType.equals(void.class) )
                     return dryRun ? true : null;

                 // If the return type T0 is void and T1 a reference, a null value is introduced.
                 if ( fromType.equals(void.class) && ! toType.isPrimitive() )
                     return dryRun ? true : null;

                 // If the return type T0 is void and T1 a primitive, a zero value is introduced.
                 if ( fromType.equals(void.class) && toType.isPrimitive() ) {
                     return dryRun ? true : BOX_MAP.get(toType).newInstance();
                 }
             }

             // If T0 and T1 are references, then a cast to T1 is applied.
             // (The types do not need to be related in any particular way.)
             if ( ! fromType.isPrimitive() && ! toType.isPrimitive() ) {
                 return dryRun ? toType.isAssignableFrom(fromType)
                               : toType.cast(fromValue);
             }

             // If T0 and T1 are primitives, then a Java method invocation conversion
             // (JLS 5.3) is applied, if one exists.
             if ( fromType.isPrimitive() && toType.isPrimitive() ) {
                 if ( dryRun ) {
                     for ( Class<?> tt : getAssignableTypesFor(toType) ) {
                         if ( tt.equals(fromType) )
                             return true;
                     }

                     return false;
                 } else {
                     return PrimitiveTypeConverter.convert(fromValue, toType);
                 }
             }

             // If T0 is a primitive and T1 a reference, a boxing conversion is applied
             // if one exists, possibly followed by a reference conversion to a superclass.
             // T1 must be a wrapper class or a supertype of one.
             if ( fromType.isPrimitive() && ! toType.isPrimitive() ) {
                 return dryRun ? toType.isAssignableFrom(BOX_MAP.get(fromType))
                               : toType.cast(fromType.cast(fromValue));
             }

             // If T0 is a reference and T1 a primitive, an unboxing conversion will be applied
             // at runtime, possibly followed by a Java method invocation conversion (JLS 5.3)
             // on the primitive value. (These are the widening conversions.) T0 must be
             // a wrapper class or a supertype of one. (In the case where T0 is Object,
             // these are the conversions allowed by java.lang.reflect.Method.invoke.)
             if ( ! fromType.isPrimitive() && toType.isPrimitive() ) {
                 if ( dryRun ) {
                     if ( ! BOX_MAP.values().contains(exactFromType) )
                         return false;


                 }

                 return dryRun ? toType.isAssignableFrom(BOX_MAP.get(fromType))
                               : toType.cast(fromType.cast(fromValue));
             }

         } catch ( Throwable t ) {
             cause = t;
         }

         if ( dryRun )
             return Boolean.FALSE;
         else
             throw (ClassCastException) (new ClassCastException("Can't convert value [" + fromValue + "] from type [" + fromType + "] to type [" + toType + "]")).initCause(cause);
     }

     public static Argument explicitCastArgument(Argument from, Class<?> toType, boolean isRetType) {
         return from; // TODO
     }

     public static Object nextRandomValueForType(Class<?> type) throws InstantiationException, IllegalAccessException {
         if (type.equals(void.class))
             return null;

         if (type.equals(boolean.class) || type.equals(Boolean.class))
             return new Boolean(Env.getRNG().nextInt(2) == 0);

         if (type.equals(byte.class) || type.equals(Byte.class))
             return new Byte((byte) Env.getRNG().nextInt(1 << Byte.SIZE));

         if (type.equals(int.class) || type.equals(Integer.class))
             return new Integer(Env.getRNG().nextInt());

         if (type.equals(short.class) || type.equals(Short.class))
             return new Short((short) Env.getRNG().nextInt(1 << Short.SIZE));

         if (type.equals(long.class) || type.equals(Long.class))
             return new Long(Env.getRNG().nextLong());

         if (type.equals(float.class) || type.equals(Float.class))
             return new Float(Env.getRNG().nextFloat());

         if (type.equals(double.class) || type.equals(Double.class))
             return new Double(Env.getRNG().nextDouble());

         if (type.equals(char.class) || type.equals(Character.class))
             return new Character((char) (32 + Env.getRNG().nextInt(96)));

         if (type.equals(Object.class))
             return new Object();

         if (type.equals(String.class)) {
             StringBuilder sb = new StringBuilder();
             for (int i = Env.getRNG().nextInt(100); i > 0; i--)
                 sb.append(nextRandomValueForType(char.class));
             return sb.toString();
         }

         throw new IllegalArgumentException("Don't know how to handle type " + type);
     }

     public static int getSlotsCount(Class<?> type) {
         if (type.equals(void.class))
             return 0;

         if ( type.equals(boolean.class) || type.equals(Boolean.class)
           || type.equals(byte.class) || type.equals(Byte.class)
           || type.equals(int.class) || type.equals(Integer.class)
           || type.equals(short.class) || type.equals(Short.class)
           || type.equals(float.class) || type.equals(Float.class)
           || type.equals(char.class) || type.equals(Character.class)
           || Object.class.isAssignableFrom(type) )
             return 1;

         if ( type.equals(long.class) || type.equals(Long.class)
           || type.equals(double.class) || type.equals(Double.class))
             return 2;

         throw new IllegalArgumentException("Don't know how to handle type " + type);
     }
 }
	/*
	* 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.mlvm.meth.share;

	import java.util.HashMap;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;

	import nsk.share.test.TestUtils;
	import vm.mlvm.share.Env;

	public class TestTypes {

	public static final Class<?>[] TYPES = {
	// void.class
	boolean.class, byte.class, char.class, short.class, int.class, long.class,
	float.class, double.class, Object.class, String.class
	};

	public static final Map<Class<?>, Class<?>> BOX_MAP = new HashMap<Class<?>, Class<?>>();
	public static final Map<Class<?>, Class<?>> UNBOX_MAP = new HashMap<Class<?>, Class<?>>();
	static {
	BOX_MAP.put(boolean.class, Boolean.class);
	BOX_MAP.put(byte.class, Byte.class);
	BOX_MAP.put(char.class, Character.class);
	BOX_MAP.put(short.class, Short.class);
	BOX_MAP.put(int.class, Integer.class);
	BOX_MAP.put(long.class, Long.class);
	BOX_MAP.put(float.class, Float.class);
	BOX_MAP.put(double.class, Double.class);

	for ( Entry<Class<?>, Class<?>> e : BOX_MAP.entrySet() ) {
	UNBOX_MAP.put(e.getValue(), e.getKey());
	}
	}

	public static final Class<?>[] PRIMITIVE_WIDENING_HIERARCHY = {
	byte.class, short.class, char.class, int.class, long.class, float.class, double.class
	};

	public static boolean isBoxedType(Class<?> type) {
	return BOX_MAP.values().contains(type);
	}

	private static void addPrimitiveAndBoxed(List<Class<?>> list, Class<?> type) {
	list.add(type);
	list.add(BOX_MAP.get(type));
	}

	/**
	* WPC = JLS 5.1.2 Widening Primitive Conversions
	* @param type
	* @return
	*/
	private static void addWPCAssignableTypesFor(List<Class<?>> result, Class<?> type) {
	if ( type.equals(short.class) ) {
	addPrimitiveAndBoxed(result, byte.class);
	}

	if ( type.equals(int.class) \|\| type.equals(long.class) \|\| type.equals(float.class) \|\| type.equals(double.class) ) {
	for ( int p = 0; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
	Class<?> c = PRIMITIVE_WIDENING_HIERARCHY[p];
	addPrimitiveAndBoxed(result, c);

	if ( c.equals(type) )
	break;
	}
	}
	}

	/**
	* NPC = JLS 5.1.3 Narrowing Primitive Conversions
	* + JLS 5.1.4 Widening and Narrowing Primitive Conversions
	*/
	private static void addNPCAssignableTypesFor(List<Class<?>> result, Class<?> type) {
	// JLS 5.1.4
	if ( type.equals(char.class) ) {
	addPrimitiveAndBoxed(result, byte.class);
	}

	// JLS 5.1.3
	int p = 0;
	for ( ; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
	if ( PRIMITIVE_WIDENING_HIERARCHY[p].equals(type) )
	break;
	}

	for ( ; p < PRIMITIVE_WIDENING_HIERARCHY.length; p++ ) {
	addPrimitiveAndBoxed(result, PRIMITIVE_WIDENING_HIERARCHY[p]);
	}
	}

	public static Class<?>[] getAssignableTypesFor(Class<?> type) {
	if ( type.equals(void.class) )
	return new Class<?>[0];

	if ( type.isPrimitive() ) {
	List<Class<?>> result = new LinkedList<Class<?>>();
	addPrimitiveAndBoxed(result, type);
	addWPCAssignableTypesFor(result, type);
	return (Class<?>[]) result.toArray();
	}

	if ( type.equals(Object.class) )
	return new Class<?>[] { Object.class, String.class };

	if ( type.equals(String.class) )
	return new Class<?>[] { String.class };

	throw new IllegalArgumentException("Don't know how to handle type " + type);
	}

	public static Class<?>[] getExplicitlyCastTypesFor(Class<?> type) {
	return TYPES;
	}

	public static boolean canConvertType(Class<?> from, Class<?> to, boolean isRetType) {
	return (Boolean) convert(from, null, to, isRetType, true);
	}

	public static boolean canExplicitlyCastType(Class<?> from, Class<?> to, boolean isRetType) {
	return true; // TODO: can use explicitCaseArguments() to convert "from" to "to"
	}

	/** convert an argument according to the rules defined in MethodHandles.convertArguments() */
	public static Argument convertArgument(Argument from, Class<?> toType, boolean isRetType) throws ClassCastException {
	Class<?> fromType = from.getType();

	if ( fromType.equals(toType) )
	return from;

	Object toValue = convert(fromType, from.getValue(), toType, isRetType, false);
	return new Argument(toType, toValue, from.isPreserved(), from.getTag());
	}

	/** convert an argument according to the rules defined in MethodHandles.convertArguments() */
	private static Object convert(Class<?> fromType, Object fromValue, Class<?> toType, boolean isRetType, boolean dryRun) {
	if ( ! dryRun ) {
	if ( ! fromType.isPrimitive() )
	TestUtils.assertTrue(fromType.isAssignableFrom(fromValue.getClass()), "fromType " + fromType + " is not assignable from the type of fromValue " + fromValue);
	else
	TestUtils.assertTrue(BOX_MAP.get(fromType).isAssignableFrom(fromValue.getClass()), "Boxed fromType " + fromType + " is not assignable from the type of fromValue " + fromValue);
	}

	// JLS 5.1.1 Identity conversion
	if ( fromType.equals(toType) )
	return dryRun ? Boolean.TRUE : fromValue;

	Class<?> exactFromType = fromValue.getClass();

	Throwable cause = null;

	try {
	if ( isRetType ) {
	// If the return type T1 is void, any returned value is discarded
	if ( toType.equals(void.class) )
	return dryRun ? true : null;

	// If the return type T0 is void and T1 a reference, a null value is introduced.
	if ( fromType.equals(void.class) && ! toType.isPrimitive() )
	return dryRun ? true : null;

	// If the return type T0 is void and T1 a primitive, a zero value is introduced.
	if ( fromType.equals(void.class) && toType.isPrimitive() ) {
	return dryRun ? true : BOX_MAP.get(toType).newInstance();
	}
	}

	// If T0 and T1 are references, then a cast to T1 is applied.
	// (The types do not need to be related in any particular way.)
	if ( ! fromType.isPrimitive() && ! toType.isPrimitive() ) {
	return dryRun ? toType.isAssignableFrom(fromType)
	: toType.cast(fromValue);
	}

	// If T0 and T1 are primitives, then a Java method invocation conversion
	// (JLS 5.3) is applied, if one exists.
	if ( fromType.isPrimitive() && toType.isPrimitive() ) {
	if ( dryRun ) {
	for ( Class<?> tt : getAssignableTypesFor(toType) ) {
	if ( tt.equals(fromType) )
	return true;
	}

	return false;
	} else {
	return PrimitiveTypeConverter.convert(fromValue, toType);
	}
	}

	// If T0 is a primitive and T1 a reference, a boxing conversion is applied
	// if one exists, possibly followed by a reference conversion to a superclass.
	// T1 must be a wrapper class or a supertype of one.
	if ( fromType.isPrimitive() && ! toType.isPrimitive() ) {
	return dryRun ? toType.isAssignableFrom(BOX_MAP.get(fromType))
	: toType.cast(fromType.cast(fromValue));
	}

	// If T0 is a reference and T1 a primitive, an unboxing conversion will be applied
	// at runtime, possibly followed by a Java method invocation conversion (JLS 5.3)
	// on the primitive value. (These are the widening conversions.) T0 must be
	// a wrapper class or a supertype of one. (In the case where T0 is Object,
	// these are the conversions allowed by java.lang.reflect.Method.invoke.)
	if ( ! fromType.isPrimitive() && toType.isPrimitive() ) {
	if ( dryRun ) {
	if ( ! BOX_MAP.values().contains(exactFromType) )
	return false;


	}

	return dryRun ? toType.isAssignableFrom(BOX_MAP.get(fromType))
	: toType.cast(fromType.cast(fromValue));
	}

	} catch ( Throwable t ) {
	cause = t;
	}

	if ( dryRun )
	return Boolean.FALSE;
	else
	throw (ClassCastException) (new ClassCastException("Can't convert value [" + fromValue + "] from type [" + fromType + "] to type [" + toType + "]")).initCause(cause);
	}

	public static Argument explicitCastArgument(Argument from, Class<?> toType, boolean isRetType) {
	return from; // TODO
	}

	public static Object nextRandomValueForType(Class<?> type) throws InstantiationException, IllegalAccessException {
	if (type.equals(void.class))
	return null;

	if (type.equals(boolean.class) \|\| type.equals(Boolean.class))
	return new Boolean(Env.getRNG().nextInt(2) == 0);

	if (type.equals(byte.class) \|\| type.equals(Byte.class))
	return new Byte((byte) Env.getRNG().nextInt(1 << Byte.SIZE));

	if (type.equals(int.class) \|\| type.equals(Integer.class))
	return new Integer(Env.getRNG().nextInt());

	if (type.equals(short.class) \|\| type.equals(Short.class))
	return new Short((short) Env.getRNG().nextInt(1 << Short.SIZE));

	if (type.equals(long.class) \|\| type.equals(Long.class))
	return new Long(Env.getRNG().nextLong());

	if (type.equals(float.class) \|\| type.equals(Float.class))
	return new Float(Env.getRNG().nextFloat());

	if (type.equals(double.class) \|\| type.equals(Double.class))
	return new Double(Env.getRNG().nextDouble());

	if (type.equals(char.class) \|\| type.equals(Character.class))
	return new Character((char) (32 + Env.getRNG().nextInt(96)));

	if (type.equals(Object.class))
	return new Object();

	if (type.equals(String.class)) {
	StringBuilder sb = new StringBuilder();
	for (int i = Env.getRNG().nextInt(100); i > 0; i--)
	sb.append(nextRandomValueForType(char.class));
	return sb.toString();
	}

	throw new IllegalArgumentException("Don't know how to handle type " + type);
	}

	public static int getSlotsCount(Class<?> type) {
	if (type.equals(void.class))
	return 0;

	if ( type.equals(boolean.class) \|\| type.equals(Boolean.class)
	\|\| type.equals(byte.class) \|\| type.equals(Byte.class)
	\|\| type.equals(int.class) \|\| type.equals(Integer.class)
	\|\| type.equals(short.class) \|\| type.equals(Short.class)
	\|\| type.equals(float.class) \|\| type.equals(Float.class)
	\|\| type.equals(char.class) \|\| type.equals(Character.class)
	\|\| Object.class.isAssignableFrom(type) )
	return 1;

	if ( type.equals(long.class) \|\| type.equals(Long.class)
	\|\| type.equals(double.class) \|\| type.equals(Double.class))
	return 2;

	throw new IllegalArgumentException("Don't know how to handle type " + type);
	}
	}