Java 类org.mockito.cglib.core.CodeGenerationException 实例源码

private static PropertyDescriptor[] getPropertiesHelper(Class type, boolean read, boolean write) {
    try {
        BeanInfo info = Introspector.getBeanInfo(type, Object.class);
        PropertyDescriptor[] all = info.getPropertyDescriptors();
        if (read && write) {
            return all;
        }
        List properties = new ArrayList(all.length);
        for (int i = 0; i < all.length; i++) {
            PropertyDescriptor pd = all[i];
            if ((read && pd.getReadMethod() != null) ||
                (write && pd.getWriteMethod() != null)) {
                properties.add(pd);
            }
        }
        return (PropertyDescriptor[])properties.toArray(new PropertyDescriptor[properties.size()]);
    } catch (IntrospectionException e) {
        throw new CodeGenerationException(e);
    }
}

public static Constructor getConstructor(final Class type, final Class[] parameterTypes) {
    try {
        return AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
          @Override
          public Constructor run() throws NoSuchMethodException {
            Constructor constructor = type.getDeclaredConstructor(parameterTypes);
            constructor.setAccessible(true);
            return constructor;
          }
        });
    } catch (PrivilegedActionException e) {
        throw new CodeGenerationException(e.getCause());
    }
}

private Class<?> createProxyClass(Class<?> mockedType, Class<?>...interfaces) {
    if (mockedType == Object.class) {
        mockedType = ClassWithSuperclassToWorkAroundCglibBug.class;
    }

    Enhancer enhancer = new Enhancer() {
        @Override
        @SuppressWarnings("unchecked")
        protected void filterConstructors(Class sc, List constructors) {
            // Don't filter
        }
    };
    enhancer.setClassLoader(SearchingClassLoader.combineLoadersOf(mockedType));
    enhancer.setUseFactory(true);
    if (mockedType.isInterface()) {
        enhancer.setSuperclass(Object.class);
        enhancer.setInterfaces(prepend(mockedType, interfaces));
    } else {
        enhancer.setSuperclass(mockedType);
        enhancer.setInterfaces(interfaces);
    }
    enhancer.setCallbackTypes(new Class[]{MethodInterceptor.class, NoOp.class});
    enhancer.setCallbackFilter(IGNORE_BRIDGE_METHODS);
    if (mockedType.getSigners() != null) {
        enhancer.setNamingPolicy(NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
    } else {
        enhancer.setNamingPolicy(MockitoNamingPolicy.INSTANCE);
    }

    try {
        return enhancer.createClass(); 
    } catch (CodeGenerationException e) {
        if (Modifier.isPrivate(mockedType.getModifiers())) {
            throw new MockitoException("\n"
                    + "Mockito cannot mock this class: " + mockedType 
                    + ".\n"
                    + "Most likely it is a private class that is not visible by Mockito");
        }
        throw new MockitoException("\n"
                + "Mockito cannot mock this class: " + mockedType 
                + "\n" 
                + "Mockito can only mock visible & non-final classes."
                + "\n" 
                + "If you're not sure why you're getting this error, please report to the mailing list.", e);
    }
}

public Class<Factory> createProxyClass(Class<?> mockedType, Class<?>... interfaces) {
    if (mockedType == Object.class) {
        mockedType = ClassWithSuperclassToWorkAroundCglibBug.class;
    }

    Enhancer enhancer = new Enhancer() {
        @Override
        @SuppressWarnings("unchecked")
        protected void filterConstructors(Class sc, List constructors) {
            // Don't filter
        }
    };
    Class<?>[] allMockedTypes = prepend(mockedType, interfaces);
    enhancer.setClassLoader(SearchingClassLoader.combineLoadersOf(allMockedTypes));
    enhancer.setUseFactory(true);
    if (mockedType.isInterface()) {
        enhancer.setSuperclass(Object.class);
        enhancer.setInterfaces(allMockedTypes);
    } else {
        enhancer.setSuperclass(mockedType);
        enhancer.setInterfaces(interfaces);
    }
    enhancer.setCallbackTypes(new Class[]{MethodInterceptor.class, NoOp.class});
    enhancer.setCallbackFilter(IGNORE_BRIDGE_METHODS);
    if (mockedType.getSigners() != null) {
        enhancer.setNamingPolicy(NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
    } else {
        enhancer.setNamingPolicy(MockitoNamingPolicy.INSTANCE);
    }

    enhancer.setSerialVersionUID(42L);

    try {
        return enhancer.createClass();
    } catch (CodeGenerationException e) {
        if (Modifier.isPrivate(mockedType.getModifiers())) {
            throw new MockitoException("\n"
                    + "Mockito cannot mock this class: " + mockedType
                    + ".\n"
                    + "Most likely it is a private class that is not visible by Mockito");
        }
        throw new MockitoException("\n"
                + "Mockito cannot mock this class: " + mockedType
                + "\n"
                + "Mockito can only mock visible & non-final classes."
                + "\n"
                + "If you're not sure why you're getting this error, please report to the mailing list.", e);
    }
}

public Class<?> createProxyClass(Class<?> mockedType, Class<?>... interfaces) {
      if (mockedType == Object.class) {
          mockedType = ClassWithSuperclassToWorkAroundCglibBug.class;
      }

      Enhancer enhancer = new Enhancer() {
          @Override
          @SuppressWarnings("unchecked")
          protected void filterConstructors(Class sc, List constructors) {
              // Don't filter
          }
      };
      Class<?>[] allMockedTypes = prepend(mockedType, interfaces);
enhancer.setClassLoader(SearchingClassLoader.combineLoadersOf(allMockedTypes));
      enhancer.setUseFactory(true);
      if (mockedType.isInterface()) {
          enhancer.setSuperclass(Object.class);
          enhancer.setInterfaces(allMockedTypes);
      } else {
          enhancer.setSuperclass(mockedType);
          enhancer.setInterfaces(interfaces);
      }
      enhancer.setCallbackTypes(new Class[]{MethodInterceptor.class, NoOp.class});
      enhancer.setCallbackFilter(IGNORE_BRIDGE_METHODS);
      if (mockedType.getSigners() != null) {
          enhancer.setNamingPolicy(NAMING_POLICY_THAT_ALLOWS_IMPOSTERISATION_OF_CLASSES_IN_SIGNED_PACKAGES);
      } else {
          enhancer.setNamingPolicy(MockitoNamingPolicy.INSTANCE);
      }

      enhancer.setSerialVersionUID(42L);

      try {
          return enhancer.createClass(); 
      } catch (CodeGenerationException e) {
          if (Modifier.isPrivate(mockedType.getModifiers())) {
              throw new MockitoException("\n"
                      + "Mockito cannot mock this class: " + mockedType 
                      + ".\n"
                      + "Most likely it is a private class that is not visible by Mockito");
          }
          throw new MockitoException("\n"
                  + "Mockito cannot mock this class: " + mockedType 
                  + "\n" 
                  + "Mockito can only mock visible & non-final classes."
                  + "\n" 
                  + "If you're not sure why you're getting this error, please report to the mailing list.", e);
      }
  }