Example #1
1
    private static boolean isSetException(Score score)
        throws NoSuchMethodException, NoSuchFieldException, IllegalAccessException,
            InvocationTargetException {
      Object craftScore = CRAFT_SCORE.cast(score);

      Object craftObjective = CRAFT_OBJECTIVE.cast(score.getObjective());
      Method craftHandle = CRAFT_OBJECTIVE.getDeclaredMethod("getHandle");
      craftHandle.setAccessible(true);
      Object craftObjectiveHandle = craftHandle.invoke(craftObjective);

      Field objective = CRAFT_SCORE.getDeclaredField("objective");
      objective.setAccessible(true);
      Object craftScoreboard = checkState(objective.get(craftScore));

      Field craftBoard = CRAFT_SCOREBOARD.getDeclaredField("board");
      craftBoard.setAccessible(true);
      Object scoreboard = craftBoard.get(craftScoreboard);
      Method playerObjectives = SCOREBOARD.getDeclaredMethod("getPlayerObjectives", String.class);
      playerObjectives.setAccessible(true);

      Field playerField = CRAFT_SCORE.getDeclaredField("entry");
      playerField.setAccessible(true);
      String playerName = (String) playerField.get(craftScore);
      Map map = (Map) playerObjectives.invoke(scoreboard, playerName);

      // return
      // objective.checkState().board.getPlayerObjectives(playerName).containsKey(objective.getHandle());
      return map.containsKey(craftObjectiveHandle);
    }
Example #2
0
 /**
  * Launch a browser window to show the given url
  *
  * @param inUrl url to show
  */
 public static void launchBrowser(String inUrl) {
   // First choice is to try the Desktop library from java 6, if available
   try {
     Class<?> d = Class.forName("java.awt.Desktop");
     d.getDeclaredMethod("browse", new Class[] {URI.class})
         .invoke(d.getDeclaredMethod("getDesktop").invoke(null), new Object[] {URI.create(inUrl)});
     // above code mimics: Desktop.getDesktop().browse(URI.create(inUrl));
   } catch (Exception ignore) {
     // The Desktop call failed, need to try backup methods
     if (!_initialised) {
       init();
     }
     if (_browserCommand == null) {
       JOptionPane.showMessageDialog(null, "Cannot show url: " + inUrl);
     } else {
       try {
         // enclose url in quotes if necessary
         String url = inUrl;
         if (_urlNeedsQuotes) {
           url = "\"" + url + "\"";
         }
         // Fill in url in last element of command array
         _browserCommand[_browserCommand.length - 1] = url;
         // execute command to launch browser
         Runtime.getRuntime().exec(_browserCommand);
       } catch (Exception e) {
         JOptionPane.showMessageDialog(null, "Failed to show url: " + inUrl);
       }
     }
   }
 }
Example #3
0
 public String getUserNameFull() {
   String s = "Это Линокс";
   if (isOSWindows()) {
     String className = "com.sun.security.auth.module.NTSystem";
     try {
       ClassLoader cL = ClassLoader.getSystemClassLoader();
       Class cls = cL.loadClass(className);
       Object obj = cls.newInstance();
       Method methodGetName = cls.getDeclaredMethod("getName");
       s = (String) methodGetName.invoke(obj);
       Method methodGetDomain = cls.getDeclaredMethod("getDomain");
       s = (String) methodGetDomain.invoke(obj) + "\\" + s;
     } catch (ClassNotFoundException e) {
       return "undefined";
     } catch (InstantiationException e) {
       return "undefined";
     } catch (IllegalAccessException e) {
       return "undefined";
     } catch (NoSuchMethodException e) {
       return "undefined";
     } catch (InvocationTargetException e) {
       return "undefined";
     }
   }
   return s;
 }
  public BaseClusterReceiver(ExecutorService executorService) {
    if (executorService == null) {
      throw new NullPointerException("Executor service is null");
    }

    _executorService = executorService;

    boolean hasDoViewAccepted = false;

    Class<?> clazz = getClass();

    try {
      clazz.getDeclaredMethod("doAddressesUpdated", List.class, List.class);

      hasDoViewAccepted = true;
    } catch (ReflectiveOperationException roe) {
    }

    _hasDoViewAccepted = hasDoViewAccepted;

    boolean hasDoCoordinatorAddressUpdated = false;

    try {
      clazz.getDeclaredMethod("doCoordinatorAddressUpdated", Address.class, Address.class);

      hasDoCoordinatorAddressUpdated = true;
    } catch (ReflectiveOperationException roe) {
    }

    _hasDoCoordinatorAddressUpdated = hasDoCoordinatorAddressUpdated;
  }
Example #5
0
  /**
   * 将查询结构设置给对应的域(一对多)
   *
   * @param list
   * @param majorMethod
   * @param fieldName
   * @param childEntities
   * @param childClass
   * @param foreignKey
   * @throws NoSuchMethodException
   * @throws InvocationTargetException
   * @throws IllegalAccessException
   */
  private void setListValue(
      List<T> list,
      Method majorMethod,
      String fieldName,
      List<Entity> childEntities,
      Class<Entity> childClass,
      String foreignKey)
      throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    Map<Object, List<Entity>> childListMap = new HashMap<Object, List<Entity>>();

    for (Entity childEntity : childEntities) {
      Method foreignKeyMethod =
          childClass.getDeclaredMethod("get".concat(StringUtils.firstToUpperCase(foreignKey)));
      Object id = foreignKeyMethod.invoke(childEntity);

      List<Entity> childList = childListMap.get(id);
      if (childList == null) {
        childList = new ArrayList<Entity>();
        childListMap.put(id, childList);
      }
      childList.add(childEntity);
    }

    String listMethodName = "set".concat(StringUtils.firstToUpperCase(fieldName));
    for (T entity : list) {
      Object id = majorMethod.invoke(entity);
      List<Entity> childLis = childListMap.get(id);

      Method listMethod = entityClass.getDeclaredMethod(listMethodName, List.class);
      listMethod.invoke(entity, childLis);
    }
  }
  /*
   * UiAutomator has a broken longClick. getAutomatorBridge is private so we
   * access the bridge via reflection to use the touchDown / touchUp methods.
   */
  private boolean correctLongClick(final int x, final int y, final int duration) {
    try {
      /*
       * bridge.getClass() returns ShellUiAutomatorBridge on API 18/19 so use
       * the super class.
       */

      final UiDevice device = UiDevice.getInstance();
      final Object bridge = enableField(device.getClass(), "mUiAutomationBridge").get(device);
      final Object controller =
          enableField(bridge.getClass().getSuperclass(), "mInteractionController").get(bridge);
      final Class<?> controllerClass = controller.getClass();

      Logger.debug("Finding methods on class: " + controllerClass);
      final Method touchDown = controllerClass.getDeclaredMethod("touchDown", int.class, int.class);
      touchDown.setAccessible(true);
      final Method touchUp = controllerClass.getDeclaredMethod("touchUp", int.class, int.class);
      touchUp.setAccessible(true);

      if ((Boolean) touchDown.invoke(controller, x, y)) {
        SystemClock.sleep(duration);
        if ((Boolean) touchUp.invoke(controller, x, y)) {
          return true;
        }
      }
      return false;

    } catch (final Exception e) {
      Logger.debug("Problem invoking correct long click: " + e);
      return false;
    }
  }
Example #7
0
 /*package*/ static boolean isModern(Class<? extends LoadStatistics> clazz) {
   // cannot use Util.isOverridden as these are protected methods.
   boolean hasGetNodes = false;
   boolean hasMatches = false;
   while (clazz != LoadStatistics.class && clazz != null && !(hasGetNodes && hasMatches)) {
     if (!hasGetNodes) {
       try {
         final Method getNodes = clazz.getDeclaredMethod("getNodes");
         hasGetNodes = !Modifier.isAbstract(getNodes.getModifiers());
       } catch (NoSuchMethodException e) {
         // ignore
       }
     }
     if (!hasMatches) {
       try {
         final Method getNodes =
             clazz.getDeclaredMethod("matches", Queue.Item.class, SubTask.class);
         hasMatches = !Modifier.isAbstract(getNodes.getModifiers());
       } catch (NoSuchMethodException e) {
         // ignore
       }
     }
     if (!(hasGetNodes && hasMatches)
         && LoadStatistics.class.isAssignableFrom(clazz.getSuperclass())) {
       clazz = (Class<? extends LoadStatistics>) clazz.getSuperclass();
     }
   }
   return hasGetNodes && hasMatches;
 }
Example #8
0
  /**
   * 将查询结构设置给对应的域(一对一/多对一)
   *
   * @param list
   * @param keyMethod
   * @param fieldName
   * @param childEntities
   * @param childClass
   * @param fileType
   * @param refKey
   * @throws NoSuchMethodException
   * @throws InvocationTargetException
   * @throws IllegalAccessException
   */
  private void setSingleValue(
      List<T> list,
      Method keyMethod,
      String fieldName,
      List<Entity> childEntities,
      Class<Entity> childClass,
      Class<?> fileType,
      String refKey)
      throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    Map<Object, Entity> childMap = new HashMap<Object, Entity>();

    for (Entity childEntity : childEntities) {
      Method refKeyMethod =
          childClass.getDeclaredMethod("get".concat(StringUtils.firstToUpperCase(refKey)));
      Object id = refKeyMethod.invoke(childEntity);

      childMap.put(id, childEntity);
    }

    String fieldMethodName = "set".concat(StringUtils.firstToUpperCase(fieldName));
    for (T entity : list) {
      Object id = keyMethod.invoke(entity);
      Entity child = childMap.get(id);

      Method fieldMethod = entityClass.getDeclaredMethod(fieldMethodName, fileType);
      fieldMethod.invoke(entity, child);
    }
  }
Example #9
0
  public static Object invokeMethod(
      Object obj, String methodName, Class<?>[] argsClasses, Object[] args) {
    Class<?> objClass = (obj instanceof Class) ? (Class<?>) obj : obj.getClass();
    if (argsClasses == null) {
      if (args != null && args.length > 0) {
        argsClasses = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
          argsClasses[i] = args[i].getClass();
        }
      }
    }

    try {
      if (argsClasses == null || argsClasses.length == 0) {
        Method objMethod = objClass.getDeclaredMethod(methodName);
        objMethod.setAccessible(true);
        return objMethod.invoke(obj);
      } else {
        Method objMethod = objClass.getDeclaredMethod(methodName, argsClasses);
        objMethod.setAccessible(true);
        return objMethod.invoke(obj, args);
      }
    } catch (InvocationTargetException e) {
      Throwable t = e.getTargetException();
      if (t instanceof RuntimeException) {
        throw (RuntimeException) t;
      }
      throw new IllegalArgumentException(t.getMessage(), t);
    } catch (RuntimeException e) {
      throw (RuntimeException) e;
    } catch (Exception e) {
      throw new IllegalArgumentException(e.getMessage(), e);
    }
  }
 static {
   sInitialized = false;
   if (!SystemProperties.getBoolean("config.disable_renderscript", false)) {
     try {
       Class<?> vm_runtime = Class.forName("dalvik.system.VMRuntime");
       Method get_runtime = vm_runtime.getDeclaredMethod("getRuntime");
       sRuntime = get_runtime.invoke(null);
       registerNativeAllocation =
           vm_runtime.getDeclaredMethod("registerNativeAllocation", Integer.TYPE);
       registerNativeFree = vm_runtime.getDeclaredMethod("registerNativeFree", Integer.TYPE);
     } catch (Exception e) {
       Log.e(LOG_TAG, "Error loading GC methods: " + e);
       throw new RSRuntimeException("Error loading GC methods: " + e);
     }
     try {
       System.loadLibrary("rs_jni");
       _nInit();
       sInitialized = true;
       sPointerSize = rsnSystemGetPointerSize();
     } catch (UnsatisfiedLinkError e) {
       Log.e(LOG_TAG, "Error loading RS jni library: " + e);
       throw new RSRuntimeException("Error loading RS jni library: " + e);
     }
   }
 }
Example #11
0
  private static void reregisterNativeMethodsForRestoredClass(@Nonnull Class<?> realClass) {
    Method registerNatives = null;

    try {
      registerNatives = realClass.getDeclaredMethod("registerNatives");
    } catch (NoSuchMethodException ignore) {
      try {
        registerNatives = realClass.getDeclaredMethod("initIDs");
      } catch (NoSuchMethodException ignored) {
      } // OK
    }

    if (registerNatives != null) {
      try {
        registerNatives.setAccessible(true);
        registerNatives.invoke(null);
      } catch (IllegalAccessException ignore) {
      } // won't happen
      catch (InvocationTargetException ignore) {
      } // shouldn't happen either
    }

    // OK, although another solution will be required for this particular class if it requires
    // natives to be explicitly registered again (not all do, such as java.lang.Float).
  }
 /**
  * Opens the specified web page in the user's default browser
  *
  * @param url A web address (URL) of a web page (ex: "http://www.google.com/")
  */
 public static void openURL(String url) {
   try { // attempt to use Desktop library from JDK 1.6+ (even if on 1.5)
     Class<?> d = Class.forName("java.awt.Desktop");
     d.getDeclaredMethod("browse", new Class[] {java.net.URI.class})
         .invoke(
             d.getDeclaredMethod("getDesktop").invoke(null),
             new Object[] {java.net.URI.create(url)});
     // above code mimics:
     //   java.awt.Desktop.getDesktop().browse(java.net.URI.create(url));
   } catch (Exception ignore) { // library not available or failed
     String osName = System.getProperty("os.name");
     try {
       if (osName.startsWith("Mac OS")) {
         Class.forName("com.apple.eio.FileManager")
             .getDeclaredMethod("openURL", new Class[] {String.class})
             .invoke(null, new Object[] {url});
       } else if (osName.startsWith("Windows"))
         Runtime.getRuntime().exec("rundll32 url.dll,FileProtocolHandler " + url);
       else { // assume Unix or Linux
         boolean found = false;
         for (String browser : browsers)
           if (!found) {
             found = Runtime.getRuntime().exec(new String[] {"which", browser}).waitFor() == 0;
             if (found) Runtime.getRuntime().exec(new String[] {browser, url});
           }
         if (!found) throw new Exception(Arrays.toString(browsers));
       }
     } catch (Exception e) {
       JOptionPane.showMessageDialog(null, errMsg + "\n" + e.toString());
     }
   }
 }
Example #13
0
  /**
   * Retrieves setter method of a field.
   *
   * @param classType class type
   * @param fieldName field name
   * @param paramType return type
   * @return Method setter method of field
   * @throws NoSuchMethodException thrown if method is not found
   */
  public static Method getSetterMethod(Class<?> classType, String fieldName, Class<?> paramType)
      throws NoSuchMethodException {

    String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
    Method m = null;
    NoSuchMethodException firstException = null;

    while (paramType != null && m == null) {
      try {
        m = classType.getDeclaredMethod(methodName, paramType);
      } catch (NoSuchMethodException e) {
        if (firstException == null) {
          firstException = e;
        }
        for (Class<?> interfaceClass : paramType.getInterfaces()) {
          try {
            m = classType.getDeclaredMethod(methodName, interfaceClass);
          } catch (NoSuchMethodException e1) {

          }
        }
        paramType = paramType.getSuperclass();
      }
    }

    if (m == null && firstException != null) {
      throw firstException;
    }

    return m;
  }
  @Override
  public Method resolveInternal() {
    Class<?> parentClass = parent.resolve();
    if (parentClass == null) return null;

    List<Class<?>> argClasses = Lists.newLinkedList();
    for (ClassRef argType : argTypes) {
      if (argType.resolve() == null) return null;
      argClasses.add(argType.resolve());
    }
    Class<?>[] args = argClasses.toArray(new Class<?>[0]);

    Method methodObj;
    try {
      methodObj = parentClass.getDeclaredMethod(srgName, args);
      methodObj.setAccessible(true);
      return methodObj;
    } catch (Exception e) {
    }

    try {
      methodObj = parentClass.getDeclaredMethod(mcpName, args);
      methodObj.setAccessible(true);
      return methodObj;
    } catch (Exception e) {
    }
    return null;
  }
Example #15
0
 public static boolean updateLanguage(Locale locale) {
   try {
     Object objIActMag, objActMagNative;
     Class<?> clzIActMag = Class.forName("android.app.IActivityManager");
     Class<?> clzActMagNative = Class.forName("android.app.ActivityManagerNative");
     Method mtdActMagNative$getDefault = clzActMagNative.getDeclaredMethod("getDefault");
     // IActivityManager iActMag = ActivityManagerNative.getDefault();
     objIActMag = mtdActMagNative$getDefault.invoke(clzActMagNative);
     // Configuration config = iActMag.getConfiguration();
     Method mtdIActMag$getConfiguration = clzIActMag.getDeclaredMethod("getConfiguration");
     Configuration config = (Configuration) mtdIActMag$getConfiguration.invoke(objIActMag);
     config.locale = locale;
     // iActMag.updateConfiguration(config);
     // 此处需要声明权限:android.permission.CHANGE_CONFIGURATION
     // 会重新调用 onCreate();
     Class<?>[] clzParams = {Configuration.class};
     Method mtdIActMag$updateConfiguration =
         clzIActMag.getDeclaredMethod("updateConfiguration", clzParams);
     mtdIActMag$updateConfiguration.invoke(objIActMag, config);
     return true;
   } catch (Exception e) {
     e.printStackTrace();
   }
   return false;
 }
Example #16
0
  /** 初始化class的method和verfiyclass的method */
  private static void initMethod() {
    Set<Entry<Object, Object>> set = prop.entrySet();
    String key = null;
    String value = null;
    for (Entry<Object, Object> entry : set) {
      key = String.valueOf(entry.getKey());
      value = null != entry.getValue() ? String.valueOf(entry.getValue()) : null;

      if (endWithString(key, value, SUFFIX_CLASS)) {
        Class<?> c;
        Method method = null;
        try {
          c = Class.forName(value);
          method = c.getDeclaredMethod(PROCESS, Param.class);
        } catch (Exception e) {
          System.err.println("init class error:" + value);
          e.printStackTrace();
        }
        classMap.put(key, method);
      } else if (endWithString(key, value, SUFFIX_VERIFY_CLASS)) {
        Class<?> c;
        Method method = null;
        try {
          c = Class.forName(value);
          method = c.getDeclaredMethod(VERIFY, Param.class);
        } catch (Exception e) {
          System.err.println("init class error:" + value);
          e.printStackTrace();
        }
        verifyClassMap.put(key, method);
      }
    }
    set = null;
    key = value = null;
  }
  public static boolean validClass(Class<?> clazz) {
    try {
      Method serialize = clazz.getDeclaredMethod("serialize");
      if (!serialize.getReturnType().equals(String.class)) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not serializable because it does not return a String");
        return false;
      }
      if (!Modifier.isPublic(serialize.getModifiers())) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not serializable because the method 'serialize' is not public");
        return false;
      }
      if (!Modifier.isStatic(serialize.getModifiers())) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not serializable because the method 'serialize' is static");
        return false;
      }

      Method deserialize = clazz.getDeclaredMethod("deserialize", String.class);
      if (!deserialize.getReturnType().equals(clazz)) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not deserializable because the method 'deserialize' does not return the class '"
                + clazz.getCanonicalName()
                + "'");
        return false;
      }

      if (!Modifier.isStatic(deserialize.getModifiers())) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not deserializable because the method 'deserialize' is not static");
        return false;
      }
      if (!Modifier.isPublic(deserialize.getModifiers())) {
        System.out.println(
            "Class '"
                + clazz.getCanonicalName()
                + "' is not deserializable because the method 'deserialize' is not public");
        return false;
      }
    } catch (NoSuchMethodException e) {
      System.out.println(
          "Class '"
              + clazz.getCanonicalName()
              + "' is not deserializable because the method 'deserialize' is does not have either the serialize and/or deserialize method(s)");
      return false;
    }
    return true;
  }
  public static void main(String[] args) throws Exception {
    int[] team1 = {7, 2, 3};
    int[] team2 = {1, 6, 4};

    System.out.println("dumbPhotoShoot = " + dumbPhotoShoot(team1, team2));
    System.out.println("photoShoot = " + photoShoot(team1, team2));

    // Benchmark
    int[] team3 = new int[10];
    int[] team4 = new int[10];
    for (int i = 0; i < 10; i++) {
      team3[i] = (int) (Math.floor(Math.random() * 100) + 1);
      team4[i] = team3[i] + 3; // guarantee a true result, which is worst-case scenario
    }
    int N = 1000000;
    String[] methodsToCompare = {"dumbPhotoShoot", "photoShoot"};
    for (String methodName : methodsToCompare) {
      Class clazz = Class.forName("book.chapter.thirteen.Problem13_06");
      Method method = clazz.getDeclaredMethod(methodName, int[].class, int[].class);

      // Time execution of the reflected method.
      long startTime = System.nanoTime();
      for (int i = 0; i < N; i++) {
        Boolean retVal = (Boolean) method.invoke(null, team3, team4);
        if (retVal == false) throw new Exception("wrong result!");
      }
      long endTime = System.nanoTime();
      System.out.println(
          "Elapsed (worst case) time for "
              + methodName
              + ": "
              + (endTime - startTime) / 1000000000.0
              + " seconds");
    }

    for (int i = 0; i < 10; i++) {
      team3[i] = (int) (Math.floor(Math.random() * 100) + 1);
      team4[i] = team3[i] + 3;
    }
    team4[2] = -1; // guarantee a false result on element 2, which is best-case
    for (String methodName : methodsToCompare) {
      Class clazz = Class.forName("book.chapter.thirteen.Problem13_06");
      Method method = clazz.getDeclaredMethod(methodName, int[].class, int[].class);

      // Time execution of the reflected method.
      long startTime = System.nanoTime();
      for (int i = 0; i < N; i++) {
        Boolean retVal = (Boolean) method.invoke(null, team3, team4);
        if (retVal == true) throw new Exception("wrong result!");
      }
      long endTime = System.nanoTime();
      System.out.println(
          "Elapsed (best case) time for "
              + methodName
              + ": "
              + (endTime - startTime) / 1000000000.0
              + " seconds");
    }
  }
  @SuppressWarnings("unchecked")
  public VolatileCode_Unknown() throws Exception {
    String versionString =
        Bukkit.getServer()
            .getClass()
            .getName()
            .replace("org.bukkit.craftbukkit.", "")
            .replace("CraftServer", "");
    String nmsPackageString = "net.minecraft.server." + versionString;
    String obcPackageString = "org.bukkit.craftbukkit." + versionString;

    classWorld = Class.forName(nmsPackageString + "World");

    classEntityVillager = Class.forName(nmsPackageString + "EntityVillager");
    classEntityVillagerConstructor = classEntityVillager.getConstructor(classWorld);
    Field[] fields = classEntityVillager.getDeclaredFields();
    for (Field field : fields) {
      if (field.getType().getName().endsWith("MerchantRecipeList")) {
        recipeListField = field;
        break;
      }
    }
    recipeListField.setAccessible(true);
    Method[] methods = classEntityVillager.getDeclaredMethods();
    for (Method method : methods) {
      if (method.getReturnType() == boolean.class
          && method.getParameterTypes().length == 1
          && method.getParameterTypes()[0].getName().endsWith("EntityHuman")) {
        openTradeMethod = method;
        break;
      }
    }
    openTradeMethod.setAccessible(true);

    classEntityInsentient = Class.forName(nmsPackageString + "EntityInsentient");
    setCustomNameMethod = classEntityInsentient.getDeclaredMethod("setCustomName", String.class);

    classNMSItemStack = Class.forName(nmsPackageString + "ItemStack");

    classCraftItemStack = Class.forName(obcPackageString + "inventory.CraftItemStack");
    asNMSCopyMethod = classCraftItemStack.getDeclaredMethod("asNMSCopy", ItemStack.class);

    classMerchantRecipe = Class.forName(nmsPackageString + "MerchantRecipe");
    merchantRecipeConstructor =
        classMerchantRecipe.getConstructor(classNMSItemStack, classNMSItemStack, classNMSItemStack);
    maxUsesField = classMerchantRecipe.getDeclaredField("maxUses");
    maxUsesField.setAccessible(true);

    classMerchantRecipeList = Class.forName(nmsPackageString + "MerchantRecipeList");
    // clearMethod = classMerchantRecipeList.getMethod("clear");
    // addMethod = classMerchantRecipeList.getMethod("add", Object.class);

    classCraftPlayer = Class.forName(obcPackageString + "entity.CraftPlayer");
    craftPlayerGetHandle = classCraftPlayer.getDeclaredMethod("getHandle");

    classEntity = Class.forName(nmsPackageString + "Entity");
    worldField = classEntity.getDeclaredField("world");
  }
  /** @see DATACMNS-393 */
  @Test
  public void detectsOverloadedMethodsCorrectly() throws Exception {

    Class<RepositoryWithAllCrudMethodOverloaded> type = RepositoryWithAllCrudMethodOverloaded.class;
    assertFindOneMethodOn(type, type.getDeclaredMethod("findOne", Long.class));
    assertDeleteMethodOn(type, type.getDeclaredMethod("delete", Long.class));
    assertSaveMethodOn(type, type.getDeclaredMethod("save", Domain.class));
    assertFindAllMethodOn(type, type.getDeclaredMethod("findAll"));
  }
  public static void botonFinalizar() {
    // Buscamos si hay una clase hija de BaremacionFAP que implemente un método de
    // chequeo de condiciones para finalizar la baremacion individual
    Class invokedClass = null;
    // Busca una clase que herede de BaremacionFAP
    List<Class> assignableClasses = Play.classloader.getAssignableClasses(BaremacionFAP.class);
    if (assignableClasses.size() > 0) {
      invokedClass = assignableClasses.get(0);
    } else {
      invokedClass = BaremacionFAP.class;
    }
    if (invokedClass != null) {
      Method method = null;
      try {
        method = invokedClass.getDeclaredMethod("checkFinalizarEvaluacion", Evaluacion.class);
      } catch (Exception ex) {
        invokedClass = BaremacionFAP.class;
        if (invokedClass != null) {
          method = null;
          try {
            method = invokedClass.getDeclaredMethod("checkFinalizarEvaluacion", Evaluacion.class);
          } catch (Exception e) {
            play.Logger.error(
                "Error: No se ha podido encontrar el método checkFinalizarEvaluacion de la clase BaremacionApp");
            Messages.error(
                "Error: No se ha podido ejecutar el método checkFinalizarEvaluacion correctamente");
          }
        }
      }

      if (!Messages.hasErrors()) {
        boolean resultado = false;
        if (method != null) {
          try {
            Long idEvaluacion = Long.parseLong(params.get("idEvaluacion"));
            Evaluacion evaluacion = Evaluacion.findById(idEvaluacion);
            resultado = (Boolean) method.invoke(ConsultarEvaluacionesController.class, evaluacion);
          } catch (Exception e) {
            play.Logger.error(
                "Error: No se ha podido invocar el método checkFinalizarEvaluacion de la clase BaremacionFAP");
            Messages.error(
                "Error: No se ha podido ejecutar el metodo checkFinalizarEvaluacion correctamente");
          }
        } else {
          play.Logger.error(
              "Error: No existe el Método apropiado para validar checkFinalizarEvaluacion");
          Messages.error("Error: No se ha podido ejecutar checkFinalizarEvaluacion correctamente");
        }
        if (!resultado) {
          play.Logger.error(
              "Error: La evaluación no cumple las condiciones indicadas en checkFinalizarEvaluacion");
          Messages.error(
              "Error: La evaluación no cumple las condiciones indicadas en checkFinalizarEvaluacion");
        }
      }
    }
  }
Example #22
0
 private RitualType(String cl, String add, String test, Class... args) {
   try {
     type = Class.forName(cl);
     addRitual = type.getDeclaredMethod(add, args);
     testPlayer = type.getDeclaredMethod(test, EntityPlayer.class);
   } catch (Exception e) {
     System.out.println("Could not construct ritual type " + this + "!");
     e.printStackTrace();
   }
 }
 public static Method getMethod(
     Class<? extends Object> thisClass, String methodName, Class<?> parameter)
     throws SecurityException, NoSuchMethodException {
   Method method = null;
   if (null == parameter) {
     method = thisClass.getDeclaredMethod(methodName);
   } else {
     method = thisClass.getDeclaredMethod(methodName, parameter);
   }
   method.setAccessible(true);
   return method;
 }
Example #24
0
  static GCMParameters extractGcmParameters(AlgorithmParameterSpec paramSpec)
      throws InvalidParameterSpecException {
    try {
      Method tLen = gcmSpecClass.getDeclaredMethod("getTLen", new Class[0]);
      Method iv = gcmSpecClass.getDeclaredMethod("getIV", new Class[0]);

      return new GCMParameters(
          (byte[]) iv.invoke(paramSpec, new Object[0]),
          ((Integer) tLen.invoke(paramSpec, new Object[0])).intValue() / 8);
    } catch (Exception e) {
      throw new InvalidParameterSpecException("Cannot process GCMParameterSpec");
    }
  }
  private static void init() {
    try {
      if (mClassType == null) {
        mClassType = Class.forName("android.os.SystemProperties");

        mGetMethod = mClassType.getDeclaredMethod("get", String.class);
        mGetIntMethod = mClassType.getDeclaredMethod("getInt", String.class, int.class);
        mGetBooleanMethod = mClassType.getDeclaredMethod("getBoolean", String.class, boolean.class);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public void setPageTransformer(
      boolean reverseDrawingOrder, ViewPager.PageTransformer transformer) {
    /**
     * 继承ViewPager,重写setPageTransformer方法,移除版本限制,通过反射设置参数和方法
     *
     * <p>getDeclaredMethod*()获取的是【类自身】声明的所有方法,包含public、protected和private方法。
     * getMethod*()获取的是类的所有共有方法,这就包括自身的所有【public方法】,和从基类继承的、从接口实现的所有【public方法】。
     *
     * <p>getDeclaredField获取的是【类自身】声明的所有字段,包含public、protected和private字段。
     * getField获取的是类的所有共有字段,这就包括自身的所有【public字段】,和从基类继承的、从接口实现的所有【public字段】。
     */
    Class viewpagerClass = ViewPager.class;

    try {
      boolean hasTransformer = transformer != null;

      Field pageTransformerField = viewpagerClass.getDeclaredField("mPageTransformer");
      pageTransformerField.setAccessible(true);
      PageTransformer mPageTransformer = (PageTransformer) pageTransformerField.get(this);

      boolean needsPopulate = hasTransformer != (mPageTransformer != null);
      pageTransformerField.set(this, transformer);

      Method setChildrenDrawingOrderEnabledCompatMethod =
          viewpagerClass.getDeclaredMethod("setChildrenDrawingOrderEnabledCompat", boolean.class);
      setChildrenDrawingOrderEnabledCompatMethod.setAccessible(true);
      setChildrenDrawingOrderEnabledCompatMethod.invoke(this, hasTransformer);

      Field drawingOrderField = viewpagerClass.getDeclaredField("mDrawingOrder");
      drawingOrderField.setAccessible(true);
      if (hasTransformer) {
        drawingOrderField.setInt(this, reverseDrawingOrder ? 2 : 1);
      } else {
        drawingOrderField.setInt(this, 0);
      }

      if (needsPopulate) {
        Method populateMethod = viewpagerClass.getDeclaredMethod("populate");
        populateMethod.setAccessible(true);
        populateMethod.invoke(this);
      }
    } catch (NoSuchFieldException e) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    } catch (InvocationTargetException e) {
      e.printStackTrace();
    }
  }
Example #27
0
 /*
  * Locates the Java methods for calling methods on {@code MethodType} instances, if those are available.
  */
 static {
   JavaMethod returnType, parameterArray;
   try {
     Class<?> methodType = JavaType.METHOD_TYPE.load();
     returnType = new JavaMethod.ForLoadedMethod(methodType.getDeclaredMethod("returnType"));
     parameterArray =
         new JavaMethod.ForLoadedMethod(methodType.getDeclaredMethod("parameterArray"));
   } catch (Exception ignored) {
     returnType = JavaMethod.ForUnavailableMethod.INSTANCE;
     parameterArray = JavaMethod.ForUnavailableMethod.INSTANCE;
   }
   RETURN_TYPE = returnType;
   PARAMETER_ARRAY = parameterArray;
 }
Example #28
0
 public static void loadAgent(Path agent) throws Exception {
   String vmName = ManagementFactory.getRuntimeMXBean().getName();
   int p = vmName.indexOf('@');
   assumeTrue(p != -1);
   String pid = vmName.substring(0, p);
   ClassLoader cl = ToolProvider.getSystemToolClassLoader();
   Class<?> c = Class.forName("com.sun.tools.attach.VirtualMachine", true, cl);
   Method attach = c.getDeclaredMethod("attach", String.class);
   Method loadAgent = c.getDeclaredMethod("loadAgent", String.class, String.class);
   Method detach = c.getDeclaredMethod("detach");
   Object vm = attach.invoke(null, pid);
   loadAgent.invoke(vm, agent.toString(), "");
   detach.invoke(vm);
 }
Example #29
0
 public static void checkShapesImplementEquals(Class[] classes) {
   for (Class clazz : classes) {
     try {
       clazz.getDeclaredMethod("equals", Object.class);
     } catch (Exception e) {
       fail("Shape needs to define 'equals' : " + clazz.getName());
     }
     try {
       clazz.getDeclaredMethod("hashCode");
     } catch (Exception e) {
       fail("Shape needs to define 'hashCode' : " + clazz.getName());
     }
   }
 }
Example #30
0
  private boolean evaluateConditions(Logger LOG, Injector injector, Module module)
      throws Exception {
    LOG.info("Evaluating module {}", module.getClass().getName());

    // The class may have multiple Conditional annotations
    for (Annotation annot : module.getClass().getAnnotations()) {
      Conditional conditional = annot.annotationType().getAnnotation(Conditional.class);
      if (conditional != null) {
        // A Conditional may have a list of multiple Conditions
        for (Class<? extends Condition> condition : conditional.value()) {
          try {
            // Construct the condition using Guice so that anything may be injected into
            // the condition
            Condition c = injector.getInstance(condition);
            // Look for method signature : boolean check(T annot)
            // where T is the annotation type.  Note that the same checker will be used
            // for all conditions of the same annotation type.
            try {
              Method check = condition.getDeclaredMethod("check", annot.annotationType());
              if (!(boolean) check.invoke(c, annot)) {
                LOG.info("  - {}", formatConditional(annot));
                return false;
              }
            }
            // If not found, look for method signature
            //      boolean check();
            catch (NoSuchMethodException e) {
              Method check = condition.getDeclaredMethod("check");
              if (!(boolean) check.invoke(c)) {
                LOG.info("  - {}", formatConditional(annot));
                return false;
              }
            }

            LOG.info("  + {}", formatConditional(annot));
          } catch (Exception e) {
            LOG.info("  - {}", formatConditional(annot));
            throw new Exception(
                "Failed to check condition '"
                    + condition
                    + "' on module '"
                    + module.getClass()
                    + "'");
          }
        }
      }
    }
    return true;
  }