/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.ipojo.manipulation;
import junit.framework.Assert;
import org.apache.felix.ipojo.InstanceManager;
import org.apache.felix.ipojo.Pojo;
import org.apache.felix.ipojo.metadata.Element;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.concurrent.Callable;
import static junit.framework.Assert.assertEquals;
import static org.fest.assertions.Assertions.assertThat;
/**
* Checks the inner class manipulation
*/
public class InnerClassAdapterTest {
public static String baseClassDirectory = "target/test-classes/";
public static ManipulatedClassLoader manipulate(String className, Manipulator manipulator) throws IOException {
final File mainClassFile = new File(baseClassDirectory + className.replace(".", "/") + ".class");
byte[] bytecode = ManipulatorTest.getBytesFromFile(
mainClassFile);
// Preparation.
try {
manipulator.prepare(bytecode);
} catch (IOException e) {
Assert.fail("Cannot read " + className);
}
// Inner class preparation
for (String inner : manipulator.getInnerClasses()) {
// Get the bytecode and start manipulation
String resourcePath = inner + ".class";
byte[] innerClassBytecode;
try {
innerClassBytecode = ManipulatorTest.getBytesFromFile(new File(baseClassDirectory + resourcePath));
manipulator.prepareInnerClass(inner, innerClassBytecode);
} catch (IOException e) {
Assert.fail("Cannot find or analyze inner class '" + resourcePath + "'");
}
}
// Now manipulate the classes.
byte[] out = new byte[0];
try {
out = manipulator.manipulate(bytecode);
} catch (IOException e) {
Assert.fail("Cannot manipulate the class " + className + " : " + e.getMessage());
}
ManipulatedClassLoader classloader = new ManipulatedClassLoader(className, out);
// Visit inner classes
for (String inner : manipulator.getInnerClasses()) {
// Get the bytecode and start manipulation
String resourcePath = inner + ".class";
byte[] innerClassBytecode;
try {
innerClassBytecode = ManipulatorTest.getBytesFromFile(new File(baseClassDirectory + resourcePath));
byte[] manipulated = manipulator.manipulateInnerClass(inner, innerClassBytecode);
classloader.addInnerClass(inner.replace("/", "."), manipulated);
} catch (IOException e) {
Assert.fail("Cannot find inner class '" + resourcePath + "'");
}
}
// Lookup for all the other inner classes (not manipulated)
File[] files = mainClassFile.getParentFile().listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.startsWith(mainClassFile.getName().substring(0, mainClassFile.getName().length() -
".class".length()) + "$");
}
});
for (File f : files) {
String name = className + f.getName().substring(f.getName().indexOf("$"));
name = name.substring(0, name.length() - ".class".length());
byte[] innerClassBytecode = ManipulatorTest.getBytesFromFile(f);
classloader.addInnerClassIfNotAlreadyDefined(name, innerClassBytecode);
}
return classloader;
}
public static ManipulatedClassLoader manipulate(String className, Manipulator manipulator,
ManipulatedClassLoader initial) throws IOException {
byte[] bytecode = initial.get(className);
final File mainClassFile = new File(baseClassDirectory + className.replace(".", "/") + ".class");
String mainClass = className;
// Preparation.
try {
manipulator.prepare(bytecode);
} catch (IOException e) {
Assert.fail("Cannot read " + className);
}
// Inner class preparation
for (String inner : manipulator.getInnerClasses()) {
// Get the bytecode and start manipulation
String resourcePath = inner + ".class";
byte[] innerClassBytecode;
try {
innerClassBytecode = initial.get(inner.replace("/", "."));
manipulator.prepareInnerClass(inner, innerClassBytecode);
} catch (IOException e) {
Assert.fail("Cannot find or analyze inner class '" + resourcePath + "'");
}
}
// Now manipulate the classes.
byte[] out = new byte[0];
try {
out = manipulator.manipulate(bytecode);
} catch (IOException e) {
Assert.fail("Cannot manipulate the class " + className + " : " + e.getMessage());
}
ManipulatedClassLoader classloader = new ManipulatedClassLoader(className, out);
// Visit inner classes
for (String inner : manipulator.getInnerClasses()) {
// Get the bytecode and start manipulation
String resourcePath = inner + ".class";
byte[] innerClassBytecode;
try {
innerClassBytecode = initial.get(inner.replace("/", "."));
byte[] manipulated = manipulator.manipulateInnerClass(inner, innerClassBytecode);
classloader.addInnerClass(inner.replace("/", "."), manipulated);
} catch (IOException e) {
Assert.fail("Cannot find inner class '" + resourcePath + "'");
}
}
// Lookup for all the other inner classes (not manipulated)
File[] files = mainClassFile.getParentFile().listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.startsWith(mainClassFile.getName().substring(0, mainClassFile.getName().length() -
".class".length()) + "$");
}
});
for (File f : files) {
String name = className + f.getName().substring(f.getName().indexOf("$"));
name = name.substring(0, name.length() - ".class".length());
byte[] innerClassBytecode = ManipulatorTest.getBytesFromFile(f);
classloader.addInnerClassIfNotAlreadyDefined(name, innerClassBytecode);
}
return classloader;
}
private static Element getInnerClassMetadataByName(Element[] inners, String name) {
for (Element element : inners) {
if (name.equals(element.getAttribute("name"))) {
return element;
}
}
return null;
}
private static Element getMethodByName(Element[] methods, String name) {
for (Element element : methods) {
if (name.equals(element.getAttribute("name"))) {
return element;
}
}
return null;
}
@Test
public void testManipulatingTheInner() throws Exception {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.PojoWithInner";
byte[] origin = ManipulatorTest.getBytesFromFile(new File(baseClassDirectory + className.replace(".",
"/") + ".class"));
ManipulatedClassLoader classloader = manipulate(className, manipulator);
Class cl = classloader.findClass(className);
Assert.assertNotNull(cl);
Assert.assertNotNull(manipulator.getManipulationMetadata());
Assert.assertFalse(manipulator.getInnerClasses().isEmpty());
System.out.println(manipulator.getManipulationMetadata());
// The manipulation add stuff to the class.
Assert.assertTrue(classloader.get(className).length > origin.length);
boolean found = false;
Constructor cst = null;
Constructor[] csts = cl.getDeclaredConstructors();
for (Constructor cst2 : csts) {
System.out.println(Arrays.asList(cst2.getParameterTypes()));
if (cst2.getParameterTypes().length == 1 &&
cst2.getParameterTypes()[0].equals(InstanceManager.class)) {
found = true;
cst = cst2;
}
}
Assert.assertTrue(found);
// We still have the empty constructor
found = false;
csts = cl.getDeclaredConstructors();
for (Constructor cst1 : csts) {
System.out.println(Arrays.asList(cst1.getParameterTypes()));
if (cst1.getParameterTypes().length == 0) {
found = true;
}
}
Assert.assertTrue(found);
// Check the POJO interface
Assert.assertTrue(Arrays.asList(cl.getInterfaces()).contains(Pojo.class));
InstanceManager im = Mockito.mock(InstanceManager.class);
cst.setAccessible(true);
Object pojo = cst.newInstance(new Object[]{im});
Assert.assertNotNull(pojo);
Assert.assertTrue(pojo instanceof Pojo);
Method method = cl.getMethod("doSomething", new Class[0]);
Assert.assertTrue(((Boolean) method.invoke(pojo, new Object[0])).booleanValue());
}
@Test
public void testInnerClasses() throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
ManipulatedClassLoader classloader = manipulate(className, manipulator);
Class clazz = classloader.findClass(className);
Assert.assertNotNull(clazz);
Assert.assertNotNull(manipulator.getManipulationMetadata());
Assert.assertFalse(manipulator.getInnerClasses().isEmpty());
// We should have found only 2 inner classes.
assertThat(manipulator.getInnerClasses().size()).isEqualTo(3);
// Check that all inner classes are manipulated.
InstanceManager im = Mockito.mock(InstanceManager.class);
Constructor constructor = clazz.getDeclaredConstructor(InstanceManager.class);
constructor.setAccessible(true);
Object pojo = constructor.newInstance(im);
Assert.assertNotNull(pojo);
Assert.assertTrue(pojo instanceof Pojo);
Method method = clazz.getMethod("doSomething", new Class[0]);
String result = (String) method.invoke(pojo);
assertEquals(result, "foofoofoofoo");
}
@Test
public void testDoubleManipulation() throws IOException, ClassNotFoundException, NoSuchMethodException,
IllegalAccessException, InvocationTargetException, InstantiationException {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
ManipulatedClassLoader classloader = manipulate(className, manipulator);
manipulator = new Manipulator(this.getClass().getClassLoader());
classloader = manipulate(className, manipulator, classloader);
Class clazz = classloader.findClass(className);
Assert.assertNotNull(clazz);
Assert.assertNotNull(manipulator.getManipulationMetadata());
Assert.assertFalse(manipulator.getInnerClasses().isEmpty());
// We should have found only 2 inner classes.
assertThat(manipulator.getInnerClasses().size()).isEqualTo(3);
// Check that all inner classes are manipulated.
InstanceManager im = Mockito.mock(InstanceManager.class);
Constructor constructor = clazz.getDeclaredConstructor(InstanceManager.class);
constructor.setAccessible(true);
Object pojo = constructor.newInstance(im);
Assert.assertNotNull(pojo);
Assert.assertTrue(pojo instanceof Pojo);
Method method = clazz.getMethod("doSomething", new Class[0]);
String result = (String) method.invoke(pojo);
assertEquals(result, "foofoofoofoo");
}
@Test
public void testThatManipulationMetadataContainsTheInnerClasses() throws IOException, ClassNotFoundException,
NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
manipulate(className, manipulator);
assertThat(manipulator.getInnerClasses().size()).isEqualTo(3);
Element manipulation = manipulator.getManipulationMetadata();
System.out.println(manipulation);
Element[] inners = manipulation.getElements("inner");
assertThat(inners.length).isEqualTo(3);
Element inner = getInnerClassMetadataByName(inners, "MyInnerWithANativeMethod");
assertThat(inner).isNotNull();
assertThat(getMethodByName(inner.getElements("method"), "foo")).isNotNull();
inner = getInnerClassMetadataByName(inners, "MyInnerClass");
assertThat(inner).isNotNull();
assertThat(getMethodByName(inner.getElements("method"), "foo")).isNotNull();
inner = getInnerClassMetadataByName(inners, "1");
assertThat(inner).isNotNull();
assertThat(getMethodByName(inner.getElements("method"), "compute")).isNotNull();
}
@Test
public void testThatTheClassContainsTheFlagsForTheInnerMethods() throws IOException, ClassNotFoundException,
NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
ManipulatedClassLoader classLoader = manipulate(className, manipulator);
Class clazz = classLoader.findClass(className);
String flag = "__M" + "MyInnerWithANativeMethod" + "___" + "foo";
assertThat(clazz.getDeclaredField(flag)).isNotNull();
flag = "__M" + "MyInnerClass" + "___" + "foo";
assertThat(clazz.getDeclaredField(flag)).isNotNull();
flag = "__M" + "1" + "___" + "compute" + "$java_lang_String";
assertThat(clazz.getDeclaredField(flag)).isNotNull();
}
@Test
public void testThatStaticInnerClassesAreNotManipulated() throws Exception {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
ManipulatedClassLoader classLoader = manipulate(className, manipulator);
Class clazz = classLoader.findClass(className);
Class inner = findInnerClass(clazz.getClasses(), "MyStaticInnerClass");
assertThat(inner).isNotNull();
Method bar = inner.getMethod("bar");
Object o = inner.newInstance();
bar.setAccessible(true);
assertThat(bar).isNotNull();
assertThat((String) bar.invoke(o)).isEqualTo("bar");
}
@Test
public void testThatAnonymousClassDeclaredInStaticFieldsAreNotManipulated() throws Exception {
Manipulator manipulator = new Manipulator(this.getClass().getClassLoader());
String className = "test.inner.ComponentWithInnerClasses";
ManipulatedClassLoader classLoader = manipulate(className, manipulator);
Class clazz = classLoader.findClass(className);
Method method = clazz.getMethod("call");
assertThat(method).isNotNull();
assertThat(method.invoke(null)).isEqualTo(1);
}
private Class findInnerClass(Class[] classes, String name) {
for (Class clazz : classes) {
if (clazz.getName().contains(name)) {
return clazz;
}
}
return null;
}
}