vm/tests/kernel/org/apache/harmony/lang/annotation/AllTypesTest.java

/*
 *  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.harmony.lang.annotation;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Method;

import org.apache.harmony.lang.AnnotatedElementTestFrame.MissingClassValAntn;

import junit.framework.TestCase;

/**
 * The test of annotation implementation, covering all possible types of elements.
 * 
 * @author Alexey V. Varlamov
 */
@AllTypesAntn
public class AllTypesTest extends TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run(AllTypesTest.class);
    }
    
    /**
     * The annotation instance should return correct default values 
     * of elements if no actual values were specified. 
     */
    public void testGetAnnotation_ByDefault() throws Throwable {
        AllTypesAntn antn = AllTypesAntn.class.getAnnotation(AllTypesAntn.class);
        assertNotNull("the annotation", antn);
        Method[] ms = AllTypesAntn.class.getDeclaredMethods();
        for (Method m : ms) {
            Object defaultValue = m.getDefaultValue();
            String name = m.getName();
            assertNotNull("null defaultValue of " + name, defaultValue);
            Object value = m.invoke(antn);
            assertNotNull("null value of " + name, value);
            Class<?> def = m.getReturnType();
            Class<?> real = value.getClass();
            if (def.isAnnotation()) {
                assertTrue("nested antn value type : def=" + def + "; real=" + real, def.isInstance(value));
            } else if (def.isPrimitive()) {
                assertSame("unboxed value type", def, real.getField("TYPE").get(null));
            } else {
                assertSame("value type", def, real);
            }
            
            if (m.getReturnType().isArray()) {
                int len = Array.getLength(defaultValue);
                assertEquals("array length of " + m.getName(), len, Array.getLength(value));
                for (int i = 0; i < len; i++) {
                    assertEquals(m.getName() + "["+i+"]", Array.get(defaultValue, i), Array.get(value, i));
                }
            } else {
                assertEquals(m.getName(), defaultValue, value);
            }
        }
    }
    
    /**
     * The annotation instance should return correct actual values 
     * of elements overriding their defaults. 
     */
    public void testGetAnnotation_NoDefault() throws Throwable {
        AllTypesAntn2 antn = AllTypesAntn2.class.getAnnotation(AllTypesAntn2.class);
        assertNotNull("the annotation", antn);
        Method[] ms = AllTypesAntn2.class.getDeclaredMethods();
        for (Method m : ms) {
            Object defaultValue = m.getDefaultValue();
            String name = m.getName();
            assertNull("defaultValue of " + name, defaultValue);
            Object value = m.invoke(antn);
            assertNotNull("null value of " + name, value);
            Class<?> def = m.getReturnType();
            Class<?> real = value.getClass();
            if (def.isAnnotation()) {
                assertTrue("nested antn value type : def=" + def + "; real=" + real, def.isInstance(value));
            } else if (def.isPrimitive()) {
                assertSame("unboxed value type", def, real.getField("TYPE").get(null));
            } else {
                assertSame("value type", def, real);
            }
        }
    }
    
    /**
     * The equals() method of annotation instance 
     * must true if equivalent annotation instance is passed, false otherwise.
     */
    @AllTypesAntn(intArrayValue=346546)
    public void testEquals() throws Throwable {
        AllTypesAntn antn = AllTypesAntn.class.getAnnotation(AllTypesAntn.class);
        assertTrue("case1", antn.equals(antn));
        Object obj = this.getClass().getAnnotation(AllTypesAntn.class);
        assertEquals("case2", obj, antn);
        assertEquals("case2_1", obj.hashCode(), antn.hashCode());
        AllTypesAntn2 antn2 = AllTypesAntn2.class.getAnnotation(AllTypesAntn2.class);
        assertEquals("case3", antn2, AllTypesAntn2.class.getAnnotation(AllTypesAntn2.class));
        assertFalse("case4", antn.equals(antn2));
        assertFalse("case5", antn.equals(
                this.getClass().getMethod("testEquals").getAnnotation(AllTypesAntn.class)));
    }

    /**
     * The equals() method of annotation instance 
     * must correctly work with alternative implementations.
     */
    public void testEquals_ForeignImpl() throws Throwable {
        AllTypesAntn antn = AllTypesAntn.class.getAnnotation(AllTypesAntn.class);
        assertTrue(antn.equals(new AllTypesAntn.MockedImpl()));
    }
    
    /**
     * The toString() method of annotation instance 
     * must return meaningful description.
     */
    public void testToString() throws Throwable {
        String s = AllTypesAntn.class.getAnnotation(AllTypesAntn.class).toString();
        assertNotNull(s);
        assertTrue(s.length() != 0);
        assertTrue(s.startsWith("@org.apache.harmony.lang.annotation.AllTypesAntn"));
    }
    
    /**
     * The annotationType() method of annotation instance 
     * must return correct Class.
     */
    public void testAnnotationType() throws Throwable {
        assertSame(AllTypesAntn.class, 
                AllTypesAntn.class.getAnnotation(AllTypesAntn.class).annotationType());
    }

    /**
     * An annotation should defer throwing TypeNotPresentException
     * for a Class-valued member until the member accessed.
     */
    @MissingClassValAntn
    public void testAnnotation_ElementError() throws Throwable {
        MissingClassValAntn antn = this.getClass().getMethod(
                "testAnnotation_ElementError").getAnnotation(MissingClassValAntn.class);
        try {
            antn.clss();
            fail("Misconfigured test: "
                    + "notfound.MissingClass should not be in classpath");
        } catch (TypeNotPresentException tnpe) {
            assertTrue("reported type name: " + tnpe.typeName(), 
                    tnpe.typeName().matches("notfound.MissingClass"));
        }

        try {
            antn.clssArray();
            fail("Misconfigured test: "
                    + "notfound.MissingClass should not be in classpath");
        } catch (TypeNotPresentException tnpe) {
            assertTrue("reported type name: " + tnpe.typeName(), 
                    tnpe.typeName().matches("notfound.MissingClass"));
        }
    }

    /**
     * Tests that annotation can be serialized and deserialized without
     * exceptions, and that deserialization really produces deeply cloned
     * objects.
     */
    public void testSerialization() throws Throwable {
        Object[] arr = new Object[] {
                AllTypesAntn.class.getAnnotation(AllTypesAntn.class),
                AllTypesAntn2.class.getAnnotation(AllTypesAntn2.class)
        };
        for (Object data : arr) {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            putObjectToStream(data, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos
                    .toByteArray());
            assertEquals(data, getObjectFromStream(bis));
        }
    }
    
    /**
     * Serializes specified object to an output stream.
     */
    static void putObjectToStream(Object obj, OutputStream os)
        throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(obj);
        oos.flush();
        oos.close();
    }

    /**
     * Deserializes single object from an input stream.
     */
    static Object getObjectFromStream(InputStream is) throws IOException,
        ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(is);
        Object result = ois.readObject();
        ois.close();
        return result;
    }
}