Merge pull request #473 from IABTechLab/cbc-UID2-1162-replace-optout-compare-bytes

Removed functions that are covered by the built-in functions

Author: cody-constine-ttd

src/main/java/com/uid2/shared/optout/OptOutHeap.java

@@ -231,14 +231,20 @@ private int maxChild(int i) {
     private int compareToEntryInHeap(byte[] entryAsBytes, int heapPos) {
         int heapBufPos = heapPos * OptOutConst.EntrySize;
         // comparing only identity hash (length == Sha256Bytes)
-        return OptOutUtils.compareByteRange(entryAsBytes, 0, store, heapBufPos, OptOutConst.Sha256Bytes);
+        return Arrays.compareUnsigned(
+                entryAsBytes, 0, OptOutConst.Sha256Bytes,
+                store, heapBufPos, heapBufPos+OptOutConst.Sha256Bytes
+        );
     }
 
     private int compareEntriesInHeap(int i, int j) {
         int p1 = i * OptOutConst.EntrySize;
         int p2 = j * OptOutConst.EntrySize;
         // comparing only identity hash (length == Sha256Bytes)
-        return OptOutUtils.compareByteRange(store, p1, store, p2, OptOutConst.Sha256Bytes);
+        return Arrays.compareUnsigned(
+                store, p1, p1+OptOutConst.Sha256Bytes,
+                store, p2, p2+OptOutConst.Sha256Bytes
+        );
     }
 
     private void swapEntriesInHeap(int srcPos, int dstPos) {

src/main/java/com/uid2/shared/optout/OptOutPartition.java

@@ -1,5 +1,7 @@
 package com.uid2.shared.optout;
 
+import java.util.Arrays;
+
 // OptOutPartition is a sorted array of items, each item is a range of bytes within the store
 // that stores identity hash (byte[]), advertising id (byte[]), and the timestamp of the optout entry
 public class OptOutPartition extends OptOutCollection {
@@ -57,7 +59,10 @@ private int compareEntryToIdentityHash(int entryIndex, byte[] identityHash) {
         int byteIndex = entryIndex * OptOutConst.EntrySize;
 
         // compare if bytes match
-        return OptOutUtils.compareByteRange(this.store, byteIndex, identityHash, 0, OptOutConst.Sha256Bytes);
+        return Arrays.compareUnsigned(
+                this.store, byteIndex, byteIndex+OptOutConst.Sha256Bytes,
+                identityHash, 0, OptOutConst.Sha256Bytes
+        );
     }
 
     private long getTimestampByIndex(int entryIndex) {

src/main/java/com/uid2/shared/optout/OptOutUtils.java

@@ -214,31 +214,6 @@ public static long toLongBE(byte[] bytes, int byteIndex) {
         return ByteBuffer.wrap(bytes, 0, Long.BYTES).order(ByteOrder.BIG_ENDIAN).getLong();
     }
 
-    // positive if arr1 > arr2
-    // negative if arr1 < arr2
-    // 0 if arr1 == arr2
-    public static int compareBytes(byte[] arr1, byte[] arr2) {
-        assert arr1.length == arr2.length;
-        return OptOutUtils.compareByteRange(arr1, 0, arr2, 0, arr1.length);
-    }
-
-    // positive if arr1 > arr2
-    // negative if arr1 < arr2
-    // 0 if arr1 == arr2
-    public static int compareByteRange(byte[] arr1, int idx1, byte[] arr2, int idx2, int bytesToCompare) {
-        assert idx1 >= 0 && idx1 + bytesToCompare <= arr1.length;
-        assert idx2 >= 0 && idx2 + bytesToCompare <= arr2.length;
-        for (int i = 0; i < bytesToCompare; ++i) {
-            int cmp = OptOutUtils.compareByte(arr1[idx1 + i], arr2[idx2 + i]);
-            if (cmp != 0) return cmp;
-        }
-        return 0;
-    }
-
-    public static int compareByte(byte a, byte b) {
-        return Byte.toUnsignedInt(a) - Byte.toUnsignedInt(b);
-    }
-
     public static boolean isDeltaFile(String fn) {
         return fn.contains(OptOutUtils.prefixDeltaFile);
     }

src/test/java/com/uid2/shared/optout/OptOutHeapTest.java

@@ -4,6 +4,7 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.HashSet;
+import java.util.Arrays;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -118,14 +119,14 @@ private void checkHeapProperty(OptOutHeap heap, int i) {
         if (leftChild >= heap.size()) return;
         OptOutEntry left = heap.get(leftChild);
         // System.out.format("self vs left: %x %x\n", self.idHashAsLong(), left.idHashAsLong());
-        assertTrue(OptOutUtils.compareBytes(self.identityHash, left.identityHash) > 0);
+        assertTrue(Arrays.compareUnsigned(self.identityHash, left.identityHash) >0 );
         checkHeapProperty(heap, leftChild);
 
         int rightChild = OptOutHeap.rightChild(i);
         if (rightChild >= heap.size()) return;
         OptOutEntry right = heap.get(rightChild);
         // System.out.format("self vs right: %x %x\n", self.idHashAsLong(), right.idHashAsLong());
-        assertTrue(OptOutUtils.compareBytes(self.identityHash, right.identityHash) > 0);
+        assertTrue(Arrays.compareUnsigned(self.identityHash, right.identityHash) >0 );
         checkHeapProperty(heap, rightChild);
     }
 }

src/test/java/com/uid2/shared/optout/OptOutUtilsTest.java

@@ -81,48 +81,6 @@ public void byteArrayToInt_tests() {
         assertEquals(0x7f7f7f7f, OptOutUtils.toInt(new byte[]{0x7f, 0x7f, 0x7f, 0x7f}, 0));
     }
 
-    @Test
-    public void compareBytes_tests() {
-        for (int i = 0; i < 1000; ++i) {
-            long a = OptOutUtils.rand.nextLong();
-            long b = OptOutUtils.rand.nextLong();
-            int cmp1 = Long.compareUnsigned(a, b);
-            // System.out.format("a vs b: %x vs %x (cmp %d)\n", a, b, cmp1);
-            byte[] x = OptOutUtils.toByteArray(a);
-            byte[] y = OptOutUtils.toByteArray(b);
-            int cmp2 = OptOutUtils.compareBytes(x, y);
-            if (cmp1 == 0) {
-                assertTrue(cmp2 == 0);
-            } else if (cmp1 > 0) {
-                // little endian doesn't guarantee byte array comparison yields the same consistent result
-                // assertTrue(cmp2 > 0);
-            } else /* cmp1 < 0 */ {
-                // little endian doesn't guarantee byte array comparison yields the same consistent result
-                // assertTrue(cmp2 < 0);
-            }
-        }
-    }
-
-    @Test
-    public void compareBytesBE_tests() {
-        for (int i = 0; i < 1000; ++i) {
-            long a = OptOutUtils.rand.nextLong();
-            long b = OptOutUtils.rand.nextLong();
-            int cmp1 = Long.compareUnsigned(a, b);
-            // System.out.format("a vs b: %x vs %x (cmp %d)\n", a, b, cmp1);
-            byte[] x = OptOutUtils.toByteArrayBE(a);
-            byte[] y = OptOutUtils.toByteArrayBE(b);
-            int cmp2 = OptOutUtils.compareBytes(x, y);
-            if (cmp1 == 0) {
-                assertTrue(cmp2 == 0);
-            } else if (cmp1 > 0) {
-                assertTrue(cmp2 > 0);
-            } else /* cmp1 < 0 */ {
-                assertTrue(cmp2 < 0);
-            }
-        }
-    }
-
     @Test
     public void nullHash_tests() {
         assertTrue(OptOutUtils.isValidSha256Hex(OptOutUtils.nullHash));