tests (94)

fix: CompareUtils - NPE for numbers
new: ValueUtils#eval

assira/pom.xml

@@ -40,10 +40,8 @@
                                 <include>net/ranides/assira/collection/lists/IntRange*</include>
                                 <include>net/ranides/assira/collection/utils/**</include>
                                 <include>net/ranides/assira/functional/**</include>
-                                <include>net/ranides/assira/generic/CompareUtils*</include>
                                 <include>net/ranides/assira/generic/LazyReference*</include>
                                 <include>net/ranides/assira/generic/SerializationUtils*</include>
-                                <include>net/ranides/assira/generic/ValueUtils*</include>
                                 <include>net/ranides/assira/generic/Wrapper*</include>
                                 <include>net/ranides/assira/io/FileUtils*</include>
                                 <include>net/ranides/assira/io/IOUtils*</include>

assira/src/main/java/net/ranides/assira/generic/CompareUtils.java

@@ -43,7 +43,7 @@ public final class CompareUtils {
      */
     public static boolean equals(Object a, Object b, double precision) {
         if(a instanceof Number && b instanceof Number) {
-            return equals((Number)a, (Number)b);
+            return equals((Number)a, (Number)b, precision);
         } else {
             return CompareUtils.equals(a, b);
         }
@@ -57,7 +57,7 @@ public final class CompareUtils {
      * @return
      */
     public static boolean equals(Number a, Number b, double precision) {
-        return Math.abs(a.doubleValue() - b.doubleValue()) <= precision;
+        return (null==a) ? (null==b) : (null!=b) && (Math.abs(a.doubleValue() - b.doubleValue()) <= precision);
     }
     
     @SuppressWarnings("unchecked")
@@ -128,8 +128,8 @@ public final class CompareUtils {
         }
     }
 
-    public static <T> Comparator reversed(Comparator<T> comparator) {
-        return (Comparator<T>) (a, b) -> -comparator.compare(a, b);
+    public static <T> Comparator<T> reversed(Comparator<T> comparator) {
+        return (Comparator<T>) (a, b) -> comparator.compare(b, a);
     }
     
     private static final class NComparator implements Comparator<Comparable>, Serializable {

assira/src/main/java/net/ranides/assira/generic/SerializationUtils.java

@@ -112,7 +112,7 @@ public final class SerializationUtils {
 
         @Override
         public String toString() {
-            return String.format("sizeof = { sum : %d, self : %d, attached : %d }", size, element, overhead);
+            return String.format("sizeof = { size : %d, element : %d, overhead : %d }", size, element, overhead);
         }
 
     }

assira/src/main/java/net/ranides/assira/generic/ValueUtils.java

@@ -6,6 +6,8 @@
  */
 package net.ranides.assira.generic;
 
+import java.util.function.Supplier;
+
 
 @SuppressWarnings({
     "PMD.ShortVar", 
@@ -47,5 +49,17 @@ public final class ValueUtils {
         if(null!=b) { return b; }
         return null;
     }
+	
+	public static <T> T eval(T ddefault, Supplier<T> supplier) {
+		try {
+			T s = supplier.get();
+			if(s != null) {
+				return s;
+			}
+		} catch(NullPointerException $0) {
+			// do nothing
+		}
+		return ddefault;
+	}
 
 }

assira/src/test/java/net/ranides/assira/generic/CompareUtilsTest.java

@@ -0,0 +1,78 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.generic;
+
+import java.util.Comparator;
+import net.ranides.assira.collection.IntComparator;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class CompareUtilsTest {
+	
+	public CompareUtilsTest() {
+	}
+
+	@Test
+	public void testEqualsObject() {
+		assertTrue( CompareUtils.equals("a", "a"));
+		assertFalse( CompareUtils.equals("#", "a"));
+		assertFalse( CompareUtils.equals(null, "a"));
+		assertFalse( CompareUtils.equals("a", null));
+		assertTrue( CompareUtils.equals(null, null));
+	}
+	
+	@Test
+	public void testEqualsObject_precision() {
+		assertTrue( CompareUtils.equals("a", "a", 1));
+		assertFalse( CompareUtils.equals("#", "a", 1));
+		assertFalse( CompareUtils.equals(null, "a", 1));
+		assertFalse( CompareUtils.equals("a", null, 1));
+		assertTrue( CompareUtils.equals((Object)null, (Object)null, 1));
+		
+		assertTrue( CompareUtils.equals((Object)10.0, (Object)9.5, 1));
+		assertFalse( CompareUtils.equals((Object)10.0, (Object)8.5, 1));
+		assertFalse( CompareUtils.equals(null, (Object)8.5, 1));
+		assertFalse( CompareUtils.equals((Object)8.5, null, 1));
+	}
+	
+	@Test
+	public void testEqualsNumber() {
+		assertTrue( CompareUtils.equals((Number)10.0, (Number)9.5, 1));
+		assertFalse( CompareUtils.equals((Number)10.0, (Number)8.5, 1));
+		assertFalse( CompareUtils.equals((Number)null, (Number)8.5, 1));
+		assertFalse( CompareUtils.equals((Number)8.5, (Number)null, 1));
+		assertTrue( CompareUtils.equals((Number)null, (Number)null, 1));
+	}
+	
+	@Test
+	public void testCmp() {
+		assertTrue( CompareUtils.cmp(1,3) < 0);
+		assertTrue( CompareUtils.cmp(5,3) > 0);
+		assertTrue( CompareUtils.cmp(5,5) == 0);
+	}
+	
+	@Test
+	public void testComparator() {
+		assertTrue(CompareUtils.<Integer>comparator(int.class) instanceof IntComparator);
+		assertTrue(CompareUtils.<Integer>comparator(Integer.class) instanceof IntComparator);
+		assertFalse(CompareUtils.<Integer>comparator(float.class) instanceof IntComparator);
+	}
+	
+	@Test
+	public void testReverse() {
+		Comparator<Integer> nc = CompareUtils.comparator();
+		Comparator<Integer> rc = CompareUtils.reversed(nc);
+		assertTrue( rc.compare(1,3) > 0);
+		assertTrue( rc.compare(5,3) < 0);
+		assertTrue( rc.compare(5,5) == 0);
+	}
+	
+}

assira/src/test/java/net/ranides/assira/generic/SerializationUtilsTest.java

@@ -0,0 +1,74 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.generic;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import static net.ranides.assira.junit.NewAssert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class SerializationUtilsTest {
+	
+	@Test
+	public void testCopy() throws IOException {
+		List<Integer> a = new ArrayList<Integer>(Arrays.asList(1,2,3,4));
+		List<Integer> b = SerializationUtils.copy(a);
+		
+		assertEquals(a,b);
+		assertEquals(a.getClass(),b.getClass());
+	}
+	
+	@Test
+	public void testSizeOf() throws IOException {
+		List<Integer> a1 = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8));
+		List<Integer> a2 = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
+		List<Float> b1 = new ArrayList<Float>(Arrays.asList(1.f, 2.f, 3.f, 4.f));
+		List<Float> b2 = new ArrayList<Float>(Arrays.asList(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f));
+		List<String> c1 = new ArrayList<String>(Arrays.asList("T1", "T2", "T3", "T4", "T5", "T6", "T7", "T8"));
+		List<String> c2 = new ArrayList<String>(Arrays.asList(
+			"T1....................................1",
+			"T2....................................2",
+			"T3....................................3",
+			"T4....................................4",
+			"T5....................................5",
+			"T6....................................6",
+			"T7....................................7",
+			"T8....................................8"
+		));
+		SerializationUtils.SizeInfo ia1 =  SerializationUtils.sizeof(a1);
+		SerializationUtils.SizeInfo ia2 =  SerializationUtils.sizeof(a2);
+		SerializationUtils.SizeInfo ib1 =  SerializationUtils.sizeof(b1);
+		SerializationUtils.SizeInfo ib2 =  SerializationUtils.sizeof(b2);
+		SerializationUtils.SizeInfo ic1 =  SerializationUtils.sizeof(c1);
+		SerializationUtils.SizeInfo ic2 =  SerializationUtils.sizeof(c2);
+		
+//		System.out.printf("a1 %s%n", ia1);
+//		System.out.printf("a2 %s%n", ia2);
+//		System.out.printf("b1 %s%n", ib1);
+//		System.out.printf("b2 %s%n", ib2);
+//		System.out.printf("c1  %s%n", ic1);
+//		System.out.printf("c2  %s%n", ic2);
+//		
+		assertTrue( ia1.size() < ia2.size());
+		assertTrue( ia1.element() == ia2.element());
+		
+		assertTrue( ib1.size() < ib2.size());
+		assertTrue( ib1.element() == ib2.element());
+		
+		assertTrue( ic1.size() < ic2.size());
+		assertTrue( ic1.element()< ic2.element());
+		
+		
+	}
+	
+}

assira/src/test/java/net/ranides/assira/generic/ValueUtilsTest.java

@@ -0,0 +1,67 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.generic;
+
+import net.ranides.assira.junit.NewAssert;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class ValueUtilsTest {
+	
+	public ValueUtilsTest() {
+	}
+
+	@Test
+	public void testIsTrue() {
+		assertTrue(ValueUtils.isTrue(true));
+		assertTrue(ValueUtils.isTrue(Boolean.TRUE));
+		assertFalse(ValueUtils.isTrue(false));
+		assertFalse(ValueUtils.isTrue(Boolean.FALSE));
+		
+		assertFalse(ValueUtils.isTrue("true"));
+		assertFalse(ValueUtils.isTrue(77));
+		assertFalse(ValueUtils.isTrue(null));
+	}
+	
+	@Test
+	public void testIsFalse() {
+		assertTrue(ValueUtils.isFalse(false));
+		assertTrue(ValueUtils.isFalse(Boolean.FALSE));
+		assertFalse(ValueUtils.isFalse(true));
+		assertFalse(ValueUtils.isFalse(Boolean.TRUE));
+		
+		assertFalse(ValueUtils.isFalse("false"));
+		assertFalse(ValueUtils.isFalse(77));
+		assertFalse(ValueUtils.isFalse(null));
+	}
+	
+	@Test
+	public void testOr() {
+		assertEquals("a", ValueUtils.or(null, null, "a"));
+		assertEquals("", ValueUtils.or(null, "", "a"));
+		assertNull( ValueUtils.or(null, null, null));
+	}
+	
+	@Test
+	public void testORF() {
+		String[] array1 = null;
+		String[] array2 = new String[]{"A", "B"};
+		
+		assertEquals("A", ValueUtils.eval("!", () -> array2[0] ));
+		assertEquals("!", ValueUtils.eval("!", () -> null ));
+		assertEquals("!", ValueUtils.eval("!", () -> array1[0] ));
+
+		NewAssert.assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+			ValueUtils.eval("!", () -> array2[4]);
+		});
+	}
+	
+}