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 <[email protected]> Authored: Tue Jan 30 10:55:43 2018 -0700 Committer: Daniel Kuppitz <[email protected]> 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
