IntrospectorTest.java

/**
 * Copyright (C) 2008 Mathieu Carbou <mathieu.carbou@gmail.com>
 *
 * 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 com.mycila.testing.core.introspect;

import com.mycila.testing.MycilaTestingException;
import com.mycila.testing.core.MyPlugin;
import static com.mycila.testing.core.introspect.Filters.*;
import static org.testng.Assert.*;
import org.testng.annotations.Test;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;

/**
 * @author Mathieu Carbou (mathieu.carbou@gmail.com)
 */
public final class IntrospectorTest {

    String field1;

    public int field2;

    @Annot
    private int field3;

    @Test
    public void test_all() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.instance(), this);
    }

    @Test
    public void test_filter_all() throws Exception {
        Introspector ti = new Introspector(this);
        System.out.println(ti.selectFields(Filters.<Field>all()));
        assertEquals(ti.selectFields(Filters.<Field>all()).size(), 3);
    }

    @Test
    public void test_filter_none() throws Exception {
        Introspector ti = new Introspector(this);
        System.out.println(ti.selectFields(Filters.<Field>all()));
        assertEquals(ti.selectFields(Filters.<Field>none()).size(), 0);
    }

    @Test
    public void test_filter_not() throws Exception {
        Introspector ti = new Introspector(this);
        System.out.println(ti.selectFields(not(fieldsAccepting(int.class))));
        assertEquals(ti.selectFields(not(fieldsAccepting(int.class))).size(), 1);
    }

    @Test
    public void test_getTargetClass() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.testClass(), getClass());
    }

    @Test
    public void test_getFieldsOfType() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectFields(fieldsAccepting(int.class)).size(), 2);
        assertEquals(ti.selectFields(fieldsAccepting(int.class)).get(0).getName(), "field2");
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test_getFieldsOfType_null() throws Exception {
        Introspector ti = new Introspector(this);
        ti.selectFields(null);
    }

    @Test
    public void test_getFieldsOfTypeAnnotatedWith() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectFields(and(fieldsAccepting(int.class), fieldsAnnotatedBy(Annot.class))).size(), 1);
        assertEquals(ti.selectFields(and(fieldsAccepting(int.class), fieldsAnnotatedBy(Annot.class))).get(0).getName(), "field3");
    }

    @Test
    public void test_getFieldsAnnotatedWith() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectFields(fieldsAnnotatedBy(Annot.class)).size(), 1);
        assertEquals(ti.selectFields(fieldsAnnotatedBy(Annot.class)).get(0).getName(), "field3");
    }

    @Test
    public void test_getFieldsAnnotatedWith_accessibility() throws Exception {
        Introspector ti = new Introspector(new MyPlugin());
        assertEquals(ti.selectFields(fieldsAnnotatedBy(Annot.class)).size(), 1);
    }

    @Test
    public void test_getMethodsOfType() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(methodsReturning(int.class)).size(), 1);
    }

    @Test
    public void test_getMethodsOfType2() throws Exception {
        Introspector ti = new Introspector(this);
        List<Method> m = ti.selectMethods(methodsReturning(String.class));
        for (Method method : m) {
            System.out.println("- " + method.getName());
        }
        assertEquals(m.size(), 1);
    }

    @Test
    public void test_getMethodsOfType3() throws Exception {
        Introspector ti = new Introspector(this);
        List<Method> m = ti.selectMethods(methodsReturning(CharSequence.class));
        for (Method method : m) {
            System.out.println("- " + method.getName());
        }
        assertEquals(m.size(), 1);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test_getMethodsOfType_null() throws Exception {
        Introspector ti = new Introspector(this);
        ti.selectMethods(methodsReturning(null));
    }

    static interface I {
        void method3();
    }

    @Test
    public void test_getMethodsAnnotatedWith_inherited() throws Exception {
        abstract class A implements I {
            private void method1() {
            }

            void method2() {
            }

            protected abstract void method4();
        }
        class B extends A {
            private void method1() {
            }

            CharSequence method2(String s) {
                return null;
            }

            public void method3() {
            }

            @Override
            protected final void method4() {
            }
        }
        class C extends B {
            @Override
            String method2(String s) {
                return null;
            }

            @Override
            public void method3() {
            }
        }
        Introspector ti = new Introspector(new C());
        System.out.println("selected:");
        for (Method method : ti.selectMethods(Filters.<Method>all())) {
            System.out.println("- " + method);
        }
        assertEquals(ti.selectMethods(Filters.<Method>all()).size(), 10); // a volatile method is created for B.method2
        System.out.println("selected:");
        for (Method method : ti.selectMethods(excludeOverridenMethods(Filters.<Method>all()))) {
            System.out.println("- " + method);
        }
        assertEquals(ti.selectMethods(excludeOverridenMethods(Filters.<Method>all())).size(), 6);
    }

    @Test
    public void test_getMethodsAnnotatedWith() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(methodsAnnotatedBy(Test.class)).size(), 22);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test_getMethodsAnnotatedWith_null() throws Exception {
        Introspector ti = new Introspector(this);
        ti.selectMethods(methodsAnnotatedBy(null));
    }

    @Test
    public void test_getMethodsOfTypeAnnotatedWith() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(and(methodsReturning(int.class), methodsAnnotatedBy(Annot.class))).size(), 1);
    }

    @Test
    public void test_invoke() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(and(methodsReturning(String.class), methodsAnnotatedBy(Annot.class))).size(), 1);
        assertEquals(ti.invoke(ti.selectMethods(and(methodsReturning(String.class), methodsAnnotatedBy(Annot.class))).get(0)), "10");
    }

    @Test(expectedExceptions = MycilaTestingException.class)
    public void test_invoke_exc() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(and(methodsReturning(int.class), methodsAnnotatedBy(Annot.class))).size(), 1);
        ti.invoke(ti.selectMethods(and(methodsReturning(int.class), methodsAnnotatedBy(Annot.class))).get(0));
    }

    @Test(expectedExceptions = MycilaTestingException.class)
    public void test_invoke_bad_args() throws Exception {
        Introspector ti = new Introspector(this);
        assertEquals(ti.selectMethods(and(methodsReturning(String.class), methodsAnnotatedBy(Annot.class))).size(), 1);
        ti.invoke(ti.selectMethods(and(methodsReturning(String.class), methodsAnnotatedBy(Annot.class))).get(0), 10, 20);
    }

    @Test
    public void test_get_set() throws Exception {
        Introspector ti = new Introspector(new MyPlugin());
        assertNull(ti.get(ti.selectFields(fieldsAnnotatedBy(Annot.class)).get(0)));
        ti.set(ti.selectFields(fieldsAnnotatedBy(Annot.class)).get(0), 10);
        assertEquals(ti.get(ti.selectFields(fieldsAnnotatedBy(Annot.class)).get(0)), 10);
    }

    @Annot
    private String method() throws Exception {
        return "10";
    }

    @Annot
    private int method2() throws Exception {
        throw new IllegalArgumentException("error !");
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.FIELD, ElementType.METHOD})
    @Inherited
    public static @interface Annot {
    }
}