| /* |
| * Copyright (C) 2011 The Guava Authors |
| * |
| * 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. |
| */ |
| |
| package com.google.common.hash; |
| |
| import static com.google.common.io.BaseEncoding.base16; |
| |
| import com.google.common.base.Charsets; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.io.BaseEncoding; |
| import com.google.common.testing.ClassSanityTester; |
| import java.util.Arrays; |
| import junit.framework.TestCase; |
| |
| /** |
| * Unit tests for {@link HashCode}. |
| * |
| * @author Dimitris Andreou |
| * @author Kurt Alfred Kluever |
| */ |
| public class HashCodeTest extends TestCase { |
| // note: asInt(), asLong() are in little endian |
| private static final ImmutableList<ExpectedHashCode> expectedHashCodes = |
| ImmutableList.of( |
| new ExpectedHashCode( |
| new byte[] { |
| (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x89, |
| (byte) 0x67, (byte) 0x45, (byte) 0x23, (byte) 0x01 |
| }, |
| 0x89abcdef, |
| 0x0123456789abcdefL, |
| "efcdab8967452301"), |
| new ExpectedHashCode( |
| new byte[] { |
| (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x89, |
| (byte) 0x67, (byte) 0x45, (byte) 0x23, |
| (byte) 0x01, // up to here, same bytes as above |
| (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, |
| (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08 |
| }, |
| 0x89abcdef, |
| 0x0123456789abcdefL, // asInt/asLong as above, due to equal eight first bytes |
| "efcdab89674523010102030405060708"), |
| new ExpectedHashCode( |
| new byte[] {(byte) 0xdf, (byte) 0x9b, (byte) 0x57, (byte) 0x13}, |
| 0x13579bdf, |
| null, |
| "df9b5713"), |
| new ExpectedHashCode( |
| new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00}, |
| 0x0000abcd, |
| null, |
| "cdab0000"), |
| new ExpectedHashCode( |
| new byte[] { |
| (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x00, |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 |
| }, |
| 0x00abcdef, |
| 0x0000000000abcdefL, |
| "efcdab0000000000")); |
| |
| // expectedHashCodes must contain at least one hash code with 4 bytes |
| public void testFromInt() { |
| for (ExpectedHashCode expected : expectedHashCodes) { |
| if (expected.bytes.length == 4) { |
| HashCode fromInt = HashCode.fromInt(expected.asInt); |
| assertExpectedHashCode(expected, fromInt); |
| } |
| } |
| } |
| |
| // expectedHashCodes must contain at least one hash code with 8 bytes |
| public void testFromLong() { |
| for (ExpectedHashCode expected : expectedHashCodes) { |
| if (expected.bytes.length == 8) { |
| HashCode fromLong = HashCode.fromLong(expected.asLong); |
| assertExpectedHashCode(expected, fromLong); |
| } |
| } |
| } |
| |
| public void testFromBytes() { |
| for (ExpectedHashCode expected : expectedHashCodes) { |
| HashCode fromBytes = HashCode.fromBytes(expected.bytes); |
| assertExpectedHashCode(expected, fromBytes); |
| } |
| } |
| |
| public void testFromBytes_copyOccurs() { |
| byte[] bytes = new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00}; |
| HashCode hashCode = HashCode.fromBytes(bytes); |
| int expectedInt = 0x0000abcd; |
| String expectedToString = "cdab0000"; |
| |
| assertEquals(expectedInt, hashCode.asInt()); |
| assertEquals(expectedToString, hashCode.toString()); |
| |
| bytes[0] = (byte) 0x00; |
| |
| assertEquals(expectedInt, hashCode.asInt()); |
| assertEquals(expectedToString, hashCode.toString()); |
| } |
| |
| public void testFromBytesNoCopy_noCopyOccurs() { |
| byte[] bytes = new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00}; |
| HashCode hashCode = HashCode.fromBytesNoCopy(bytes); |
| |
| assertEquals(0x0000abcd, hashCode.asInt()); |
| assertEquals("cdab0000", hashCode.toString()); |
| |
| bytes[0] = (byte) 0x00; |
| |
| assertEquals(0x0000ab00, hashCode.asInt()); |
| assertEquals("00ab0000", hashCode.toString()); |
| } |
| |
| public void testGetBytesInternal_noCloneOccurs() { |
| byte[] bytes = new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00}; |
| HashCode hashCode = HashCode.fromBytes(bytes); |
| |
| assertEquals(0x0000abcd, hashCode.asInt()); |
| assertEquals("cdab0000", hashCode.toString()); |
| |
| hashCode.getBytesInternal()[0] = (byte) 0x00; |
| |
| assertEquals(0x0000ab00, hashCode.asInt()); |
| assertEquals("00ab0000", hashCode.toString()); |
| } |
| |
| public void testPadToLong() { |
| assertEquals(0x1111111111111111L, HashCode.fromLong(0x1111111111111111L).padToLong()); |
| assertEquals(0x9999999999999999L, HashCode.fromLong(0x9999999999999999L).padToLong()); |
| assertEquals(0x0000000011111111L, HashCode.fromInt(0x11111111).padToLong()); |
| assertEquals(0x0000000099999999L, HashCode.fromInt(0x99999999).padToLong()); |
| } |
| |
| public void testPadToLongWith4Bytes() { |
| assertEquals(0x0000000099999999L, HashCode.fromBytesNoCopy(byteArrayWith9s(4)).padToLong()); |
| } |
| |
| public void testPadToLongWith6Bytes() { |
| assertEquals(0x0000999999999999L, HashCode.fromBytesNoCopy(byteArrayWith9s(6)).padToLong()); |
| } |
| |
| public void testPadToLongWith8Bytes() { |
| assertEquals(0x9999999999999999L, HashCode.fromBytesNoCopy(byteArrayWith9s(8)).padToLong()); |
| } |
| |
| private static byte[] byteArrayWith9s(int size) { |
| byte[] bytez = new byte[size]; |
| Arrays.fill(bytez, (byte) 0x99); |
| return bytez; |
| } |
| |
| public void testToString() { |
| byte[] data = new byte[] {127, -128, 5, -1, 14}; |
| assertEquals("7f8005ff0e", HashCode.fromBytes(data).toString()); |
| assertEquals("7f8005ff0e", base16().lowerCase().encode(data)); |
| } |
| |
| public void testHashCode_nulls() throws Exception { |
| sanityTester().testNulls(); |
| } |
| |
| public void testHashCode_equalsAndSerializable() throws Exception { |
| sanityTester().testEqualsAndSerializable(); |
| } |
| |
| public void testRoundTripHashCodeUsingBaseEncoding() { |
| HashCode hash1 = Hashing.sha1().hashString("foo", Charsets.US_ASCII); |
| HashCode hash2 = HashCode.fromBytes(BaseEncoding.base16().lowerCase().decode(hash1.toString())); |
| assertEquals(hash1, hash2); |
| } |
| |
| public void testObjectHashCode() { |
| HashCode hashCode42 = HashCode.fromInt(42); |
| assertEquals(42, hashCode42.hashCode()); |
| } |
| |
| // See https://code.google.com/p/guava-libraries/issues/detail?id=1494 |
| public void testObjectHashCodeWithSameLowOrderBytes() { |
| // These will have the same first 4 bytes (all 0). |
| byte[] bytesA = new byte[5]; |
| byte[] bytesB = new byte[5]; |
| |
| // Change only the last (5th) byte |
| bytesA[4] = (byte) 0xbe; |
| bytesB[4] = (byte) 0xef; |
| |
| HashCode hashCodeA = HashCode.fromBytes(bytesA); |
| HashCode hashCodeB = HashCode.fromBytes(bytesB); |
| |
| // They aren't equal... |
| assertFalse(hashCodeA.equals(hashCodeB)); |
| |
| // But they still have the same Object#hashCode() value. |
| // Technically not a violation of the equals/hashCode contract, but...? |
| assertEquals(hashCodeA.hashCode(), hashCodeB.hashCode()); |
| } |
| |
| public void testRoundTripHashCodeUsingFromString() { |
| HashCode hash1 = Hashing.sha1().hashString("foo", Charsets.US_ASCII); |
| HashCode hash2 = HashCode.fromString(hash1.toString()); |
| assertEquals(hash1, hash2); |
| } |
| |
| public void testRoundTrip() { |
| for (ExpectedHashCode expected : expectedHashCodes) { |
| String string = HashCode.fromBytes(expected.bytes).toString(); |
| assertEquals(expected.toString, string); |
| assertEquals( |
| expected.toString, |
| HashCode.fromBytes(BaseEncoding.base16().lowerCase().decode(string)).toString()); |
| } |
| } |
| |
| public void testFromStringFailsWithInvalidHexChar() { |
| try { |
| HashCode.fromString("7f8005ff0z"); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testFromStringFailsWithUpperCaseString() { |
| String string = Hashing.sha1().hashString("foo", Charsets.US_ASCII).toString().toUpperCase(); |
| try { |
| HashCode.fromString(string); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testFromStringFailsWithShortInputs() { |
| try { |
| HashCode.fromString(""); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| try { |
| HashCode.fromString("7"); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| HashCode unused = HashCode.fromString("7f"); |
| } |
| |
| public void testFromStringFailsWithOddLengthInput() { |
| try { |
| HashCode.fromString("7f8"); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testIntWriteBytesTo() { |
| byte[] dest = new byte[4]; |
| HashCode.fromInt(42).writeBytesTo(dest, 0, 4); |
| assertTrue(Arrays.equals(HashCode.fromInt(42).asBytes(), dest)); |
| } |
| |
| public void testLongWriteBytesTo() { |
| byte[] dest = new byte[8]; |
| HashCode.fromLong(42).writeBytesTo(dest, 0, 8); |
| assertTrue(Arrays.equals(HashCode.fromLong(42).asBytes(), dest)); |
| } |
| |
| private static final HashCode HASH_ABCD = |
| HashCode.fromBytes(new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd}); |
| |
| public void testWriteBytesTo() { |
| byte[] dest = new byte[4]; |
| HASH_ABCD.writeBytesTo(dest, 0, 4); |
| assertTrue( |
| Arrays.equals(new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd}, dest)); |
| } |
| |
| public void testWriteBytesToOversizedArray() { |
| byte[] dest = new byte[5]; |
| HASH_ABCD.writeBytesTo(dest, 0, 4); |
| assertTrue( |
| Arrays.equals( |
| new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0x00}, dest)); |
| } |
| |
| public void testWriteBytesToOversizedArrayLongMaxLength() { |
| byte[] dest = new byte[5]; |
| HASH_ABCD.writeBytesTo(dest, 0, 5); |
| assertTrue( |
| Arrays.equals( |
| new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0x00}, dest)); |
| } |
| |
| public void testWriteBytesToOversizedArrayShortMaxLength() { |
| byte[] dest = new byte[5]; |
| HASH_ABCD.writeBytesTo(dest, 0, 3); |
| assertTrue( |
| Arrays.equals( |
| new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0x00, (byte) 0x00}, dest)); |
| } |
| |
| public void testWriteBytesToUndersizedArray() { |
| byte[] dest = new byte[3]; |
| try { |
| HASH_ABCD.writeBytesTo(dest, 0, 4); |
| fail(); |
| } catch (IndexOutOfBoundsException expected) { |
| } |
| } |
| |
| public void testWriteBytesToUndersizedArrayLongMaxLength() { |
| byte[] dest = new byte[3]; |
| try { |
| HASH_ABCD.writeBytesTo(dest, 0, 5); |
| fail(); |
| } catch (IndexOutOfBoundsException expected) { |
| } |
| } |
| |
| public void testWriteBytesToUndersizedArrayShortMaxLength() { |
| byte[] dest = new byte[3]; |
| HASH_ABCD.writeBytesTo(dest, 0, 2); |
| assertTrue(Arrays.equals(new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0x00}, dest)); |
| } |
| |
| private static ClassSanityTester.FactoryMethodReturnValueTester sanityTester() { |
| return new ClassSanityTester() |
| .setDefault(byte[].class, new byte[] {1, 2, 3, 4}) |
| .setDistinctValues(byte[].class, new byte[] {1, 2, 3, 4}, new byte[] {5, 6, 7, 8}) |
| .setDistinctValues(String.class, "7f8005ff0e", "7f8005ff0f") |
| .forAllPublicStaticMethods(HashCode.class); |
| } |
| |
| private static void assertExpectedHashCode(ExpectedHashCode expectedHashCode, HashCode hash) { |
| assertTrue(Arrays.equals(expectedHashCode.bytes, hash.asBytes())); |
| byte[] bb = new byte[hash.bits() / 8]; |
| hash.writeBytesTo(bb, 0, bb.length); |
| assertTrue(Arrays.equals(expectedHashCode.bytes, bb)); |
| assertEquals(expectedHashCode.asInt, hash.asInt()); |
| if (expectedHashCode.asLong == null) { |
| try { |
| hash.asLong(); |
| fail(); |
| } catch (IllegalStateException expected) { |
| } |
| } else { |
| assertEquals(expectedHashCode.asLong.longValue(), hash.asLong()); |
| } |
| assertEquals(expectedHashCode.toString, hash.toString()); |
| assertSideEffectFree(hash); |
| assertReadableBytes(hash); |
| } |
| |
| private static void assertSideEffectFree(HashCode hash) { |
| byte[] original = hash.asBytes(); |
| byte[] mutated = hash.asBytes(); |
| mutated[0]++; |
| assertTrue(Arrays.equals(original, hash.asBytes())); |
| } |
| |
| private static void assertReadableBytes(HashCode hashCode) { |
| assertTrue(hashCode.bits() >= 32); // sanity |
| byte[] hashBytes = hashCode.asBytes(); |
| int totalBytes = hashCode.bits() / 8; |
| |
| for (int bytes = 0; bytes < totalBytes; bytes++) { |
| byte[] bb = new byte[bytes]; |
| hashCode.writeBytesTo(bb, 0, bb.length); |
| |
| assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb)); |
| } |
| } |
| |
| private static class ExpectedHashCode { |
| final byte[] bytes; |
| final int asInt; |
| final Long asLong; // null means that asLong should throw an exception |
| final String toString; |
| |
| ExpectedHashCode(byte[] bytes, int asInt, Long asLong, String toString) { |
| this.bytes = bytes; |
| this.asInt = asInt; |
| this.asLong = asLong; |
| this.toString = toString; |
| } |
| } |
| } |