test/580-crc32/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed 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.
  */

 import java.util.zip.CRC32;
 import java.util.Random;
 import java.nio.ByteBuffer;

 /**
  * The ART compiler can use intrinsics for the java.util.zip.CRC32 methods:
  *   private native static int update(int crc, int b)
  *   private native static int updateBytes(int crc, byte[] b, int off, int len)
  *
  * As the methods are private it is not possible to check the use of intrinsics
  * for them directly.
  * The tests check that correct checksums are produced.
  */
 public class Main {
   public Main() {
   }

   public static long CRC32Byte(int value) {
     CRC32 crc32 = new CRC32();
     crc32.update(value);
     return crc32.getValue();
   }

   public static long CRC32BytesUsingUpdateInt(int... values) {
     CRC32 crc32 = new CRC32();
     for (int value : values) {
       crc32.update(value);
     }
     return crc32.getValue();
   }

   public static void assertEqual(long expected, long actual) {
     if (expected != actual) {
       throw new Error("Expected: " + expected + ", found: " + actual);
     }
   }

   private static void assertEqual(boolean expected, boolean actual) {
     if (expected != actual) {
       throw new Error("Expected: " + expected + ", found: " + actual);
     }
   }

   private static void TestCRC32Update() {
     // public void update(int b)
     //
     // Tests for checksums of the byte 0x0
     // Check that only the low eight bits of the argument are used.
     assertEqual(0xD202EF8DL, CRC32Byte(0x0));
     assertEqual(0xD202EF8DL, CRC32Byte(0x0100));
     assertEqual(0xD202EF8DL, CRC32Byte(0x010000));
     assertEqual(0xD202EF8DL, CRC32Byte(0x01000000));
     assertEqual(0xD202EF8DL, CRC32Byte(0xff00));
     assertEqual(0xD202EF8DL, CRC32Byte(0xffff00));
     assertEqual(0xD202EF8DL, CRC32Byte(0xffffff00));
     assertEqual(0xD202EF8DL, CRC32Byte(0x1200));
     assertEqual(0xD202EF8DL, CRC32Byte(0x123400));
     assertEqual(0xD202EF8DL, CRC32Byte(0x12345600));
     assertEqual(0xD202EF8DL, CRC32Byte(Integer.MIN_VALUE));

     // Tests for checksums of the byte 0x1
     // Check that only the low eight bits of the argument are used.
     assertEqual(0xA505DF1BL, CRC32Byte(0x1));
     assertEqual(0xA505DF1BL, CRC32Byte(0x0101));
     assertEqual(0xA505DF1BL, CRC32Byte(0x010001));
     assertEqual(0xA505DF1BL, CRC32Byte(0x01000001));
     assertEqual(0xA505DF1BL, CRC32Byte(0xff01));
     assertEqual(0xA505DF1BL, CRC32Byte(0xffff01));
     assertEqual(0xA505DF1BL, CRC32Byte(0xffffff01));
     assertEqual(0xA505DF1BL, CRC32Byte(0x1201));
     assertEqual(0xA505DF1BL, CRC32Byte(0x123401));
     assertEqual(0xA505DF1BL, CRC32Byte(0x12345601));

     // Tests for checksums of the byte 0x0f
     // Check that only the low eight bits of the argument are used.
     assertEqual(0x42BDF21CL, CRC32Byte(0x0f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x010f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x01000f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x0100000f));
     assertEqual(0x42BDF21CL, CRC32Byte(0xff0f));
     assertEqual(0x42BDF21CL, CRC32Byte(0xffff0f));
     assertEqual(0x42BDF21CL, CRC32Byte(0xffffff0f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x120f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x12340f));
     assertEqual(0x42BDF21CL, CRC32Byte(0x1234560f));

     // Tests for checksums of the byte 0xff
     // Check that only the low eight bits of the argument are used.
     assertEqual(0xFF000000L, CRC32Byte(0x00ff));
     assertEqual(0xFF000000L, CRC32Byte(0x01ff));
     assertEqual(0xFF000000L, CRC32Byte(0x0100ff));
     assertEqual(0xFF000000L, CRC32Byte(0x010000ff));
     assertEqual(0xFF000000L, CRC32Byte(0x0000ffff));
     assertEqual(0xFF000000L, CRC32Byte(0x00ffffff));
     assertEqual(0xFF000000L, CRC32Byte(0xffffffff));
     assertEqual(0xFF000000L, CRC32Byte(0x12ff));
     assertEqual(0xFF000000L, CRC32Byte(0x1234ff));
     assertEqual(0xFF000000L, CRC32Byte(0x123456ff));
     assertEqual(0xFF000000L, CRC32Byte(Integer.MAX_VALUE));

     // Tests for sequences
     // Check that only the low eight bits of the values are used.
     assertEqual(0xFF41D912L, CRC32BytesUsingUpdateInt(0, 0, 0));
     assertEqual(0xFF41D912L,
                 CRC32BytesUsingUpdateInt(0x0100, 0x010000, 0x01000000));
     assertEqual(0xFF41D912L,
                 CRC32BytesUsingUpdateInt(0xff00, 0xffff00, 0xffffff00));
     assertEqual(0xFF41D912L,
                 CRC32BytesUsingUpdateInt(0x1200, 0x123400, 0x12345600));

     assertEqual(0x909FB2F2L, CRC32BytesUsingUpdateInt(1, 1, 1));
     assertEqual(0x909FB2F2L,
                 CRC32BytesUsingUpdateInt(0x0101, 0x010001, 0x01000001));
     assertEqual(0x909FB2F2L,
                 CRC32BytesUsingUpdateInt(0xff01, 0xffff01, 0xffffff01));
     assertEqual(0x909FB2F2L,
                 CRC32BytesUsingUpdateInt(0x1201, 0x123401, 0x12345601));

     assertEqual(0xE33A9F71L, CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f));
     assertEqual(0xE33A9F71L,
                 CRC32BytesUsingUpdateInt(0x010f, 0x01000f, 0x0100000f));
     assertEqual(0xE33A9F71L,
                 CRC32BytesUsingUpdateInt(0xff0f, 0xffff0f, 0xffffff0f));
     assertEqual(0xE33A9F71L,
                 CRC32BytesUsingUpdateInt(0x120f, 0x12340f, 0x1234560f));

     assertEqual(0xFFFFFF00L, CRC32BytesUsingUpdateInt(0x0ff, 0x0ff, 0x0ff));
     assertEqual(0xFFFFFF00L,
                 CRC32BytesUsingUpdateInt(0x01ff, 0x0100ff, 0x010000ff));
     assertEqual(0xFFFFFF00L,
                 CRC32BytesUsingUpdateInt(0x00ffff, 0x00ffffff, 0xffffffff));
     assertEqual(0xFFFFFF00L,
                 CRC32BytesUsingUpdateInt(0x12ff, 0x1234ff, 0x123456ff));

     assertEqual(0xB6CC4292L, CRC32BytesUsingUpdateInt(0x01, 0x02));

     assertEqual(0xB2DE047CL,
                 CRC32BytesUsingUpdateInt(0x0, -1, Integer.MIN_VALUE, Integer.MAX_VALUE));
   }

   private static long CRC32ByteArray(byte[] bytes, int off, int len) {
     CRC32 crc32 = new CRC32();
     crc32.update(bytes, off, len);
     return crc32.getValue();
   }

   // This is used to test we generate correct code for constant offsets.
   // In this case the offset is 0.
   private static long CRC32ByteArray(byte[] bytes) {
     CRC32 crc32 = new CRC32();
     crc32.update(bytes);
     return crc32.getValue();
   }

   private static long CRC32ByteAndByteArray(int value, byte[] bytes) {
     CRC32 crc32 = new CRC32();
     crc32.update(value);
     crc32.update(bytes);
     return crc32.getValue();
   }

   private static long CRC32ByteArrayAndByte(byte[] bytes, int value) {
     CRC32 crc32 = new CRC32();
     crc32.update(bytes);
     crc32.update(value);
     return crc32.getValue();
   }

   private static boolean CRC32ByteArrayThrowsAIOOBE(byte[] bytes, int off, int len) {
     try {
       CRC32 crc32 = new CRC32();
       crc32.update(bytes, off, len);
     } catch (ArrayIndexOutOfBoundsException ex) {
       return true;
     }
     return false;
   }

   private static boolean CRC32ByteArrayThrowsNPE() {
     try {
       CRC32 crc32 = new CRC32();
       crc32.update(null, 0, 0);
       return false;
     } catch (NullPointerException e) {}

     try {
       CRC32 crc32 = new CRC32();
       crc32.update(null, 1, 2);
       return false;
     } catch (NullPointerException e) {}

     try {
       CRC32 crc32 = new CRC32();
       crc32.update((byte[])null);
       return false;
     } catch (NullPointerException e) {}

     return true;
   }

   private static long CRC32BytesUsingUpdateInt(byte[] bytes, int off, int len) {
     CRC32 crc32 = new CRC32();
     while (len-- > 0) {
       crc32.update(bytes[off++]);
     }
     return crc32.getValue();
   }

   private static void TestCRC32UpdateBytes() {
     assertEqual(0L, CRC32ByteArray(new byte[] {}));
     assertEqual(0L, CRC32ByteArray(new byte[] {}, 0, 0));
     assertEqual(0L, CRC32ByteArray(new byte[] {0}, 0, 0));
     assertEqual(0L, CRC32ByteArray(new byte[] {0}, 1, 0));
     assertEqual(0L, CRC32ByteArray(new byte[] {0, 0}, 1, 0));

     assertEqual(true, CRC32ByteArrayThrowsNPE());
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, -1, 0));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, -1, 1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, 0, -1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, -1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 1, 0));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, -1, 1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 1, -1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, 1));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, 10));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, 0, 10));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 10, 10));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0, 0, 0, 0}, 2, 3));
     assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0, 0, 0, 0}, 3, 2));

     assertEqual(CRC32Byte(0), CRC32ByteArray(new byte[] {0}));
     assertEqual(CRC32Byte(0), CRC32ByteArray(new byte[] {0}, 0, 1));
     assertEqual(CRC32Byte(1), CRC32ByteArray(new byte[] {1}));
     assertEqual(CRC32Byte(1), CRC32ByteArray(new byte[] {1}, 0, 1));
     assertEqual(CRC32Byte(0x0f), CRC32ByteArray(new byte[] {0x0f}));
     assertEqual(CRC32Byte(0x0f), CRC32ByteArray(new byte[] {0x0f}, 0, 1));
     assertEqual(CRC32Byte(0xff), CRC32ByteArray(new byte[] {-1}));
     assertEqual(CRC32Byte(0xff), CRC32ByteArray(new byte[] {-1}, 0, 1));
     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteArray(new byte[] {0, 0, 0}));
     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteArray(new byte[] {0, 0, 0}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteArray(new byte[] {1, 1, 1}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteArray(new byte[] {1, 1, 1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteArray(new byte[] {0x0f, 0x0f, 0x0f}));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteArray(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteArray(new byte[] {-1, -1, -1}));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteArray(new byte[] {-1, -1, -1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2),
                 CRC32ByteArray(new byte[] {1, 2}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2),
                 CRC32ByteArray(new byte[] {1, 2}, 0, 2));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteArray(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteArray(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteAndByteArray(0, new byte[] {0, 0}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteAndByteArray(1, new byte[] {1, 1}));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteAndByteArray(0x0f, new byte[] {0x0f, 0x0f}));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteAndByteArray(-1, new byte[] {-1, -1}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
                 CRC32ByteAndByteArray(1, new byte[] {2, 3}));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteAndByteArray(0, new byte[] {-1, Byte.MIN_VALUE, Byte.MAX_VALUE}));

     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteArrayAndByte(new byte[] {0, 0}, 0));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteArrayAndByte(new byte[] {1, 1}, 1));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteArrayAndByte(new byte[] {0x0f, 0x0f}, 0x0f));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteArrayAndByte(new byte[] {-1, -1}, -1));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
                 CRC32ByteArrayAndByte(new byte[] {1, 2}, 3));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteArrayAndByte(new byte[] {0, -1, Byte.MIN_VALUE}, Byte.MAX_VALUE));

     byte[] bytes = new byte[128 * 1024];
     Random rnd = new Random(0);
     rnd.nextBytes(bytes);

     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, bytes.length),
                 CRC32ByteArray(bytes));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
                 CRC32ByteArray(bytes, 0, 8 * 1024));

     int off = rnd.nextInt(bytes.length / 2);
     for (int len = 0; len <= 16; ++len) {
       assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                   CRC32ByteArray(bytes, off, len));
     }

     // Check there are no issues with unaligned accesses.
     for (int o = 1; o < 8; ++o) {
       for (int l = 0; l <= 16; ++l) {
         assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
                     CRC32ByteArray(bytes, o, l));
       }
     }

     int len = bytes.length / 2;
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
                 CRC32ByteArray(bytes, 0, len - 1));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
                 CRC32ByteArray(bytes, 0, len));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
                 CRC32ByteArray(bytes, 0, len + 1));

     len = rnd.nextInt(bytes.length + 1);
     off = rnd.nextInt(bytes.length - len);
     assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                 CRC32ByteArray(bytes, off, len));
   }

   private static long CRC32ByteBuffer(byte[] bytes, int off, int len) {
     ByteBuffer buf = ByteBuffer.wrap(bytes, 0, off + len);
     buf.position(off);
     CRC32 crc32 = new CRC32();
     crc32.update(buf);
     return crc32.getValue();
   }

   private static void TestCRC32UpdateByteBuffer() {
     assertEqual(0L, CRC32ByteBuffer(new byte[] {}, 0, 0));
     assertEqual(0L, CRC32ByteBuffer(new byte[] {0}, 0, 0));
     assertEqual(0L, CRC32ByteBuffer(new byte[] {0}, 1, 0));
     assertEqual(0L, CRC32ByteBuffer(new byte[] {0, 0}, 1, 0));

     assertEqual(CRC32Byte(0), CRC32ByteBuffer(new byte[] {0}, 0, 1));
     assertEqual(CRC32Byte(1), CRC32ByteBuffer(new byte[] {1}, 0, 1));
     assertEqual(CRC32Byte(0x0f), CRC32ByteBuffer(new byte[] {0x0f}, 0, 1));
     assertEqual(CRC32Byte(0xff), CRC32ByteBuffer(new byte[] {-1}, 0, 1));
     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteBuffer(new byte[] {0, 0, 0}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteBuffer(new byte[] {1, 1, 1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteBuffer(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteBuffer(new byte[] {-1, -1, -1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2),
                 CRC32ByteBuffer(new byte[] {1, 2}, 0, 2));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteBuffer(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

     byte[] bytes = new byte[128 * 1024];
     Random rnd = new Random(0);
     rnd.nextBytes(bytes);

     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
                 CRC32ByteBuffer(bytes, 0, 8 * 1024));

     int off = rnd.nextInt(bytes.length / 2);
     for (int len = 0; len <= 16; ++len) {
       assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                   CRC32ByteBuffer(bytes, off, len));
     }

     // Check there are no issues with unaligned accesses.
     for (int o = 1; o < 8; ++o) {
       for (int l = 0; l <= 16; ++l) {
         assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
                     CRC32ByteBuffer(bytes, o, l));
       }
     }

     int len = bytes.length / 2;
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
                 CRC32ByteBuffer(bytes, 0, len - 1));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
                 CRC32ByteBuffer(bytes, 0, len));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
                 CRC32ByteBuffer(bytes, 0, len + 1));

     len = rnd.nextInt(bytes.length + 1);
     off = rnd.nextInt(bytes.length - len);
     assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                 CRC32ByteBuffer(bytes, off, len));
   }

   private static long CRC32DirectByteBuffer(byte[] bytes, int off, int len) {
     final int total_len = off + len;
     ByteBuffer buf = ByteBuffer.allocateDirect(total_len).put(bytes, 0, total_len);
     buf.position(off);
     CRC32 crc32 = new CRC32();
     crc32.update(buf);
     return crc32.getValue();
   }

   private static long CRC32ByteAndDirectByteBuffer(int value, byte[] bytes) {
     ByteBuffer buf = ByteBuffer.allocateDirect(bytes.length).put(bytes);
     buf.position(0);
     CRC32 crc32 = new CRC32();
     crc32.update(value);
     crc32.update(buf);
     return crc32.getValue();
   }

   private static long CRC32DirectByteBufferAndByte(byte[] bytes, int value) {
     ByteBuffer buf = ByteBuffer.allocateDirect(bytes.length).put(bytes);
     buf.position(0);
     CRC32 crc32 = new CRC32();
     crc32.update(buf);
     crc32.update(value);
     return crc32.getValue();
   }

   private static void TestCRC32UpdateDirectByteBuffer() {
     assertEqual(0L, CRC32DirectByteBuffer(new byte[] {}, 0, 0));
     assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0}, 0, 0));
     assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0}, 1, 0));
     assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0, 0}, 1, 0));

     assertEqual(CRC32Byte(0), CRC32DirectByteBuffer(new byte[] {0}, 0, 1));
     assertEqual(CRC32Byte(1), CRC32DirectByteBuffer(new byte[] {1}, 0, 1));
     assertEqual(CRC32Byte(0x0f), CRC32DirectByteBuffer(new byte[] {0x0f}, 0, 1));
     assertEqual(CRC32Byte(0xff), CRC32DirectByteBuffer(new byte[] {-1}, 0, 1));
     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32DirectByteBuffer(new byte[] {0, 0, 0}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32DirectByteBuffer(new byte[] {1, 1, 1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32DirectByteBuffer(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32DirectByteBuffer(new byte[] {-1, -1, -1}, 0, 3));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2),
                 CRC32DirectByteBuffer(new byte[] {1, 2}, 0, 2));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32DirectByteBuffer(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32ByteAndDirectByteBuffer(0, new byte[] {0, 0}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32ByteAndDirectByteBuffer(1, new byte[] {1, 1}));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32ByteAndDirectByteBuffer(0x0f, new byte[] {0x0f, 0x0f}));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32ByteAndDirectByteBuffer(-1, new byte[] {-1, -1}));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
                 CRC32ByteAndDirectByteBuffer(1, new byte[] {2, 3}));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32ByteAndDirectByteBuffer(0, new byte[] {-1, Byte.MIN_VALUE, Byte.MAX_VALUE}));

     assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
                 CRC32DirectByteBufferAndByte(new byte[] {0, 0}, 0));
     assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
                 CRC32DirectByteBufferAndByte(new byte[] {1, 1}, 1));
     assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
                 CRC32DirectByteBufferAndByte(new byte[] {0x0f, 0x0f}, 0x0f));
     assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
                 CRC32DirectByteBufferAndByte(new byte[] {-1, -1}, -1));
     assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
                 CRC32DirectByteBufferAndByte(new byte[] {1, 2}, 3));
     assertEqual(
         CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
         CRC32DirectByteBufferAndByte(new byte[] {0, -1, Byte.MIN_VALUE}, Byte.MAX_VALUE));

     byte[] bytes = new byte[128 * 1024];
     Random rnd = new Random(0);
     rnd.nextBytes(bytes);

     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, bytes.length),
                 CRC32DirectByteBuffer(bytes, 0, bytes.length));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
                 CRC32DirectByteBuffer(bytes, 0, 8 * 1024));

     int off = rnd.nextInt(bytes.length / 2);
     for (int len = 0; len <= 16; ++len) {
       assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                   CRC32DirectByteBuffer(bytes, off, len));
     }

     // Check there are no issues with unaligned accesses.
     for (int o = 1; o < 8; ++o) {
       for (int l = 0; l <= 16; ++l) {
         assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
                     CRC32DirectByteBuffer(bytes, o, l));
       }
     }

     int len = bytes.length / 2;
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
                 CRC32DirectByteBuffer(bytes, 0, len - 1));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
                 CRC32DirectByteBuffer(bytes, 0, len));
     assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
                 CRC32DirectByteBuffer(bytes, 0, len + 1));

     len = rnd.nextInt(bytes.length + 1);
     off = rnd.nextInt(bytes.length - len);
     assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
                 CRC32DirectByteBuffer(bytes, off, len));
   }

   public static void main(String args[]) {
     TestCRC32Update();
     TestCRC32UpdateBytes();
     TestCRC32UpdateByteBuffer();
     TestCRC32UpdateDirectByteBuffer();
   }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed 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.
	*/

	import java.util.zip.CRC32;
	import java.util.Random;
	import java.nio.ByteBuffer;

	/**
	* The ART compiler can use intrinsics for the java.util.zip.CRC32 methods:
	* private native static int update(int crc, int b)
	* private native static int updateBytes(int crc, byte[] b, int off, int len)
	*
	* As the methods are private it is not possible to check the use of intrinsics
	* for them directly.
	* The tests check that correct checksums are produced.
	*/
	public class Main {
	public Main() {
	}

	public static long CRC32Byte(int value) {
	CRC32 crc32 = new CRC32();
	crc32.update(value);
	return crc32.getValue();
	}

	public static long CRC32BytesUsingUpdateInt(int... values) {
	CRC32 crc32 = new CRC32();
	for (int value : values) {
	crc32.update(value);
	}
	return crc32.getValue();
	}

	public static void assertEqual(long expected, long actual) {
	if (expected != actual) {
	throw new Error("Expected: " + expected + ", found: " + actual);
	}
	}

	private static void assertEqual(boolean expected, boolean actual) {
	if (expected != actual) {
	throw new Error("Expected: " + expected + ", found: " + actual);
	}
	}

	private static void TestCRC32Update() {
	// public void update(int b)
	//
	// Tests for checksums of the byte 0x0
	// Check that only the low eight bits of the argument are used.
	assertEqual(0xD202EF8DL, CRC32Byte(0x0));
	assertEqual(0xD202EF8DL, CRC32Byte(0x0100));
	assertEqual(0xD202EF8DL, CRC32Byte(0x010000));
	assertEqual(0xD202EF8DL, CRC32Byte(0x01000000));
	assertEqual(0xD202EF8DL, CRC32Byte(0xff00));
	assertEqual(0xD202EF8DL, CRC32Byte(0xffff00));
	assertEqual(0xD202EF8DL, CRC32Byte(0xffffff00));
	assertEqual(0xD202EF8DL, CRC32Byte(0x1200));
	assertEqual(0xD202EF8DL, CRC32Byte(0x123400));
	assertEqual(0xD202EF8DL, CRC32Byte(0x12345600));
	assertEqual(0xD202EF8DL, CRC32Byte(Integer.MIN_VALUE));

	// Tests for checksums of the byte 0x1
	// Check that only the low eight bits of the argument are used.
	assertEqual(0xA505DF1BL, CRC32Byte(0x1));
	assertEqual(0xA505DF1BL, CRC32Byte(0x0101));
	assertEqual(0xA505DF1BL, CRC32Byte(0x010001));
	assertEqual(0xA505DF1BL, CRC32Byte(0x01000001));
	assertEqual(0xA505DF1BL, CRC32Byte(0xff01));
	assertEqual(0xA505DF1BL, CRC32Byte(0xffff01));
	assertEqual(0xA505DF1BL, CRC32Byte(0xffffff01));
	assertEqual(0xA505DF1BL, CRC32Byte(0x1201));
	assertEqual(0xA505DF1BL, CRC32Byte(0x123401));
	assertEqual(0xA505DF1BL, CRC32Byte(0x12345601));

	// Tests for checksums of the byte 0x0f
	// Check that only the low eight bits of the argument are used.
	assertEqual(0x42BDF21CL, CRC32Byte(0x0f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x010f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x01000f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x0100000f));
	assertEqual(0x42BDF21CL, CRC32Byte(0xff0f));
	assertEqual(0x42BDF21CL, CRC32Byte(0xffff0f));
	assertEqual(0x42BDF21CL, CRC32Byte(0xffffff0f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x120f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x12340f));
	assertEqual(0x42BDF21CL, CRC32Byte(0x1234560f));

	// Tests for checksums of the byte 0xff
	// Check that only the low eight bits of the argument are used.
	assertEqual(0xFF000000L, CRC32Byte(0x00ff));
	assertEqual(0xFF000000L, CRC32Byte(0x01ff));
	assertEqual(0xFF000000L, CRC32Byte(0x0100ff));
	assertEqual(0xFF000000L, CRC32Byte(0x010000ff));
	assertEqual(0xFF000000L, CRC32Byte(0x0000ffff));
	assertEqual(0xFF000000L, CRC32Byte(0x00ffffff));
	assertEqual(0xFF000000L, CRC32Byte(0xffffffff));
	assertEqual(0xFF000000L, CRC32Byte(0x12ff));
	assertEqual(0xFF000000L, CRC32Byte(0x1234ff));
	assertEqual(0xFF000000L, CRC32Byte(0x123456ff));
	assertEqual(0xFF000000L, CRC32Byte(Integer.MAX_VALUE));

	// Tests for sequences
	// Check that only the low eight bits of the values are used.
	assertEqual(0xFF41D912L, CRC32BytesUsingUpdateInt(0, 0, 0));
	assertEqual(0xFF41D912L,
	CRC32BytesUsingUpdateInt(0x0100, 0x010000, 0x01000000));
	assertEqual(0xFF41D912L,
	CRC32BytesUsingUpdateInt(0xff00, 0xffff00, 0xffffff00));
	assertEqual(0xFF41D912L,
	CRC32BytesUsingUpdateInt(0x1200, 0x123400, 0x12345600));

	assertEqual(0x909FB2F2L, CRC32BytesUsingUpdateInt(1, 1, 1));
	assertEqual(0x909FB2F2L,
	CRC32BytesUsingUpdateInt(0x0101, 0x010001, 0x01000001));
	assertEqual(0x909FB2F2L,
	CRC32BytesUsingUpdateInt(0xff01, 0xffff01, 0xffffff01));
	assertEqual(0x909FB2F2L,
	CRC32BytesUsingUpdateInt(0x1201, 0x123401, 0x12345601));

	assertEqual(0xE33A9F71L, CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f));
	assertEqual(0xE33A9F71L,
	CRC32BytesUsingUpdateInt(0x010f, 0x01000f, 0x0100000f));
	assertEqual(0xE33A9F71L,
	CRC32BytesUsingUpdateInt(0xff0f, 0xffff0f, 0xffffff0f));
	assertEqual(0xE33A9F71L,
	CRC32BytesUsingUpdateInt(0x120f, 0x12340f, 0x1234560f));

	assertEqual(0xFFFFFF00L, CRC32BytesUsingUpdateInt(0x0ff, 0x0ff, 0x0ff));
	assertEqual(0xFFFFFF00L,
	CRC32BytesUsingUpdateInt(0x01ff, 0x0100ff, 0x010000ff));
	assertEqual(0xFFFFFF00L,
	CRC32BytesUsingUpdateInt(0x00ffff, 0x00ffffff, 0xffffffff));
	assertEqual(0xFFFFFF00L,
	CRC32BytesUsingUpdateInt(0x12ff, 0x1234ff, 0x123456ff));

	assertEqual(0xB6CC4292L, CRC32BytesUsingUpdateInt(0x01, 0x02));

	assertEqual(0xB2DE047CL,
	CRC32BytesUsingUpdateInt(0x0, -1, Integer.MIN_VALUE, Integer.MAX_VALUE));
	}

	private static long CRC32ByteArray(byte[] bytes, int off, int len) {
	CRC32 crc32 = new CRC32();
	crc32.update(bytes, off, len);
	return crc32.getValue();
	}

	// This is used to test we generate correct code for constant offsets.
	// In this case the offset is 0.
	private static long CRC32ByteArray(byte[] bytes) {
	CRC32 crc32 = new CRC32();
	crc32.update(bytes);
	return crc32.getValue();
	}

	private static long CRC32ByteAndByteArray(int value, byte[] bytes) {
	CRC32 crc32 = new CRC32();
	crc32.update(value);
	crc32.update(bytes);
	return crc32.getValue();
	}

	private static long CRC32ByteArrayAndByte(byte[] bytes, int value) {
	CRC32 crc32 = new CRC32();
	crc32.update(bytes);
	crc32.update(value);
	return crc32.getValue();
	}

	private static boolean CRC32ByteArrayThrowsAIOOBE(byte[] bytes, int off, int len) {
	try {
	CRC32 crc32 = new CRC32();
	crc32.update(bytes, off, len);
	} catch (ArrayIndexOutOfBoundsException ex) {
	return true;
	}
	return false;
	}

	private static boolean CRC32ByteArrayThrowsNPE() {
	try {
	CRC32 crc32 = new CRC32();
	crc32.update(null, 0, 0);
	return false;
	} catch (NullPointerException e) {}

	try {
	CRC32 crc32 = new CRC32();
	crc32.update(null, 1, 2);
	return false;
	} catch (NullPointerException e) {}

	try {
	CRC32 crc32 = new CRC32();
	crc32.update((byte[])null);
	return false;
	} catch (NullPointerException e) {}

	return true;
	}

	private static long CRC32BytesUsingUpdateInt(byte[] bytes, int off, int len) {
	CRC32 crc32 = new CRC32();
	while (len-- > 0) {
	crc32.update(bytes[off++]);
	}
	return crc32.getValue();
	}

	private static void TestCRC32UpdateBytes() {
	assertEqual(0L, CRC32ByteArray(new byte[] {}));
	assertEqual(0L, CRC32ByteArray(new byte[] {}, 0, 0));
	assertEqual(0L, CRC32ByteArray(new byte[] {0}, 0, 0));
	assertEqual(0L, CRC32ByteArray(new byte[] {0}, 1, 0));
	assertEqual(0L, CRC32ByteArray(new byte[] {0, 0}, 1, 0));

	assertEqual(true, CRC32ByteArrayThrowsNPE());
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, -1, 0));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, -1, 1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, 0, -1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, -1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 1, 0));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, -1, 1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 1, -1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, 1));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 0, 10));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0}, 0, 10));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {}, 10, 10));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0, 0, 0, 0}, 2, 3));
	assertEqual(true, CRC32ByteArrayThrowsAIOOBE(new byte[] {0, 0, 0, 0}, 3, 2));

	assertEqual(CRC32Byte(0), CRC32ByteArray(new byte[] {0}));
	assertEqual(CRC32Byte(0), CRC32ByteArray(new byte[] {0}, 0, 1));
	assertEqual(CRC32Byte(1), CRC32ByteArray(new byte[] {1}));
	assertEqual(CRC32Byte(1), CRC32ByteArray(new byte[] {1}, 0, 1));
	assertEqual(CRC32Byte(0x0f), CRC32ByteArray(new byte[] {0x0f}));
	assertEqual(CRC32Byte(0x0f), CRC32ByteArray(new byte[] {0x0f}, 0, 1));
	assertEqual(CRC32Byte(0xff), CRC32ByteArray(new byte[] {-1}));
	assertEqual(CRC32Byte(0xff), CRC32ByteArray(new byte[] {-1}, 0, 1));
	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteArray(new byte[] {0, 0, 0}));
	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteArray(new byte[] {0, 0, 0}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteArray(new byte[] {1, 1, 1}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteArray(new byte[] {1, 1, 1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteArray(new byte[] {0x0f, 0x0f, 0x0f}));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteArray(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteArray(new byte[] {-1, -1, -1}));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteArray(new byte[] {-1, -1, -1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2),
	CRC32ByteArray(new byte[] {1, 2}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2),
	CRC32ByteArray(new byte[] {1, 2}, 0, 2));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteArray(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteArray(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteAndByteArray(0, new byte[] {0, 0}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteAndByteArray(1, new byte[] {1, 1}));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteAndByteArray(0x0f, new byte[] {0x0f, 0x0f}));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteAndByteArray(-1, new byte[] {-1, -1}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
	CRC32ByteAndByteArray(1, new byte[] {2, 3}));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteAndByteArray(0, new byte[] {-1, Byte.MIN_VALUE, Byte.MAX_VALUE}));

	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteArrayAndByte(new byte[] {0, 0}, 0));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteArrayAndByte(new byte[] {1, 1}, 1));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteArrayAndByte(new byte[] {0x0f, 0x0f}, 0x0f));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteArrayAndByte(new byte[] {-1, -1}, -1));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
	CRC32ByteArrayAndByte(new byte[] {1, 2}, 3));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteArrayAndByte(new byte[] {0, -1, Byte.MIN_VALUE}, Byte.MAX_VALUE));

	byte[] bytes = new byte[128 * 1024];
	Random rnd = new Random(0);
	rnd.nextBytes(bytes);

	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, bytes.length),
	CRC32ByteArray(bytes));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
	CRC32ByteArray(bytes, 0, 8 * 1024));

	int off = rnd.nextInt(bytes.length / 2);
	for (int len = 0; len <= 16; ++len) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32ByteArray(bytes, off, len));
	}

	// Check there are no issues with unaligned accesses.
	for (int o = 1; o < 8; ++o) {
	for (int l = 0; l <= 16; ++l) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
	CRC32ByteArray(bytes, o, l));
	}
	}

	int len = bytes.length / 2;
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
	CRC32ByteArray(bytes, 0, len - 1));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
	CRC32ByteArray(bytes, 0, len));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
	CRC32ByteArray(bytes, 0, len + 1));

	len = rnd.nextInt(bytes.length + 1);
	off = rnd.nextInt(bytes.length - len);
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32ByteArray(bytes, off, len));
	}

	private static long CRC32ByteBuffer(byte[] bytes, int off, int len) {
	ByteBuffer buf = ByteBuffer.wrap(bytes, 0, off + len);
	buf.position(off);
	CRC32 crc32 = new CRC32();
	crc32.update(buf);
	return crc32.getValue();
	}

	private static void TestCRC32UpdateByteBuffer() {
	assertEqual(0L, CRC32ByteBuffer(new byte[] {}, 0, 0));
	assertEqual(0L, CRC32ByteBuffer(new byte[] {0}, 0, 0));
	assertEqual(0L, CRC32ByteBuffer(new byte[] {0}, 1, 0));
	assertEqual(0L, CRC32ByteBuffer(new byte[] {0, 0}, 1, 0));

	assertEqual(CRC32Byte(0), CRC32ByteBuffer(new byte[] {0}, 0, 1));
	assertEqual(CRC32Byte(1), CRC32ByteBuffer(new byte[] {1}, 0, 1));
	assertEqual(CRC32Byte(0x0f), CRC32ByteBuffer(new byte[] {0x0f}, 0, 1));
	assertEqual(CRC32Byte(0xff), CRC32ByteBuffer(new byte[] {-1}, 0, 1));
	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteBuffer(new byte[] {0, 0, 0}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteBuffer(new byte[] {1, 1, 1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteBuffer(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteBuffer(new byte[] {-1, -1, -1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2),
	CRC32ByteBuffer(new byte[] {1, 2}, 0, 2));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteBuffer(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

	byte[] bytes = new byte[128 * 1024];
	Random rnd = new Random(0);
	rnd.nextBytes(bytes);

	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
	CRC32ByteBuffer(bytes, 0, 8 * 1024));

	int off = rnd.nextInt(bytes.length / 2);
	for (int len = 0; len <= 16; ++len) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32ByteBuffer(bytes, off, len));
	}

	// Check there are no issues with unaligned accesses.
	for (int o = 1; o < 8; ++o) {
	for (int l = 0; l <= 16; ++l) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
	CRC32ByteBuffer(bytes, o, l));
	}
	}

	int len = bytes.length / 2;
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
	CRC32ByteBuffer(bytes, 0, len - 1));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
	CRC32ByteBuffer(bytes, 0, len));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
	CRC32ByteBuffer(bytes, 0, len + 1));

	len = rnd.nextInt(bytes.length + 1);
	off = rnd.nextInt(bytes.length - len);
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32ByteBuffer(bytes, off, len));
	}

	private static long CRC32DirectByteBuffer(byte[] bytes, int off, int len) {
	final int total_len = off + len;
	ByteBuffer buf = ByteBuffer.allocateDirect(total_len).put(bytes, 0, total_len);
	buf.position(off);
	CRC32 crc32 = new CRC32();
	crc32.update(buf);
	return crc32.getValue();
	}

	private static long CRC32ByteAndDirectByteBuffer(int value, byte[] bytes) {
	ByteBuffer buf = ByteBuffer.allocateDirect(bytes.length).put(bytes);
	buf.position(0);
	CRC32 crc32 = new CRC32();
	crc32.update(value);
	crc32.update(buf);
	return crc32.getValue();
	}

	private static long CRC32DirectByteBufferAndByte(byte[] bytes, int value) {
	ByteBuffer buf = ByteBuffer.allocateDirect(bytes.length).put(bytes);
	buf.position(0);
	CRC32 crc32 = new CRC32();
	crc32.update(buf);
	crc32.update(value);
	return crc32.getValue();
	}

	private static void TestCRC32UpdateDirectByteBuffer() {
	assertEqual(0L, CRC32DirectByteBuffer(new byte[] {}, 0, 0));
	assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0}, 0, 0));
	assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0}, 1, 0));
	assertEqual(0L, CRC32DirectByteBuffer(new byte[] {0, 0}, 1, 0));

	assertEqual(CRC32Byte(0), CRC32DirectByteBuffer(new byte[] {0}, 0, 1));
	assertEqual(CRC32Byte(1), CRC32DirectByteBuffer(new byte[] {1}, 0, 1));
	assertEqual(CRC32Byte(0x0f), CRC32DirectByteBuffer(new byte[] {0x0f}, 0, 1));
	assertEqual(CRC32Byte(0xff), CRC32DirectByteBuffer(new byte[] {-1}, 0, 1));
	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32DirectByteBuffer(new byte[] {0, 0, 0}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32DirectByteBuffer(new byte[] {1, 1, 1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32DirectByteBuffer(new byte[] {0x0f, 0x0f, 0x0f}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32DirectByteBuffer(new byte[] {-1, -1, -1}, 0, 3));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2),
	CRC32DirectByteBuffer(new byte[] {1, 2}, 0, 2));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32DirectByteBuffer(new byte[] {0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE}, 0, 4));

	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32ByteAndDirectByteBuffer(0, new byte[] {0, 0}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32ByteAndDirectByteBuffer(1, new byte[] {1, 1}));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32ByteAndDirectByteBuffer(0x0f, new byte[] {0x0f, 0x0f}));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32ByteAndDirectByteBuffer(-1, new byte[] {-1, -1}));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
	CRC32ByteAndDirectByteBuffer(1, new byte[] {2, 3}));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32ByteAndDirectByteBuffer(0, new byte[] {-1, Byte.MIN_VALUE, Byte.MAX_VALUE}));

	assertEqual(CRC32BytesUsingUpdateInt(0, 0, 0),
	CRC32DirectByteBufferAndByte(new byte[] {0, 0}, 0));
	assertEqual(CRC32BytesUsingUpdateInt(1, 1, 1),
	CRC32DirectByteBufferAndByte(new byte[] {1, 1}, 1));
	assertEqual(CRC32BytesUsingUpdateInt(0x0f, 0x0f, 0x0f),
	CRC32DirectByteBufferAndByte(new byte[] {0x0f, 0x0f}, 0x0f));
	assertEqual(CRC32BytesUsingUpdateInt(0xff, 0xff, 0xff),
	CRC32DirectByteBufferAndByte(new byte[] {-1, -1}, -1));
	assertEqual(CRC32BytesUsingUpdateInt(1, 2, 3),
	CRC32DirectByteBufferAndByte(new byte[] {1, 2}, 3));
	assertEqual(
	CRC32BytesUsingUpdateInt(0, -1, Byte.MIN_VALUE, Byte.MAX_VALUE),
	CRC32DirectByteBufferAndByte(new byte[] {0, -1, Byte.MIN_VALUE}, Byte.MAX_VALUE));

	byte[] bytes = new byte[128 * 1024];
	Random rnd = new Random(0);
	rnd.nextBytes(bytes);

	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, bytes.length),
	CRC32DirectByteBuffer(bytes, 0, bytes.length));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, 8 * 1024),
	CRC32DirectByteBuffer(bytes, 0, 8 * 1024));

	int off = rnd.nextInt(bytes.length / 2);
	for (int len = 0; len <= 16; ++len) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32DirectByteBuffer(bytes, off, len));
	}

	// Check there are no issues with unaligned accesses.
	for (int o = 1; o < 8; ++o) {
	for (int l = 0; l <= 16; ++l) {
	assertEqual(CRC32BytesUsingUpdateInt(bytes, o, l),
	CRC32DirectByteBuffer(bytes, o, l));
	}
	}

	int len = bytes.length / 2;
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len - 1),
	CRC32DirectByteBuffer(bytes, 0, len - 1));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len),
	CRC32DirectByteBuffer(bytes, 0, len));
	assertEqual(CRC32BytesUsingUpdateInt(bytes, 0, len + 1),
	CRC32DirectByteBuffer(bytes, 0, len + 1));

	len = rnd.nextInt(bytes.length + 1);
	off = rnd.nextInt(bytes.length - len);
	assertEqual(CRC32BytesUsingUpdateInt(bytes, off, len),
	CRC32DirectByteBuffer(bytes, off, len));
	}

	public static void main(String args[]) {
	TestCRC32Update();
	TestCRC32UpdateBytes();
	TestCRC32UpdateByteBuffer();
	TestCRC32UpdateDirectByteBuffer();
	}
	}