Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(169)

Side by Side Diff: chrome/common/instant_restricted_id_cache_unittest.cc

Issue 12498002: InstantExtended: Adding InstantRestrictedIDCache. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Minor test fix. Created 7 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <string>
6 #include <utility>
7 #include <vector>
8 #include "chrome/common/instant_restricted_id_cache.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10
11 namespace {
12
13 struct TestData {
14 TestData() {}
15 explicit TestData(const std::string& i_value) : value(i_value) {}
16
17 bool operator==(const TestData& rhs) const {
18 return rhs.value == value;
19 }
20
21 std::string value;
22 };
23
24 // For printing failures nicely.
25 void PrintTo(const TestData& data, std::ostream* os) {
26 *os << data.value;
27 }
28
29 } // namespace
30
31 typedef testing::Test InstantRestrictedIDCacheTest;
32 typedef InstantRestrictedIDCache<TestData>::ItemIDPair ItemIDPair;
33
34 TEST_F(InstantRestrictedIDCacheTest, AutoIDGeneration) {
35 InstantRestrictedIDCache<TestData> cache(7);
36 EXPECT_EQ(0u, cache.cache_.size());
37 EXPECT_EQ(0, cache.last_restricted_id_);
38
39 // Check first addition.
40 std::vector<TestData> input1;
41 input1.push_back(TestData("A"));
42 input1.push_back(TestData("B"));
43 input1.push_back(TestData("C"));
44 cache.AddItems(input1);
45 EXPECT_EQ(3u, cache.cache_.size());
46 EXPECT_EQ(3, cache.last_restricted_id_);
47
48 std::vector<ItemIDPair> output;
49 cache.GetCurrentItems(&output);
50 EXPECT_EQ(3u, output.size());
51 for (int i = 0; i < 3; ++i) {
52 EXPECT_EQ(i + 1, output[i].first);
53 EXPECT_EQ(input1[i], output[i].second);
54 }
55
56 TestData t;
57 EXPECT_FALSE(cache.GetItemWithRestrictedID(4, &t));
58 EXPECT_TRUE(cache.GetItemWithRestrictedID(3, &t));
59 EXPECT_EQ(input1[2], t);
60
61 // Add more items, no overflow.
62 std::vector<TestData> input2;
63 input2.push_back(TestData("D"));
64 input2.push_back(TestData("E"));
65 cache.AddItems(input2);
66 EXPECT_EQ(5u, cache.cache_.size());
67 EXPECT_EQ(5, cache.last_restricted_id_);
68
69 output.clear();
70 cache.GetCurrentItems(&output);
71 EXPECT_EQ(2u, output.size());
72 for (int i = 0; i < 2; ++i) {
73 EXPECT_EQ(i + 4, output[i].first);
74 EXPECT_EQ(input2[i], output[i].second);
75 }
76
77 EXPECT_FALSE(cache.GetItemWithRestrictedID(6, &t));
78 EXPECT_TRUE(cache.GetItemWithRestrictedID(3, &t));
79 EXPECT_EQ(input1[2], t);
80 EXPECT_TRUE(cache.GetItemWithRestrictedID(5, &t));
81 EXPECT_EQ(input2[1], t);
82
83 // Add another set, overflows.
84 std::vector<TestData> input3;
85 input3.push_back(TestData("F"));
86 input3.push_back(TestData("G"));
87 input3.push_back(TestData("H"));
88 input3.push_back(TestData("I"));
89 cache.AddItems(input3);
90 EXPECT_EQ(7u, cache.cache_.size());
91 EXPECT_EQ(9, cache.last_restricted_id_);
92
93 output.clear();
94 cache.GetCurrentItems(&output);
95 EXPECT_EQ(4u, output.size());
96 for (int i = 0; i < 3; ++i) {
97 EXPECT_EQ(i + 6, output[i].first);
98 EXPECT_EQ(input3[i], output[i].second);
99 }
100
101 EXPECT_FALSE(cache.GetItemWithRestrictedID(1, &t));
102 EXPECT_FALSE(cache.GetItemWithRestrictedID(2, &t));
103 EXPECT_TRUE(cache.GetItemWithRestrictedID(3, &t));
104 EXPECT_EQ(input1[2], t);
105 EXPECT_TRUE(cache.GetItemWithRestrictedID(5, &t));
106 EXPECT_EQ(input2[1], t);
107 EXPECT_TRUE(cache.GetItemWithRestrictedID(7, &t));
108 EXPECT_EQ(input3[1], t);
109 }
110
111 TEST_F(InstantRestrictedIDCacheTest, ManualIDGeneration) {
112 InstantRestrictedIDCache<TestData> cache(5);
113 EXPECT_EQ(0u, cache.cache_.size());
114 EXPECT_EQ(0, cache.last_restricted_id_);
115
116 // Check first addition.
117 std::vector<ItemIDPair> input1;
118 input1.push_back(std::make_pair(1, TestData("A")));
119 input1.push_back(std::make_pair(2, TestData("B")));
120 input1.push_back(std::make_pair(4, TestData("C")));
121 cache.AddItemsWithRestrictedID(input1);
122 EXPECT_EQ(3u, cache.cache_.size());
123 EXPECT_EQ(4, cache.last_restricted_id_);
124
125 std::vector<ItemIDPair> output;
126 cache.GetCurrentItems(&output);
127 EXPECT_EQ(3u, output.size());
128 for (int i = 0; i < 3; ++i) {
129 EXPECT_EQ(input1[i].first, output[i].first);
130 EXPECT_EQ(input1[i].second, output[i].second);
131 }
132
133 TestData t;
134 EXPECT_FALSE(cache.GetItemWithRestrictedID(3, &t));
135 EXPECT_TRUE(cache.GetItemWithRestrictedID(4, &t));
136 EXPECT_EQ(input1[2].second, t);
137
138
139 // Add more items, one with same rid, no overflow.
140 std::vector<ItemIDPair> input2;
141 input2.push_back(std::make_pair(4, TestData("D")));
142 input2.push_back(std::make_pair(7, TestData("E")));
143 cache.AddItemsWithRestrictedID(input2);
144 EXPECT_EQ(5u, cache.cache_.size());
145 EXPECT_EQ(7, cache.last_restricted_id_);
146
147 output.clear();
148 cache.GetCurrentItems(&output);
149 EXPECT_EQ(2u, output.size());
150 for (int i = 0; i < 2; ++i) {
151 EXPECT_EQ(input2[i].first, output[i].first);
152 EXPECT_EQ(input2[i].second, output[i].second);
153 }
154
155 EXPECT_FALSE(cache.GetItemWithRestrictedID(6, &t));
156 EXPECT_TRUE(cache.GetItemWithRestrictedID(2, &t));
157 EXPECT_EQ(input1[1].second, t);
158 EXPECT_TRUE(cache.GetItemWithRestrictedID(4, &t));
159 EXPECT_EQ(input2[0].second, t);
160 EXPECT_TRUE(cache.GetItemWithRestrictedID(7, &t));
161 EXPECT_EQ(input2[1].second, t);
162
163 // Add another set, duplicate rids, overflows.
164 std::vector<ItemIDPair> input3;
165 input3.push_back(std::make_pair(1, TestData("F")));
166 input3.push_back(std::make_pair(7, TestData("G")));
167 input3.push_back(std::make_pair(9, TestData("H")));
168 cache.AddItemsWithRestrictedID(input3);
169 EXPECT_EQ(5u, cache.cache_.size());
170 EXPECT_EQ(9, cache.last_restricted_id_);
171
172 output.clear();
173 cache.GetCurrentItems(&output);
174 EXPECT_EQ(3u, output.size());
175 for (int i = 0; i < 2; ++i) {
176 EXPECT_EQ(input3[i].first, output[i].first);
177 EXPECT_EQ(input3[i].second, output[i].second);
178 }
179
180 EXPECT_TRUE(cache.GetItemWithRestrictedID(1, &t));
181 EXPECT_EQ(input3[0].second, t);
182 EXPECT_FALSE(cache.GetItemWithRestrictedID(2, &t));
183 EXPECT_FALSE(cache.GetItemWithRestrictedID(3, &t));
184 EXPECT_TRUE(cache.GetItemWithRestrictedID(4, &t));
185 EXPECT_EQ(input2[0].second, t);
186 EXPECT_FALSE(cache.GetItemWithRestrictedID(6, &t));
187 EXPECT_TRUE(cache.GetItemWithRestrictedID(7, &t));
188 EXPECT_EQ(input3[1].second, t);
189 EXPECT_FALSE(cache.GetItemWithRestrictedID(8, &t));
190 EXPECT_TRUE(cache.GetItemWithRestrictedID(9, &t));
191 EXPECT_EQ(input3[2].second, t);
192 }
193
194 TEST_F(InstantRestrictedIDCacheTest, CrazyIDGeneration) {
195 InstantRestrictedIDCache<TestData> cache(4);
196 EXPECT_EQ(0u, cache.cache_.size());
197 EXPECT_EQ(0, cache.last_restricted_id_);
198
199 // Check first addition.
200 std::vector<ItemIDPair> input1;
201 input1.push_back(std::make_pair(0, TestData("A")));
202 input1.push_back(std::make_pair(kint32max, TestData("B")));
203 input1.push_back(std::make_pair(-100, TestData("C")));
204 cache.AddItemsWithRestrictedID(input1);
205 EXPECT_EQ(3u, cache.cache_.size());
206 EXPECT_EQ(kint32max, cache.last_restricted_id_);
207
208 std::vector<ItemIDPair> output;
209 cache.GetCurrentItems(&output);
210 EXPECT_EQ(3u, output.size());
211 for (int i = 0; i < 3; ++i) {
212 EXPECT_EQ(input1[i].first, output[i].first);
213 EXPECT_EQ(input1[i].second, output[i].second);
214 }
215
216 TestData t;
217 EXPECT_FALSE(cache.GetItemWithRestrictedID(1, &t));
218 EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32max, &t));
219 EXPECT_EQ(input1[1].second, t);
220 EXPECT_TRUE(cache.GetItemWithRestrictedID(-100, &t));
221 EXPECT_EQ(input1[2].second, t);
222
223 // Add more items, one with same rid, no overflow.
224 std::vector<ItemIDPair> input2;
225 input2.push_back(std::make_pair(kint32min, TestData("D")));
226 input2.push_back(std::make_pair(7, TestData("E")));
227 cache.AddItemsWithRestrictedID(input2);
228 EXPECT_EQ(4u, cache.cache_.size());
229 EXPECT_EQ(kint32max, cache.last_restricted_id_);
230
231 output.clear();
232 cache.GetCurrentItems(&output);
233 EXPECT_EQ(2u, output.size());
234 for (int i = 0; i < 2; ++i) {
235 EXPECT_EQ(input2[i].first, output[i].first);
236 EXPECT_EQ(input2[i].second, output[i].second);
237 }
238
239 EXPECT_FALSE(cache.GetItemWithRestrictedID(0, &t));
240 EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32max, &t));
241 EXPECT_EQ(input1[1].second, t);
242 EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32min, &t));
243 EXPECT_EQ(input2[0].second, t);
244 EXPECT_TRUE(cache.GetItemWithRestrictedID(7, &t));
245 EXPECT_EQ(input2[1].second, t);
246
247 // Add an item without RID. last_restricted_id_ will overflow.
248 std::vector<TestData> input3;
249 input3.push_back(TestData("F"));
250 input3.push_back(TestData("G"));
251 cache.AddItems(input3);
252 EXPECT_EQ(4u, cache.cache_.size());
253 EXPECT_EQ(kint32min + 1, cache.last_restricted_id_);
254
255 output.clear();
256 cache.GetCurrentItems(&output);
257 EXPECT_EQ(2u, output.size());
258 for (int i = 0; i < 2; ++i) {
259 EXPECT_EQ(kint32min + i, output[i].first);
260 EXPECT_EQ(input3[i], output[i].second);
261 }
262
263 EXPECT_TRUE(cache.GetItemWithRestrictedID(kint32min, &t));
264 EXPECT_EQ(input3[0], t);
265 }
266
267 TEST_F(InstantRestrictedIDCacheTest, MixIDGeneration) {
268 InstantRestrictedIDCache<TestData> cache(5);
269 EXPECT_EQ(0u, cache.cache_.size());
270 EXPECT_EQ(0, cache.last_restricted_id_);
271
272 // Add some items with manually assigned ids.
273 std::vector<ItemIDPair> input1;
274 input1.push_back(std::make_pair(1, TestData("A")));
275 input1.push_back(std::make_pair(2, TestData("B")));
276 input1.push_back(std::make_pair(4, TestData("C")));
277 cache.AddItemsWithRestrictedID(input1);
278 EXPECT_EQ(3u, cache.cache_.size());
279 EXPECT_EQ(4, cache.last_restricted_id_);
280
281 std::vector<ItemIDPair> output;
282 cache.GetCurrentItems(&output);
283 EXPECT_EQ(3u, output.size());
284 for (int i = 0; i < 3; ++i) {
285 EXPECT_EQ(input1[i].first, output[i].first);
286 EXPECT_EQ(input1[i].second, output[i].second);
287 }
288
289 TestData t;
290 EXPECT_FALSE(cache.GetItemWithRestrictedID(3, &t));
291 EXPECT_TRUE(cache.GetItemWithRestrictedID(4, &t));
292 EXPECT_EQ(input1[2].second, t);
293
294 // Add items with auto id generation.
295 std::vector<TestData> input2;
296 input2.push_back(TestData("D"));
297 input2.push_back(TestData("E"));
298 cache.AddItems(input2);
299 EXPECT_EQ(5u, cache.cache_.size());
300 EXPECT_EQ(6, cache.last_restricted_id_);
301
302 output.clear();
303 cache.GetCurrentItems(&output);
304 EXPECT_EQ(2u, output.size());
305 for (int i = 0; i < 2; ++i) {
306 EXPECT_EQ(i + 5, output[i].first);
307 EXPECT_EQ(input2[i], output[i].second);
308 }
309
310 EXPECT_FALSE(cache.GetItemWithRestrictedID(3, &t));
311 EXPECT_TRUE(cache.GetItemWithRestrictedID(2, &t));
312 EXPECT_EQ(input1[1].second, t);
313 EXPECT_TRUE(cache.GetItemWithRestrictedID(4, &t));
314 EXPECT_EQ(input1[2].second, t);
315 EXPECT_TRUE(cache.GetItemWithRestrictedID(5, &t));
316 EXPECT_EQ(input2[0], t);
317 EXPECT_TRUE(cache.GetItemWithRestrictedID(6, &t));
318 EXPECT_EQ(input2[1], t);
319 EXPECT_FALSE(cache.GetItemWithRestrictedID(7, &t));
320
321 // Add manually assigned ids again.
322 std::vector<ItemIDPair> input3;
323 input3.push_back(std::make_pair(1, TestData("F")));
324 input3.push_back(std::make_pair(5, TestData("G")));
325 input3.push_back(std::make_pair(6, TestData("H")));
326 cache.AddItemsWithRestrictedID(input3);
327 EXPECT_EQ(5u, cache.cache_.size());
328 EXPECT_EQ(6, cache.last_restricted_id_);
329
330 output.clear();
331 cache.GetCurrentItems(&output);
332 EXPECT_EQ(3u, output.size());
333 for (int i = 0; i < 2; ++i) {
334 EXPECT_EQ(input3[i].first, output[i].first);
335 EXPECT_EQ(input3[i].second, output[i].second);
336 }
337
338 EXPECT_TRUE(cache.GetItemWithRestrictedID(1, &t));
339 EXPECT_EQ(input3[0].second, t);
340 EXPECT_FALSE(cache.GetItemWithRestrictedID(2, &t));
341 EXPECT_FALSE(cache.GetItemWithRestrictedID(4, &t));
342 EXPECT_TRUE(cache.GetItemWithRestrictedID(5, &t));
343 EXPECT_EQ(input3[1].second, t);
344 EXPECT_TRUE(cache.GetItemWithRestrictedID(6, &t));
345 EXPECT_EQ(input3[2].second, t);
346 EXPECT_FALSE(cache.GetItemWithRestrictedID(7, &t));
347 }
348
349 TEST_F(InstantRestrictedIDCacheTest, AdditionOverflow) {
350 InstantRestrictedIDCache<TestData> cache(2);
351
352 EXPECT_EQ(0u, cache.cache_.size());
353 EXPECT_EQ(0, cache.last_restricted_id_);
354
355 // Add too many.
356 std::vector<TestData> input1;
357 input1.push_back(TestData("A"));
358 input1.push_back(TestData("B"));
359 input1.push_back(TestData("C"));
360 cache.AddItems(input1);
361 EXPECT_EQ(2u, cache.cache_.size());
362 EXPECT_EQ(3, cache.last_restricted_id_);
363
364 std::vector<ItemIDPair> output;
365 cache.GetCurrentItems(&output);
366 EXPECT_EQ(2u, output.size());
367 for (int i = 0; i < 2; ++i) {
368 EXPECT_EQ(i + 2, output[i].first);
369 EXPECT_EQ(input1[i + 1], output[i].second);
370 }
371
372 TestData t;
373 EXPECT_FALSE(cache.GetItemWithRestrictedID(1, &t));
374 EXPECT_FALSE(cache.GetItemWithRestrictedID(4, &t));
375 EXPECT_TRUE(cache.GetItemWithRestrictedID(3, &t));
376 EXPECT_EQ(input1[2], t);
377 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698