/**
   * Does basic sanity checks to make sure the constructor can be properly invoked by our generated
   * class.
   *
   * @param clazz
   */
  private void validateClass(Class<? extends DataSerializable> clazz) {
    Assert.isTrue(
        !Modifier.isAbstract(clazz.getModifiers()), "Cannot instantiate abstract classes");
    Assert.isTrue(Modifier.isPublic(clazz.getModifiers()), "Only public classes are supported");
    try {
      Constructor<? extends DataSerializable> ctor = clazz.getConstructor();
      Assert.isTrue(Modifier.isPublic(ctor.getModifiers()), "Default constructor is not public");

    } catch (Exception ex) {
      throw new IllegalArgumentException("Class " + clazz + " unsuitable for instantiation", ex);
    }
  }
  // -----------------------------------------------------------------------
  public void testSingleton() throws Exception {
    Class cls = NullConverter.class;
    assertEquals(false, Modifier.isPublic(cls.getModifiers()));
    assertEquals(false, Modifier.isProtected(cls.getModifiers()));
    assertEquals(false, Modifier.isPrivate(cls.getModifiers()));

    Constructor con = cls.getDeclaredConstructor((Class[]) null);
    assertEquals(1, cls.getDeclaredConstructors().length);
    assertEquals(true, Modifier.isProtected(con.getModifiers()));

    Field fld = cls.getDeclaredField("INSTANCE");
    assertEquals(false, Modifier.isPublic(fld.getModifiers()));
    assertEquals(false, Modifier.isProtected(fld.getModifiers()));
    assertEquals(false, Modifier.isPrivate(fld.getModifiers()));
  }
  private void generateConstructors(JavaClass jClass, String superClassName) {
    for (Constructor baseCtor : _cl.getDeclaredConstructors()) {
      if (Modifier.isPrivate(baseCtor.getModifiers())) continue;

      generateConstructor(jClass, superClassName, baseCtor);
    }
  }
示例#4
0
 public static JoinPoint.StaticPart makeEncSJP(Member member) {
   Signature sig = null;
   String kind = null;
   if (member instanceof Method) {
     Method method = (Method) member;
     sig =
         new MethodSignatureImpl(
             method.getModifiers(),
             method.getName(),
             method.getDeclaringClass(),
             method.getParameterTypes(),
             new String[method.getParameterTypes().length],
             method.getExceptionTypes(),
             method.getReturnType());
     kind = JoinPoint.METHOD_EXECUTION;
   } else if (member instanceof Constructor) {
     Constructor cons = (Constructor) member;
     sig =
         new ConstructorSignatureImpl(
             cons.getModifiers(),
             cons.getDeclaringClass(),
             cons.getParameterTypes(),
             new String[cons.getParameterTypes().length],
             cons.getExceptionTypes());
     kind = JoinPoint.CONSTRUCTOR_EXECUTION;
   } else {
     throw new IllegalArgumentException("member must be either a method or constructor");
   }
   return new JoinPointImpl.EnclosingStaticPartImpl(-1, kind, sig, null);
 }
示例#5
0
 /** Checks whether the constructor parsed from API xml file and Java reflection are compliant. */
 @SuppressWarnings("unchecked")
 private void checkConstructorCompliance() {
   for (JDiffConstructor con : jDiffConstructors) {
     try {
       Constructor<?> c = findMatchingConstructor(con);
       if (c == null) {
         mResultObserver.notifyFailure(
             SignatureTestActivity.FAILURE_TYPE.MISSING_METHOD,
             con.toReadableString(mAbsoluteClassName),
             "No method with correct signature found:" + con.toSignatureString());
       } else {
         if (c.isVarArgs()) { // some method's parameter are variable args
           con.mModifier |= METHOD_MODIFIER_VAR_ARGS;
         }
         if (c.getModifiers() != con.mModifier) {
           mResultObserver.notifyFailure(
               SignatureTestActivity.FAILURE_TYPE.MISMATCH_METHOD,
               con.toReadableString(mAbsoluteClassName),
               "Non-compatible method found when looking for " + con.toSignatureString());
         }
       }
     } catch (Exception e) {
       SignatureTestLog.e("Got exception when checking constructor compliance", e);
       mResultObserver.notifyFailure(
           SignatureTestActivity.FAILURE_TYPE.CAUGHT_EXCEPTION,
           con.toReadableString(mAbsoluteClassName),
           "Exception!");
     }
   }
 }
 @SuppressWarnings("unchecked")
 private boolean hasValidConstructor(java.lang.Class<?> aClass) {
   // The cast below is not necessary with the Java 5 compiler, but necessary with the Java 6
   // compiler,
   // where the return type of Class.getDeclaredConstructors() was changed
   // from Constructor<T>[] to Constructor<?>[]
   Constructor<? extends TestCase>[] constructors =
       (Constructor<? extends TestCase>[]) aClass.getConstructors();
   for (Constructor<? extends TestCase> constructor : constructors) {
     if (Modifier.isPublic(constructor.getModifiers())) {
       java.lang.Class<?>[] parameterTypes = constructor.getParameterTypes();
       if (parameterTypes.length == 0
           || (parameterTypes.length == 1 && parameterTypes[0] == String.class)) {
         return true;
       }
     }
   }
   Log.i(
       LOG_TAG,
       String.format(
           "TestCase class %s is missing a public constructor with no parameters "
               + "or a single String parameter - skipping",
           aClass.getName()));
   return false;
 }
示例#7
0
 /**
  * Make the given constructor accessible, explicitly setting it accessible if necessary. The
  * <code>setAccessible(true)</code> method is only called when actually necessary, to avoid
  * unnecessary conflicts with a JVM SecurityManager (if active).
  *
  * @param ctor the constructor to make accessible
  * @see java.lang.reflect.Constructor#setAccessible
  */
 public static void makeAccessible(Constructor<?> ctor) {
   if ((!Modifier.isPublic(ctor.getModifiers())
           || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers()))
       && !ctor.isAccessible()) {
     ctor.setAccessible(true);
   }
 }
示例#8
0
 public static <T> Constructor<T> findConstructor(Class<T> cls, boolean canFixAccess)
     throws IllegalArgumentException {
   try {
     Constructor<T> ctor = cls.getDeclaredConstructor();
     if (canFixAccess) {
       checkAndFixAccess(ctor);
     } else {
       // Has to be public...
       if (!Modifier.isPublic(ctor.getModifiers())) {
         throw new IllegalArgumentException(
             "Default constructor for "
                 + cls.getName()
                 + " is not accessible (non-public?): not allowed to try modify access via Reflection: can not instantiate type");
       }
     }
     return ctor;
   } catch (NoSuchMethodException e) {;
   } catch (Exception e) {
     ClassUtil.unwrapAndThrowAsIAE(
         e,
         "Failed to find default constructor of class "
             + cls.getName()
             + ", problem: "
             + e.getMessage());
   }
   return null;
 }
 /**
  * Test to see if a private Constructor exists.
  *
  * @throws Exception to JUnit, indicates error
  */
 @Test
 public void testPrivateCtor() throws Exception {
   Constructor<?> privateCtor = Helper.class.getDeclaredConstructors()[0];
   assertTrue(Modifier.isPrivate(privateCtor.getModifiers()));
   privateCtor.setAccessible(true);
   privateCtor.newInstance(new Object[] {});
 }
示例#10
0
  /**
   * Finds constructors of the specified access level in the supplied class.
   *
   * @param c the class to search in
   * @param level the access level to look for
   * @param sb the StringBuffer where the results should be added
   */
  private static void listConstructors(Class c, int level, StringBuffer sb) {
    Constructor[] constrs = c.getDeclaredConstructors();
    Constructor constructor;
    Class[] exceptions;
    StringBuffer cons;

    for (int index = 0; index < constrs.length; index++) {
      constructor = constrs[index];
      if (isAccessible(constructor.getModifiers(), level)) {
        cons = new StringBuffer(100);
        cons.append(printConstructor(constructor.getName(), constructor.getParameterTypes()));
        // Add exceptions
        exceptions = constructor.getExceptionTypes();

        if (exceptions.length > 0) {
          cons.append(printExceptions(exceptions));
        } else {
          cons.append(NIL);
        }
        cons.append(END_PAREN);
        if (sb.toString().lastIndexOf(cons.toString()) == -1) {
          sb.append(cons);
        }
      }
    }
  }
示例#11
0
 /**
  * Tests the private constructor.
  *
  * @throws Exception if oops
  */
 @Test
 public void testConstructorIsPrivate() throws Exception {
   Constructor<Sanity> constructor = Sanity.class.getDeclaredConstructor();
   Assert.assertTrue(Modifier.isPrivate(constructor.getModifiers()));
   constructor.setAccessible(true);
   constructor.newInstance();
 }
示例#12
0
 @Test
 public void checkThatConstructorIsProtected() {
   for (Constructor<?> constr : Earth.class.getDeclaredConstructors()) {
     assertTrue(
         "Constructors should be protected to allow subclasses of singleton",
         Modifier.isProtected(constr.getModifiers()));
   }
 }
  @Test
  public void testConstructorIsPrivate() throws Exception {
    Constructor<ReflectionUtils> con = ReflectionUtils.class.getDeclaredConstructor();
    Assert.assertEquals(Modifier.PRIVATE, con.getModifiers() & Modifier.PRIVATE);
    con.setAccessible(true);

    Assert.assertNotNull(con.newInstance());
  }
示例#14
0
 public boolean isConstructorAccessibleForDecoding(Class clazz) {
   try {
     Constructor constr = clazz.getDeclaredConstructor(null);
     return isWithin(constr.getModifiers(), decodingAccessScope.get(CONSTRUCTOR_SCOPE));
   } catch (Exception e) {
     return false;
   }
 }
 /** java.lang.reflect.InvocationTargetException#InvocationTargetException() */
 public void test_Constructor() throws Exception {
   Constructor<InvocationTargetException> ctor =
       InvocationTargetException.class.getDeclaredConstructor();
   assertNotNull("Parameterless constructor does not exist.", ctor);
   assertTrue("Constructor is not protected", Modifier.isProtected(ctor.getModifiers()));
   // create an instance of a subtype using this constructor
   SubInvocationTargetException subException = new SubInvocationTargetException();
 }
示例#16
0
  private Class<?> loadBeanClass() {
    if (beanClass == null) {
      String className = beanInfo.getClassName();
      Class<?> clazz = loadClass(className);
      ApplicationAssociate associate = ApplicationAssociate.getCurrentInstance();

      if (!associate.isDevModeEnabled()) {
        beanClass = clazz;
      }

      // validate the bean class is public and has a public
      // no-arg ctor
      int classModifiers = clazz.getModifiers();
      if (!Modifier.isPublic(classModifiers)) {
        String message =
            MessageUtils.getExceptionMessageString(
                MessageUtils.MANAGED_BEAN_CLASS_IS_NOT_PUBLIC_ERROR_ID,
                className,
                beanInfo.getName());
        queueMessage(message);
      }
      if (Modifier.isInterface(classModifiers) || Modifier.isAbstract(classModifiers)) {
        String message =
            MessageUtils.getExceptionMessageString(
                MessageUtils.MANAGED_BEAN_CLASS_IS_ABSTRACT_ERROR_ID,
                className,
                beanInfo.getName());
        queueMessage(message);
      }

      try {
        Constructor ctor = clazz.getConstructor(RIConstants.EMPTY_CLASS_ARGS);
        if (!Modifier.isPublic(ctor.getModifiers())) {
          String message =
              MessageUtils.getExceptionMessageString(
                  MessageUtils.MANAGED_BEAN_CLASS_NO_PUBLIC_NOARG_CTOR_ERROR_ID,
                  className,
                  beanInfo.getName());
          queueMessage(message);
        }
      } catch (NoSuchMethodException nsme) {
        String message =
            MessageUtils.getExceptionMessageString(
                MessageUtils.MANAGED_BEAN_CLASS_NO_PUBLIC_NOARG_CTOR_ERROR_ID,
                className,
                beanInfo.getName());
        queueMessage(message);
      }

      if (!hasMessages()) {
        // class is ok, scan for annotations
        this.isInjectible = scanForAnnotations(clazz);
      }
      return clazz;
    }
    return beanClass;
  }
示例#17
0
 @Test
 public void constructorShouldBePrivate()
     throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
         InstantiationException {
   Constructor<MultiDex> constructor = MultiDex.class.getDeclaredConstructor();
   assertTrue(Modifier.isPrivate(constructor.getModifiers()));
   constructor.setAccessible(true);
   constructor.newInstance();
 }
示例#18
0
 @Test
 public void testConstructor() throws Exception {
   Class<HMAC> c = HMAC.class;
   assertEquals(1, c.getDeclaredConstructors().length);
   Constructor<HMAC> constructor = c.getDeclaredConstructor();
   assertTrue(Modifier.isPrivate(constructor.getModifiers()));
   constructor.setAccessible(true);
   constructor.newInstance();
 }
 public void setConstructor(Constructor<?> constructor, List<String> fields) {
   check(implInterface || !dataTypeIn.isInterface());
   checkNotNull(constructor);
   checkNotNull(fields);
   check(this.constructor == null, "Constructor is already set: %s", this.constructor);
   check(!isPrivate(constructor.getModifiers()), "Constructor cannot be private: %s", constructor);
   check(constructor.getGenericParameterTypes().length == fields.size());
   this.constructor = constructor;
   this.constructorParams = fields;
 }
 /**
  * This method tests the private constructor of {@code Descriptions} for the tests coverage..
  *
  * @throws NoSuchMethodException
  * @throws SecurityException
  * @throws java.lang.reflect.InvocationTargetException
  * @throws IllegalAccessException
  * @throws InstantiationException
  * @throws IllegalArgumentException
  */
 @Test
 public void test_private_constructor_for_the_tests_coverage()
     throws SecurityException, NoSuchMethodException, IllegalArgumentException,
         InstantiationException, IllegalAccessException, InvocationTargetException {
   Constructor<Descriptions> constructor = Descriptions.class.getDeclaredConstructor();
   assertThat(Modifier.isPrivate(constructor.getModifiers())).isTrue();
   constructor.setAccessible(true);
   constructor.newInstance();
   constructor.setAccessible(false);
 }
示例#21
0
  /**
   * Returns a new injection point for the injectable constructor of {@code type}.
   *
   * @param type a concrete type with exactly one constructor annotated {@literal @}{@link Inject},
   *     or a no-arguments constructor that is not private.
   * @throws ConfigurationException if there is no injectable constructor, more than one injectable
   *     constructor, or if parameters of the injectable constructor are malformed, such as a
   *     parameter with multiple binding annotations.
   */
  public static InjectionPoint forConstructorOf(TypeLiteral<?> type) {
    Class<?> rawType = getRawType(type.getType());
    Errors errors = new Errors(rawType);

    Constructor<?> injectableConstructor = null;
    for (Constructor<?> constructor : rawType.getDeclaredConstructors()) {

      boolean optional;
      Inject guiceInject = constructor.getAnnotation(Inject.class);
      if (guiceInject == null) {
        javax.inject.Inject javaxInject = constructor.getAnnotation(javax.inject.Inject.class);
        if (javaxInject == null) {
          continue;
        }
        optional = false;
      } else {
        optional = guiceInject.optional();
      }

      if (optional) {
        errors.optionalConstructor(constructor);
      }

      if (injectableConstructor != null) {
        errors.tooManyConstructors(rawType);
      }

      injectableConstructor = constructor;
      checkForMisplacedBindingAnnotations(injectableConstructor, errors);
    }

    errors.throwConfigurationExceptionIfErrorsExist();

    if (injectableConstructor != null) {
      return new InjectionPoint(type, injectableConstructor);
    }

    // If no annotated constructor is found, look for a no-arg constructor instead.
    try {
      Constructor<?> noArgConstructor = rawType.getDeclaredConstructor();

      // Disallow private constructors on non-private classes (unless they have @Inject)
      if (Modifier.isPrivate(noArgConstructor.getModifiers())
          && !Modifier.isPrivate(rawType.getModifiers())) {
        errors.missingConstructor(rawType);
        throw new ConfigurationException(errors.getMessages());
      }

      checkForMisplacedBindingAnnotations(noArgConstructor, errors);
      return new InjectionPoint(type, noArgConstructor);
    } catch (NoSuchMethodException e) {
      errors.missingConstructor(rawType);
      throw new ConfigurationException(errors.getMessages());
    }
  }
示例#22
0
 @Override
 protected boolean matchesSafely(final Class<?> clazz) {
   try {
     Constructor<?> constructor = clazz.getDeclaredConstructor();
     constructor.setAccessible(true);
     constructor.newInstance();
     return Modifier.isPrivate(constructor.getModifiers());
   } catch (final Exception ignored) {
   }
   return false;
 }
示例#23
0
 /**
  * Create a name for the given reflected constructor. The resulting name will be in a resolved
  * state.
  */
 public MemberName(Constructor ctor) {
   Object[] typeInfo = {void.class, ctor.getParameterTypes()};
   init(
       ctor.getDeclaringClass(),
       CONSTRUCTOR_NAME,
       typeInfo,
       flagsMods(IS_CONSTRUCTOR, ctor.getModifiers()));
   // fill in vmtarget, vmindex while we have ctor in hand:
   MethodHandleNatives.init(this, ctor);
   assert (isResolved());
 }
  /**
   * Visit every class/interface this proxy should implement, and generate the appropriate bytecode
   * for delegation if available.
   *
   * @param clazz an class for which to generate bytecode
   */
  private void visitClass(final Class clazz) {
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
      Class<?>[] exceptionTypes = method.getExceptionTypes();
      String[] exceptions = new String[exceptionTypes.length];
      for (int i = 0; i < exceptions.length; i++) {
        exceptions[i] = BytecodeHelper.getClassInternalName(exceptionTypes[i]);
      }
      // for each method defined in the class, generate the appropriate delegation bytecode
      visitMethod(
          method.getModifiers(),
          method.getName(),
          BytecodeHelper.getMethodDescriptor(method.getReturnType(), method.getParameterTypes()),
          null,
          exceptions);
    }
    Constructor[] constructors = clazz.getDeclaredConstructors();
    for (Constructor method : constructors) {
      Class<?>[] exceptionTypes = method.getExceptionTypes();
      String[] exceptions = new String[exceptionTypes.length];
      for (int i = 0; i < exceptions.length; i++) {
        exceptions[i] = BytecodeHelper.getClassInternalName(exceptionTypes[i]);
      }
      // for each method defined in the class, generate the appropriate delegation bytecode
      visitMethod(
          method.getModifiers(),
          "<init>",
          BytecodeHelper.getMethodDescriptor(Void.TYPE, method.getParameterTypes()),
          null,
          exceptions);
    }

    for (Class intf : clazz.getInterfaces()) {
      visitClass(intf);
    }
    Class superclass = clazz.getSuperclass();
    if (superclass != null) visitClass(superclass);

    // Ultimately, methods can be available in the closure map which are not defined by the
    // superclass
    // nor the interfaces
    for (Map.Entry<String, Boolean> entry : delegatedClosures.entrySet()) {
      Boolean visited = entry.getValue();
      if (!visited) {
        String name = entry.getKey();
        if (!"*".equals(name)) {
          // generate a new method
          visitMethod(ACC_PUBLIC, name, "([Ljava/lang/Object;)Ljava/lang/Object;", null, null);
        }
      }
    }
  }
示例#25
0
 private Object preprocess(Constructor<?> method) {
   try {
     return preprocessMethodOrConstructor(
         method.getModifiers(),
         null,
         method.getDeclaringClass(),
         null,
         method.getParameterTypes(),
         method.getExceptionTypes());
   } catch (Exception e) {
     return "<" + e + ">";
   }
 }
示例#26
0
 public static void validateNoargsConstructor(Class<?> clazz) {
   if (!clazz.isInterface() && !Modifier.isAbstract(clazz.getModifiers())) {
     Constructor<?>[] constructors = clazz.getConstructors();
     for (Constructor<?> constructor : constructors) {
       if (Modifier.isPublic(constructor.getModifiers())
           && constructor.getParameterTypes().length == 0) {
         return;
       }
     }
     throw new AchillesException(
         "The class '" + clazz.getCanonicalName() + "' should have a public default constructor");
   }
 }
示例#27
0
 private static <T> void checkIsValidPartial(Class<T> cls) {
   checkArgument(isAbstract(cls.getModifiers()), "Partial class must be abstract");
   checkArgument(
       cls.getDeclaredConstructors().length == 1,
       "Partial class %s must have exactly one constructor (found %s)",
       cls,
       cls.getDeclaredConstructors().length);
   Constructor<?> constructor = cls.getDeclaredConstructors()[0];
   checkArgument(
       !isPrivate(constructor.getModifiers()),
       "Partial class %s must have a package-visible constructor",
       cls);
 }
  public static boolean hasValidDefaultConstructor(Class cls) {
    try {
      if (cls != null) {
        Constructor c = cls.getConstructor(new Class[] {});
        int mod = c.getModifiers();
        return Modifier.isPublic(mod);
      }
    } catch (Throwable t) {
      return false;
    }

    return false;
  }
  @Test
  public void shouldBeWellDefined() throws Exception {
    assertThat(mKlass.getSuperclass()).isEqualTo(Object.class);
    assertThat(Modifier.isFinal(mKlass.getModifiers())).isTrue();
    assertThat(mKlass.getDeclaredConstructors()).hasSize(1);

    final Constructor<?> constructor = mKlass.getDeclaredConstructor();
    assertThat(constructor.isAccessible()).isFalse();
    assertThat(Modifier.isPrivate(constructor.getModifiers())).isTrue();

    for (final Method method : mKlass.getDeclaredMethods()) {
      assertThat(Modifier.isStatic(method.getModifiers())).describedAs(method.getName()).isTrue();
    }
  }
 /** Creates an instance. */
 private DefaultUIComponentFactory(Class<?> type) {
   if (type.isInterface() || Modifier.isAbstract(type.getModifiers())) {
     throw new IllegalArgumentException("Type is not instantiable: " + type.getName());
   }
   Constructor cons;
   try {
     cons = type.getDeclaredConstructor(MetaUIComponent.class);
   } catch (ReflectiveOperationException ex) {
     throw new IllegalArgumentException(ex);
   }
   if (Modifier.isPublic(cons.getModifiers()) == false) {
     throw new IllegalArgumentException("Constructor is not public: " + cons);
   }
   this.constructor = cons;
 }