summaryrefslogtreecommitdiff
path: root/src/mongo/base/murmurhash3_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mongo/base/murmurhash3_test.cpp')
-rw-r--r--src/mongo/base/murmurhash3_test.cpp142
1 files changed, 59 insertions, 83 deletions
diff --git a/src/mongo/base/murmurhash3_test.cpp b/src/mongo/base/murmurhash3_test.cpp
index fd780ce6217..a2f4219b856 100644
--- a/src/mongo/base/murmurhash3_test.cpp
+++ b/src/mongo/base/murmurhash3_test.cpp
@@ -30,32 +30,35 @@
#include <array>
#include <string>
-#include "mongo/base/data_type_endian.h"
-#include "mongo/base/data_view.h"
-#include "mongo/unittest/unittest.h"
-#include "mongo/util/murmur3.h"
+#include <third_party/murmurhash3/MurmurHash3.h>
-#define TEST_STRING32(str, seed, expected) \
- ASSERT_EQUALS(murmur3<sizeof(uint32_t)>(StringData{str}, seed), expected)
+#include "mongo/unittest/unittest.h"
-#define TEST_STRING64(str, seed, expected) \
- ASSERT_EQUALS(murmur3<sizeof(uint64_t)>(StringData{str}, seed), expected)
+#include "mongo/base/data_type_endian.h"
+#include "mongo/base/data_view.h"
-#define TEST_STRING128(str, seed, a, b) \
- do { \
- auto pair = compute128(StringData{str}, seed); \
- ASSERT_EQUALS(pair.first, a); \
- ASSERT_EQUALS(pair.second, b); \
+#define TEST_STRING32(str, seed, expected) ASSERT_EQUALS(compute32(str, seed), expected)
+#define TEST_STRING64(str, seed, a, b) \
+ do { \
+ auto pair = compute128(str, seed); \
+ ASSERT_EQUALS(pair.first, a); \
+ ASSERT_EQUALS(pair.second, b); \
} while (0)
namespace mongo {
namespace {
+uint32_t compute32(StringData input, uint32_t seed) {
+ char hash[4];
+ MurmurHash3_x86_32(input.rawData(), input.size(), seed, &hash);
+ return ConstDataView(hash).read<LittleEndian<uint32_t>>();
+}
+
std::pair<uint64_t, uint64_t> compute128(StringData input, uint32_t seed) {
- std::array<char, 16> hash;
- murmur3(input, seed, hash);
- return {ConstDataView(hash.data()).read<LittleEndian<uint64_t>>(),
- ConstDataView(hash.data()).read<LittleEndian<uint64_t>>(8)};
+ char hash[16];
+ MurmurHash3_x64_128(input.rawData(), input.size(), seed, &hash);
+ return {ConstDataView(hash).read<LittleEndian<uint64_t>>(),
+ ConstDataView(hash).read<LittleEndian<uint64_t>>(8)};
}
TEST(MurmurHash3, TestVectors32) {
@@ -89,78 +92,51 @@ TEST(MurmurHash3, TestVectors32) {
}
-TEST(MurmurHash3, TestVectors128) {
- TEST_STRING128("", 0, 0ULL, 0ULL);
-
- TEST_STRING128("", 1ULL, 5048724184180415669ULL, 5864299874987029891ULL);
- // Make sure seed value is handled unsigned.
- TEST_STRING128("", 0xffffffffULL, 7706185961851046380ULL, 9616347466054386795ULL);
- // Make sure we handle embedded nulls.
- TEST_STRING128("\0\0\0\0"_sd, 0ULL, 14961230494313510588ULL, 6383328099726337777ULL);
-
- // One full chunk.
- TEST_STRING128("aaaa", 0x9747b28cULL, 13033599803469372400ULL, 11949150323828610719ULL);
- // Three characters.
- TEST_STRING128("aaa", 0x9747b28cULL, 10278871841506805355ULL, 17952965428487426844ULL);
- // Two characters.
- TEST_STRING128("aa", 0x9747b28cULL, 1343929393636293407ULL, 16804672932933964801ULL);
- // One character.
- TEST_STRING128("a", 0x9747b28cULL, 6694838689256856093ULL, 11415968713816993796ULL);
-
- // Endian order within the chunks
- TEST_STRING128("abcd", 0x9747b28cULL, 5310993687375067025ULL, 9979528070057666491ULL);
- TEST_STRING128("abc", 0x9747b28cULL, 3982135406228655836ULL, 14835035517329147071ULL);
- TEST_STRING128("ab", 0x9747b28cULL, 9526501539032868875ULL, 9131386788375312171ULL);
- TEST_STRING128("a", 0x9747b28cULL, 6694838689256856093ULL, 11415968713816993796ULL);
-
- TEST_STRING128(
- "Hello, world!", 0x9747b28cULL, 17132966038248896814ULL, 17896881015324243642ULL);
-
- // Make sure to handle UTF-8 high characters. A bcrypt implementation messed this up. Here we
- // use U+03C0: Greek Small Letter Pi.
- TEST_STRING128("ππππππππ", 0x9747b28cULL, 10874605236735318559ULL, 17921841414653337979ULL);
-
- // String of 256 characters. Make sure you don't store string lengths in a char, and overflow at
- // 255 bytes (as OpenBSD's canonical BCrypt implementation did).
- TEST_STRING128(
- std::string(256, 'a'), 0x9747b28cULL, 557766291455132100ULL, 14184293241195392597ULL);
-}
-
-// Output of the 64-bit version of murmur3() should be the same as the first 8 bytes of the 128-bit
-// version.
TEST(MurmurHash3, TestVectors64) {
- TEST_STRING64("", 0, 0ULL);
-
- TEST_STRING64("", 1ULL, 5048724184180415669ULL);
- // Make sure seed value is handled unsigned.
- TEST_STRING64("", 0xffffffffULL, 7706185961851046380ULL);
- // Make sure we handle embedded nulls.
- TEST_STRING64("\0\0\0\0"_sd, 0ULL, 14961230494313510588ULL);
-
- // One full chunk.
- TEST_STRING64("aaaa", 0x9747b28cULL, 13033599803469372400ULL);
- // Three characters.
- TEST_STRING64("aaa", 0x9747b28cULL, 10278871841506805355ULL);
- // Two characters.
- TEST_STRING64("aa", 0x9747b28cULL, 1343929393636293407ULL);
- // One character.
- TEST_STRING64("a", 0x9747b28cULL, 6694838689256856093ULL);
+ TEST_STRING64("", 0, 0ULL, 0ULL);
+
+ TEST_STRING64("", 1ULL, 5048724184180415669ULL, 5864299874987029891ULL);
+ TEST_STRING64("",
+ 0xffffffffULL,
+ 7706185961851046380ULL,
+ 9616347466054386795ULL); // make sure seed value is handled unsigned
+ TEST_STRING64("\0\0\0\0"_sd,
+ 0ULL,
+ 14961230494313510588ULL,
+ 6383328099726337777ULL); // make sure we handle embedded nulls
+
+
+ TEST_STRING64(
+ "aaaa", 0x9747b28cULL, 13033599803469372400ULL, 11949150323828610719ULL); // one full chunk
+ TEST_STRING64("aaa",
+ 0x9747b28cULL,
+ 10278871841506805355ULL,
+ 17952965428487426844ULL); // three characters
+ TEST_STRING64(
+ "aa", 0x9747b28cULL, 1343929393636293407ULL, 16804672932933964801ULL); // two characters
+ TEST_STRING64(
+ "a", 0x9747b28cULL, 6694838689256856093ULL, 11415968713816993796ULL); // one character
// Endian order within the chunks
- TEST_STRING64("abcd", 0x9747b28cULL, 5310993687375067025ULL);
- TEST_STRING64("abc", 0x9747b28cULL, 3982135406228655836ULL);
- TEST_STRING64("ab", 0x9747b28cULL, 9526501539032868875ULL);
- TEST_STRING64("a", 0x9747b28cULL, 6694838689256856093ULL);
+ TEST_STRING64(
+ "abcd", 0x9747b28cULL, 5310993687375067025ULL, 9979528070057666491ULL); // one full chunk
+ TEST_STRING64("abc", 0x9747b28cULL, 3982135406228655836ULL, 14835035517329147071ULL);
+ TEST_STRING64("ab", 0x9747b28cULL, 9526501539032868875ULL, 9131386788375312171ULL);
+ TEST_STRING64("a", 0x9747b28cULL, 6694838689256856093ULL, 11415968713816993796ULL);
- TEST_STRING64("Hello, world!", 0x9747b28cULL, 17132966038248896814ULL);
+ TEST_STRING64("Hello, world!", 0x9747b28cULL, 17132966038248896814ULL, 17896881015324243642ULL);
- // Make sure to handle UTF-8 high characters. A bcrypt implementation messed this up. Here we
- // use U+03C0: Greek Small Letter Pi.
- TEST_STRING64("ππππππππ", 0x9747b28cULL, 10874605236735318559ULL);
+ // Make sure you handle UTF-8 high characters. A bcrypt implementation messed this up
+ TEST_STRING64("ππππππππ",
+ 0x9747b28cULL,
+ 10874605236735318559ULL,
+ 17921841414653337979ULL); // U+03C0: Greek Small Letter Pi
- // String of 256 characters. Make sure you don't store string lengths in a char, and overflow at
- // 255 bytes (as OpenBSD's canonical BCrypt implementation did).
- TEST_STRING64(std::string(256, 'a'), 0x9747b28cULL, 557766291455132100ULL);
+ // String of 256 characters.
+ // Make sure you don't store string lengths in a char, and overflow at 255 bytes (as OpenBSD's
+ // canonical BCrypt implementation did)
+ TEST_STRING64(
+ std::string(256, 'a'), 0x9747b28cULL, 557766291455132100ULL, 14184293241195392597ULL);
}
} // namespace
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-11 10:59:55 +0000