// Copyright 2006, 2007, 2008, 2010, 2011 The Apache Software Foundation
//
// Licensed 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.tapestry5.internal.services;
import static java.lang.Thread.currentThread;
import static java.util.Arrays.asList;
import java.lang.annotation.Documented;
import java.lang.annotation.Target;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.net.URLClassLoader;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.Loader;
import javassist.LoaderClassPath;
import javassist.NotFoundException;
import org.apache.tapestry5.annotations.Meta;
import org.apache.tapestry5.annotations.OnEvent;
import org.apache.tapestry5.annotations.Retain;
import org.apache.tapestry5.annotations.SetupRender;
import org.apache.tapestry5.internal.InternalComponentResources;
import org.apache.tapestry5.internal.model.MutableComponentModelImpl;
import org.apache.tapestry5.internal.test.InternalBaseTestCase;
import org.apache.tapestry5.internal.transform.InheritedAnnotation;
import org.apache.tapestry5.internal.transform.TestPackageAwareLoader;
import org.apache.tapestry5.internal.transform.pages.AbstractFoo;
import org.apache.tapestry5.internal.transform.pages.BarImpl;
import org.apache.tapestry5.internal.transform.pages.ChildClassInheritsAnnotation;
import org.apache.tapestry5.internal.transform.pages.ClaimedFields;
import org.apache.tapestry5.internal.transform.pages.EventHandlerTarget;
import org.apache.tapestry5.internal.transform.pages.FieldAccessBean;
import org.apache.tapestry5.internal.transform.pages.MethodAccessSubject;
import org.apache.tapestry5.internal.transform.pages.MethodIdentifier;
import org.apache.tapestry5.internal.transform.pages.ParentClass;
import org.apache.tapestry5.internal.transform.pages.ReadOnlyBean;
import org.apache.tapestry5.internal.transform.pages.TargetObject;
import org.apache.tapestry5.ioc.internal.services.ClassFactoryClassPool;
import org.apache.tapestry5.ioc.internal.services.ClassFactoryImpl;
import org.apache.tapestry5.ioc.internal.services.CtClassSourceImpl;
import org.apache.tapestry5.ioc.services.ClassFactory;
import org.apache.tapestry5.ioc.services.PropertyAccess;
import org.apache.tapestry5.model.MutableComponentModel;
import org.apache.tapestry5.runtime.Component;
import org.apache.tapestry5.runtime.ComponentResourcesAware;
import org.apache.tapestry5.services.ClassTransformation;
import org.apache.tapestry5.services.ComponentClassTransformWorker;
import org.apache.tapestry5.services.ComponentMethodAdvice;
import org.apache.tapestry5.services.ComponentMethodInvocation;
import org.apache.tapestry5.services.MethodAccess;
import org.apache.tapestry5.services.MethodFilter;
import org.apache.tapestry5.services.MethodInvocationResult;
import org.apache.tapestry5.services.TransformMethod;
import org.apache.tapestry5.services.TransformMethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* The tests share a number of resources, and so are run sequentially.
*/
@Test
public class InternalClassTransformationImplTest extends InternalBaseTestCase
{
private static final String STRING_CLASS_NAME = "java.lang.String";
private PropertyAccess access;
private final ClassLoader contextClassLoader = currentThread().getContextClassLoader();
private ClassFactory classFactory;
private Loader loader;
private ClassFactoryClassPool classFactoryClassPool;
private CtClassSourceImpl classSource;
@BeforeClass
public void setup_access()
{
access = getService("PropertyAccess", PropertyAccess.class);
}
@AfterClass
public void cleanup_access()
{
access = null;
}
/**
* We need a new ClassPool for each individual test, since many of the tests will end up modifying one or more
* CtClass instances.
*/
@BeforeMethod
public void setup_classpool()
{
ClassLoader threadDeadlockBuffer = new URLClassLoader(new URL[0], contextClassLoader);
classFactoryClassPool = new ClassFactoryClassPool(threadDeadlockBuffer);
loader = new TestPackageAwareLoader(threadDeadlockBuffer, classFactoryClassPool);
// Inside Maven Surefire, the system classpath is not sufficient to find all
// the necessary files.
classFactoryClassPool.appendClassPath(new LoaderClassPath(loader));
Logger logger = LoggerFactory.getLogger(InternalClassTransformationImplTest.class);
classFactory = new ClassFactoryImpl(loader, classFactoryClassPool, logger);
classSource = new CtClassSourceImpl(classFactoryClassPool, loader);
}
private Object transform(Class componentClass, ComponentClassTransformWorker worker) throws Exception
{
InternalComponentResources resources = mockInternalComponentResources();
CtClass targetObjectCtClass = findCtClass(componentClass);
Logger logger = mockLogger();
MutableComponentModel model = mockMutableComponentModel(logger);
replay();
InternalClassTransformation ct = new InternalClassTransformationImpl(classFactory, targetObjectCtClass,
new ComponentClassCacheImpl(classFactory, null), model, classSource, false);
worker.transform(ct, model);
ct.finish();
Instantiator instantiator = ct.createInstantiator();
Component instance = instantiator.newInstance(resources);
verify();
expect(resources.getComponent()).andReturn(instance).anyTimes();
replay();
// Return the instance for further testing
return instance;
}
private CtClass findCtClass(Class targetClass) throws NotFoundException
{
return classFactoryClassPool.get(targetClass.getName());
}
private Class toClass(CtClass ctClass) throws Exception
{
return classFactoryClassPool.toClass(ctClass, loader, null);
}
@Test
public void new_member_name() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
assertEquals(ct.newMemberName("fred"), "_$fred");
assertEquals(ct.newMemberName("fred"), "_$fred_0");
// Here we're exposing a bit of the internal algorithm, which strips
// off '$' and '_' before tacking "_$" in front.
assertEquals(ct.newMemberName("_fred"), "_$fred_1");
assertEquals(ct.newMemberName("_$fred"), "_$fred_2");
assertEquals(ct.newMemberName("__$___$____$_fred"), "_$fred_3");
// Here we're trying to force conflicts with existing declared
// fields and methods of the class.
assertEquals(ct.newMemberName("_parentField"), "_$parentField");
assertEquals(ct.newMemberName("conflictField"), "_$conflictField_0");
assertEquals(ct.newMemberName("conflictMethod"), "_$conflictMethod_0");
verify();
}
@Test
public void new_member_name_with_prefix() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
assertEquals(ct.newMemberName("prefix", "fred"), "_$prefix_fred");
assertEquals(ct.newMemberName("prefix", "fred"), "_$prefix_fred_0");
// Here we're exposing a bit of the internal algorithm, which strips
// off '$' and '_' before tacking "_$" in front.
assertEquals(ct.newMemberName("prefix", "_fred"), "_$prefix_fred_1");
assertEquals(ct.newMemberName("prefix", "_$fred"), "_$prefix_fred_2");
assertEquals(ct.newMemberName("prefix", "__$___$____$_fred"), "_$prefix_fred_3");
verify();
}
private InternalClassTransformation createClassTransformation(Class targetClass, Logger logger)
throws NotFoundException
{
CtClass ctClass = findCtClass(targetClass);
MutableComponentModel model = stubMutableComponentModel(logger);
return new InternalClassTransformationImpl(classFactory, ctClass, null, model, null, false);
}
private MutableComponentModel stubMutableComponentModel(Logger logger)
{
return new MutableComponentModelImpl("unknown-class", logger, null, null);
}
@Test
public void find_annotation_on_unknown_field() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
try
{
ct.getFieldAnnotation("unknownField", Retain.class);
unreachable();
}
catch (RuntimeException ex)
{
assertEquals(ex.getMessage(),
"Class org.apache.tapestry5.internal.transform.pages.ParentClass does not contain a field named 'unknownField'.");
}
verify();
}
@Test
public void find_field_annotation() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
Retain retain = ct.getFieldAnnotation("_annotatedField", Retain.class);
assertNotNull(retain);
verify();
}
@Test
public void field_does_not_contain_requested_annotation() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
// Field with annotation, but not that annotation
assertNull(ct.getFieldAnnotation("_annotatedField", Override.class));
// Field with no annotation
assertNull(ct.getFieldAnnotation("_parentField", Override.class));
verify();
}
@Test
public void find_fields_with_annotation() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
List<String> fields = ct.findFieldsWithAnnotation(Retain.class);
assertEquals(fields.size(), 1);
assertEquals(fields.get(0), "_annotatedField");
verify();
}
@Test
public void get_field_modifiers() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(CheckFieldType.class, logger);
assertEquals(ct.getFieldModifiers("_privateField"), Modifier.PRIVATE);
assertEquals(ct.getFieldModifiers("_map"), Modifier.PRIVATE + Modifier.FINAL);
}
@Test
public void get_field_exists() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(CheckFieldType.class, logger);
assertTrue(ct.isField("_privateField"));
assertFalse(ct.isField("_doesNotExist"));
verify();
}
@Test
public void no_fields_contain_requested_annotation() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
List<String> fields = ct.findFieldsWithAnnotation(Documented.class);
assertTrue(fields.isEmpty());
verify();
}
@Test
public void claim_fields() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ClaimedFields.class, logger);
List<String> unclaimed = ct.findUnclaimedFields();
assertEquals(unclaimed, asList("_field1", "_field4", "_zzfield"));
ct.claimField("_field4", "Fred");
unclaimed = ct.findUnclaimedFields();
assertEquals(unclaimed, asList("_field1", "_zzfield"));
try
{
ct.claimField("_field4", "Barney");
unreachable();
}
catch (RuntimeException ex)
{
assertEquals(
ex.getMessage(),
"Field _field4 of class org.apache.tapestry5.internal.transform.pages.ClaimedFields is already claimed by Fred and can not be claimed by Barney.");
}
verify();
}
@Test
public void added_fields_are_not_listed_as_unclaimed_fields() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ClaimedFields.class, logger);
ct.addField(Modifier.PRIVATE, "int", "newField");
List<String> unclaimed = ct.findUnclaimedFields();
assertEquals(unclaimed, asList("_field1", "_field4", "_zzfield"));
verify();
}
@Test
public void find_class_annotations() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ParentClass.class, logger);
Meta meta = ct.getAnnotation(Meta.class);
assertNotNull(meta);
// Try again (the annotation will be cached). Use an annotation
// that will not be present.
Target t = ct.getAnnotation(Target.class);
assertNull(t);
verify();
}
/**
* More a test of how Javassist works. Javassist does not honor the Inherited annotation for classes (this kind of
* makes sense, since it won't necessarily have the super-class in memory).
*/
@Test
public void ensure_subclasses_inherit_parent_class_annotations() throws Exception
{
// The Java runtime does honor @Inherited
assertNotNull(ChildClassInheritsAnnotation.class.getAnnotation(InheritedAnnotation.class));
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ChildClassInheritsAnnotation.class, logger);
InheritedAnnotation ia = ct.getAnnotation(InheritedAnnotation.class);
// Javassist does not, but ClassTransformation patches around that.
assertNotNull(ia);
verify();
}
// TAPESTRY-2481
@Test
public void ensure_only_inherited_annotations_from_parent_class_are_visible() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(ChildClassInheritsAnnotation.class, logger);
Meta meta = ct.getAnnotation(Meta.class);
assertNull(meta);
verify();
}
/**
* These tests are really to assert my understanding of Javassist's API. I guess we should keep them around to make
* sure that future versions of Javassist work the same as our expectations.
*/
@Test
public void ensure_javassist_still_does_not_show_inherited_interfaces() throws Exception
{
CtClass ctClass = findCtClass(BarImpl.class);
CtClass[] interfaces = ctClass.getInterfaces();
// Just the interfaces implemented by this particular class, not
// inherited interfaces.
assertEquals(interfaces.length, 1);
assertEquals(interfaces[0].getName(), BarInterface.class.getName());
CtClass parentClass = ctClass.getSuperclass();
interfaces = parentClass.getInterfaces();
assertEquals(interfaces.length, 1);
assertEquals(interfaces[0].getName(), FooInterface.class.getName());
}
@Test
public void ensure_javassist_does_not_show_interface_methods_on_abstract_class() throws Exception
{
CtClass ctClass = findCtClass(AbstractFoo.class);
CtClass[] interfaces = ctClass.getInterfaces();
assertEquals(interfaces.length, 1);
assertEquals(interfaces[0].getName(), FooInterface.class.getName());
// In some cases, Java reflection on an abstract class implementing an interface
// will show the interface methods as abstract methods on the class. This seems
// to vary from JVM to JVM. I believe Javassist is more consistent here.
CtMethod[] methods = ctClass.getDeclaredMethods();
assertEquals(methods.length, 0);
}
@Test
public void ensure_javassist_does_not_show_extended_interface_methods_on_interface() throws Exception
{
CtClass ctClass = findCtClass(FooBarInterface.class);
// Just want to check that an interface that extends other interfaces
// doesn't show those other interface's methods.
CtMethod[] methods = ctClass.getDeclaredMethods();
assertEquals(methods.length, 0);
}
public static final TransformMethodSignature RUN = new TransformMethodSignature("run");
@Test
public void access_to_protected_void_no_args_method() throws Exception
{
Object instance = transform(MethodAccessSubject.class, new ComponentClassTransformWorker()
{
public void transform(ClassTransformation transformation, MutableComponentModel model)
{
transformation.addImplementedInterface(Runnable.class);
TransformMethodSignature targetMethodSignature = new TransformMethodSignature(Modifier.PROTECTED,
"void", "protectedVoidNoArgs", null, null);
TransformMethod pvna = transformation.getOrCreateMethod(targetMethodSignature);
final MethodAccess pvnaAccess = pvna.getAccess();
transformation.getOrCreateMethod(RUN).addAdvice(new ComponentMethodAdvice()
{
public void advise(ComponentMethodInvocation invocation)
{
invocation.proceed();
MethodInvocationResult invocationResult = pvnaAccess.invoke(invocation.getInstance());
assertFalse(invocationResult.isFail(), "fail should be false, no checked exception thrown");
}
});
}
});
Runnable r = (Runnable) instance;
r.run();
assertEquals(access.get(r, "marker"), "protectedVoidNoArgs");
}
@Test
public void access_to_public_void_throws_exception() throws Exception
{
Object instance = transform(MethodAccessSubject.class, new ComponentClassTransformWorker()
{
public void transform(ClassTransformation transformation, MutableComponentModel model)
{
transformation.addImplementedInterface(Runnable.class);
TransformMethodSignature targetMethodSignature = new TransformMethodSignature(Modifier.PUBLIC, "void",
"publicVoidThrowsException", null, new String[]
{ SQLException.class.getName() });
TransformMethod targetMethod = transformation.getOrCreateMethod(targetMethodSignature);
final MethodAccess targetAccess = targetMethod.getAccess();
transformation.getOrCreateMethod(RUN).addAdvice(new ComponentMethodAdvice()
{
public void advise(ComponentMethodInvocation invocation)
{
invocation.proceed();
MethodInvocationResult invocationResult = targetAccess.invoke(invocation.getInstance());
assertTrue(invocationResult.isFail(), "fail should be true; checked exception thrown");
SQLException ex = invocationResult.getThrown(SQLException.class);
assertNotNull(ex);
assertEquals(ex.getMessage(), "From publicVoidThrowsException()");
}
});
}
});
Runnable r = (Runnable) instance;
r.run();
assertEquals(access.get(r, "marker"), "publicVoidThrowsException");
}
public interface ProcessInteger
{
int operate(int input);
}
@Test
public void access_to_public_method_with_argument_and_return_value() throws Exception
{
Object instance = transform(MethodAccessSubject.class, new ComponentClassTransformWorker()
{
public void transform(ClassTransformation transformation, MutableComponentModel model)
{
transformation.addImplementedInterface(ProcessInteger.class);
TransformMethod incrementer = transformation.getOrCreateMethod(new TransformMethodSignature(
Modifier.PUBLIC, "int", "incrementer", new String[]
{ "int" }, null));
final MethodAccess incrementerAccess = incrementer.getAccess();
TransformMethodSignature operateSig = new TransformMethodSignature(Modifier.PUBLIC, "int", "operate",
new String[]
{ "int" }, null);
TransformMethod operate = transformation.getOrCreateMethod(operateSig);
operate.addAdvice(new ComponentMethodAdvice()
{
public void advise(ComponentMethodInvocation invocation)
{
// This advice *replaces* the original do-nothing method, because
// it never calls invocation.proceed().
// This kind of advice always needs some special knowledge of
// the parameters to the original method, so that they can be mapped
// to some other method (including a MethodAccess).
Integer parameter = (Integer) invocation.getParameter(0);
MethodInvocationResult result = incrementerAccess.invoke(invocation.getInstance(), parameter);
invocation.overrideResult(result.getReturnValue());
}
});
}
});
ProcessInteger pi = (ProcessInteger) instance;
assertEquals(pi.operate(99), 100);
assertEquals(access.get(instance, "marker"), "incrementer(99)");
}
public interface ProcessStringAndInteger
{
String process(String input, int value);
}
@Test
public void access_to_private_method() throws Exception
{
Object instance = transform(MethodAccessSubject.class, new ComponentClassTransformWorker()
{
public void transform(ClassTransformation transformation, MutableComponentModel model)
{
transformation.addImplementedInterface(ProcessStringAndInteger.class);
TransformMethod targetMethod = transformation.getOrCreateMethod(new TransformMethodSignature(
Modifier.PRIVATE, "java.lang.String", "privateMethod", new String[]
{ "java.lang.String", "int" }, null));
final MethodAccess targetMethodAccess = targetMethod.getAccess();
TransformMethodSignature processSig = new TransformMethodSignature(Modifier.PUBLIC, "java.lang.String",
"process", new String[]
{ "java.lang.String", "int" }, null);
TransformMethod process = transformation.getOrCreateMethod(processSig);
process.addAdvice(new ComponentMethodAdvice()
{
public void advise(ComponentMethodInvocation invocation)
{
// Don't even bother with proceed() this time, which is OK (but
// somewhat rare).
MethodInvocationResult result = targetMethodAccess.invoke(invocation.getInstance(), invocation
.getParameter(0), invocation.getParameter(1));
invocation.overrideResult(result.getReturnValue());
}
});
}
});
ProcessStringAndInteger p = (ProcessStringAndInteger) instance;
assertEquals(p.process("Tapestry!", 2), "Tapestry!Tapestry!");
assertEquals(access.get(instance, "marker"), "privateMethod");
}
@Test
public void add_injected_field() throws Exception
{
InternalComponentResources resources = mockInternalComponentResources();
CtClass targetObjectCtClass = findCtClass(TargetObject.class);
Logger logger = mockLogger();
MutableComponentModel model = mockMutableComponentModel(logger);
replay();
InternalClassTransformation ct = new InternalClassTransformationImpl(classFactory, targetObjectCtClass, null,
model, null, false);
// Default behavior is to add an injected field for the InternalComponentResources object,
// so we'll just check that.
ct.finish();
Instantiator instantiator = ct.createInstantiator();
ComponentResourcesAware instance = instantiator.newInstance(resources);
assertSame(instance.getComponentResources(), resources);
verify();
}
@Test
public void make_field_read_only() throws Exception
{
InternalComponentResources resources = mockInternalComponentResources();
Logger logger = mockLogger();
MutableComponentModel model = mockMutableComponentModel(logger);
replay();
CtClass targetObjectCtClass = findCtClass(ReadOnlyBean.class);
InternalClassTransformation ct = new InternalClassTransformationImpl(classFactory, targetObjectCtClass, null,
model, null, false);
ct.makeReadOnly("_value");
ct.finish();
Object target = instantiate(ReadOnlyBean.class, ct, resources);
try
{
access.set(target, "value", "anything");
unreachable();
}
catch (RuntimeException ex)
{
// The PropertyAccess layer adds a wrapper exception around the real one.
assertEquals(ex.getCause().getMessage(),
"Field org.apache.tapestry5.internal.transform.pages.ReadOnlyBean._value is read-only.");
}
verify();
}
@Test
public void inject_field() throws Exception
{
InternalComponentResources resources = mockInternalComponentResources();
Logger logger = mockLogger();
MutableComponentModel model = mockMutableComponentModel(logger);
replay();
CtClass targetObjectCtClass = findCtClass(ReadOnlyBean.class);
InternalClassTransformation ct = new InternalClassTransformationImpl(classFactory, targetObjectCtClass, null,
model, null, false);
ct.injectField("_value", "Tapestry");
ct.finish();
Object target = instantiate(ReadOnlyBean.class, ct, resources);
assertEquals(access.get(target, "value"), "Tapestry");
try
{
access.set(target, "value", "anything");
unreachable();
}
catch (RuntimeException ex)
{
// The PropertyAccess layer adds a wrapper exception around the real one.
assertEquals(ex.getCause().getMessage(),
"Field org.apache.tapestry5.internal.transform.pages.ReadOnlyBean._value is read-only.");
}
verify();
}
/**
* Tests the basic functionality of overriding read and write; also tests the case for multiple field read/field
* write substitions.
*/
@Test
public void override_field_read_and_write() throws Exception
{
InternalComponentResources resources = mockInternalComponentResources();
Logger logger = mockLogger();
MutableComponentModel model = mockMutableComponentModel(logger);
replay();
CtClass targetObjectCtClass = findCtClass(FieldAccessBean.class);
InternalClassTransformation ct = new InternalClassTransformationImpl(classFactory, targetObjectCtClass, null,
model, null, false);
replaceAccessToField(ct, "foo");
replaceAccessToField(ct, "bar");
// Stuff ...
ct.finish();
Object target = instantiate(FieldAccessBean.class, ct, resources);
// target is no longer assignable to FieldAccessBean; its a new class from a new class
// loader. So we use reflective access, which doesn't care about such things.
checkReplacedFieldAccess(target, "foo");
checkReplacedFieldAccess(target, "bar");
verify();
}
private void checkReplacedFieldAccess(Object target, String propertyName)
{
try
{
access.get(target, propertyName);
unreachable();
}
catch (RuntimeException ex)
{
// PropertyAccess adds a wrapper exception
assertEquals(ex.getCause().getMessage(), "read " + propertyName);
}
try
{
access.set(target, propertyName, "new value");
unreachable();
}
catch (RuntimeException ex)
{
// PropertyAccess adds a wrapper exception
assertEquals(ex.getCause().getMessage(), "write " + propertyName);
}
}
private void replaceAccessToField(InternalClassTransformation ct, String baseName)
{
String fieldName = "_" + baseName;
String readMethodName = "_read_" + baseName;
TransformMethodSignature readMethodSignature = new TransformMethodSignature(Modifier.PRIVATE,
STRING_CLASS_NAME, readMethodName, null, null);
ct.addNewMethod(readMethodSignature, String.format("throw new RuntimeException(\"read %s\");", baseName));
ct.replaceReadAccess(fieldName, readMethodName);
String writeMethodName = "_write_" + baseName;
TransformMethodSignature writeMethodSignature = new TransformMethodSignature(Modifier.PRIVATE, "void",
writeMethodName, new String[]
{ STRING_CLASS_NAME }, null);
ct.addNewMethod(writeMethodSignature, String.format("throw new RuntimeException(\"write %s\");", baseName));
ct.replaceWriteAccess(fieldName, writeMethodName);
}
@Test
public void find_methods_with_annotation() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(AnnotatedPage.class, logger);
List<TransformMethodSignature> l = ct.findMethodsWithAnnotation(SetupRender.class);
// Check order
assertEquals(l.size(), 2);
assertEquals(l.get(0).toString(), "void beforeRender()");
assertEquals(l.get(1).toString(), "boolean earlyRender(org.apache.tapestry5.MarkupWriter)");
// Check up on cacheing
assertEquals(ct.findMethodsWithAnnotation(SetupRender.class), l);
// Check up on no match.
assertTrue(ct.findFieldsWithAnnotation(Deprecated.class).isEmpty());
verify();
}
@Test
public void find_methods_using_filter() throws Exception
{
Logger logger = mockLogger();
replay();
final ClassTransformation ct = createClassTransformation(AnnotatedPage.class, logger);
// Duplicates, somewhat less efficiently, the logic in find_methods_with_annotation().
MethodFilter filter = new MethodFilter()
{
public boolean accept(TransformMethodSignature signature)
{
return ct.getMethodAnnotation(signature, SetupRender.class) != null;
}
};
List<TransformMethodSignature> l = ct.findMethods(filter);
// Check order
assertEquals(l.size(), 2);
assertEquals(l.get(0).toString(), "void beforeRender()");
assertEquals(l.get(1).toString(), "boolean earlyRender(org.apache.tapestry5.MarkupWriter)");
// Check up on cacheing
assertEquals(ct.findMethodsWithAnnotation(SetupRender.class), l);
// Check up on no match.
assertTrue(ct.findFieldsWithAnnotation(Deprecated.class).isEmpty());
verify();
}
@Test
public void to_class_with_primitive_type() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(AnnotatedPage.class, logger);
assertSame(ct.toClass("float"), Float.class);
verify();
}
@Test
public void to_class_with_object_type() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(AnnotatedPage.class, logger);
assertSame(ct.toClass("java.util.Map"), Map.class);
verify();
}
@Test
public void non_private_fields_are_an_exception() throws Exception
{
Logger logger = mockLogger();
replay();
try
{
InternalClassTransformation ct = createClassTransformation(VisibilityBean.class, logger);
unreachable();
}
catch (RuntimeException ex)
{
assertMessageContains(ex, "Class " + VisibilityBean.class.getName() + " contains field(s)",
"_$myPackagePrivate", "_$myProtected", "_$myPublic");
}
verify();
}
@Test
public void find_annotation_in_method() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(EventHandlerTarget.class, logger);
OnEvent annotation = ct.getMethodAnnotation(new TransformMethodSignature("handler"), OnEvent.class);
// Check that the attributes of the annotation match the expectation.
assertEquals(annotation.value(), "fred");
assertEquals(annotation.component(), "alpha");
verify();
}
private Component instantiate(Class<?> expectedClass, InternalClassTransformation ct,
InternalComponentResources resources) throws Exception
{
Instantiator ins = ct.createInstantiator();
return ins.newInstance(resources);
}
@Test
public void get_method_identifier() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(MethodIdentifier.class, logger);
List<TransformMethodSignature> sigs = ct.findMethodsWithAnnotation(OnEvent.class);
assertEquals(sigs.size(), 1);
TransformMethodSignature sig = sigs.get(0);
assertEquals(
ct.getMethodIdentifier(sig),
"org.apache.tapestry5.internal.transform.pages.MethodIdentifier.makeWaves(java.lang.String, int[]) (at MethodIdentifier.java:24)");
verify();
}
@Test
public void base_class_methods_are_never_overridden() throws Exception
{
Logger logger = mockLogger();
replay();
MethodFilter filter = new MethodFilter()
{
public boolean accept(TransformMethodSignature signature)
{
return true;
}
};
ClassTransformation ct = createClassTransformation(SimpleBean.class, logger);
List<TransformMethodSignature> methods = ct.findMethods(filter);
assertFalse(methods.isEmpty());
for (TransformMethodSignature sig : methods)
{
assertFalse(ct.isMethodOverride(sig));
}
verify();
}
@Test
public void check_for_method_override_on_non_declared_method() throws Exception
{
Logger logger = mockLogger();
replay();
ClassTransformation ct = createClassTransformation(SimpleBean.class, logger);
TransformMethodSignature sig = new TransformMethodSignature("methodDoesNotExist");
try
{
ct.isMethodOverride(sig);
unreachable();
}
catch (IllegalArgumentException ex)
{
assertEquals(
ex.getMessage(),
"Method public void methodDoesNotExist() is not implemented by transformed class org.apache.tapestry5.internal.services.SimpleBean.");
}
verify();
}
@Test
public void check_for_overridden_methods() throws Exception
{
Logger logger = mockLogger();
replay();
InternalClassTransformation parentTransform = createClassTransformation(SimpleBean.class, logger);
parentTransform.finish();
CtClass childClass = findCtClass(SimpleBeanSubclass.class);
ClassTransformation childTransform = parentTransform.createChildTransformation(childClass,
stubMutableComponentModel(logger));
assertFalse(childTransform.isMethodOverride(new TransformMethodSignature("notOverridden")));
assertTrue(childTransform.isMethodOverride(new TransformMethodSignature(Modifier.PUBLIC, "void", "setAge",
new String[]
{ "int" }, null)));
}
}