org.objenesis.Objenesis Java Examples

@Before
public void setup() {
	this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();

	// prepare mocks
	this.noteStoreOperations = mock(NoteStoreOperations.class, withSettings().extraInterfaces(StoreClientHolder.class));
	this.userStoreOperations = mock(UserStoreOperations.class, withSettings().extraInterfaces(StoreClientHolder.class));

	// To work around getClass() method to return actual store-client class for parameter name discovery, use
	// objenesis to create actual impl class instead of mocking.
	// mockito cannot mock getClass() since this method is final.
	Objenesis objenesis = new ObjenesisStd();
	UserStoreClient userStoreClient = (UserStoreClient) objenesis.newInstance(UserStoreClient.class);
	NoteStoreClient noteStoreClient = (NoteStoreClient) objenesis.newInstance(NoteStoreClient.class);
	when(((StoreClientHolder) userStoreOperations).getStoreClient()).thenReturn(userStoreClient);
	when(((StoreClientHolder) noteStoreOperations).getStoreClient()).thenReturn(noteStoreClient);

	when(this.evernote.userStoreOperations()).thenReturn(userStoreOperations);
	when(this.evernote.noteStoreOperations()).thenReturn(noteStoreOperations);
}
 

@Override
public Object getProxy(ClassLoader classLoader) {
    Enhancer enhancer = new Enhancer();
    enhancer.setClassLoader(classLoader);
    enhancer.setCallbackType(MethodInterceptor.class);

    Class<?> targetClass = support.getBeanClass();
    enhancer.setSuperclass(targetClass);
    enhancer.setInterfaces(new Class[]{FestivalProxy.class, TargetClassAware.class});
    Class<?> proxyClass = enhancer.createClass();

    Objenesis objenesis = new ObjenesisStd();
    ObjectInstantiator<?> instantiator = objenesis.getInstantiatorOf(proxyClass);
    Object proxyInstance = instantiator.newInstance();

    ((Factory) proxyInstance).setCallbacks(new Callback[]{new CglibMethodInterceptor(support)});

    return proxyInstance;
}
 

/**
 * @param objenesisStandard Objenesis instance used to instantiate classes the standard way (no constructor called)
 * @param objenesisSerializer Objenesis instance used to instantiate classes in a serialization compliant way (first not serializable constructor called)
 * @param reporter Where to report the results of the tests to
 */
public TCK(Objenesis objenesisStandard, Objenesis objenesisSerializer, Reporter reporter) {
   this.objenesisStandard = objenesisStandard;
   this.objenesisSerializer = objenesisSerializer;
   this.reporter = reporter;

   try {
      loadCandidates();
   }
   catch(IOException e) {
      throw new RuntimeException(e);
   }

   Collections.sort(candidates);
}
 

@Deployment
public static JavaArchive createDeployment() {
    JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "camel-hipchat-tests.jar");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    archive.addClasses(HipchatComponentSupport.class, HipchatEndpointSupport.class);
    return archive;
}
 

@Configuration
public Option[] config() {
   String version = getImplementationVersion(Objenesis.class);
   return options(
      bundle("file:../main/target/objenesis-" + version + ".jar"),
      junitBundles()
   );
}
 

private void runCandidate(Reporter reporter, Class<?> candidate, Objenesis objenesis, Candidate.CandidateType type) {
   try {
      Object instance = objenesis.newInstance(candidate);
      boolean success = instance != null && instance.getClass() == candidate;
      reporter.result(type, success);
   }
   catch(Exception e) {
      reporter.exception(type, e);
   }
}
 

private void runFeature(Reporter reporter, Class<?> clazz, Objenesis objenesis, Candidate.CandidateType type) {
   try {
      @SuppressWarnings("unchecked") Constructor<Feature> constructor = (Constructor<Feature>) clazz.getConstructor();
      Feature feature = constructor.newInstance();
      boolean compliant = feature.isCompliant(objenesis);
      reporter.result(type, compliant);
   }
   catch(Exception e) {
      reporter.exception(type, e);
   }
}
 

private void runTest(Reporter reporter, Class<?> candidate, Objenesis objenesis, Candidate.CandidateType type) {
   if(Feature.class.isAssignableFrom(candidate)) {
      runFeature(reporter, candidate, objenesis, type);
   }
   else {
      runCandidate(reporter, candidate, objenesis, type);
   }
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   try {
      objenesis.newInstance(NotSerializable.class);
   }
   catch(ObjenesisException e) {
      return true;
   }
   return false;
}
 

@Override
public void startTests(String platformDescription, Objenesis objenesisStandard, Objenesis objenesisSerializer) {
   this.platformDescription = platformDescription;
   this.objenesisStandard = objenesisStandard;
   this.objenesisSerializer = objenesisSerializer;
   this.currentCandidate = null;
   this.errorCount = 0;
   this.results.clear();
   this.startTime = System.currentTimeMillis();
}
 

@Override
public void startTests(String platformDescription, Objenesis objenesisStandard, Objenesis objenesisSerializer) {
   this.platformDescription = platformDescription;
   this.objenesisStandard = objenesisStandard;
   this.objenesisSerializer = objenesisSerializer;
   this.currentCandidate = null;
   this.errorCount = 0;
   this.results.clear();
   this.startTime = System.currentTimeMillis();
}
 

@BeforeClass
public static void throwAway() {
  log.info("BEFORE_CLASS BEGINS");
  // this is just ot keep checkClusterConfiguration happy... actually better to do this per-test
  // to avoid cross talk between tests (see SOLR-12801 test revamp in solr)
  // future versions of solr won't require this....
  Objenesis objenesis = new ObjenesisStd();
  ObjectInstantiator<MiniSolrCloudCluster> instantiatorOf = objenesis.getInstantiatorOf(MiniSolrCloudCluster.class);
  cluster = instantiatorOf.newInstance();
  log.info("BEFORE_CLASS ENDSS");
}
 

@Deployment
public static JavaArchive deployment() {
    final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "camel-lpr-tests");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   objenesis.newInstance(ExtendsSerializable.class);
   return called.isEmpty();
}
 

@Deployment
public static JavaArchive createDeployment() {
    return ShrinkWrap.create(JavaArchive.class, "camel-google-bigquery-tests.jar")
        .addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
}
 

@Deployment
public static JavaArchive createdeployment() {
    final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "camel-beanstalk-tests");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@SuppressWarnings("unchecked")
private static <T> T create(final Class<T> classToMock) {
  Objenesis objenesis = new ObjenesisStd();
  return objenesis.getInstantiatorOf(classToMock).newInstance();
}
 

@Deployment
public static JavaArchive deployment() {
    final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "hazelcast-map-producer-tests");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@Deployment
public static JavaArchive deployment() {
    final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "hazelcast-map-consumer-tests");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@Deployment
public static JavaArchive createDeployment() {
    final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "camel-nagios-test");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@Deployment
public static JavaArchive createDeployment() {
    JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "camel-openstack-tests.jar");
    archive.addPackages(true, Mockito.class.getPackage(), Objenesis.class.getPackage(), ByteBuddy.class.getPackage());
    return archive;
}
 

@Override
public void startTests(String platformDescription, Objenesis objenesisStandard, Objenesis objenesisSerializer) {
   log.append("startTests()\n");
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   return true;
}
 

@Test
public void testReportsSuccessesInTabularFormat() {
   Objenesis instantiator1 = new ObjenesisBase(new SingleInstantiatorStrategy(
      ConstructorInstantiator.class));
   Objenesis instantiator2 = new ObjenesisBase(new SingleInstantiatorStrategy(
      FailingInstantiator.class));

   textReporter.startTests("Some platform", instantiator1, instantiator2);

   textReporter.startTest(new Candidate(TCKTest.CandidateA.class, "candidate A",
      Candidate.CandidateType.STANDARD, Candidate.CandidateType.SERIALIZATION));
   textReporter.result(Candidate.CandidateType.STANDARD,false);
   textReporter.result(Candidate.CandidateType.SERIALIZATION, true);

   textReporter.startTest(new Candidate(TCKTest.CandidateB.class, "candidate B", Candidate.CandidateType.STANDARD));
   textReporter.result(Candidate.CandidateType.STANDARD,true);

   textReporter.startTest(new Candidate(TCKTest.CandidateC.class,"candidate C",
      Candidate.CandidateType.STANDARD, Candidate.CandidateType.SERIALIZATION));
   textReporter.exception(Candidate.CandidateType.STANDARD, new RuntimeException("Problem"));
   textReporter.result(Candidate.CandidateType.SERIALIZATION, false);

   textReporter.startTest(new Candidate(TCKTest.CandidateD.class,"candidate D",
      Candidate.CandidateType.SERIALIZATION));
   textReporter.result(Candidate.CandidateType.SERIALIZATION, true);

   textReporter.endTests();

   ByteArrayOutputStream expectedSummaryBuffer = new ByteArrayOutputStream();
   PrintStream out = new PrintStream(expectedSummaryBuffer);
   out.println("Running TCK on platform: Some platform");
   out.println();
   out.println("Instantiators used: ");
   out.println("   Objenesis standard  : org.objenesis.instantiator.basic.ConstructorInstantiator");
   out.println("   Objenesis serializer: org.objenesis.instantiator.basic.FailingInstantiator");
   out.println();
   out.println("            Objenesis standard   Objenesis serializer");
   out.println("candidate A n                    Y                   ");
   out.println("candidate B Y                    N/A                 ");
   out.println("candidate C n                    n                   ");
   out.println("candidate D N/A                  Y                   ");
   out.println();
   out.println("--- FAILED: 3 error(s) occurred ---");
   out.println();

   assertEquals(expectedSummaryBuffer.toString(), summaryBuffer.toString());
}
 

@Override
public void startTests(String platformDescription, Objenesis objenesisStandard, Objenesis objenesisSerializer) {
}
 

@Override
public void startTests(String platformDescription, Objenesis objenesisStandard, Objenesis objenesisSerializer) {
}
 

@Test
public void testDefineClass() throws Exception {
   byte[] b = ClassDefinitionUtils.readClass(className);
   Class<?> c = ClassDefinitionUtils.defineClass(className, b, Objenesis.class, getClass().getClassLoader());
   assertEquals(c.getName(), className);
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   objenesis.newInstance(ExtendsNotSerializable.class);
   return called.size() == 1 && called.get(0).equals(NotSerializableClass.NotSerializable.class.getSimpleName() + ".<init>");
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   objenesis.newInstance(ReadObjectAndAll.class);
   return called.isEmpty();
}
 

@Override
public boolean isCompliant(Objenesis objenesis) {
   objenesis.newInstance(IsSerializable.class);
   return called.isEmpty();
}