--- /dev/null	2014-10-20 18:23:34.362607988 -0700
+++ new/test/java/util/zip/CheckCRC32C.java	2014-10-21 10:26:01.596978317 -0700
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+/**
+ * @test @summary Check that CRC-32C returns the expected CRC value for the
+ * string 123456789
+ * http://reveng.sourceforge.net/crc-catalogue/all.htm#crc.cat.crc-32c
+ */
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.zip.CRC32C;
+
+public class CheckCRC32C {
+
+    private final static byte[] BYTES_123456789 = "123456789".getBytes(StandardCharsets.US_ASCII);
+    private final static long EXPECTED_CRC = 0xE3069283L;
+
+    public static void main(String[] args) {
+        testBytes();
+        testByteArray();
+        testByteBuffer();
+        testDirectByteBuffer();
+        testByteArrayOffset();
+        testDirectByteBufferOffset();
+        testLittleEndianDirectByteBufferOffset();
+        testWrappedByteBufferOffset();
+        testLittleEndianWrappedByteBufferOffset();
+    }
+
+    private static void testBytes() {
+        CRC32C crc32c = new CRC32C();
+        for (byte bits : BYTES_123456789) {
+            crc32c.update(bits);
+        }
+        checkChecksum(crc32c);
+    }
+
+    private static void testByteArray() {
+        CRC32C crc32c = new CRC32C();
+        crc32c.update(BYTES_123456789);
+        checkChecksum(crc32c);
+    }
+
+    private static void testByteBuffer() {
+        CRC32C crc32c = new CRC32C();
+        ByteBuffer bb = ByteBuffer.wrap(BYTES_123456789);
+        crc32c.update(bb);
+        checkChecksum(crc32c);
+    }
+
+    private static void testDirectByteBuffer() {
+        CRC32C crc32c = new CRC32C();
+        ByteBuffer bb = ByteBuffer.allocateDirect(BYTES_123456789.length);
+        bb.put(BYTES_123456789);
+        bb.rewind();
+        crc32c.update(bb);
+        checkChecksum(crc32c);
+    }
+
+    private static void checkChecksum(CRC32C crc) {
+        if (crc.getValue() != EXPECTED_CRC) {
+            throw new RuntimeException("Calculated CRC32C result was invalid."
+                    + " Expected " + Long.toHexString(EXPECTED_CRC)
+                    + ", but got " + Long.toHexString(crc.getValue()) + ".");
+        }
+    }
+
+    private static void testByteArrayOffset() {
+        byte[] unaligned_bytes_123456789 = new byte[BYTES_123456789.length + 64];
+        for (int i = 0; i < unaligned_bytes_123456789.length - BYTES_123456789.length; i++) {
+            CRC32C crc = new CRC32C();
+            System.arraycopy(BYTES_123456789, 0, unaligned_bytes_123456789, i, BYTES_123456789.length);
+            crc.update(unaligned_bytes_123456789, i, BYTES_123456789.length);
+            if (crc.getValue() != EXPECTED_CRC) {
+                throw new RuntimeException("Calculated CRC32C result was invalid. Array offset "
+                        + i + ". Expected: " + Long.toHexString(EXPECTED_CRC) + ", Got: "
+                        + Long.toHexString(crc.getValue()));
+            }
+        }
+    }
+
+    private static void testDirectByteBufferOffset() {
+        byte[] unaligned_bytes_123456789 = new byte[BYTES_123456789.length + 64];
+        for (int i = 0; i < unaligned_bytes_123456789.length - BYTES_123456789.length; i++) {
+            CRC32C crc = new CRC32C();
+            ByteBuffer bb = ByteBuffer.allocateDirect(unaligned_bytes_123456789.length);
+            System.arraycopy(BYTES_123456789, 0, unaligned_bytes_123456789, i, BYTES_123456789.length);
+            bb.put(unaligned_bytes_123456789);
+            bb.position(i);
+            bb.limit(i + BYTES_123456789.length);
+            crc.update(bb);
+            if (crc.getValue() != EXPECTED_CRC) {
+                throw new RuntimeException("Calculated CRC32C result was invalid. Array offset "
+                        + i + ". Expected: " + Long.toHexString(EXPECTED_CRC) + ", Got: "
+                        + Long.toHexString(crc.getValue()));
+            }
+        }
+    }
+
+    private static void testLittleEndianDirectByteBufferOffset() {
+        byte[] unaligned_bytes_123456789 = new byte[BYTES_123456789.length + 64];
+        for (int i = 0; i < unaligned_bytes_123456789.length - BYTES_123456789.length; i++) {
+            CRC32C crc = new CRC32C();
+            ByteBuffer bb = ByteBuffer.allocateDirect(unaligned_bytes_123456789.length);
+            bb.order(ByteOrder.LITTLE_ENDIAN);
+            System.arraycopy(BYTES_123456789, 0, unaligned_bytes_123456789, i, BYTES_123456789.length);
+            bb.put(unaligned_bytes_123456789);
+            bb.position(i);
+            bb.limit(i + BYTES_123456789.length);
+            crc.update(bb);
+            if (crc.getValue() != EXPECTED_CRC) {
+                throw new RuntimeException("Calculated CRC32C result was invalid. Array offset "
+                        + i + ". Expected: " + Long.toHexString(EXPECTED_CRC) + ", Got: "
+                        + Long.toHexString(crc.getValue()));
+            }
+        }
+    }
+
+    private static void testWrappedByteBufferOffset() {
+        byte[] unaligned_bytes_123456789 = new byte[BYTES_123456789.length + 64];
+        for (int i = 0; i < unaligned_bytes_123456789.length - BYTES_123456789.length; i++) {
+            CRC32C crc = new CRC32C();
+            System.arraycopy(BYTES_123456789, 0, unaligned_bytes_123456789, i, BYTES_123456789.length);
+            ByteBuffer bb = ByteBuffer.wrap(unaligned_bytes_123456789);
+            bb.position(i);
+            bb.limit(i + BYTES_123456789.length);
+            crc.update(bb);
+            if (crc.getValue() != EXPECTED_CRC) {
+                throw new RuntimeException("Calculated CRC32C result was invalid. Array offset "
+                        + i + ". Expected: " + Long.toHexString(EXPECTED_CRC) + ", Got: "
+                        + Long.toHexString(crc.getValue()));
+            }
+        }
+    }
+
+    private static void testLittleEndianWrappedByteBufferOffset() {
+        byte[] unaligned_bytes_123456789 = new byte[BYTES_123456789.length + 64];
+        for (int i = 0; i < unaligned_bytes_123456789.length - BYTES_123456789.length; i++) {
+            CRC32C crc = new CRC32C();
+            System.arraycopy(BYTES_123456789, 0, unaligned_bytes_123456789, i, BYTES_123456789.length);
+            ByteBuffer bb = ByteBuffer.wrap(unaligned_bytes_123456789);
+            bb.order(ByteOrder.LITTLE_ENDIAN);
+            bb.position(i);
+            bb.limit(i + BYTES_123456789.length);
+            crc.update(bb);
+            if (crc.getValue() != EXPECTED_CRC) {
+                throw new RuntimeException("Calculated CRC32C result was invalid. Array offset "
+                        + i + ". Expected: " + Long.toHexString(EXPECTED_CRC) + ", Got: "
+                        + Long.toHexString(crc.getValue()));
+            }
+        }
+    }
+}