| // Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| package com.android.tools.r8.desugar.backports; |
| |
| import com.android.tools.r8.TestParameters; |
| import com.android.tools.r8.utils.AndroidApiLevel; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.Parameterized; |
| import org.junit.runners.Parameterized.Parameters; |
| |
| @RunWith(Parameterized.class) |
| public final class MathBackportTest extends AbstractBackportTest { |
| @Parameters(name = "{0}") |
| public static Iterable<?> data() { |
| return getTestParameters() |
| .withAllRuntimesAndApiLevels() |
| .build(); |
| } |
| |
| public MathBackportTest(TestParameters parameters) { |
| super(parameters, Math.class, Main.class); |
| registerTarget(AndroidApiLevel.N, 97); |
| ignoreInvokes("nextAfter"); // Available in API 9, used to test nextDown. |
| } |
| |
| static final class Main extends MiniAssert { |
| public static void main(String[] args) { |
| testAddExactInteger(); |
| testAddExactLong(); |
| testDecrementExactInteger(); |
| testDecrementExactLong(); |
| testFloorDivInteger(); |
| testFloorDivLong(); |
| testFloorModInteger(); |
| testFloorModLong(); |
| testIncrementExactInteger(); |
| testIncrementExactLong(); |
| testMultiplyExactInteger(); |
| testMultiplyExactLong(); |
| testNegateExactInteger(); |
| testNegateExactLong(); |
| testNextDownDouble(); |
| testNextDownFloat(); |
| testSubtractExactInteger(); |
| testSubtractExactLong(); |
| testToIntExact(); |
| } |
| |
| private static void testAddExactInteger() { |
| assertEquals(2, Math.addExact(1, 1)); |
| assertEquals(-2, Math.addExact(-1, -1)); |
| |
| assertEquals(Integer.MAX_VALUE, Math.addExact(Integer.MAX_VALUE, 0)); |
| assertEquals(Integer.MIN_VALUE, Math.addExact(Integer.MIN_VALUE, 0)); |
| |
| try { |
| throw new AssertionError(Math.addExact(1, Integer.MAX_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.addExact(-1, Integer.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testAddExactLong() { |
| assertEquals(2L, Math.addExact(1L, 1L)); |
| assertEquals(-2L, Math.addExact(-1L, -1L)); |
| |
| assertEquals(Long.MAX_VALUE, Math.addExact(Long.MAX_VALUE, 0L)); |
| assertEquals(Long.MIN_VALUE, Math.addExact(Long.MIN_VALUE, 0L)); |
| |
| try { |
| throw new AssertionError(Math.addExact(1L, Long.MAX_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.addExact(-1L, Long.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testDecrementExactInteger() { |
| assertEquals(-1, Math.decrementExact(0)); |
| assertEquals(Integer.MIN_VALUE, Math.decrementExact(Integer.MIN_VALUE + 1)); |
| |
| try { |
| throw new AssertionError(Math.decrementExact(Integer.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testDecrementExactLong() { |
| assertEquals(-1L, Math.decrementExact(0L)); |
| assertEquals(Long.MIN_VALUE, Math.decrementExact(Long.MIN_VALUE + 1L)); |
| |
| try { |
| throw new AssertionError(Math.decrementExact(Long.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testFloorDivInteger() { |
| assertEquals(1, Math.floorDiv(4, 4)); |
| assertEquals(1, Math.floorDiv(-4, -4)); |
| assertEquals(-1, Math.floorDiv(-4, 4)); |
| assertEquals(-1, Math.floorDiv(4, -4)); |
| |
| assertEquals(1, Math.floorDiv(4, 3)); |
| assertEquals(1, Math.floorDiv(-4, -3)); |
| assertEquals(-2, Math.floorDiv(-4, 3)); |
| assertEquals(-2, Math.floorDiv(4, -3)); |
| |
| // Spec edge case: result is actually MAX_VALUE+1 which becomes MIN_VALUE. |
| assertEquals(Integer.MIN_VALUE, Math.floorDiv(Integer.MIN_VALUE, -1)); |
| } |
| |
| private static void testFloorDivLong() { |
| assertEquals(1L, Math.floorDiv(4L, 4L)); |
| assertEquals(1L, Math.floorDiv(-4L, -4L)); |
| assertEquals(-1L, Math.floorDiv(-4L, 4L)); |
| assertEquals(-1L, Math.floorDiv(4L, -4L)); |
| |
| assertEquals(1L, Math.floorDiv(4L, 3L)); |
| assertEquals(1L, Math.floorDiv(-4L, -3L)); |
| assertEquals(-2L, Math.floorDiv(-4L, 3L)); |
| assertEquals(-2L, Math.floorDiv(4L, -3L)); |
| |
| // Spec edge case: result is actually MAX_VALUE+1 which becomes MIN_VALUE. |
| assertEquals(Long.MIN_VALUE, Math.floorDiv(Long.MIN_VALUE, -1L)); |
| } |
| |
| private static void testFloorModInteger() { |
| assertEquals(0, Math.floorMod(4, 4)); |
| assertEquals(0, Math.floorMod(-4, -4)); |
| assertEquals(0, Math.floorMod(-4, 4)); |
| assertEquals(0, Math.floorMod(4, -4)); |
| |
| assertEquals(1L, Math.floorMod(4L, 3L)); |
| assertEquals(-1L, Math.floorMod(-4L, -3L)); |
| assertEquals(2L, Math.floorMod(-4L, 3L)); |
| assertEquals(-2L, Math.floorMod(4L, -3L)); |
| } |
| |
| private static void testFloorModLong() { |
| assertEquals(0L, Math.floorMod(4L, 4L)); |
| assertEquals(0L, Math.floorMod(-4L, -4L)); |
| assertEquals(0L, Math.floorMod(-4L, 4L)); |
| assertEquals(0L, Math.floorMod(4L, -4L)); |
| |
| assertEquals(1L, Math.floorMod(4L, 3L)); |
| assertEquals(-1L, Math.floorMod(-4L, -3L)); |
| assertEquals(2L, Math.floorMod(-4L, 3L)); |
| assertEquals(-2L, Math.floorMod(4L, -3L)); |
| } |
| |
| private static void testIncrementExactInteger() { |
| assertEquals(1, Math.incrementExact(0)); |
| assertEquals(Integer.MAX_VALUE, Math.incrementExact(Integer.MAX_VALUE - 1)); |
| |
| try { |
| throw new AssertionError(Math.incrementExact(Integer.MAX_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testIncrementExactLong() { |
| assertEquals(1L, Math.incrementExact(0L)); |
| assertEquals(Long.MAX_VALUE, Math.incrementExact(Long.MAX_VALUE - 1L)); |
| |
| try { |
| throw new AssertionError(Math.incrementExact(Long.MAX_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testMultiplyExactInteger() { |
| assertEquals(8, Math.multiplyExact(2, 4)); |
| assertEquals(Integer.MAX_VALUE, Math.multiplyExact(Integer.MAX_VALUE, 1)); |
| assertEquals(Integer.MIN_VALUE, Math.multiplyExact(Integer.MIN_VALUE / 2, 2)); |
| |
| try { |
| throw new AssertionError(Math.multiplyExact(Integer.MAX_VALUE, 2)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.multiplyExact(Integer.MIN_VALUE, 2)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testMultiplyExactLong() { |
| assertEquals(8L, Math.multiplyExact(2L, 4L)); |
| assertEquals(Long.MAX_VALUE, Math.multiplyExact(Long.MAX_VALUE, 1L)); |
| assertEquals(Long.MIN_VALUE, Math.multiplyExact(Long.MIN_VALUE / 2L, 2L)); |
| |
| try { |
| throw new AssertionError(Math.multiplyExact(Long.MAX_VALUE, 2L)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.multiplyExact(Long.MIN_VALUE, 2L)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testNegateExactInteger() { |
| assertEquals(0, Math.negateExact(0)); |
| assertEquals(-1, Math.negateExact(1)); |
| assertEquals(1, Math.negateExact(-1)); |
| assertEquals(-2_147_483_647, Math.negateExact(Integer.MAX_VALUE)); |
| |
| try { |
| throw new AssertionError(Math.negateExact(Integer.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testNegateExactLong() { |
| assertEquals(0L, Math.negateExact(0L)); |
| assertEquals(-1L, Math.negateExact(1L)); |
| assertEquals(1L, Math.negateExact(-1L)); |
| assertEquals(-9_223_372_036_854_775_807L, Math.negateExact(Long.MAX_VALUE)); |
| |
| try { |
| throw new AssertionError(Math.negateExact(Long.MIN_VALUE)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testNextDownDouble() { |
| double[] interestingValues = { |
| Double.MIN_VALUE, Double.MAX_VALUE, |
| Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, |
| Integer.MIN_VALUE, Integer.MAX_VALUE, |
| Long.MIN_VALUE, Long.MAX_VALUE, |
| Double.NaN, |
| 0d, |
| -1d, 1d, |
| -0.5d, 0.5d, |
| -0.1d, 0.1d, |
| }; |
| for (double interestingValue : interestingValues) { |
| assertEquals(Math.nextAfter(interestingValue, Double.NEGATIVE_INFINITY), |
| Math.nextDown(interestingValue)); |
| } |
| } |
| |
| private static void testNextDownFloat() { |
| float[] interestingValues = { |
| Float.MIN_VALUE, Float.MAX_VALUE, |
| Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, |
| Integer.MIN_VALUE, Integer.MAX_VALUE, |
| Long.MIN_VALUE, Long.MAX_VALUE, |
| Float.NaN, |
| 0f, |
| -1f, 1f, |
| -0.5f, 0.5f, |
| -0.1f, 0.1f, |
| }; |
| for (float interestingValue : interestingValues) { |
| assertEquals(Math.nextAfter(interestingValue, Float.NEGATIVE_INFINITY), |
| Math.nextDown(interestingValue)); |
| } |
| } |
| |
| private static void testSubtractExactInteger() { |
| assertEquals(-1, Math.subtractExact(0, 1)); |
| assertEquals(1, Math.subtractExact(0, -1)); |
| |
| assertEquals(Integer.MAX_VALUE, Math.subtractExact(Integer.MAX_VALUE, 0)); |
| assertEquals(Integer.MIN_VALUE, Math.subtractExact(Integer.MIN_VALUE, 0)); |
| |
| try { |
| throw new AssertionError(Math.subtractExact(Integer.MIN_VALUE, 1)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.subtractExact(Integer.MAX_VALUE, -1)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testSubtractExactLong() { |
| assertEquals(-1L, Math.subtractExact(0L, 1L)); |
| assertEquals(1L, Math.subtractExact(0L, -1L)); |
| |
| assertEquals(Long.MAX_VALUE, Math.subtractExact(Long.MAX_VALUE, 0L)); |
| assertEquals(Long.MIN_VALUE, Math.subtractExact(Long.MIN_VALUE, 0L)); |
| |
| try { |
| throw new AssertionError(Math.subtractExact(Long.MIN_VALUE, 1L)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.subtractExact(Long.MAX_VALUE, -1L)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| |
| private static void testToIntExact() { |
| assertEquals(0, Math.toIntExact(0L)); |
| assertEquals(Integer.MAX_VALUE, Math.toIntExact(Integer.MAX_VALUE)); |
| assertEquals(Integer.MIN_VALUE, Math.toIntExact(Integer.MIN_VALUE)); |
| |
| try { |
| throw new AssertionError(Math.toIntExact(Integer.MAX_VALUE + 1L)); |
| } catch (ArithmeticException expected) { |
| } |
| try { |
| throw new AssertionError(Math.toIntExact(Integer.MIN_VALUE - 1L)); |
| } catch (ArithmeticException expected) { |
| } |
| } |
| } |
| } |