-
Notifications
You must be signed in to change notification settings - Fork 4
/
Copy pathhash_test.go
314 lines (288 loc) · 10.2 KB
/
hash_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
package xhash
import (
"encoding/hex"
"hash/maphash"
"math"
"strconv"
"testing"
"github.com/fufuok/utils"
"github.com/fufuok/utils/assert"
)
var (
tmpS = "Fufu 中 文加密/解密~{a"
testString = " Fufu 中 文\u2728->?\n*\U0001F63A "
testBytes = []byte(testString)
seed = maphash.MakeSeed()
)
func TestSha256Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "ed3772cefd8991edac6d198df7b62c224b92038e2d435a9a1e2734211e5b5e0b",
Sha256Hex(tmpS))
}
func TestSha512Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "c3b70022a04f57c1ad335256d2adb2aeec825c6641b2576b48f64abf1bb2c3210dff1087b9f"+
"27261e4062779e64f29fc39d555164c5a2ea6eb3fd6d8b19ed1d1",
Sha512Hex(tmpS))
}
func TestSha1Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "ad4ebd7a388c536ff4fcb494ffb36c047151f751",
Sha1Hex(tmpS))
}
func TestHmacSHA256Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "6d502095be042aab03ac7ae36dd0ca504e54eb72569547dca4e16e5de605ae7c",
HmacSHA256Hex(tmpS, "Fufu"))
}
func TestHmacSHA512Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "516825116f0c14c563f0fdd377729dd0a2024fb9f16f0dc81d83450e97114683ece5c8886"+
"aaa912af970b1a40505333fb16e770e6b9df1826556e5fac680782b",
HmacSHA512Hex(tmpS, "Fufu"))
}
func TestHmacSHA1Hex(t *testing.T) {
t.Parallel()
assert.Equal(t, "e6720f969c4aa396324845bed13e3cbf550b0d6d",
HmacSHA1Hex(tmpS, "Fufu"))
}
func TestMD5Hex(t *testing.T) {
for _, v := range []struct {
in, out string
}{
{"12345", "827ccb0eea8a706c4c34a16891f84e7b"},
{testString, "8d47309acf79aa15378c82475c167865"},
{"Fufu 中 文", "0ab5820207b25880bc0a1d09ed64f10c"},
} {
assert.Equal(t, v.out, MD5Hex(v.in))
assert.Equal(t, v.out, MD5BytesHex([]byte(v.in)))
assert.Equal(t, v.out, hex.EncodeToString(MD5([]byte(v.in))))
}
}
func TestMD5Sum(t *testing.T) {
t.Parallel()
res, _ := MD5Sum("LICENSE")
expected := []string{
// Real result
"8fad15baa71cfe5901d9ac1bbec2c56c",
// Result on github windows (LF would be replaced by CRLF, Maybe core.autocrlf is true)
"cd5c4d3bd8efa894619c1f3eab8a9174",
}
assert.Equal(t, true, utils.InStrings(expected, res))
assert.Equal(t, true, utils.InStrings(expected, MustMD5Sum("LICENSE")))
}
func TestHashString(t *testing.T) {
for _, v := range []struct {
in, out string
}{
{"", "14695981039346656037"},
{"12345", "16534377278781491704"},
{testString, "13467076781014605639"},
{"Fufu 中 文", "1485575821508720008"},
} {
assert.Equal(t, v.out, HashString(v.in))
assert.Equal(t, v.out, HashBytes([]byte(v.in)))
}
for _, v := range []struct {
in string
out uint32
}{
{"", 2166136261},
{"12345", 1136836824},
{testString, 475021159},
{"Fufu 中 文", 2300112168},
} {
assert.Equal(t, v.out, HashString32(v.in))
assert.Equal(t, v.out, HashBytes32([]byte(v.in)))
}
}
func TestHashUint(t *testing.T) {
for _, v := range []struct {
in, out uint64
}{
{0, 12161962213042174405},
{1, 12161961113530546194},
{offset64, 5063649278745802162},
{prime64, 14714463944532698764},
{math.MaxUint64, 10157053723145373757},
} {
assert.Equal(t, v.out, HashUint64(v.in))
}
for _, v := range []struct {
in, out uint32
}{
{0, 1268118805},
{1, 1251341186},
{offset32, 2870680790},
{prime32, 2389395716},
{math.MaxUint32, 3809873841},
} {
assert.Equal(t, v.out, HashUint32(v.in))
}
}
func TestHashStringToInt(t *testing.T) {
assert.Equal(t, uint64(offset64), Sum64(""))
assert.Equal(t, uint32(offset32), Sum32(""))
assert.Equal(t, uint64(offset64), FnvHash(""))
assert.Equal(t, uint32(offset32), FnvHash32(""))
assert.Equal(t, uint64(13467076781014605639), Sum64(testString))
assert.Equal(t, uint32(475021159), Sum32(testString))
assert.Equal(t, uint64(13467076781014605639), FnvHash(testString))
assert.Equal(t, uint32(475021159), FnvHash32(testString))
v := MemHash(testString)
for i := 0; i < 100000; i++ {
assert.Equal(t, v, MemHash(testString))
}
v = MemHashb(testBytes)
for i := 0; i < 100000; i++ {
assert.Equal(t, v, MemHashb(testBytes))
}
v32 := MemHash32(testString)
for i := 0; i < 100000; i++ {
assert.Equal(t, v32, MemHash32(testString))
}
v32 = Djb33(testString)
for i := 0; i < 100000; i++ {
assert.Equal(t, v32, Djb33(testString))
}
}
func TestHashSeedString(t *testing.T) {
const numEntries = 1000
m := make(map[uint64]uint64)
for i := 0; i < numEntries; i++ {
k := HashSeedString(seed, strconv.Itoa(i))
if _, ok := m[k]; ok {
t.Fatalf("expect key %d to not exist", k)
}
m[k] = k
}
if len(m) != numEntries {
t.Fatalf("expect count of %d, but got: %d", numEntries, len(m))
}
}
func TestHashSeedUint64(t *testing.T) {
const numEntries = 1000
m := make(map[uint64]uint64)
for i := 0; i < numEntries; i++ {
k := HashSeedUint64(seed, uint64(i))
if _, ok := m[k]; ok {
t.Fatalf("expect key %d to not exist", k)
}
m[k] = k
}
if len(m) != numEntries {
t.Fatalf("expect count of %d, but got: %d", numEntries, len(m))
}
}
func BenchmarkHashString(b *testing.B) {
str := utils.RandString(20)
b.ResetTimer()
b.Run("MD5Hex", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = MD5Hex(str)
}
})
b.Run("HashString", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = HashString(str)
}
})
}
// go test -run=^$ -benchmem -benchtime=1s -count=3 -bench=BenchmarkHashString
// goos: linux
// goarch: amd64
// pkg: github.com/fufuok/utils
// cpu: Intel(R) Xeon(R) CPU E3-1230 V2 @ 3.30GHz
// BenchmarkHashString/MD5Hex-8 5115880 226.1 ns/op 64 B/op 2 allocs/op
// BenchmarkHashString/MD5Hex-8 5377476 230.3 ns/op 64 B/op 2 allocs/op
// BenchmarkHashString/MD5Hex-8 5227404 226.4 ns/op 64 B/op 2 allocs/op
// BenchmarkHashString/HashString-8 11307057 102.8 ns/op 24 B/op 1 allocs/op
// BenchmarkHashString/HashString-8 12567037 96.83 ns/op 24 B/op 1 allocs/op
// BenchmarkHashString/HashString-8 12295094 101.1 ns/op 24 B/op 1 allocs/op
func BenchmarkHash(b *testing.B) {
buf := utils.RandBytes(20)
str := utils.RandString(20)
b.ResetTimer()
b.Run("Sum64", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Sum64(str)
}
})
b.Run("Sum32", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Sum32(str)
}
})
b.Run("FnvHash", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = FnvHash(str)
}
})
b.Run("FnvHash32", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = FnvHash32(str)
}
})
b.Run("MemHashb", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = MemHashb(buf)
}
})
b.Run("MemHash", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = MemHash(str)
}
})
b.Run("MemHashb32", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = MemHashb32(buf)
}
})
b.Run("MemHash32", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = MemHash32(str)
}
})
b.Run("Djb33", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Djb33(str)
}
})
b.Run("SeedString", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = HashSeedString(seed, str)
}
})
}
// go test -run=^$ -benchmem -benchtime=1s -count=3 -bench=BenchmarkHash$
// goos: linux
// goarch: amd64
// pkg: github.com/fufuok/utils
// cpu: Intel(R) Xeon(R) CPU E3-1230 V2 @ 3.30GHz
// BenchmarkHash/Sum64-8 53414522 22.67 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Sum64-8 54474142 22.05 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Sum64-8 47609222 22.30 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Sum32-8 48003264 21.97 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Sum32-8 56251669 21.41 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Sum32-8 51219012 22.23 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash-8 28918519 37.55 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash-8 33735345 35.68 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash-8 36855715 37.35 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash32-8 35083820 32.14 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash32-8 47042220 28.03 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/FnvHash32-8 46833836 28.16 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb-8 153161814 9.470 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb-8 152563350 8.079 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb-8 142128412 7.964 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash-8 125632875 8.775 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash-8 150410337 8.372 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash-8 135773145 9.427 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb32-8 146760392 7.950 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb32-8 146271644 7.759 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHashb32-8 154832995 8.686 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash32-8 100000000 10.13 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash32-8 100000000 10.30 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/MemHash32-8 143592832 8.360 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Djb33-8 60568434 18.17 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Djb33-8 75151240 18.17 ns/op 0 B/op 0 allocs/op
// BenchmarkHash/Djb33-8 68428705 19.79 ns/op 0 B/op 0 allocs/op