AnnotatedMemberEqualityTest.java

package tools.jackson.databind.introspect;

import org.junit.jupiter.api.Test;

import tools.jackson.databind.DeserializationConfig;
import tools.jackson.databind.JavaType;
import tools.jackson.databind.ObjectMapper;
import tools.jackson.databind.testutil.DatabindTestUtil;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;

public class AnnotatedMemberEqualityTest extends DatabindTestUtil
{
    static class SomeBean {
        private String value;

        public SomeBean(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

    static class NoArgBean {
        public NoArgBean() { }
    }

    static class FactoryBean {
        public static FactoryBean create() {
            return new FactoryBean();
        }
    }

    private final ObjectMapper MAPPER = newJsonMapper();

 // [databind#3187]
    @Test
    public void testAnnotatedConstructorEquality() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance1 = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedClass instance2 = AnnotatedClassResolver.resolve(context, beanType, context);

        AnnotatedConstructor constructor1 = instance1.getConstructors().get(0);
        AnnotatedConstructor constructor2 = instance2.getConstructors().get(0);

        assertEquals(instance1, instance2);
        assertEquals(constructor1.getAnnotated(), constructor2.getAnnotated());
        assertEquals(constructor1, constructor2);
        assertEquals(constructor1.getParameter(0), constructor2.getParameter(0));
    }

    @Test
    public void testAnnotatedConstructorRawParameterTypeIsCached() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedConstructor constructor = instance.getConstructors().get(0);

        assertNull(constructor._paramClasses);
        assertEquals(String.class, constructor.getRawParameterType(0));
        Class<?>[] paramTypes = constructor._paramClasses;
        assertNull(constructor.getRawParameterType(1));
        assertSame(paramTypes, constructor._paramClasses);
    }

    // [databind#6187]
    @Test
    public void annotatedConstructorDoesNotEagerlyConstructInvokers() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedConstructor constructor = instance.getConstructors().get(0);

        assertNull(constructor._invokerNullary);
        assertNull(constructor._invokerUnary);
        assertNull(constructor._invokerFixedArity);
    }

    // [databind#6187]
    @Test
    public void annotatedConstructorBuildsOnlyTheInvokerItUses() throws Exception {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedConstructor constructor = instance.getConstructors().get(0);

        SomeBean created = (SomeBean) constructor.call(new Object[] { "x" });
        assertEquals("x", created.getValue());
        assertNull(constructor._invokerNullary);
        assertNull(constructor._invokerUnary);
        assertNotNull(constructor._invokerFixedArity);

        SomeBean viaCall1 = (SomeBean) constructor.call1("y");
        assertEquals("y", viaCall1.getValue());
        assertNull(constructor._invokerNullary);
        assertNotNull(constructor._invokerUnary);
        assertNotNull(constructor._invokerFixedArity);
    }

    // [databind#6187]
    @Test
    public void annotatedConstructorNullaryCallBuildsOnlyNullaryInvoker() throws Exception {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(NoArgBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedConstructor constructor = instance.getDefaultConstructor();
        assertNotNull(constructor);

        assertNull(constructor._invokerNullary);
        Object created = constructor.call();
        assertEquals(NoArgBean.class, created.getClass());
        assertNotNull(constructor._invokerNullary);
        assertNull(constructor._invokerUnary);
        assertNull(constructor._invokerFixedArity);
    }

    // [databind#6198]
    @Test
    public void annotatedMethodDoesNotEagerlyConstructInvokers() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedMethod getter = instance.findMethod("getValue", new Class<?>[0]);
        assertNotNull(getter);

        assertNull(getter._invokerNullary);
        assertNull(getter._invokerUnary);
        assertNull(getter._invokerFixedArity);
    }

    // [databind#6198]
    @Test
    public void annotatedMethodCallOnBuildsOnlyUnaryInvoker() throws Exception {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedMethod getter = instance.findMethod("getValue", new Class<?>[0]);
        SomeBean bean = new SomeBean("x");

        assertEquals("x", getter.callOn(bean));
        assertNull(getter._invokerNullary);
        assertNotNull(getter._invokerUnary);
        assertNull(getter._invokerFixedArity);
    }

    // [databind#6198]
    @Test
    public void annotatedMethodCallOnWithBuildsOnlyFixedArityInvoker() throws Exception {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedMethod setter = instance.findMethod("setValue", new Class<?>[] { String.class });
        SomeBean bean = new SomeBean("old");

        setter.callOnWith(bean, "new");
        assertEquals("new", bean.getValue());
        assertNull(setter._invokerNullary);
        assertNull(setter._invokerUnary);
        assertNotNull(setter._invokerFixedArity);
    }

    // [databind#6198]
    @Test
    public void annotatedMethodNullaryCallBuildsOnlyNullaryInvoker() throws Exception {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(FactoryBean.class);

        AnnotatedClass instance = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedMethod factory = null;
        for (AnnotatedMethod m : instance.getFactoryMethods()) {
            if ("create".equals(m.getName()) && m.getParameterCount() == 0) {
                factory = m;
                break;
            }
        }
        assertNotNull(factory);

        Object created = factory.call();
        assertEquals(FactoryBean.class, created.getClass());
        assertNotNull(factory._invokerNullary);
        assertNull(factory._invokerUnary);
        assertNull(factory._invokerFixedArity);
    }

    // [databind#3187]
    @Test
    public void testAnnotatedMethodEquality() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance1 = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedClass instance2 = AnnotatedClassResolver.resolve(context, beanType, context);

        String methodName = "setValue";
        Class<?>[] paramTypes = {String.class};
        AnnotatedMethod method1 = instance1.findMethod(methodName, paramTypes);
        AnnotatedMethod method2 = instance2.findMethod(methodName, paramTypes);

        assertEquals(instance1, instance2);
        assertEquals(method1.getAnnotated(), method2.getAnnotated());
        assertEquals(method1, method2);
        assertEquals(method1.getParameter(0), method2.getParameter(0));
    }

    // [databind#3187]
    @Test
    public void testAnnotatedFieldEquality() {
        DeserializationConfig context = MAPPER.deserializationConfig();
        JavaType beanType = MAPPER.constructType(SomeBean.class);

        AnnotatedClass instance1 = AnnotatedClassResolver.resolve(context, beanType, context);
        AnnotatedClass instance2 = AnnotatedClassResolver.resolve(context, beanType, context);

        AnnotatedField field1 = instance1.fields().iterator().next();
        AnnotatedField field2 = instance2.fields().iterator().next();

        assertEquals(instance1, instance2);
        assertEquals(field1.getAnnotated(), field2.getAnnotated());
        assertEquals(field1, field2);
    }
}