200 lines
6.2 KiB
Java
200 lines
6.2 KiB
Java
/*
|
|
* Copyright (C) 2015 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.base.Charsets.ISO_8859_1;
|
|
import static com.google.common.base.Charsets.UTF_8;
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
|
|
import com.google.common.base.Strings;
|
|
import java.util.Arrays;
|
|
import junit.framework.TestCase;
|
|
|
|
/**
|
|
* Unit test for FarmHashFingerprint64.
|
|
*
|
|
* @author Kyle Maddison
|
|
* @author Geoff Pike
|
|
*/
|
|
public class FarmHashFingerprint64Test extends TestCase {
|
|
|
|
private static final HashFunction HASH_FN = Hashing.farmHashFingerprint64();
|
|
|
|
// If this test fails, all bets are off
|
|
public void testReallySimpleFingerprints() {
|
|
assertEquals(8581389452482819506L, fingerprint("test".getBytes(UTF_8)));
|
|
// 32 characters long
|
|
assertEquals(-4196240717365766262L, fingerprint(Strings.repeat("test", 8).getBytes(UTF_8)));
|
|
// 256 characters long
|
|
assertEquals(3500507768004279527L, fingerprint(Strings.repeat("test", 64).getBytes(UTF_8)));
|
|
}
|
|
|
|
public void testStringsConsistency() {
|
|
for (String s : Arrays.asList("", "some", "test", "strings", "to", "try")) {
|
|
assertEquals(HASH_FN.newHasher().putUnencodedChars(s).hash(), HASH_FN.hashUnencodedChars(s));
|
|
}
|
|
}
|
|
|
|
public void testUtf8() {
|
|
char[] charsA = new char[128];
|
|
char[] charsB = new char[128];
|
|
|
|
for (int i = 0; i < charsA.length; i++) {
|
|
if (i < 100) {
|
|
charsA[i] = 'a';
|
|
charsB[i] = 'a';
|
|
} else {
|
|
// Both two-byte characters, but must be different
|
|
charsA[i] = (char) (0x0180 + i);
|
|
charsB[i] = (char) (0x0280 + i);
|
|
}
|
|
}
|
|
|
|
String stringA = new String(charsA);
|
|
String stringB = new String(charsB);
|
|
assertThat(stringA).isNotEqualTo(stringB);
|
|
assertThat(HASH_FN.hashUnencodedChars(stringA))
|
|
.isNotEqualTo(HASH_FN.hashUnencodedChars(stringB));
|
|
assertThat(fingerprint(stringA.getBytes(UTF_8)))
|
|
.isNotEqualTo(fingerprint(stringB.getBytes(UTF_8)));
|
|
|
|
// ISO 8859-1 only has 0-255 (ubyte) representation so throws away UTF-8 characters
|
|
// greater than 127 (ie with their top bit set).
|
|
// Don't attempt to do this in real code.
|
|
assertEquals(
|
|
fingerprint(stringA.getBytes(ISO_8859_1)), fingerprint(stringB.getBytes(ISO_8859_1)));
|
|
}
|
|
|
|
public void testPutNonChars() {
|
|
Hasher hasher = HASH_FN.newHasher();
|
|
// Expected data is 0x0100010100000000
|
|
hasher
|
|
.putBoolean(true)
|
|
.putBoolean(true)
|
|
.putBoolean(false)
|
|
.putBoolean(true)
|
|
.putBoolean(false)
|
|
.putBoolean(false)
|
|
.putBoolean(false)
|
|
.putBoolean(false);
|
|
final long hashCode = hasher.hash().asLong();
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher
|
|
.putByte((byte) 0x01)
|
|
.putByte((byte) 0x01)
|
|
.putByte((byte) 0x00)
|
|
.putByte((byte) 0x01)
|
|
.putByte((byte) 0x00)
|
|
.putByte((byte) 0x00)
|
|
.putByte((byte) 0x00)
|
|
.putByte((byte) 0x00);
|
|
assertEquals(hashCode, hasher.hash().asLong());
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher
|
|
.putChar((char) 0x0101)
|
|
.putChar((char) 0x0100)
|
|
.putChar((char) 0x0000)
|
|
.putChar((char) 0x0000);
|
|
assertEquals(hashCode, hasher.hash().asLong());
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher.putBytes(new byte[] {0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00});
|
|
assertEquals(hashCode, hasher.hash().asLong());
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher.putLong(0x0000000001000101L);
|
|
assertEquals(hashCode, hasher.hash().asLong());
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher
|
|
.putShort((short) 0x0101)
|
|
.putShort((short) 0x0100)
|
|
.putShort((short) 0x0000)
|
|
.putShort((short) 0x0000);
|
|
assertEquals(hashCode, hasher.hash().asLong());
|
|
}
|
|
|
|
public void testHashFloatIsStable() {
|
|
// Just a spot check. Better than nothing.
|
|
Hasher hasher = HASH_FN.newHasher();
|
|
hasher.putFloat(0x01000101f).putFloat(0f);
|
|
assertEquals(0x49f9d18ee8ae1b28L, hasher.hash().asLong());
|
|
|
|
hasher = HASH_FN.newHasher();
|
|
hasher.putDouble(0x0000000001000101d);
|
|
assertEquals(0x388ee898bad75cbfL, hasher.hash().asLong());
|
|
}
|
|
|
|
/** Convenience method to compute a fingerprint on a full bytes array. */
|
|
private static long fingerprint(byte[] bytes) {
|
|
return fingerprint(bytes, bytes.length);
|
|
}
|
|
|
|
/** Convenience method to compute a fingerprint on a subset of a byte array. */
|
|
private static long fingerprint(byte[] bytes, int length) {
|
|
return HASH_FN.hashBytes(bytes, 0, length).asLong();
|
|
}
|
|
|
|
/**
|
|
* Tests that the Java port of FarmHashFingerprint64 provides the same results on buffers up to
|
|
* 800 bytes long as the C++ reference implementation.
|
|
*/
|
|
public void testMultipleLengths() {
|
|
int iterations = 800;
|
|
byte[] buf = new byte[iterations * 4];
|
|
int bufLen = 0;
|
|
long h = 0;
|
|
for (int i = 0; i < iterations; ++i) {
|
|
h ^= fingerprint(buf, i);
|
|
h = remix(h);
|
|
buf[bufLen++] = getChar(h);
|
|
|
|
h ^= fingerprint(buf, i * i % bufLen);
|
|
h = remix(h);
|
|
buf[bufLen++] = getChar(h);
|
|
|
|
h ^= fingerprint(buf, i * i * i % bufLen);
|
|
h = remix(h);
|
|
buf[bufLen++] = getChar(h);
|
|
|
|
h ^= fingerprint(buf, bufLen);
|
|
h = remix(h);
|
|
buf[bufLen++] = getChar(h);
|
|
|
|
int x0 = buf[bufLen - 1] & 0xff;
|
|
int x1 = buf[bufLen - 2] & 0xff;
|
|
int x2 = buf[bufLen - 3] & 0xff;
|
|
int x3 = buf[bufLen / 2] & 0xff;
|
|
buf[((x0 << 16) + (x1 << 8) + x2) % bufLen] ^= x3;
|
|
buf[((x1 << 16) + (x2 << 8) + x3) % bufLen] ^= i % 256;
|
|
}
|
|
assertEquals(0x7a1d67c50ec7e167L, h);
|
|
}
|
|
|
|
private static long remix(long h) {
|
|
h ^= h >>> 41;
|
|
h *= 949921979;
|
|
return h;
|
|
}
|
|
|
|
private static byte getChar(long h) {
|
|
return (byte) ('a' + ((h & 0xfffff) % 26));
|
|
}
|
|
}
|