1/*
2 * Copyright (C) 2013 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27
28#include "wtf/StringHasher.h"
29#include <gtest/gtest.h>
30
31namespace {
32
33static const LChar nullLChars[2] = { 0, 0 };
34static const UChar nullUChars[2] = { 0, 0 };
35
36static const unsigned emptyStringHash = 0x4EC889EU;
37static const unsigned singleNullCharacterHash = 0x3D3ABF44U;
38
39static const LChar testALChars[6] = { 0x41, 0x95, 0xFF, 0x50, 0x01, 0 };
40static const UChar testAUChars[6] = { 0x41, 0x95, 0xFF, 0x50, 0x01, 0 };
41static const UChar testBUChars[6] = { 0x41, 0x95, 0xFFFF, 0x1080, 0x01, 0 };
42
43static const unsigned testAHash1 = 0xEA32B004;
44static const unsigned testAHash2 = 0x93F0F71E;
45static const unsigned testAHash3 = 0xCB609EB1;
46static const unsigned testAHash4 = 0x7984A706;
47static const unsigned testAHash5 = 0x0427561F;
48
49static const unsigned testBHash1 = 0xEA32B004;
50static const unsigned testBHash2 = 0x93F0F71E;
51static const unsigned testBHash3 = 0x59EB1B2C;
52static const unsigned testBHash4 = 0xA7BCCC0A;
53static const unsigned testBHash5 = 0x79201649;
54
55TEST(StringHasherTest, StringHasher)
56{
57    StringHasher hasher;
58
59    // The initial state of the hasher.
60    EXPECT_EQ(emptyStringHash, hasher.hash());
61    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
62}
63
64TEST(StringHasherTest, StringHasher_addCharacter)
65{
66    StringHasher hasher;
67
68    // Hashing a single character.
69    hasher = StringHasher();
70    hasher.addCharacter(0);
71    EXPECT_EQ(singleNullCharacterHash, hasher.hash());
72    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
73
74    // Hashing five characters, checking the intermediate state after each is added.
75    hasher = StringHasher();
76    hasher.addCharacter(testAUChars[0]);
77    EXPECT_EQ(testAHash1, hasher.hash());
78    EXPECT_EQ(testAHash1 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
79    hasher.addCharacter(testAUChars[1]);
80    EXPECT_EQ(testAHash2, hasher.hash());
81    EXPECT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
82    hasher.addCharacter(testAUChars[2]);
83    EXPECT_EQ(testAHash3, hasher.hash());
84    EXPECT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
85    hasher.addCharacter(testAUChars[3]);
86    EXPECT_EQ(testAHash4, hasher.hash());
87    EXPECT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
88    hasher.addCharacter(testAUChars[4]);
89    EXPECT_EQ(testAHash5, hasher.hash());
90    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
91
92    // Hashing a second set of five characters, including non-Latin-1 characters.
93    hasher = StringHasher();
94    hasher.addCharacter(testBUChars[0]);
95    EXPECT_EQ(testBHash1, hasher.hash());
96    EXPECT_EQ(testBHash1 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
97    hasher.addCharacter(testBUChars[1]);
98    EXPECT_EQ(testBHash2, hasher.hash());
99    EXPECT_EQ(testBHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
100    hasher.addCharacter(testBUChars[2]);
101    EXPECT_EQ(testBHash3, hasher.hash());
102    EXPECT_EQ(testBHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
103    hasher.addCharacter(testBUChars[3]);
104    EXPECT_EQ(testBHash4, hasher.hash());
105    EXPECT_EQ(testBHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
106    hasher.addCharacter(testBUChars[4]);
107    EXPECT_EQ(testBHash5, hasher.hash());
108    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
109}
110
111TEST(StringHasherTest, StringHasher_addCharacters)
112{
113    StringHasher hasher;
114
115    // Hashing zero characters.
116    hasher = StringHasher();
117    hasher.addCharacters(static_cast<LChar*>(0), 0);
118    EXPECT_EQ(emptyStringHash, hasher.hash());
119    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
120    hasher = StringHasher();
121    hasher.addCharacters(nullLChars, 0);
122    EXPECT_EQ(emptyStringHash, hasher.hash());
123    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
124    hasher = StringHasher();
125    hasher.addCharacters(static_cast<UChar*>(0), 0);
126    EXPECT_EQ(emptyStringHash, hasher.hash());
127    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
128    hasher = StringHasher();
129    hasher.addCharacters(nullUChars, 0);
130    EXPECT_EQ(emptyStringHash, hasher.hash());
131    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
132
133    // Hashing one character.
134    hasher = StringHasher();
135    hasher.addCharacters(nullLChars, 1);
136    EXPECT_EQ(singleNullCharacterHash, hasher.hash());
137    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
138    hasher = StringHasher();
139    hasher.addCharacters(nullUChars, 1);
140    EXPECT_EQ(singleNullCharacterHash, hasher.hash());
141    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
142
143    // Hashing five characters, all at once.
144    hasher = StringHasher();
145    hasher.addCharacters(testALChars, 5);
146    EXPECT_EQ(testAHash5, hasher.hash());
147    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
148    hasher = StringHasher();
149    hasher.addCharacters(testAUChars, 5);
150    EXPECT_EQ(testAHash5, hasher.hash());
151    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
152    hasher = StringHasher();
153    hasher.addCharacters(testBUChars, 5);
154    EXPECT_EQ(testBHash5, hasher.hash());
155    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
156
157    // Hashing five characters, in groups of two, then the last one.
158    hasher = StringHasher();
159    hasher.addCharacters(testALChars, 2);
160    EXPECT_EQ(testAHash2, hasher.hash());
161    EXPECT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
162    hasher.addCharacters(testALChars + 2, 2);
163    EXPECT_EQ(testAHash4, hasher.hash());
164    EXPECT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
165    hasher.addCharacters(testALChars + 4, 1);
166    EXPECT_EQ(testAHash5, hasher.hash());
167    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
168    hasher = StringHasher();
169    hasher.addCharacters(testALChars, 2);
170    hasher.addCharacters(testALChars + 2, 2);
171    hasher.addCharacters(testALChars + 4, 1);
172    EXPECT_EQ(testAHash5, hasher.hash());
173    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
174    hasher = StringHasher();
175    hasher.addCharacters(testAUChars, 2);
176    EXPECT_EQ(testAHash2, hasher.hash());
177    EXPECT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
178    hasher.addCharacters(testAUChars + 2, 2);
179    EXPECT_EQ(testAHash4, hasher.hash());
180    EXPECT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
181    hasher.addCharacters(testAUChars + 4, 1);
182    EXPECT_EQ(testAHash5, hasher.hash());
183    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
184    hasher = StringHasher();
185    hasher.addCharacters(testAUChars, 2);
186    hasher.addCharacters(testAUChars + 2, 2);
187    hasher.addCharacters(testAUChars + 4, 1);
188    EXPECT_EQ(testAHash5, hasher.hash());
189    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
190    hasher = StringHasher();
191    hasher.addCharacters(testBUChars, 2);
192    EXPECT_EQ(testBHash2, hasher.hash());
193    EXPECT_EQ(testBHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
194    hasher.addCharacters(testBUChars + 2, 2);
195    EXPECT_EQ(testBHash4, hasher.hash());
196    EXPECT_EQ(testBHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
197    hasher.addCharacters(testBUChars + 4, 1);
198    EXPECT_EQ(testBHash5, hasher.hash());
199    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
200    hasher = StringHasher();
201    hasher.addCharacters(testBUChars, 2);
202    hasher.addCharacters(testBUChars + 2, 2);
203    hasher.addCharacters(testBUChars + 4, 1);
204    EXPECT_EQ(testBHash5, hasher.hash());
205    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
206
207    // Hashing five characters, the first three, then the last two.
208    hasher = StringHasher();
209    hasher.addCharacters(testALChars, 3);
210    EXPECT_EQ(testAHash3, hasher.hash());
211    EXPECT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
212    hasher.addCharacters(testALChars + 3, 2);
213    EXPECT_EQ(testAHash5, hasher.hash());
214    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
215    hasher = StringHasher();
216    hasher.addCharacters(testALChars, 3);
217    EXPECT_EQ(testAHash3, hasher.hash());
218    EXPECT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
219    hasher.addCharacters(testALChars + 3, 2);
220    EXPECT_EQ(testAHash5, hasher.hash());
221    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
222    hasher = StringHasher();
223    hasher.addCharacters(testAUChars, 3);
224    EXPECT_EQ(testAHash3, hasher.hash());
225    EXPECT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
226    hasher.addCharacters(testAUChars + 3, 2);
227    EXPECT_EQ(testAHash5, hasher.hash());
228    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
229    hasher = StringHasher();
230    hasher.addCharacters(testAUChars, 3);
231    EXPECT_EQ(testAHash3, hasher.hash());
232    EXPECT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
233    hasher.addCharacters(testAUChars + 3, 2);
234    EXPECT_EQ(testAHash5, hasher.hash());
235    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
236    hasher = StringHasher();
237    hasher.addCharacters(testBUChars, 3);
238    EXPECT_EQ(testBHash3, hasher.hash());
239    EXPECT_EQ(testBHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
240    hasher.addCharacters(testBUChars + 3, 2);
241    EXPECT_EQ(testBHash5, hasher.hash());
242    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
243    hasher = StringHasher();
244    hasher.addCharacters(testBUChars, 3);
245    hasher.addCharacters(testBUChars + 3, 2);
246    EXPECT_EQ(testBHash5, hasher.hash());
247    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
248}
249
250TEST(StringHasherTest, StringHasher_addCharactersAssumingAligned)
251{
252    StringHasher hasher;
253
254    // Hashing zero characters.
255    hasher = StringHasher();
256    hasher.addCharactersAssumingAligned(static_cast<LChar*>(0), 0);
257    EXPECT_EQ(emptyStringHash, hasher.hash());
258    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
259    hasher = StringHasher();
260    hasher.addCharactersAssumingAligned(nullLChars, 0);
261    EXPECT_EQ(emptyStringHash, hasher.hash());
262    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
263    hasher = StringHasher();
264    hasher.addCharactersAssumingAligned(static_cast<UChar*>(0), 0);
265    EXPECT_EQ(emptyStringHash, hasher.hash());
266    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
267    hasher = StringHasher();
268    hasher.addCharactersAssumingAligned(nullUChars, 0);
269    EXPECT_EQ(emptyStringHash, hasher.hash());
270    EXPECT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
271
272    // Hashing one character.
273    hasher = StringHasher();
274    hasher.addCharactersAssumingAligned(nullLChars, 1);
275    EXPECT_EQ(singleNullCharacterHash, hasher.hash());
276    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
277    hasher = StringHasher();
278    hasher.addCharactersAssumingAligned(nullUChars, 1);
279    EXPECT_EQ(singleNullCharacterHash, hasher.hash());
280    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
281
282    // Hashing five characters, all at once.
283    hasher = StringHasher();
284    hasher.addCharactersAssumingAligned(testALChars, 5);
285    EXPECT_EQ(testAHash5, hasher.hash());
286    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
287    hasher = StringHasher();
288    hasher.addCharactersAssumingAligned(testAUChars, 5);
289    EXPECT_EQ(testAHash5, hasher.hash());
290    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
291    hasher = StringHasher();
292    hasher.addCharactersAssumingAligned(testBUChars, 5);
293    EXPECT_EQ(testBHash5, hasher.hash());
294    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
295
296    // Hashing five characters, in groups of two, then the last one.
297    hasher = StringHasher();
298    hasher.addCharactersAssumingAligned(testALChars, 2);
299    EXPECT_EQ(testAHash2, hasher.hash());
300    EXPECT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
301    hasher.addCharactersAssumingAligned(testALChars + 2, 2);
302    EXPECT_EQ(testAHash4, hasher.hash());
303    EXPECT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
304    hasher.addCharactersAssumingAligned(testALChars + 4, 1);
305    EXPECT_EQ(testAHash5, hasher.hash());
306    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
307    hasher = StringHasher();
308    hasher.addCharactersAssumingAligned(testALChars, 2);
309    hasher.addCharactersAssumingAligned(testALChars + 2, 2);
310    hasher.addCharactersAssumingAligned(testALChars + 4, 1);
311    EXPECT_EQ(testAHash5, hasher.hash());
312    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
313    hasher = StringHasher();
314    hasher.addCharactersAssumingAligned(testAUChars, 2);
315    EXPECT_EQ(testAHash2, hasher.hash());
316    EXPECT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
317    hasher.addCharactersAssumingAligned(testAUChars + 2, 2);
318    EXPECT_EQ(testAHash4, hasher.hash());
319    EXPECT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
320    hasher.addCharactersAssumingAligned(testAUChars + 4, 1);
321    EXPECT_EQ(testAHash5, hasher.hash());
322    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
323    hasher = StringHasher();
324    hasher.addCharactersAssumingAligned(testAUChars, 2);
325    hasher.addCharactersAssumingAligned(testAUChars + 2, 2);
326    hasher.addCharactersAssumingAligned(testAUChars + 4, 1);
327    EXPECT_EQ(testAHash5, hasher.hash());
328    EXPECT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
329    hasher = StringHasher();
330    hasher.addCharactersAssumingAligned(testBUChars, 2);
331    EXPECT_EQ(testBHash2, hasher.hash());
332    EXPECT_EQ(testBHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
333    hasher.addCharactersAssumingAligned(testBUChars + 2, 2);
334    EXPECT_EQ(testBHash4, hasher.hash());
335    EXPECT_EQ(testBHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
336    hasher.addCharactersAssumingAligned(testBUChars + 4, 1);
337    EXPECT_EQ(testBHash5, hasher.hash());
338    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
339    hasher = StringHasher();
340    hasher.addCharactersAssumingAligned(testBUChars, 2);
341    hasher.addCharactersAssumingAligned(testBUChars + 2, 2);
342    hasher.addCharactersAssumingAligned(testBUChars + 4, 1);
343    EXPECT_EQ(testBHash5, hasher.hash());
344    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
345
346    // Hashing five characters, first two characters one at a time,
347    // then two more, then the last one.
348    hasher = StringHasher();
349    hasher.addCharacter(testBUChars[0]);
350    EXPECT_EQ(testBHash1, hasher.hash());
351    EXPECT_EQ(testBHash1 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
352    hasher.addCharacter(testBUChars[1]);
353    EXPECT_EQ(testBHash2, hasher.hash());
354    EXPECT_EQ(testBHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
355    hasher.addCharactersAssumingAligned(testBUChars[2], testBUChars[3]);
356    EXPECT_EQ(testBHash4, hasher.hash());
357    EXPECT_EQ(testBHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
358    hasher.addCharactersAssumingAligned(testBUChars + 4, 1);
359    EXPECT_EQ(testBHash5, hasher.hash());
360    EXPECT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked());
361}
362
363TEST(StringHasherTest, StringHasher_computeHash)
364{
365    EXPECT_EQ(emptyStringHash, StringHasher::computeHash(static_cast<LChar*>(0), 0));
366    EXPECT_EQ(emptyStringHash, StringHasher::computeHash(nullLChars, 0));
367    EXPECT_EQ(emptyStringHash, StringHasher::computeHash(static_cast<UChar*>(0), 0));
368    EXPECT_EQ(emptyStringHash, StringHasher::computeHash(nullUChars, 0));
369
370    EXPECT_EQ(singleNullCharacterHash, StringHasher::computeHash(nullLChars, 1));
371    EXPECT_EQ(singleNullCharacterHash, StringHasher::computeHash(nullUChars, 1));
372
373    EXPECT_EQ(testAHash5, StringHasher::computeHash(testALChars, 5));
374    EXPECT_EQ(testAHash5, StringHasher::computeHash(testAUChars, 5));
375    EXPECT_EQ(testBHash5, StringHasher::computeHash(testBUChars, 5));
376}
377
378TEST(StringHasherTest, StringHasher_computeHashAndMaskTop8Bits)
379{
380    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(static_cast<LChar*>(0), 0));
381    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(nullLChars, 0));
382    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(static_cast<UChar*>(0), 0));
383    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(nullUChars, 0));
384
385    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(nullLChars, 1));
386    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(nullUChars, 1));
387
388    EXPECT_EQ(testAHash5 & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(testALChars, 5));
389    EXPECT_EQ(testAHash5 & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(testAUChars, 5));
390    EXPECT_EQ(testBHash5 & 0xFFFFFF, StringHasher::computeHashAndMaskTop8Bits(testBUChars, 5));
391}
392
393TEST(StringHasherTest, StringHasher_hashMemory)
394{
395    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory(0, 0));
396    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory(nullUChars, 0));
397    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory<0>(0));
398    EXPECT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory<0>(nullUChars));
399
400    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::hashMemory(nullUChars, 2));
401    EXPECT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::hashMemory<2>(nullUChars));
402
403    EXPECT_EQ(testAHash5 & 0xFFFFFF, StringHasher::hashMemory(testAUChars, 10));
404    EXPECT_EQ(testAHash5 & 0xFFFFFF, StringHasher::hashMemory<10>(testAUChars));
405    EXPECT_EQ(testBHash5 & 0xFFFFFF, StringHasher::hashMemory(testBUChars, 10));
406    EXPECT_EQ(testBHash5 & 0xFFFFFF, StringHasher::hashMemory<10>(testBUChars));
407}
408
409} // namespace
410