src/test/java/com/android/tools/r8/desugar/backports/ObjectsBackportTest.java

// 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 java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import static java.util.Collections.reverseOrder;

@RunWith(Parameterized.class) public final class ObjectsBackportTest extends AbstractBackportTest {
  @Parameters(name = "{0}") public static Iterable<?> data() {
    return getTestParameters().withAllRuntimes().build();
  }

  public ObjectsBackportTest(TestParameters parameters) {
    super(parameters, Objects.class, Main.class);
    registerTarget(AndroidApiLevel.N, 59);
    registerTarget(AndroidApiLevel.K, 55);
  }

  static final class Main extends MiniAssert {
    public static void main(String[] args) {
      testCompare();
      testDeepEquals();
      testEquals();
      testHash();
      testHashCode();
      testIsNull();
      testNonNull();
      testToString();
      testToStringOrDefault();
      testRequireNonNull();
      testRequireNonNullOrMessage();
    }

    private static void testCompare() {
      Comparator<String> stringsNullLast = (o1, o2) -> {
        if (o1 == null) {
          return o2 == null ? 0 : 1;
        }
        return o2 == null ? -1 : o1.compareTo(o2);
      };

      assertEquals(-1, Objects.compare("a", "b", stringsNullLast));
      assertEquals(0, Objects.compare("a", "a", stringsNullLast));
      assertEquals(1, Objects.compare("b", "a", stringsNullLast));

      assertEquals(-1, Objects.compare("a", null, stringsNullLast));
      assertEquals(0, Objects.compare(null, null, stringsNullLast));
      assertEquals(1, Objects.compare(null, "a", stringsNullLast));
    }

    private static void testDeepEquals() {
      assertTrue(Objects.deepEquals(null, null));

      assertTrue(Objects.deepEquals(true, true));
      assertTrue(Objects.deepEquals((byte) 1, (byte) 1));
      assertTrue(Objects.deepEquals('a', 'a'));
      assertTrue(Objects.deepEquals((double) 1, (double) 1));
      assertTrue(Objects.deepEquals(1f, 1f));
      assertTrue(Objects.deepEquals(1, 1));
      assertTrue(Objects.deepEquals(1L, 1L));
      assertTrue(Objects.deepEquals((short) 1, (short) 1));
      assertTrue(Objects.deepEquals("abc", "abc"));

      // Test primitive arrays against another instance with the same contents.
      assertTrue(Objects.deepEquals(new boolean[] { true, false, true },
          new boolean[] { true, false, true }));
      assertTrue(Objects.deepEquals(new byte[] { 4, 8, 15, 16, 23, 42 },
          new byte[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new char[] { 4, 8, 15, 16, 23, 42 },
          new char[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new double[] { 4, 8, 15, 16, 23, 42 },
          new double[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new float[] { 4, 8, 15, 16, 23, 42 },
          new float[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new int[] { 4, 8, 15, 16, 23, 42 },
          new int[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new long[] { 4, 8, 15, 16, 23, 42 },
          new long[] { 4, 8, 15, 16, 23, 42 }));
      assertTrue(Objects.deepEquals(new short[] { 4, 8, 15, 16, 23, 42 },
          new short[] { 4, 8, 15, 16, 23, 42 }));

      // Test Object arrays against other arrays of the same contents, including nested arrays.
      assertTrue(Objects.deepEquals(new Object[] { (byte) 4, (char) 8, 15d, 16f, 23, 42L },
          new Object[] { (byte) 4, (char) 8, 15d, 16f, 23, 42L }));
      assertTrue(Objects.deepEquals(new Object[] {
          new boolean[] { true, false },
          "hey",
          new int[] { 4, 8, 15, 16, 23, 42 },
          new Object[] {
              new long[] { 1, 2, 4, 8, 16, 32 },
              "hello",
          },
      }, new Object[] {
          new boolean[] { true, false },
          "hey",
          new int[] { 4, 8, 15, 16, 23, 42 },
          new Object[] {
              new long[] { 1, 2, 4, 8, 16, 32 },
              "hello",
          },
      }));

      // Test primitive arrays against incompatible types or the same type with different contents.
      Object[] testArrays = {
          new boolean[] { false, true, false },
          new byte[] { 1, 2, 4, 8, 16, 32 },
          new char[] { 1, 2, 4, 8, 16, 32 },
          new double[] { 1, 2, 4, 8, 16, 32 },
          new float[] { 1, 2, 4, 8, 16, 32 },
          new int[] { 1, 2, 4, 8, 16, 32 },
          new long[] { 1, 2, 4, 8, 16, 32 },
          new short[] { 1, 2, 4, 8, 16, 32 },
      };
      for (Object testArray : testArrays) {
        assertFalse(Objects.deepEquals(testArray, new boolean[] { true, false, true }));
        assertFalse(Objects.deepEquals(testArray, new byte[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new char[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new double[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new float[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new int[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new long[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray, new short[] { 4, 8, 15, 16, 23, 42 }));
        assertFalse(Objects.deepEquals(testArray,
            new Object[] { false, (byte) 4, (char) 8, 15d, 16f, 23, 42L, (short) 108 }));
      }
    }

    private static void testHash() {
      assertEquals(0, Objects.hash((Object[]) null));
      assertEquals(1, Objects.hash());

      assertEquals(Arrays.hashCode(new Object[] { "a" }), Objects.hash("a"));
      assertEquals(Arrays.hashCode(new Object[] { 1, "2", 3d, 4f, 5L }),
          Objects.hash(1, "2", 3d, 4f, 5L));
    }

    private static void testHashCode() {
      assertEquals(0, Objects.hashCode(null));

      // Ensure we invoke hashCode() and propagate its result.
      assertEquals(5, Objects.hashCode(new Object() {
        @Override public int hashCode() {
          return 5;
        }
      }));
    }

    private static void testEquals() {
      assertTrue(Objects.equals(null, null));

      assertFalse(Objects.equals(null, "non-null"));
      assertFalse(Objects.equals("non-null", null));

      // Ensure we invoke equals() and propagate its result.
      Object second = new Object();
      assertTrue(Objects.equals(new Object() {
        @Override public boolean equals(Object obj) {
          assertSame(obj, second);
          return true;
        }
      }, second));
      assertFalse(Objects.equals(new Object() {
        @Override public boolean equals(Object obj) {
          assertSame(obj, second);
          return false;
        }
      }, second));
    }

    private static void testIsNull() {
      assertTrue(Objects.isNull(null));
      assertFalse(Objects.isNull("non-null"));
    }

    private static void testNonNull() {
      assertTrue(Objects.nonNull("non-null"));
      assertFalse(Objects.nonNull(null));
    }

    private static void testToString() {
      assertEquals("null", Objects.toString(null));

      // Ensure we invoke toString() and propagate its result.
      assertEquals("non-null", Objects.toString(new Object() {
        @Override public String toString() {
          return "non-null";
        }
      }));
    }

    private static void testToStringOrDefault() {
      assertEquals(null, Objects.toString(null, null));
      assertEquals("null default", Objects.toString(null, "null default"));

      // Ensure we invoke toString() and propagate its result.
      assertEquals("non-null", Objects.toString(new Object() {
        @Override public String toString() {
          return "non-null";
        }
      }, "null default"));
    }

    private static void testRequireNonNull() {
      Object o = new Object();
      assertSame(o, Objects.requireNonNull(o));

      try {
        throw new AssertionError(Objects.requireNonNull(null));
      } catch (NullPointerException expected) {
      }
    }

    private static void testRequireNonNullOrMessage() {
      Object o = new Object();
      assertSame(o, Objects.requireNonNull(o, "unexpected"));

      try {
        throw new AssertionError(Objects.requireNonNull(null, "expected"));
      } catch (NullPointerException e) {
        assertTrue(e.getMessage().contains("expected"));
      }
    }
  }
}