Skip to content

Commit 9577509

Browse files
pdimovpdimov
committed
Add tests with reference values (test vectors)
1 parent 230bfc1 commit 9577509

File tree

4 files changed

+358
-0
lines changed

4 files changed

+358
-0
lines changed

‎mulxp1_32_test.cpp‎

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
// Copyright 2024 Peter Dimov
2+
// Distributed under the Boost Software License, Version 1.0.
3+
// https://www.boost.org/LICENSE_1_0.txt
4+
5+
#include "mulxp_hash.hpp"
6+
#include <vector>
7+
#include <cstdio>
8+
9+
// Test vectors for mulxp1_hash32
10+
11+
struct reference_entry
12+
{
13+
std::size_t length;
14+
std::uint32_t seed;
15+
std::uint32_t result;
16+
};
17+
18+
reference_entry const ref[] =
19+
{
20+
{ 0, 0x00000000, 0x6F5D607C },
21+
{ 0, 0x9E3779B9, 0x43490025 },
22+
{ 17, 0x00000000, 0xA9830593 },
23+
{ 17, 0x9E3779B9, 0x598FD8D7 },
24+
{ 34, 0x00000000, 0x580A9DFB },
25+
{ 34, 0x9E3779B9, 0xC2AD87D3 },
26+
{ 51, 0x00000000, 0xEC81A87C },
27+
{ 51, 0x9E3779B9, 0xA10ACFF3 },
28+
{ 68, 0x00000000, 0x044EB1FA },
29+
{ 68, 0x9E3779B9, 0x5338B628 },
30+
{ 85, 0x00000000, 0xBD925846 },
31+
{ 85, 0x9E3779B9, 0x59152FD8 },
32+
{ 102, 0x00000000, 0x1D6857EA },
33+
{ 102, 0x9E3779B9, 0xE36D99EE },
34+
{ 119, 0x00000000, 0xB1F4C4A5 },
35+
{ 119, 0x9E3779B9, 0xE388FA34 },
36+
{ 136, 0x00000000, 0x2F519887 },
37+
{ 136, 0x9E3779B9, 0x553589F1 },
38+
{ 153, 0x00000000, 0x4923B36C },
39+
{ 153, 0x9E3779B9, 0x14E7BBC5 },
40+
{ 170, 0x00000000, 0xB9FF9CB5 },
41+
{ 170, 0x9E3779B9, 0x4DBD9553 },
42+
{ 187, 0x00000000, 0x9DC48EA3 },
43+
{ 187, 0x9E3779B9, 0x2254A716 },
44+
{ 204, 0x00000000, 0x42495C84 },
45+
{ 204, 0x9E3779B9, 0x55FF9CE3 },
46+
{ 221, 0x00000000, 0x1A1E98A3 },
47+
{ 221, 0x9E3779B9, 0x6C68A1C2 },
48+
{ 238, 0x00000000, 0x2DF87B0B },
49+
{ 238, 0x9E3779B9, 0xA1F5D706 },
50+
{ 255, 0x00000000, 0xBFB8759B },
51+
{ 255, 0x9E3779B9, 0x6D0EBE83 },
52+
{ 272, 0x00000000, 0x3FA97697 },
53+
{ 272, 0x9E3779B9, 0x0657CB99 },
54+
};
55+
56+
int main()
57+
{
58+
int errors = 0;
59+
60+
for( int i = 0; i < sizeof(ref) / sizeof(ref[0]); ++i )
61+
{
62+
reference_entry const& e = ref[ i ];
63+
64+
std::vector<unsigned char> v( e.length, 0x9C );
65+
66+
std::uint32_t r = mulxp1_hash32( v.data(), v.size(), e.seed );
67+
68+
if( r != e.result )
69+
{
70+
std::fprintf( stderr, "Reference value mismatch for length %zu, seed %08X: was %08X, expected %08X\n", e.length, e.seed, r, e.result );
71+
++errors;
72+
}
73+
}
74+
75+
if( errors == 0 )
76+
{
77+
std::puts( "No errors detected." );
78+
}
79+
80+
return errors;
81+
}

‎mulxp1_test.cpp‎

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,98 @@
1+
// Copyright 2024 Peter Dimov
2+
// Distributed under the Boost Software License, Version 1.0.
3+
// https://www.boost.org/LICENSE_1_0.txt
4+
5+
#include "mulxp_hash.hpp"
6+
#include <vector>
7+
#include <cstdio>
8+
9+
// Test vectors for mulxp1_hash
10+
11+
struct reference_entry
12+
{
13+
std::size_t length;
14+
std::uint64_t seed;
15+
std::uint64_t result;
16+
};
17+
18+
reference_entry const ref[] =
19+
{
20+
{ 0, 0x0000000000000000, 0x1C97DA6F7F24EBA6 },
21+
{ 0, 0x000000009E3779B9, 0x51BDC03984425EB7 },
22+
{ 0, 0x9E3779B97F4A7C15, 0x7728005A58BB1B47 },
23+
{ 17, 0x0000000000000000, 0xDEBC51778DD91488 },
24+
{ 17, 0x000000009E3779B9, 0x325B4BEA16D09575 },
25+
{ 17, 0x9E3779B97F4A7C15, 0xC43CBAE27255479E },
26+
{ 34, 0x0000000000000000, 0x2BB78778295CD3D2 },
27+
{ 34, 0x000000009E3779B9, 0x60186FF61453E3A3 },
28+
{ 34, 0x9E3779B97F4A7C15, 0x5EB1F10F73FE70AA },
29+
{ 51, 0x0000000000000000, 0x1AFEB63C8AAE2E48 },
30+
{ 51, 0x000000009E3779B9, 0x8D76E8A925788723 },
31+
{ 51, 0x9E3779B97F4A7C15, 0x3124AF349FED5035 },
32+
{ 68, 0x0000000000000000, 0x5BA86803557780A1 },
33+
{ 68, 0x000000009E3779B9, 0x429EA61BFF709526 },
34+
{ 68, 0x9E3779B97F4A7C15, 0x9EBE025BEC7B8F88 },
35+
{ 85, 0x0000000000000000, 0xC51A8F4284C1B9F1 },
36+
{ 85, 0x000000009E3779B9, 0x70B49B47E7EF71DD },
37+
{ 85, 0x9E3779B97F4A7C15, 0x5013DB821469205F },
38+
{ 102, 0x0000000000000000, 0x22DCBAA741B97A0B },
39+
{ 102, 0x000000009E3779B9, 0x18EAB7540C5E7AF7 },
40+
{ 102, 0x9E3779B97F4A7C15, 0x45AA8F1C8D6C85DE },
41+
{ 119, 0x0000000000000000, 0x58FF9B0F9CE8D41E },
42+
{ 119, 0x000000009E3779B9, 0x0C192C0D099137A0 },
43+
{ 119, 0x9E3779B97F4A7C15, 0xD743AD0FDEEB9F0B },
44+
{ 136, 0x0000000000000000, 0x56BE5124B008605D },
45+
{ 136, 0x000000009E3779B9, 0xFD34F2560C610087 },
46+
{ 136, 0x9E3779B97F4A7C15, 0xA6664F1A9D45D45E },
47+
{ 153, 0x0000000000000000, 0x78B2A761C4FC343E },
48+
{ 153, 0x000000009E3779B9, 0xDABD744401EDCB72 },
49+
{ 153, 0x9E3779B97F4A7C15, 0x5EFF81FE3AC47A1B },
50+
{ 170, 0x0000000000000000, 0x066FCFF2E49E6CAF },
51+
{ 170, 0x000000009E3779B9, 0xA30B1D473CD6DBA4 },
52+
{ 170, 0x9E3779B97F4A7C15, 0xDD7C87D691EE7AFF },
53+
{ 187, 0x0000000000000000, 0x9FE11A4D8F9B4365 },
54+
{ 187, 0x000000009E3779B9, 0x80BE5E8912B81194 },
55+
{ 187, 0x9E3779B97F4A7C15, 0x610431AE251CEC8B },
56+
{ 204, 0x0000000000000000, 0x8A56C2026BFCC344 },
57+
{ 204, 0x000000009E3779B9, 0x47271D582D54FCFD },
58+
{ 204, 0x9E3779B97F4A7C15, 0x4D4B0F722C9EFACB },
59+
{ 221, 0x0000000000000000, 0x1FEE1669F3BE0DAE },
60+
{ 221, 0x000000009E3779B9, 0x1EADD262E7E2C8D2 },
61+
{ 221, 0x9E3779B97F4A7C15, 0xC0A9B4FB0301623C },
62+
{ 238, 0x0000000000000000, 0x8B332C7D8A1DAB7F },
63+
{ 238, 0x000000009E3779B9, 0x4973EFB3A14BEB94 },
64+
{ 238, 0x9E3779B97F4A7C15, 0xBF78C4B4D032BBC6 },
65+
{ 255, 0x0000000000000000, 0x651957B949FB304C },
66+
{ 255, 0x000000009E3779B9, 0x9133DBEE15F361E1 },
67+
{ 255, 0x9E3779B97F4A7C15, 0x80BD6CEF705B2C84 },
68+
{ 272, 0x0000000000000000, 0xFF49BF87CBA392E2 },
69+
{ 272, 0x000000009E3779B9, 0x623F71308C2CECD5 },
70+
{ 272, 0x9E3779B97F4A7C15, 0x7B174B440D2E8DA9 },
71+
};
72+
73+
int main()
74+
{
75+
int errors = 0;
76+
77+
for( int i = 0; i < sizeof(ref) / sizeof(ref[0]); ++i )
78+
{
79+
reference_entry const& e = ref[ i ];
80+
81+
std::vector<unsigned char> v( e.length, 0x9C );
82+
83+
std::uint64_t r = mulxp1_hash( v.data(), v.size(), e.seed );
84+
85+
if( r != e.result )
86+
{
87+
std::fprintf( stderr, "Reference value mismatch for length %zu, seed %016llX: was %016llX, expected %016llX\n", e.length, e.seed, r, e.result );
88+
++errors;
89+
}
90+
}
91+
92+
if( errors == 0 )
93+
{
94+
std::puts( "No errors detected." );
95+
}
96+
97+
return errors;
98+
}

‎mulxp3_32_test.cpp‎

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
// Copyright 2024 Peter Dimov
2+
// Distributed under the Boost Software License, Version 1.0.
3+
// https://www.boost.org/LICENSE_1_0.txt
4+
5+
#include "mulxp_hash.hpp"
6+
#include <vector>
7+
#include <cstdio>
8+
9+
// Test vectors for mulxp1_hash32
10+
11+
struct reference_entry
12+
{
13+
std::size_t length;
14+
std::uint32_t seed;
15+
std::uint32_t result;
16+
};
17+
18+
reference_entry const ref[] =
19+
{
20+
{ 0, 0x00000000, 0x8E655EAE },
21+
{ 0, 0x9E3779B9, 0x0283AE69 },
22+
{ 17, 0x00000000, 0x69931AE7 },
23+
{ 17, 0x9E3779B9, 0x946D68AF },
24+
{ 34, 0x00000000, 0xEBFAD8A5 },
25+
{ 34, 0x9E3779B9, 0x7C8FE598 },
26+
{ 51, 0x00000000, 0xAA337B35 },
27+
{ 51, 0x9E3779B9, 0x2E027F82 },
28+
{ 68, 0x00000000, 0x42BABC15 },
29+
{ 68, 0x9E3779B9, 0xDFFFB879 },
30+
{ 85, 0x00000000, 0x1A39F5C2 },
31+
{ 85, 0x9E3779B9, 0xCA5D002A },
32+
{ 102, 0x00000000, 0xCA101728 },
33+
{ 102, 0x9E3779B9, 0x7E135B64 },
34+
{ 119, 0x00000000, 0xD95677AE },
35+
{ 119, 0x9E3779B9, 0x9230B6D4 },
36+
{ 136, 0x00000000, 0xD9E48D12 },
37+
{ 136, 0x9E3779B9, 0xFB27B42D },
38+
{ 153, 0x00000000, 0x2C6040EB },
39+
{ 153, 0x9E3779B9, 0xB1DFD3A4 },
40+
{ 170, 0x00000000, 0x6B8F0E37 },
41+
{ 170, 0x9E3779B9, 0x420E68A8 },
42+
{ 187, 0x00000000, 0x6EA8D6AC },
43+
{ 187, 0x9E3779B9, 0x12729B87 },
44+
{ 204, 0x00000000, 0x11568A19 },
45+
{ 204, 0x9E3779B9, 0x453D7330 },
46+
{ 221, 0x00000000, 0x733B857D },
47+
{ 221, 0x9E3779B9, 0xAB8AED59 },
48+
{ 238, 0x00000000, 0x9EF34228 },
49+
{ 238, 0x9E3779B9, 0xA0C348EC },
50+
{ 255, 0x00000000, 0x5ACF71B8 },
51+
{ 255, 0x9E3779B9, 0xFB410806 },
52+
{ 272, 0x00000000, 0xFF645816 },
53+
{ 272, 0x9E3779B9, 0xF1EBACDD },
54+
};
55+
56+
int main()
57+
{
58+
int errors = 0;
59+
60+
for( int i = 0; i < sizeof(ref) / sizeof(ref[0]); ++i )
61+
{
62+
reference_entry const& e = ref[ i ];
63+
64+
std::vector<unsigned char> v( e.length, 0x9C );
65+
66+
std::uint32_t r = mulxp3_hash32( v.data(), v.size(), e.seed );
67+
68+
if( r != e.result )
69+
{
70+
std::fprintf( stderr, "Reference value mismatch for length %zu, seed %08X: was %08X, expected %08X\n", e.length, e.seed, r, e.result );
71+
++errors;
72+
}
73+
}
74+
75+
if( errors == 0 )
76+
{
77+
std::puts( "No errors detected." );
78+
}
79+
80+
return errors;
81+
}

‎mulxp3_test.cpp‎

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,98 @@
1+
// Copyright 2024 Peter Dimov
2+
// Distributed under the Boost Software License, Version 1.0.
3+
// https://www.boost.org/LICENSE_1_0.txt
4+
5+
#include "mulxp_hash.hpp"
6+
#include <vector>
7+
#include <cstdio>
8+
9+
// Test vectors for mulxp3_hash
10+
11+
struct reference_entry
12+
{
13+
std::size_t length;
14+
std::uint64_t seed;
15+
std::uint64_t result;
16+
};
17+
18+
reference_entry const ref[] =
19+
{
20+
{ 0, 0x0000000000000000, 0xC814FCA3D94F2D9D },
21+
{ 0, 0x000000009E3779B9, 0x8F790749C68256EE },
22+
{ 0, 0x9E3779B97F4A7C15, 0x100135371D77D2E0 },
23+
{ 17, 0x0000000000000000, 0x5E3490480D57F9E9 },
24+
{ 17, 0x000000009E3779B9, 0x7B677C70534372FC },
25+
{ 17, 0x9E3779B97F4A7C15, 0xB4EDBDEB2D3D92F3 },
26+
{ 34, 0x0000000000000000, 0xC746ADC8A63A4706 },
27+
{ 34, 0x000000009E3779B9, 0x2F77B7B2E6ADA87A },
28+
{ 34, 0x9E3779B97F4A7C15, 0x0ABF9EB2F7A1C79C },
29+
{ 51, 0x0000000000000000, 0xC6EE9C1504815F77 },
30+
{ 51, 0x000000009E3779B9, 0x62C47698A815540B },
31+
{ 51, 0x9E3779B97F4A7C15, 0x058BB7486A7C3120 },
32+
{ 68, 0x0000000000000000, 0x371B2CA8CE900A3E },
33+
{ 68, 0x000000009E3779B9, 0x905B2A4C75D71C44 },
34+
{ 68, 0x9E3779B97F4A7C15, 0xE7335ED7FC62CC30 },
35+
{ 85, 0x0000000000000000, 0x2909D55C4E276AF3 },
36+
{ 85, 0x000000009E3779B9, 0x5AC80FE851CBAEC4 },
37+
{ 85, 0x9E3779B97F4A7C15, 0x9535FDF19D6D8D5C },
38+
{ 102, 0x0000000000000000, 0x1D965BD19075E377 },
39+
{ 102, 0x000000009E3779B9, 0xC7D2849DF10C4853 },
40+
{ 102, 0x9E3779B97F4A7C15, 0xE5150A034928991E },
41+
{ 119, 0x0000000000000000, 0xC8898B9959253496 },
42+
{ 119, 0x000000009E3779B9, 0x910357D7BB7A1870 },
43+
{ 119, 0x9E3779B97F4A7C15, 0xB440740C5F0CF770 },
44+
{ 136, 0x0000000000000000, 0x8BE5DCF4366C7F7C },
45+
{ 136, 0x000000009E3779B9, 0x1BD293C4EF0D84ED },
46+
{ 136, 0x9E3779B97F4A7C15, 0x197B8C424C12F6CC },
47+
{ 153, 0x0000000000000000, 0xD2F4DE0FCEA3A349 },
48+
{ 153, 0x000000009E3779B9, 0x896FB2D39FB7EFA7 },
49+
{ 153, 0x9E3779B97F4A7C15, 0x963FA900E393DF5F },
50+
{ 170, 0x0000000000000000, 0x2947A0DF25D037E1 },
51+
{ 170, 0x000000009E3779B9, 0xD2FA104770E9B6A9 },
52+
{ 170, 0x9E3779B97F4A7C15, 0xA78BD679580E9BD0 },
53+
{ 187, 0x0000000000000000, 0xA8D2977F35CAD60E },
54+
{ 187, 0x000000009E3779B9, 0xD9141E18F2D9ACA2 },
55+
{ 187, 0x9E3779B97F4A7C15, 0xC727D6B05516DDCB },
56+
{ 204, 0x0000000000000000, 0x3875A65033134A3A },
57+
{ 204, 0x000000009E3779B9, 0x3EAE20AAFEA1531E },
58+
{ 204, 0x9E3779B97F4A7C15, 0xEF1095EEB8705021 },
59+
{ 221, 0x0000000000000000, 0x3F9CC647D7341AA1 },
60+
{ 221, 0x000000009E3779B9, 0x632EE74082F74872 },
61+
{ 221, 0x9E3779B97F4A7C15, 0x335FD82FF23FCF24 },
62+
{ 238, 0x0000000000000000, 0xAB509AF2B5D2EDC1 },
63+
{ 238, 0x000000009E3779B9, 0xD939C11E09589C49 },
64+
{ 238, 0x9E3779B97F4A7C15, 0x58A6BEA2BC9DC61B },
65+
{ 255, 0x0000000000000000, 0x4FE4BE6884AF8E2A },
66+
{ 255, 0x000000009E3779B9, 0x3E22D2D3DA7251C4 },
67+
{ 255, 0x9E3779B97F4A7C15, 0x9FA0D7C0817E2345 },
68+
{ 272, 0x0000000000000000, 0x087DC6E88BC4432A },
69+
{ 272, 0x000000009E3779B9, 0x2D9EA73EBF915613 },
70+
{ 272, 0x9E3779B97F4A7C15, 0x0805FC8A45A8B483 },
71+
};
72+
73+
int main()
74+
{
75+
int errors = 0;
76+
77+
for( int i = 0; i < sizeof(ref) / sizeof(ref[0]); ++i )
78+
{
79+
reference_entry const& e = ref[ i ];
80+
81+
std::vector<unsigned char> v( e.length, 0x9C );
82+
83+
std::uint64_t r = mulxp3_hash( v.data(), v.size(), e.seed );
84+
85+
if( r != e.result )
86+
{
87+
std::fprintf( stderr, "Reference value mismatch for length %zu, seed %016llX: was %016llX, expected %016llX\n", e.length, e.seed, r, e.result );
88+
++errors;
89+
}
90+
}
91+
92+
if( errors == 0 )
93+
{
94+
std::puts( "No errors detected." );
95+
}
96+
97+
return errors;
98+
}

0 commit comments

Comments
 (0)