test/java/lang/invoke/LFCaching/TestMethods.java

Print this page

        

@@ -38,15 +38,15 @@
  *
  * @author kshefov
  */
 public enum TestMethods {
 
-    FOLD_ARGUMENTS("foldArguments") {
+    FOLD_ARGUMENTS("foldArguments", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int modifierMHArgNum = Helper.RNG.nextInt(realArity + 1);

@@ -77,23 +77,23 @@
                             mtTarget.parameterList().subList(combListStart,
                                     modifierMHArgNum), kind);
                     return MethodHandles.foldArguments(target, combiner);
                 }
             },
-    DROP_ARGUMENTS("dropArguments") {
+    DROP_ARGUMENTS("dropArguments", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int dropArgsPos = Helper.RNG.nextInt(realArity + 1);
                     data.put("dropArgsPos", dropArgsPos);
                     MethodType mtDropArgs = TestMethods.randomMethodTypeGenerator(
-                            Helper.RNG.nextInt(Helper.MAX_ARITY - realArity));
+                            Helper.RNG.nextInt(getMaxArity(this) - realArity));
                     data.put("mtDropArgs", mtDropArgs);
                     return data;
                 }
 
                 @Override

@@ -104,24 +104,24 @@
                     MethodHandle target = TestMethods.methodHandleGenerator(mtTarget.returnType(),
                             mtTarget.parameterList(), kind);
                     int mtTgtSlotsCount = TestMethods.argSlotsCount(mtTarget);
                     int mtDASlotsCount = TestMethods.argSlotsCount(mtDropArgs);
                     List<Class<?>> fakeParList;
-                    if (mtTgtSlotsCount + mtDASlotsCount > Helper.MAX_ARITY - 1) {
+                    if (mtTgtSlotsCount + mtDASlotsCount > getMaxArity(this) - 1) {
                         fakeParList = TestMethods.reduceArgListToSlotsCount(mtDropArgs.parameterList(),
-                                Helper.MAX_ARITY - mtTgtSlotsCount - 1);
+                                getMaxArity(this) - mtTgtSlotsCount - 1);
                     } else {
                         fakeParList = mtDropArgs.parameterList();
                     }
                     return MethodHandles.dropArguments(target, dropArgsPos, fakeParList);
                 }
             },
-    EXPLICIT_CAST_ARGUMENTS("explicitCastArguments") {
+    EXPLICIT_CAST_ARGUMENTS("explicitCastArguments", Helper.MAX_ARITY / 2) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY / 2);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     MethodType mtExcplCastArgs = TestMethods.randomMethodTypeGenerator(realArity);

@@ -144,15 +144,15 @@
                     MethodHandle target = TestMethods.methodHandleGenerator(mtTarget.returnType(),
                             mtTarget.parameterList(), kind);
                     return MethodHandles.explicitCastArguments(target, mtExcplCastArgs);
                 }
             },
-    FILTER_ARGUMENTS("filterArguments") {
+    FILTER_ARGUMENTS("filterArguments", Helper.MAX_ARITY / 2) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY / 2);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int filterArgsPos = Helper.RNG.nextInt(realArity + 1);

@@ -178,15 +178,15 @@
                                 mtTarget.parameterType(filterArgsPos + i), kind);
                     }
                     return MethodHandles.filterArguments(target, filterArgsPos, filters);
                 }
             },
-    FILTER_RETURN_VALUE("filterReturnValue") {
+    FILTER_RETURN_VALUE("filterReturnValue", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int filterArgsPos = Helper.RNG.nextInt(realArity + 1);

@@ -205,15 +205,15 @@
                     MethodHandle filter = TestMethods.filterGenerator(mtTarget.returnType(),
                             mtFilter.returnType(), kind);
                     return MethodHandles.filterReturnValue(target, filter);
                 }
             },
-    INSERT_ARGUMENTS("insertArguments") {
+    INSERT_ARGUMENTS("insertArguments", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int insertArgsPos = Helper.RNG.nextInt(realArity + 1);

@@ -234,22 +234,22 @@
                             mtTarget.parameterList(), kind);
                     Object[] insertList = Helper.randomArgs(mtInsertArgs.parameterList());
                     return MethodHandles.insertArguments(target, insertArgsPos, insertList);
                 }
             },
-    PERMUTE_ARGUMENTS("permuteArguments") {
+    PERMUTE_ARGUMENTS("permuteArguments", Helper.MAX_ARITY / 2) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY / 2);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int[] permuteArgsReorderArray = new int[realArity];
-                    int mtParmuteArgsNum = Helper.RNG.nextInt(Helper.MAX_ARITY);
-                    mtParmuteArgsNum = mtParmuteArgsNum == 0 ? 1 : mtParmuteArgsNum;
-                    MethodType mtPermuteArgs = TestMethods.randomMethodTypeGenerator(mtParmuteArgsNum);
+                    int mtPermuteArgsNum = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    mtPermuteArgsNum = mtPermuteArgsNum == 0 ? 1 : mtPermuteArgsNum;
+                    MethodType mtPermuteArgs = TestMethods.randomMethodTypeGenerator(mtPermuteArgsNum);
                     mtTarget = mtTarget.changeReturnType(mtPermuteArgs.returnType());
                     for (int i = 0; i < realArity; i++) {
                         int mtPermuteArgsParNum = Helper.RNG.nextInt(mtPermuteArgs.parameterCount());
                         permuteArgsReorderArray[i] = mtPermuteArgsParNum;
                         mtTarget = mtTarget.changeParameterType(

@@ -269,15 +269,15 @@
                     MethodHandle target = TestMethods.methodHandleGenerator(mtTarget.returnType(),
                             mtTarget.parameterList(), kind);
                     return MethodHandles.permuteArguments(target, mtPermuteArgs, permuteArgsReorderArray);
                 }
             },
-    THROW_EXCEPTION("throwException") {
+    THROW_EXCEPTION("throwException", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -287,15 +287,15 @@
                     Class<?> rType = mtTarget.returnType();
                     return MethodHandles.throwException(rType, Exception.class
                     );
                 }
             },
-    GUARD_WITH_TEST("guardWithTest") {
+    GUARD_WITH_TEST("guardWithTest", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int modifierMHArgNum = Helper.RNG.nextInt(realArity + 1);

@@ -323,15 +323,15 @@
                     MethodHandle test = TestMethods.methodHandleGenerator(boolean.class,
                             mtTarget.parameterList().subList(0, modifierMHArgNum), kind);
                     return MethodHandles.guardWithTest(test, target, fallback);
                 }
             },
-    CATCH_EXCEPTION("catchException") {
+    CATCH_EXCEPTION("catchException", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int modifierMHArgNum = Helper.RNG.nextInt(realArity + 1);

@@ -357,15 +357,15 @@
                     MethodHandle handler = TestMethods.methodHandleGenerator(
                             mtTarget.returnType(), handlerParamList, TestMethods.Kind.TWO);
                     return MethodHandles.catchException(target, Exception.class, handler);
                 }
             },
-    INVOKER("invoker") {
+    INVOKER("invoker", Helper.MAX_ARITY - 1) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -373,15 +373,15 @@
                 protected MethodHandle getMH(Map<String, Object> data, TestMethods.Kind kind) {
                     MethodType mtTarget = (MethodType) data.get("mtTarget");
                     return MethodHandles.invoker(mtTarget);
                 }
             },
-    EXACT_INVOKER("exactInvoker") {
+    EXACT_INVOKER("exactInvoker", Helper.MAX_ARITY - 1) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -389,15 +389,15 @@
                 protected MethodHandle getMH(Map<String, Object> data, TestMethods.Kind kind) {
                     MethodType mtTarget = (MethodType) data.get("mtTarget");
                     return MethodHandles.exactInvoker(mtTarget);
                 }
             },
-    SPREAD_INVOKER("spreadInvoker") {
+    SPREAD_INVOKER("spreadInvoker", Helper.MAX_ARITY - 1) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     // Arity after reducing because of long and double take 2 slots.
                     int realArity = mtTarget.parameterCount();
                     int modifierMHArgNum = Helper.RNG.nextInt(realArity + 1);

@@ -410,15 +410,15 @@
                     MethodType mtTarget = (MethodType) data.get("mtTarget");
                     int modifierMHArgNum = (int) data.get("modifierMHArgNum");
                     return MethodHandles.spreadInvoker(mtTarget, modifierMHArgNum);
                 }
             },
-    ARRAY_ELEMENT_GETTER("arrayElementGetter") {
+    ARRAY_ELEMENT_GETTER("arrayElementGetter", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -430,15 +430,15 @@
                         rType = Object.class;
                     }
                     return MethodHandles.arrayElementGetter(Array.newInstance(rType, 2).getClass());
                 }
             },
-    ARRAY_ELEMENT_SETTER("arrayElementSetter") {
+    ARRAY_ELEMENT_SETTER("arrayElementSetter", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -450,15 +450,15 @@
                         rType = Object.class;
                     }
                     return MethodHandles.arrayElementSetter(Array.newInstance(rType, 2).getClass());
                 }
             },
-    CONSTANT("constant") {
+    CONSTANT("constant", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -475,15 +475,15 @@
                     } else {
                         return MethodHandles.constant(rType, kind.getValue(rType));
                     }
                 }
             },
-    IDENTITY("identity") {
+    IDENTITY("identity", Helper.MAX_ARITY) {
                 @Override
                 public Map<String, Object> getTestCaseData() {
                     Map<String, Object> data = new HashMap<>();
-                    int desiredArity = Helper.RNG.nextInt(Helper.MAX_ARITY);
+                    int desiredArity = Helper.RNG.nextInt(getMaxArity(this));
                     MethodType mtTarget = TestMethods.randomMethodTypeGenerator(desiredArity);
                     data.put("mtTarget", mtTarget);
                     return data;
                 }
 

@@ -501,12 +501,14 @@
     /**
      * Test method's name.
      */
     public final String name;
 
-    private TestMethods(String name) {
-        this.name = name;
+    private final int maxArity;
+    
+    private static int getMaxArity(TestMethods tm) {
+        return tm.maxArity;
     }
 
     protected MethodHandle getMH(Map<String, Object> data, TestMethods.Kind kind) throws NoSuchMethodException, IllegalAccessException {
         throw new UnsupportedOperationException("TESTBUG: getMH method is not implemented for test method " + this);
     }