package net.bytebuddy.implementation.bind.annotation;
import net.bytebuddy.description.annotation.AnnotationDescription;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.method.ParameterDescription;
import net.bytebuddy.description.type.TypeDefinition;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.implementation.Implementation;
import net.bytebuddy.implementation.bytecode.StackManipulation;
import net.bytebuddy.implementation.bytecode.assign.Assigner;
import net.bytebuddy.test.utility.MockitoRule;
import org.hamcrest.CoreMatchers;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.lang.annotation.Annotation;
import java.util.Collections;
import java.util.Iterator;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.*;
public abstract class AbstractAnnotationBinderTest<T extends Annotation> extends AbstractAnnotationTest<T> {
@Rule
public TestRule mockitoRule = new MockitoRule(this);
protected AnnotationDescription.Loadable<T> annotationDescription;
protected T annotation;
@Mock
protected MethodDescription.InDefinedShape source;
@Mock
protected ParameterDescription target;
@Mock
protected Implementation.Target implementationTarget;
@Mock
protected TypeDescription instrumentedType, sourceDeclaringType, targetDeclaringType;
@Mock
protected Assigner assigner;
@Mock
protected StackManipulation stackManipulation;
protected AbstractAnnotationBinderTest(Class<T> annotationType) {
super(annotationType);
}
protected abstract TargetMethodAnnotationDrivenBinder.ParameterBinder<T> getSimpleBinder();
@Test
public void testHandledType() throws Exception {
assertThat(getSimpleBinder().getHandledType(), CoreMatchers.<Class<?>>is(annotationType));
}
@Before
@SuppressWarnings("unchecked")
public void setUp() throws Exception {
when(sourceDeclaringType.asErasure()).thenReturn(sourceDeclaringType);
when(targetDeclaringType.asErasure()).thenReturn(targetDeclaringType);
when(source.getDeclaringType()).thenReturn(sourceDeclaringType);
annotation = mock(annotationType);
doReturn(annotationType).when(annotation).annotationType();
annotationDescription = AnnotationDescription.ForLoadedAnnotation.of(annotation);
when(assigner.assign(any(TypeDescription.Generic.class), any(TypeDescription.Generic.class), any(Assigner.Typing.class))).thenReturn(stackManipulation);
when(implementationTarget.getInstrumentedType()).thenReturn(instrumentedType);
when(implementationTarget.getOriginType()).thenReturn(instrumentedType);
when(instrumentedType.asErasure()).thenReturn(instrumentedType);
when(instrumentedType.iterator()).then(new Answer<Iterator<TypeDefinition>>() {
@Override
public Iterator<TypeDefinition> answer(InvocationOnMock invocationOnMock) throws Throwable {
return Collections.<TypeDefinition>singleton(instrumentedType).iterator();
}
});
}
}