tests: reflection

assira/src/main/java/net/ranides/assira/reflection/util/MemberUtils.java

@@ -60,10 +60,6 @@ public final class MemberUtils {
         return Modifier.isNative(member.getModifiers());
     }
 
-    public static boolean isInterface(Member member) {
-        return Modifier.isInterface(member.getModifiers());
-    }
-
     public static boolean isFinal(Member member) {
         return Modifier.isFinal(member.getModifiers());
     }

assira/src/main/java/net/ranides/assira/reflection/util/MethodUtils.java

@@ -64,7 +64,7 @@ public final class MethodUtils {
      * @throws InspectException
      */
     public static Object invoke(Method method, Object that, Object... arguments) {
-        assert that != null || MemberUtils.isStatic(method);
+        assert that != null || MemberUtils.isStatic(method) : "non-static method require this!=null";
         try {
             return method.invoke(that, arguments);
         } catch (InvocationTargetException ex) {

assira/src/test/java/net/ranides/assira/reflection/mockup/ForMemberUtils.java

@@ -18,14 +18,19 @@ import net.ranides.assira.trace.ExceptionUtils;
 @SuppressWarnings("PMD")
 public abstract class ForMemberUtils {
     
-    public static final Member PUBLIC     = $field("f_public");
-    public static final Member PROTECTED  = $field("f_protected");
-    public static final Member PRIVATE    = $field("f_private");
-    public static final Member FINAL      = $field("f_final");
-    public static final Member STATIC     = $field("f_static");
-    public static final Member ABSTRACT   = $method("m_abstract");
-    public static final Member NO_ABSTRACT= $method("m_no_abstract");
-    public static final Member NOTHING    = $field("f_nothing");
+    public static final Member PUBLIC       = $field("f_public");
+    public static final Member PROTECTED    = $field("f_protected");
+    public static final Member PRIVATE      = $field("f_private");
+    public static final Member FINAL        = $field("f_final");
+    public static final Member STATIC       = $field("f_static");
+    public static final Member VOLATILE     = $field("f_volatile");
+    public static final Member TRANSIENT    = $field("f_transient");
+    public static final Member ABSTRACT     = $method("m_abstract");
+    public static final Member METHOD       = $method("m_no_abstract");
+    public static final Member SYNCHRONIZED = $method("m_synchronized");
+    public static final Member STRICT       = $method("m_strict");
+    public static final Member NATIVE       = $method("m_native");
+    public static final Member NOTHING      = $field("f_nothing");
 //    
     
     public int f_public;
@@ -40,10 +45,20 @@ public abstract class ForMemberUtils {
     
     static int f_static;
     
+    volatile int f_volatile;
+    
+    transient int f_transient;
+    
     public abstract void m_abstract();
     
     public void m_no_abstract() { }
     
+    public synchronized void m_synchronized() { }
+    
+    public strictfp void m_strict() { }
+    
+    public native void m_native();
+    
     private static Field $field(String name) {
         try {
             return ForMemberUtils.class.getDeclaredField(name);

assira/src/test/java/net/ranides/assira/reflection/mockup/ForMethodUtils.java

@@ -10,6 +10,7 @@ package net.ranides.assira.reflection.mockup;
  *
  * @author Ranides Atterwim <ranides@gmail.com>
  */
+@SuppressWarnings("PMD")
 public class ForMethodUtils {
     
     public static class Root {

assira/src/test/java/net/ranides/assira/reflection/util/MemberUtilsTest.java

@@ -25,20 +25,27 @@ public class MemberUtilsTest {
         assertTrue(MemberUtils.isProtected(ForMemberUtils.PROTECTED) );
         assertTrue(MemberUtils.isPrivate(ForMemberUtils.PRIVATE) );
         assertTrue(MemberUtils.isStatic(ForMemberUtils.STATIC) );
+        assertTrue(MemberUtils.isVolatile(ForMemberUtils.VOLATILE) );
+        assertTrue(MemberUtils.isTransient(ForMemberUtils.TRANSIENT) );
         assertTrue(MemberUtils.isFinal(ForMemberUtils.FINAL) );
         assertTrue(MemberUtils.isAbstract(ForMemberUtils.ABSTRACT) );
-        assertFalse(MemberUtils.isAbstract(ForMemberUtils.NO_ABSTRACT) );
-        assertFalse(MemberUtils.isAbstract(ForMemberUtils.FINAL) );
-        
-        
-        
+        assertTrue(MemberUtils.isSynchronized(ForMemberUtils.SYNCHRONIZED) );
+        assertTrue(MemberUtils.isStrict(ForMemberUtils.STRICT) );
+        assertTrue(MemberUtils.isNative(ForMemberUtils.NATIVE) );
         
         assertFalse(MemberUtils.isPublic(ForMemberUtils.NOTHING) );
         assertFalse(MemberUtils.isProtected(ForMemberUtils.NOTHING) );
         assertFalse(MemberUtils.isPrivate(ForMemberUtils.NOTHING) );
         assertFalse(MemberUtils.isStatic(ForMemberUtils.NOTHING) );
+        assertFalse(MemberUtils.isVolatile(ForMemberUtils.NOTHING) );
+        assertFalse(MemberUtils.isTransient(ForMemberUtils.NOTHING) );
         assertFalse(MemberUtils.isFinal(ForMemberUtils.NOTHING) );
         assertFalse(MemberUtils.isAbstract(ForMemberUtils.NOTHING) );
+        assertFalse(MemberUtils.isAbstract(ForMemberUtils.METHOD) );
+        assertFalse(MemberUtils.isAbstract(ForMemberUtils.FINAL) );
+        assertFalse(MemberUtils.isSynchronized(ForMemberUtils.METHOD) );
+        assertFalse(MemberUtils.isStrict(ForMemberUtils.METHOD) );
+        assertFalse(MemberUtils.isNative(ForMemberUtils.METHOD) );
                 
 //        assertFalse(MemberUtils.isInterface(ForMemberUtils.NOTHING) );
 

assira/src/test/java/net/ranides/assira/reflection/util/MethodUtilsTest.java

@@ -17,7 +17,51 @@ import net.ranides.assira.reflection.mockup.ForMethodUtils.*;
  */
 public class MethodUtilsTest {
     
-    public MethodUtilsTest() {
+    @Test
+    public void testInvoke() {
+        String error1 = "java.lang.IllegalArgumentException: object is not an instance of declaring class";
+        String error2 = "java.lang.IllegalArgumentException: argument type mismatch";
+        String error3 = "java.lang.IllegalArgumentException: wrong number of arguments";
+        String error4 = "java.lang.AssertionError: non-static method require this!=null";
+        String error5 = "java.lang.NumberFormatException: NFE";
+
+        
+        Method r2 = $method(Root.class, "fun2");
+        Method b2 = $method(B.class, "fun2");
+        Method b3 = $method(B.class, "fun3");
+
+        Object r = new Root();
+        Object b = new B();
+        Object c1 = new C("c1");
+        Object c2 = new C("c2");
+        
+        assertEquals(null, MethodUtils.invoke(r2, r, 33));
+        assertEquals("hello", MethodUtils.invoke(r2, b, 33));
+        assertEquals("c1#8", MethodUtils.invoke(r2, c1, 8));
+        assertEquals("c2#9", MethodUtils.invoke(r2, c2, 9));
+        
+        
+        
+        assertThrows(e -> error1.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b2, r, 33); 
+        });
+        assertThrows(e -> error1.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b2, c1, 8);
+        });
+        assertEquals("hello", MethodUtils.invoke(b2, b, 33));
+        
+        assertThrows(e -> error5.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b3, b, 'a', 'b');
+        });
+        assertThrows(e -> error2.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b3, b, 'a', 5);
+        });
+        assertThrows(e -> error3.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b3, b, 'a', 'b', 'c');
+        });
+        assertThrows(e -> error4.equals(e.toString()), () -> { 
+            MethodUtils.invoke(b3, null, 'a', 'b', 'c');
+        });
     }
 
     @Test
@@ -80,12 +124,31 @@ public class MethodUtilsTest {
         public void fun1(int a) { }
         
         @Override
-        public String fun2(int a) { return null; }
+        public String fun2(int a) { 
+            return "hello"; 
+        }
         
-        public void fun3(int x, char y) {}
+        public void fun3(int x, char y) {
+            throw new NumberFormatException("NFE");
+        }
         
         void fun4(String z) { }
         
     }
     
+    public static class C extends Root {
+        
+        private final String text;
+
+        public C(String text) {
+            this.text = text;
+        }
+        
+        @Override
+        public String fun2(int a) { 
+            return text + "#" + a; 
+        }
+        
+    }
+        
 }