tinkerpop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From spmalle...@apache.org
Subject [34/50] [abbrv] tinkerpop git commit: added NumberHelperTest
Date Thu, 01 Feb 2018 15:30:45 GMT
added NumberHelperTest


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/b039d6fb
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/b039d6fb
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/b039d6fb

Branch: refs/heads/TINKERPOP-1857
Commit: b039d6fb510a99441bddd6b294d53cbb30a8ead5
Parents: 6cf10ff
Author: Daniel Kuppitz <daniel_kuppitz@hotmail.com>
Authored: Tue Jan 30 10:55:43 2018 -0700
Committer: Daniel Kuppitz <daniel_kuppitz@hotmail.com>
Committed: Tue Jan 30 10:55:43 2018 -0700

----------------------------------------------------------------------
 .../gremlin/util/NumberHelperTest.java          | 422 +++++++++++++++++++
 1 file changed, 422 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/b039d6fb/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
new file mode 100644
index 0000000..ecffe7c
--- /dev/null
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
@@ -0,0 +1,422 @@
+/*
+ * 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.tinkerpop.gremlin.util;
+
+import org.javatuples.Quartet;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.apache.tinkerpop.gremlin.process.traversal.NumberHelper.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Daniel Kuppitz (http://gremlin.guru)
+ */
+public class NumberHelperTest {
+
+    private final static List<Number> EACH_NUMBER_TYPE = Arrays.asList(
+            (byte) 1, (short) 1, 1, 1L, 1F, 1D, BigInteger.ONE, BigDecimal.ONE
+    );
+
+    private final static List<Quartet<Number, Number, Class<? extends Number>,
Class<? extends Number>>> COMMON_NUMBER_CLASSES =
+            Arrays.asList(
+                    // BYTE
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, (byte) 1, Byte.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, (short) 1, Short.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, 1, Integer.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, 1L, Long.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, 1F, Float.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, BigInteger.ONE, BigInteger.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((byte) 1, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // SHORT
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, (short) 1, Short.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, 1, Integer.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, 1L, Long.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, 1F, Float.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, BigInteger.ONE, BigInteger.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>((short) 1, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // INTEGER
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, 1, Integer.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, 1L, Long.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, 1F, Float.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, BigInteger.ONE, BigInteger.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // LONG
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1L, 1L, Long.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1L, 1F, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1L, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1L, BigInteger.ONE, BigInteger.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1L, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // FLOAT
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1F, 1F, Float.class, Float.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1F, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1F, BigInteger.ONE, BigDecimal.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1F, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // DOUBLE
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1D, 1D, Double.class, Double.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1D, BigInteger.ONE, BigDecimal.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(1D, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // BIG INTEGER
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(BigInteger.ONE, BigInteger.ONE, BigInteger.class, BigDecimal.class),
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(BigInteger.ONE, BigDecimal.ONE, BigDecimal.class, BigDecimal.class),
+                    // BIG DECIMAL
+                    new Quartet<Number, Number, Class<? extends Number>, Class<?
extends Number>>(BigDecimal.ONE, BigDecimal.ONE, BigDecimal.class, BigDecimal.class)
+            );
+
+    @Test
+    public void shouldReturnHighestCommonNumberClass() {
+        for (final Quartet<Number, Number, Class<? extends Number>, Class<? extends
Number>> q : COMMON_NUMBER_CLASSES) {
+            assertEquals(q.getValue2(), getHighestCommonNumberClass(q.getValue0(), q.getValue1()));
+            assertEquals(q.getValue2(), getHighestCommonNumberClass(q.getValue1(), q.getValue0()));
+            assertEquals(q.getValue3(), getHighestCommonNumberClass(true, q.getValue0(),
q.getValue1()));
+            assertEquals(q.getValue3(), getHighestCommonNumberClass(true, q.getValue1(),
q.getValue0()));
+        }
+        // Double.NaN and null are not numbers and thus should be ignored
+        for (final Number number : EACH_NUMBER_TYPE) {
+            assertEquals(number.getClass(), getHighestCommonNumberClass(number, Double.NaN));
+            assertEquals(number.getClass(), getHighestCommonNumberClass(Double.NaN, number));
+            assertEquals(number.getClass(), getHighestCommonNumberClass(number, null));
+            assertEquals(number.getClass(), getHighestCommonNumberClass(null, number));
+        }
+    }
+
+    @Test
+    public void shouldAddAndReturnCorrectType() {
+
+        // NOTE: The smallest possible number type for return values is Integer; this seems
to be a JVM thing and has
+        //       nothing to do with the actual NumberHelper implementation
+
+        // BYTE
+        assertEquals(2, add((byte) 1, (byte) 1));
+        assertEquals(2, add((byte) 1, (short) 1));
+        assertEquals(2, add((byte) 1, 1));
+        assertEquals(2L, add((byte) 1, 1L));
+        assertEquals(2F, add((byte) 1, 1F));
+        assertEquals(2D, add((byte) 1, 1D));
+        assertEquals(BigInteger.ONE.add(BigInteger.ONE), add((byte) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add((byte) 1, BigDecimal.ONE));
+
+        // SHORT
+        assertEquals(2, add((short) 1, (short) 1));
+        assertEquals(2, add((short) 1, 1));
+        assertEquals(2L, add((short) 1, 1L));
+        assertEquals(2F, add((short) 1, 1F));
+        assertEquals(2D, add((short) 1, 1D));
+        assertEquals(BigInteger.ONE.add(BigInteger.ONE), add((short) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add((short) 1, BigDecimal.ONE));
+
+        // INTEGER
+        assertEquals(2, add(1, 1));
+        assertEquals(2L, add(1, 1L));
+        assertEquals(2F, add(1, 1F));
+        assertEquals(2D, add(1, 1D));
+        assertEquals(BigInteger.ONE.add(BigInteger.ONE), add(1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add(1, BigDecimal.ONE));
+
+        // LONG
+        assertEquals(2L, add(1L, 1L));
+        assertEquals(2D, add(1L, 1F));
+        assertEquals(2D, add(1L, 1D));
+        assertEquals(BigInteger.ONE.add(BigInteger.ONE), add(1L, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add(1L, BigDecimal.ONE));
+
+        // FLOAT
+        assertEquals(2F, add(1F, 1F));
+        assertEquals(2D, add(1F, 1D));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE).setScale(1, RoundingMode.HALF_UP),
add(1F, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE).setScale(1, RoundingMode.HALF_UP),
add(1F, BigDecimal.ONE));
+
+        // DOUBLE
+        assertEquals(2D, add(1D, 1D));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE).setScale(1, RoundingMode.HALF_UP),
add(1D, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE).setScale(1, RoundingMode.HALF_UP),
add(1D, BigDecimal.ONE));
+
+        // BIG INTEGER
+        assertEquals(BigInteger.ONE.add(BigInteger.ONE), add(BigInteger.ONE, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add(BigInteger.ONE, BigDecimal.ONE));
+
+        // BIG DECIMAL
+        assertEquals(BigDecimal.ONE.add(BigDecimal.ONE), add(BigDecimal.ONE, BigDecimal.ONE));
+    }
+
+    @Test
+    public void shouldSubtractAndReturnCorrectType() {
+
+        // NOTE: The smallest possible number type for return values is Integer; this seems
to be a JVM thing and has
+        //       nothing to do with the actual NumberHelper implementation
+
+        // BYTE
+        assertEquals(0, sub((byte) 1, (byte) 1));
+        assertEquals(0, sub((byte) 1, (short) 1));
+        assertEquals(0, sub((byte) 1, 1));
+        assertEquals(0L, sub((byte) 1, 1L));
+        assertEquals(0F, sub((byte) 1, 1F));
+        assertEquals(0D, sub((byte) 1, 1D));
+        assertEquals(BigInteger.ZERO, sub((byte) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO, sub((byte) 1, BigDecimal.ONE));
+
+        // SHORT
+        assertEquals(0, sub((short) 1, (short) 1));
+        assertEquals(0, sub((short) 1, 1));
+        assertEquals(0L, sub((short) 1, 1L));
+        assertEquals(0F, sub((short) 1, 1F));
+        assertEquals(0D, sub((short) 1, 1D));
+        assertEquals(BigInteger.ZERO, sub((short) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO, sub((short) 1, BigDecimal.ONE));
+
+        // INTEGER
+        assertEquals(0, sub(1, 1));
+        assertEquals(0L, sub(1, 1L));
+        assertEquals(0F, sub(1, 1F));
+        assertEquals(0D, sub(1, 1D));
+        assertEquals(BigInteger.ZERO, sub(1, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO, sub(1, BigDecimal.ONE));
+
+        // LONG
+        assertEquals(0L, sub(1L, 1L));
+        assertEquals(0D, sub(1L, 1F));
+        assertEquals(0D, sub(1L, 1D));
+        assertEquals(BigInteger.ZERO, sub(1L, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO, sub(1L, BigDecimal.ONE));
+
+        // FLOAT
+        assertEquals(0F, sub(1F, 1F));
+        assertEquals(0D, sub(1F, 1D));
+        assertEquals(BigDecimal.ZERO.setScale(1, RoundingMode.HALF_UP), sub(1F, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO.setScale(1, RoundingMode.HALF_UP), sub(1F, BigDecimal.ONE));
+
+        // DOUBLE
+        assertEquals(0D, sub(1D, 1D));
+        assertEquals(BigDecimal.ZERO.setScale(1, RoundingMode.HALF_UP), sub(1D, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO.setScale(1, RoundingMode.HALF_UP), sub(1D, BigDecimal.ONE));
+
+        // BIG INTEGER
+        assertEquals(BigInteger.ZERO, sub(BigInteger.ONE, BigInteger.ONE));
+        assertEquals(BigDecimal.ZERO, sub(BigInteger.ONE, BigDecimal.ONE));
+
+        // BIG DECIMAL
+        assertEquals(BigDecimal.ZERO, sub(BigDecimal.ONE, BigDecimal.ONE));
+    }
+
+    @Test
+    public void shouldMultiplyAndReturnCorrectType() {
+
+        // NOTE: The smallest possible number type for return values is Integer; this seems
to be a JVM thing and has
+        //       nothing to do with the actual NumberHelper implementation
+
+        // BYTE
+        assertEquals(1, mul((byte) 1, (byte) 1));
+        assertEquals(1, mul((byte) 1, (short) 1));
+        assertEquals(1, mul((byte) 1, 1));
+        assertEquals(1L, mul((byte) 1, 1L));
+        assertEquals(1F, mul((byte) 1, 1F));
+        assertEquals(1D, mul((byte) 1, 1D));
+        assertEquals(BigInteger.ONE, mul((byte) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, mul((byte) 1, BigDecimal.ONE));
+
+        // SHORT
+        assertEquals(1, mul((short) 1, (short) 1));
+        assertEquals(1, mul((short) 1, 1));
+        assertEquals(1L, mul((short) 1, 1L));
+        assertEquals(1F, mul((short) 1, 1F));
+        assertEquals(1D, mul((short) 1, 1D));
+        assertEquals(BigInteger.ONE, mul((short) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, mul((short) 1, BigDecimal.ONE));
+
+        // INTEGER
+        assertEquals(1, mul(1, 1));
+        assertEquals(1L, mul(1, 1L));
+        assertEquals(1F, mul(1, 1F));
+        assertEquals(1D, mul(1, 1D));
+        assertEquals(BigInteger.ONE, mul(1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, mul(1, BigDecimal.ONE));
+
+        // LONG
+        assertEquals(1L, mul(1L, 1L));
+        assertEquals(1D, mul(1L, 1F));
+        assertEquals(1D, mul(1L, 1D));
+        assertEquals(BigInteger.ONE, mul(1L, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, mul(1L, BigDecimal.ONE));
+
+        // FLOAT
+        assertEquals(1F, mul(1F, 1F));
+        assertEquals(1D, mul(1F, 1D));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), mul(1F, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), mul(1F, BigDecimal.ONE));
+
+        // DOUBLE
+        assertEquals(1D, mul(1D, 1D));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), mul(1D, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), mul(1D, BigDecimal.ONE));
+
+        // BIG INTEGER
+        assertEquals(BigInteger.ONE, mul(BigInteger.ONE, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, mul(BigInteger.ONE, BigDecimal.ONE));
+
+        // BIG DECIMAL
+        assertEquals(BigDecimal.ONE, mul(BigDecimal.ONE, BigDecimal.ONE));
+    }
+
+    @Test
+    public void shouldDivideAndReturnCorrectType() {
+
+        // NOTE: The smallest possible number type for return values is Integer; this seems
to be a JVM thing and has
+        //       nothing to do with the actual NumberHelper implementation
+
+        // BYTE
+        assertEquals(1, div((byte) 1, (byte) 1));
+        assertEquals(1, div((byte) 1, (short) 1));
+        assertEquals(1, div((byte) 1, 1));
+        assertEquals(1L, div((byte) 1, 1L));
+        assertEquals(1F, div((byte) 1, 1F));
+        assertEquals(1D, div((byte) 1, 1D));
+        assertEquals(BigInteger.ONE, div((byte) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, div((byte) 1, BigDecimal.ONE));
+
+        // SHORT
+        assertEquals(1, div((short) 1, (short) 1));
+        assertEquals(1, div((short) 1, 1));
+        assertEquals(1L, div((short) 1, 1L));
+        assertEquals(1F, div((short) 1, 1F));
+        assertEquals(1D, div((short) 1, 1D));
+        assertEquals(BigInteger.ONE, div((short) 1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, div((short) 1, BigDecimal.ONE));
+
+        // INTEGER
+        assertEquals(1, div(1, 1));
+        assertEquals(1L, div(1, 1L));
+        assertEquals(1F, div(1, 1F));
+        assertEquals(1D, div(1, 1D));
+        assertEquals(BigInteger.ONE, div(1, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, div(1, BigDecimal.ONE));
+
+        // LONG
+        assertEquals(1L, div(1L, 1L));
+        assertEquals(1D, div(1L, 1F));
+        assertEquals(1D, div(1L, 1D));
+        assertEquals(BigInteger.ONE, div(1L, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, div(1L, BigDecimal.ONE));
+
+        // FLOAT
+        assertEquals(1F, div(1F, 1F));
+        assertEquals(1D, div(1F, 1D));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1F, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1F, BigDecimal.ONE));
+
+        // DOUBLE
+        assertEquals(1D, div(1D, 1D));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1D, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1D, BigDecimal.ONE));
+
+        // BIG INTEGER
+        assertEquals(BigInteger.ONE, div(BigInteger.ONE, BigInteger.ONE));
+        assertEquals(BigDecimal.ONE, div(BigInteger.ONE, BigDecimal.ONE));
+
+        // BIG DECIMAL
+        assertEquals(BigDecimal.ONE, div(BigDecimal.ONE, BigDecimal.ONE));
+    }
+
+    @Test
+    public void shouldDivideForceFloatingPointAndReturnCorrectType() {
+
+        // NOTE: The smallest possible number type for return values is Integer; this seems
to be a JVM thing and has
+        //       nothing to do with the actual NumberHelper implementation
+
+        // BYTE
+        assertEquals(1F, div((byte) 1, (byte) 1, true));
+        assertEquals(1F, div((byte) 1, (short) 1, true));
+        assertEquals(1F, div((byte) 1, 1, true));
+        assertEquals(1D, div((byte) 1, 1L, true));
+        assertEquals(1F, div((byte) 1, 1F, true));
+        assertEquals(1D, div((byte) 1, 1D, true));
+        assertEquals(BigDecimal.ONE, div((byte) 1, BigInteger.ONE, true));
+        assertEquals(BigDecimal.ONE, div((byte) 1, BigDecimal.ONE, true));
+
+        // SHORT
+        assertEquals(1F, div((short) 1, (short) 1, true));
+        assertEquals(1F, div((short) 1, 1, true));
+        assertEquals(1D, div((short) 1, 1L, true));
+        assertEquals(1F, div((short) 1, 1F, true));
+        assertEquals(1D, div((short) 1, 1D, true));
+        assertEquals(BigDecimal.ONE, div((short) 1, BigInteger.ONE, true));
+        assertEquals(BigDecimal.ONE, div((short) 1, BigDecimal.ONE, true));
+
+        // INTEGER
+        assertEquals(1F, div(1, 1, true));
+        assertEquals(1D, div(1, 1L, true));
+        assertEquals(1F, div(1, 1F, true));
+        assertEquals(1D, div(1, 1D, true));
+        assertEquals(BigDecimal.ONE, div(1, BigInteger.ONE, true));
+        assertEquals(BigDecimal.ONE, div(1, BigDecimal.ONE, true));
+
+        // LONG
+        assertEquals(1D, div(1L, 1L, true));
+        assertEquals(1D, div(1L, 1F, true));
+        assertEquals(1D, div(1L, 1D, true));
+        assertEquals(BigDecimal.ONE, div(1L, BigInteger.ONE, true));
+        assertEquals(BigDecimal.ONE, div(1L, BigDecimal.ONE, true));
+
+        // FLOAT
+        assertEquals(1F, div(1F, 1F, true));
+        assertEquals(1D, div(1F, 1D, true));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1F, BigInteger.ONE,
true));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1F, BigDecimal.ONE,
true));
+
+        // DOUBLE
+        assertEquals(1D, div(1D, 1D, true));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1D, BigInteger.ONE,
true));
+        assertEquals(BigDecimal.ONE.setScale(1, RoundingMode.HALF_UP), div(1D, BigDecimal.ONE,
true));
+
+        // BIG INTEGER
+        assertEquals(BigDecimal.ONE, div(BigInteger.ONE, BigInteger.ONE, true));
+        assertEquals(BigDecimal.ONE, div(BigInteger.ONE, BigDecimal.ONE, true));
+
+        // BIG DECIMAL
+        assertEquals(BigDecimal.ONE, div(BigDecimal.ONE, BigDecimal.ONE, true));
+    }
+
+    @Test
+    public void testMinMaxCompare() {
+
+        final List<Number> zeros = Arrays.asList((byte) 0, (short) 0, 0, 0L, 0F, 0D,
BigInteger.ZERO, BigDecimal.ZERO);
+        final List<Number> ones = Arrays.asList((byte) 1, (short) 1, 1, 1L, 1F, 1D,
BigInteger.ONE, BigDecimal.ONE);
+
+        for (Number zero : zeros) {
+            for (Number one : ones) {
+                assertEquals(0, min(zero, one).intValue());
+                assertEquals(0, min(one, zero).intValue());
+                assertEquals(1, max(zero, one).intValue());
+                assertEquals(1, max(one, zero).intValue());
+                assertTrue(compare(zero, one) < 0);
+                assertTrue(compare(one, zero) > 0);
+                assertTrue(compare(zero, zero) == 0);
+                assertTrue(compare(one, one) == 0);
+            }
+        }
+    }
+}
\ No newline at end of file


Mime
View raw message