• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
31 namespace {
32 
33 static const LChar nullLChars[2] = { 0, 0 };
34 static const UChar nullUChars[2] = { 0, 0 };
35 
36 static const unsigned emptyStringHash = 0x4EC889EU;
37 static const unsigned singleNullCharacterHash = 0x3D3ABF44U;
38 
39 static const LChar testALChars[6] = { 0x41, 0x95, 0xFF, 0x50, 0x01, 0 };
40 static const UChar testAUChars[6] = { 0x41, 0x95, 0xFF, 0x50, 0x01, 0 };
41 static const UChar testBUChars[6] = { 0x41, 0x95, 0xFFFF, 0x1080, 0x01, 0 };
42 
43 static const unsigned testAHash1 = 0xEA32B004;
44 static const unsigned testAHash2 = 0x93F0F71E;
45 static const unsigned testAHash3 = 0xCB609EB1;
46 static const unsigned testAHash4 = 0x7984A706;
47 static const unsigned testAHash5 = 0x0427561F;
48 
49 static const unsigned testBHash1 = 0xEA32B004;
50 static const unsigned testBHash2 = 0x93F0F71E;
51 static const unsigned testBHash3 = 0x59EB1B2C;
52 static const unsigned testBHash4 = 0xA7BCCC0A;
53 static const unsigned testBHash5 = 0x79201649;
54 
TEST(StringHasherTest,StringHasher)55 TEST(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 
TEST(StringHasherTest,StringHasher_addCharacter)64 TEST(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 
TEST(StringHasherTest,StringHasher_addCharacters)111 TEST(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 
TEST(StringHasherTest,StringHasher_addCharactersAssumingAligned)250 TEST(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 
TEST(StringHasherTest,StringHasher_computeHash)363 TEST(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 
TEST(StringHasherTest,StringHasher_computeHashAndMaskTop8Bits)378 TEST(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 
TEST(StringHasherTest,StringHasher_hashMemory)393 TEST(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