AnnotatedTypesTest.java example

Explorer
core-master
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2010, Red Hat, Inc., and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * 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.jboss.weld.tests.unit.util;

import java.util.Iterator;

import javax.enterprise.inject.Default;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.AnnotatedField;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.util.AnnotationLiteral;

import org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType;
import org.jboss.weld.annotated.enhanced.jlr.EnhancedAnnotatedTypeImpl;
import org.jboss.weld.annotated.slim.AnnotatedTypeIdentifier;
import org.jboss.weld.annotated.slim.backed.BackedAnnotatedType;
import org.jboss.weld.bootstrap.api.helpers.RegistrySingletonProvider;
import org.jboss.weld.metadata.TypeStore;
import org.jboss.weld.resources.ClassTransformer;
import org.jboss.weld.resources.ReflectionCacheFactory;
import org.jboss.weld.resources.SharedObjectCache;
import org.jboss.weld.test.util.annotated.TestAnnotatedTypeBuilder;
import org.jboss.weld.util.AnnotatedTypes;
import org.testng.Assert;
import org.testng.annotations.Test;

/**
 * Test comparison and id creation for AnnotatedTypes
 * @author Stuart Douglas <stuart@baileyroberts.com.au>
 *
 */
public class AnnotatedTypesTest {
    /**
     * tests the AnnotatedTypes.compareAnnotatedTypes
     */
    @Test
    public void testComparison() throws SecurityException, NoSuchFieldException, NoSuchMethodException {
        //check that two weld classes on the same underlying are equal
        TypeStore ts = new TypeStore();
        ClassTransformer ct = new ClassTransformer(ts, new SharedObjectCache(), ReflectionCacheFactory.newInstance(ts), RegistrySingletonProvider.STATIC_INSTANCE);
        EnhancedAnnotatedType<Chair> chair1 = EnhancedAnnotatedTypeImpl.of(BackedAnnotatedType.of(Chair.class, ct.getSharedObjectCache(), ct.getReflectionCache(), RegistrySingletonProvider.STATIC_INSTANCE, AnnotatedTypeIdentifier.NULL_BDA_ID), ct);
        EnhancedAnnotatedType<Chair> chair2 = EnhancedAnnotatedTypeImpl.of(BackedAnnotatedType.of(Chair.class, ct.getSharedObjectCache(), ct.getReflectionCache(), RegistrySingletonProvider.STATIC_INSTANCE, AnnotatedTypeIdentifier.NULL_BDA_ID), ct);
        Assert.assertTrue(AnnotatedTypes.compareAnnotatedTypes(chair1, chair2));

        //check that a different implementation of annotated type is equal to the weld implementation
        TestAnnotatedTypeBuilder<Chair> builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToClass(new DefaultLiteral());
        builder.addToField(Chair.class.getField("legs"), new ProducesLiteral());
        builder.addToMethod(Chair.class.getMethod("sit"), new ProducesLiteral());
        AnnotatedType<Chair> chair3 = builder.create();
        Assert.assertTrue(AnnotatedTypes.compareAnnotatedTypes(chair1, chair3));

        //check that the implementation returns false if a field annotation changes
        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToClass(new DefaultLiteral());
        builder.addToField(Chair.class.getField("legs"), new DefaultLiteral());
        builder.addToMethod(Chair.class.getMethod("sit"), new ProducesLiteral());
        chair3 = builder.create();
        Assert.assertFalse(AnnotatedTypes.compareAnnotatedTypes(chair1, chair3));

        //check that the implementation returns false if a class level annotation changes
        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToClass(new ProducesLiteral());
        builder.addToField(Chair.class.getField("legs"), new DefaultLiteral());
        builder.addToMethod(Chair.class.getMethod("sit"), new ProducesLiteral());
        chair3 = builder.create();
        Assert.assertFalse(AnnotatedTypes.compareAnnotatedTypes(chair1, chair3));

    }

    @Test
    public void testFieldId() throws SecurityException, NoSuchFieldException {
        TestAnnotatedTypeBuilder<Chair> builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToField(Chair.class.getField("legs"), new ProducesLiteral());
        AnnotatedType<Chair> chair3 = builder.create();
        AnnotatedField<? super Chair> field = chair3.getFields().iterator().next();
        String id = AnnotatedTypes.createFieldId(field);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.legs[@javax.enterprise.inject.Produces()]", id, "wrong id for field :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        chair3 = builder.create();
        field = chair3.getFields().iterator().next();
        id = AnnotatedTypes.createFieldId(field);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.legs", id, "wrong id for field :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToField(Chair.class.getField("legs"), new ComfyChairLiteral());
        chair3 = builder.create();
        field = chair3.getFields().iterator().next();
        id = AnnotatedTypes.createFieldId(field);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.legs[@org.jboss.weld.tests.unit.util.ComfyChair(softness=1)]", id, "wrong id for field :" + id);
    }

    @Test
    public void testMethodId() throws SecurityException, NoSuchMethodException {
        TestAnnotatedTypeBuilder<Chair> builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToMethod(Chair.class.getMethod("sit"), new ProducesLiteral());
        AnnotatedType<Chair> chair3 = builder.create();
        Iterator<AnnotatedMethod<? super Chair>> it = chair3.getMethods().iterator();
        AnnotatedMethod<? super Chair> method = it.next();
        while (!method.getJavaMember().getName().equals("sit")) method = it.next();
        String id = AnnotatedTypes.createCallableId(method);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.sit[@javax.enterprise.inject.Produces()]()", id, "wrong id for method :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        chair3 = builder.create();
        it = chair3.getMethods().iterator();
        method = it.next();
        while (!method.getJavaMember().getName().equals("sit")) method = it.next();
        id = AnnotatedTypes.createCallableId(method);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.sit()", id, "wrong id for method :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToMethod(Chair.class.getMethod("sit"), new ComfyChairLiteral());
        chair3 = builder.create();
        it = chair3.getMethods().iterator();
        method = it.next();
        while (!method.getJavaMember().getName().equals("sit")) method = it.next();
        id = AnnotatedTypes.createCallableId(method);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair.sit[@org.jboss.weld.tests.unit.util.ComfyChair(softness=1)]()", id, "wrong id for method :" + id);
    }

    @Test
    public void testTypeId() throws SecurityException, NoSuchMethodException {
        TestAnnotatedTypeBuilder<Chair> builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToMethod(Chair.class.getMethod("sit"), new ProducesLiteral());
        AnnotatedType<Chair> chair3 = builder.create();
        String id = AnnotatedTypes.createTypeId(chair3);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair{org.jboss.weld.tests.unit.util.Chair.sit[@javax.enterprise.inject.Produces()]();}", id, "wrong id for type :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        chair3 = builder.create();
        id = AnnotatedTypes.createTypeId(chair3);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair{}", id, "wrong id for type :" + id);

        builder = new TestAnnotatedTypeBuilder<Chair>(Chair.class);
        builder.addToMethod(Chair.class.getMethod("sit"), new ComfyChairLiteral());
        chair3 = builder.create();
        id = AnnotatedTypes.createTypeId(chair3);
        Assert.assertEquals("org.jboss.weld.tests.unit.util.Chair{org.jboss.weld.tests.unit.util.Chair.sit[@org.jboss.weld.tests.unit.util.ComfyChair(softness=1)]();}", id, "wrong id for type :" + id);
    }

    private static class DefaultLiteral extends AnnotationLiteral<Default> implements Default {
    }

    private static class ProducesLiteral extends AnnotationLiteral<Produces> implements Produces {
    }

    private static class ComfyChairLiteral extends AnnotationLiteral<ComfyChair> implements ComfyChair {
        public int softness() {
            return 1;
        }

    }

}