tests (93)

assira/pom.xml

@@ -48,25 +48,11 @@
                                 <include>net/ranides/assira/lexer/**</include>
                                 
                                 <include>net/ranides/assira/reflection/IAnnotations*</include>
-                                <include>net/ranides/assira/reflection/IArgument*</include>
                                 <include>net/ranides/assira/reflection/IArguments*</include>
-                                <include>net/ranides/assira/reflection/IClasses*</include>
-                                <include>net/ranides/assira/reflection/IElement*</include>
-                                <include>net/ranides/assira/reflection/IElements*</include>
                                 <include>net/ranides/assira/reflection/IField*</include>
                                 <include>net/ranides/assira/reflection/IFields*</include>
-                                <include>net/ranides/assira/reflection/IHints*</include>
-                                <include>net/ranides/assira/reflection/IMethod*</include>
-                                <include>net/ranides/assira/reflection/IMethods*</include>
-                                <include>net/ranides/assira/reflection/IVariable*</include>
-                                <include>net/ranides/assira/reflection/IVariables*</include>
-                                
-<!--                                <include>net/ranides/assira/reflection/impl/*</include>-->
-                                
-                                <include>net/ranides/assira/reflection/impl/AArguments*</include>
-                                <include>net/ranides/assira/reflection/impl/CArgument*</include>
-                                <include>net/ranides/assira/reflection/impl/RArgument*</include>
                                 
+                                <include>net/ranides/assira/reflection/impl/RBean*</include>
                                 <include>net/ranides/assira/reflection/Bean*</include>
                                 
                                 <include>net/ranides/assira/text/LexicalCast*</include>

assira/src/main/java/net/ranides/assira/reflection/IAnnotations.java

@@ -21,10 +21,14 @@ public interface IAnnotations extends IElements<Annotation> {
         return AAnnotations.of(annotations);
     }
     
-    static IAnnotations oflist(Annotation... annotations) {
+    static IAnnotations of(Annotation... annotations) {
         return AAnnotations.of(annotations);
     }
     
+    static IAnnotations of() {
+        return AAnnotations.EMPTY;
+    }
+    
     <A extends Annotation> A first(Class<A> type);
     
     IAnnotations require(Predicate<? super Annotation> predicate);

assira/src/main/java/net/ranides/assira/reflection/impl/AAnnotations.java

@@ -20,7 +20,7 @@ import net.ranides.assira.reflection.util.AnnotationUtils;
  */
 public class AAnnotations extends AElements<Annotation> implements IAnnotations {
     
-    static final AAnnotations EMPTY = new AAnnotations(AHints.EMPTY, CQueryBuilder.empty());
+    public static final AAnnotations EMPTY = new AAnnotations(AHints.EMPTY, CQueryBuilder.empty());
 
     AAnnotations(IHints hints, CQuery<Annotation> stream) {
         super(hints, stream);

assira/src/test/java/net/ranides/assira/reflection/IArgumentsTest.java

@@ -8,12 +8,17 @@ package net.ranides.assira.reflection;
 
 import java.util.Arrays;
 import java.util.List;
+import javax.jws.WebParam;
 import net.ranides.assira.collection.maps.OrderedMap;
 import net.ranides.assira.collection.maps.RandomAccessMap;
 import net.ranides.assira.generic.TypeToken;
 import net.ranides.assira.reflection.mockup.ForIArguments;
 import org.junit.Test;
 import static net.ranides.assira.junit.NewAssert.*;
+import static net.ranides.assira.reflection.IAttribute.*;
+import net.ranides.assira.reflection.mockup.ForMethodUtils;
+import net.ranides.assira.reflection.util.AnnotationBuilder;
+import net.ranides.assira.reflection.util.AnnotationUtils;
 
 /**
  *
@@ -21,6 +26,8 @@ import static net.ranides.assira.junit.NewAssert.*;
  */
 public class IArgumentsTest {
     
+    IClass ic = IClass.typeinfo(ForIArguments.class);
+    
     @Test
     public void testMethods() {
         IArguments a1 = IArguments.typeinfo(new TypeToken<List<String>>(){});
@@ -41,7 +48,7 @@ public class IArgumentsTest {
         args6.put("p2", IClass.typeinfo(char.class));
         IArguments a6 = IArguments.typeinfo(args6);
         
-        IClass ic = IClass.typeinfo(ForIArguments.class);
+        
         
         assertEquals(Arrays.asList("fun6"), ic.methods().require(a1).names());
         assertEquals(Arrays.asList("fun5"), ic.methods().require(a2).names());
@@ -51,4 +58,117 @@ public class IArgumentsTest {
         assertEquals(Arrays.asList("fun8"), ic.methods().require(a6).names());
     }
     
+    @Test
+    public void testNames() {
+        assertEquals(Arrays.asList("a","b"), ic.method("fun1").arguments().names());
+        assertEquals(Arrays.asList("a","b"), ic.method("fun2").arguments().names());
+        assertEquals(Arrays.asList("ia","ib"), ic.method("fun3").arguments().names());
+        assertEquals(Arrays.asList("map"), ic.method("fun4").arguments().names());
+        
+        assertEquals(Arrays.asList(IClass.OBJECT), IClass.OBJECT.method("equals").arguments().types().list());
+        assertThrows(UnsupportedOperationException.class, ()->{
+            IClass.OBJECT.method("equals").arguments().names();
+        });
+    }
+    
+    @Test
+    public void testParent() {
+        IMethod m1 = ic.method("fun1");
+        IMethod m2 = IClass.typeinfo(ForMethodUtils.A.class).method("fun3");
+        IMethod m3 = IClass.typeinfo(ForMethodUtils.B.class).method("fun3");
+        
+        assertEquals(Arrays.asList(m1,m1), m1.arguments().parent().list());
+        assertEquals(Arrays.asList(m2,m2), m2.arguments().parent().list());
+        assertEquals(Arrays.asList(m3,m3), m3.arguments().parent().list());
+        
+        assertEquals(ic, m1.arguments().parent().parent().first());
+        assertEquals(IClass.typeinfo(ForMethodUtils.A.class), m2.arguments().parent().parent().first());
+        assertEquals(IClass.typeinfo(ForMethodUtils.Root.class), m3.arguments().parent().parent().first());
+        
+    }
+    
+    @Test
+    public void testMap() {
+        IMethod m1 = ic.method("fun1");
+        IMethod m2 = IClass.typeinfo(ForMethodUtils.A.class).method("fun3");
+        IMethod m3 = IClass.typeinfo(ForMethodUtils.B.class).method("fun3");
+        IMethod m4 = ic.method("fun4");
+        
+        assertEquals("{a=int a, b=int b}", m1.arguments().map().toString());
+        assertEquals("{x=int x, y=char y}", m2.arguments().map().toString());
+        assertEquals("{x=int x, y=int y}", m3.arguments().map().toString());
+        assertEquals("{map=java.util.Map<java.lang.Integer, java.lang.String> map}", m4.arguments().map().toString());
+        
+        assertEquals("[int a, int b]", m1.arguments().reflective().list().toString());
+        assertEquals("[int x, char y]", m2.arguments().reflective().list().toString());
+        assertEquals("[int x, int y]", m3.arguments().reflective().list().toString());
+        assertEquals("[java.util.Map<java.lang.Integer, java.lang.String> map]", m4.arguments().reflective().list().toString());
+    }
+    
+    @Test
+    public void testAttributes() {
+        List<IArgument> params = ic.method("fun9").arguments().list();
+        
+        assertEquals(collect(PACKAGE, DECLARED), params.get(0).attributes());
+        assertEquals(collect(PACKAGE, DECLARED, PARAMETERIZED), params.get(1).attributes());
+    }
+    
+    @Test
+    public void testAnnotations() {
+        List<IArgument> params = ic.method("fun9").arguments().list();
+        Deprecated a1 = AnnotationUtils.make(Deprecated.class);
+        WebParam a2 = new AnnotationBuilder<>(WebParam.class)
+                .param("name", "yparam")
+                .result();
+        assertEquals(Arrays.asList(a1), params.get(0).annotations().list());
+        assertEquals(Arrays.asList(a2), params.get(1).annotations().list());
+        
+        IArguments cparams = IArguments.typeinfo(IClass.typeinfo(boolean.class), new TypeToken<List<String>>(){});
+        
+        assertThrows(UnsupportedOperationException.class, ()->{
+            cparams.names();
+        });
+        
+        assertSymEquals(cparams.list(), params);
+        assertSymEquals(cparams.list().get(0), params.get(0));
+        assertSymEquals(cparams.list().get(1), params.get(1));
+    }
+    
+    @Test
+    public void testCParams() {
+        IArguments cparams1 = IArguments.typeinfo(
+            IClass.typeinfo(boolean.class), 
+            new TypeToken<List<String>>(){}
+        );
+        
+        assertThrows(UnsupportedOperationException.class, ()->{
+            cparams1.names();
+        });
+        
+        RandomAccessMap<String, IClass> iparams2 = new RandomAccessMap<>();
+        iparams2.put("name", IClass.typeinfo(boolean.class));
+        iparams2.put("list", new TypeToken<List<String>>(){});
+        
+        IArguments cparams2 = IArguments.typeinfo(iparams2);
+        assertEquals(Arrays.asList("name","list"), cparams2.names());
+        
+        assertEquals(collect(PACKAGE, DECLARED), cparams2.list().get(0).attributes());
+        assertEquals(collect(PACKAGE, DECLARED, PARAMETERIZED), cparams2.list().get(1).attributes());
+        
+        assertEquals(IAnnotations.of(), cparams2.list().get(0).annotations());
+        assertEquals(IAnnotations.of(), cparams2.list().get(1).annotations());
+        
+        assertEquals(IContext.DEFAULT, cparams2.list().get(0).context());
+        assertEquals(IContext.DEFAULT, cparams2.list().get(1).context());
+
+        assertThrows(UnsupportedOperationException.class, ()->{
+            cparams2.parent().list();
+        });
+        assertThrows(UnsupportedOperationException.class, ()->{
+            cparams2.reflective().list();
+        });
+        
+    }
+    
+    
 }

assira/src/test/java/net/ranides/assira/reflection/impl/AFieldsTest.java

@@ -8,6 +8,7 @@ package net.ranides.assira.reflection.impl;
 
 import java.lang.reflect.Field;
 import java.util.Arrays;
+import java.util.List;
 import net.ranides.assira.annotations.Meta;
 import net.ranides.assira.reflection.IAnnotations;
 import net.ranides.assira.reflection.IClass;
@@ -61,26 +62,26 @@ public class AFieldsTest {
     
     @Test
     public void testDiscardAttr() {
-        assertEquivalent(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(TRANSIENT).names());
-        assertEquivalent(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(PUBLIC).names());
+        assertEquiList(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(TRANSIENT).names());
+        assertEquiList(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(PUBLIC).names());
         
-        assertEquivalent(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT)).names());
-        assertEquivalent(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(collect(PUBLIC)).names());
-        assertEquivalent(Arrays.asList("b","b", "c", "c", "b2", "c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT, PUBLIC)).names());
+        assertEquiList(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT)).names());
+        assertEquiList(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(collect(PUBLIC)).names());
+        assertEquiList(Arrays.asList("b","b", "c", "c", "b2", "c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT, PUBLIC)).names());
     }
     
     @Test
     public void testReflective() {
-        assertEquivalent(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(TRANSIENT).reflective().map(Field::getName).list());
-        assertEquivalent(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(PUBLIC).reflective().map(Field::getName).list());
+        assertEquiList(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(TRANSIENT).reflective().map(Field::getName).list());
+        assertEquiList(Arrays.asList("b","b", "c", "c", "b2"), ic.fields().discard(PUBLIC).reflective().map(Field::getName).list());
         
-        assertEquivalent(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT)).reflective().map(Field::getName).list());
+        assertEquiList(Arrays.asList("c2", "f1", "f4"), ic.fields().discard(collect(TRANSIENT)).reflective().map(Field::getName).list());
     }
     
     @Test
     public void testDiscardName() {
-        assertEquivalent(Arrays.asList("c", "c", "b2"), ic.fields().discard(PUBLIC).discard("b").names());
-        assertEquivalent(Arrays.asList("b","b", "b2"), ic.fields().discard(PUBLIC).discard("c").names());
+        assertEquiList(Arrays.asList("c", "c", "b2"), ic.fields().discard(PUBLIC).discard("b").names());
+        assertEquiList(Arrays.asList("b","b", "b2"), ic.fields().discard(PUBLIC).discard("c").names());
     }
     
     @Test
@@ -96,7 +97,9 @@ public class AFieldsTest {
         assertEquivalent(Arrays.asList(ForFields.B.class, ForFields.A.class), ic.fields().require("a").parent().reflective().list());
     }
     
-    private static void assertEquivalent2(Object i, Object b) {
-        System.out.printf("%s%n", b);
+    private static void assertEquiList(List<String> expected, List<String> values) {
+        while(values.remove("$jacocoData")) { }
+        assertEquivalent(expected, values);
     }
+    
 }

assira/src/test/java/net/ranides/assira/reflection/impl/RFieldTest.java

@@ -57,9 +57,9 @@ public class RFieldTest {
         List<String> exp1 = Arrays.asList("Record rid", "Record name", "ARecord AMAX", "ARecord aid", "ARecord name");
         List<String> exp2 = Arrays.asList("Record rid", "Record pid", "Record name");
         List<String> exp3 = Arrays.asList("Record rid", "Record pid", "Record name", "ARecord AMAX", "ARecord APRIV", "ARecord aid", "ARecord pid", "ARecord name");
-        assertEquivalent(exp1, cr.fields().list(this::field2str));
-        assertEquivalent(exp2, cr.fields().require(IAttribute.DECLARED).list(this::field2str));
-        assertEquivalent(exp3, cr.fields().require(IAttribute.ANY).list(this::field2str));
+        assertEquiList(exp1, cr.fields().list(this::field2str));
+        assertEquiList(exp2, cr.fields().require(IAttribute.DECLARED).list(this::field2str));
+        assertEquiList(exp3, cr.fields().require(IAttribute.ANY).list(this::field2str));
     }
     
     private String field2str(IField f) {
@@ -135,6 +135,13 @@ public class RFieldTest {
         });
          
     }
+    
+    private static void assertEquiList(List<String> expected, List<String> values) {
+        while(values.remove("$jacocoData")) { }
+        while(values.remove("Record $jacocoData")) { }
+        while(values.remove("ARecord $jacocoData")) { }
+        assertEquivalent(expected, values);
+    }
 
     
 }

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

@@ -8,6 +8,8 @@ package net.ranides.assira.reflection.mockup;
 
 import java.util.List;
 import java.util.Map;
+import javax.jws.WebParam;
+import net.ranides.assira.annotations.Meta;
 
 /**
  *
@@ -37,4 +39,9 @@ public class ForIArguments {
     
     public void fun8(boolean x, char y) { }
     
+    public void fun9(
+        @Deprecated boolean reserved, 
+        @WebParam(name = "yparam") List<String> list
+    ) { }
+    
 }