OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 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 "chrome/browser/bookmarks/bookmark_tag_model.h" | |
6 | |
7 #include "base/strings/utf_string_conversions.h" | |
8 #include "chrome/browser/bookmarks/bookmark_tag_model_observer.h" | |
9 #include "testing/gtest/include/gtest/gtest.h" | |
10 | |
11 | |
12 namespace { | |
13 | |
14 static struct { | |
15 const std::string input_tag; | |
16 const std::string expected_tag; | |
17 } whitespace_test_cases[] = { | |
18 // Newlines. | |
19 {"foo\nbar", "foo bar"}, | |
20 {"foo\n\nbar", "foo bar"}, | |
21 {"foo\n\n\nbar", "foo bar"}, | |
22 {"foo\r\nbar", "foo bar"}, | |
23 {"foo\r\n\r\nbar", "foo bar"}, | |
24 {"\nfoo\nbar\n", "foo bar"}, | |
25 // Spaces. | |
26 {"foo bar", "foo bar"}, | |
27 {" foo bar ", "foo bar"}, | |
28 {" foo bar ", "foo bar"}, | |
29 // Tabs. | |
30 {"\tfoo\tbar\t", "foo bar"}, | |
31 {"\tfoo bar\t", "foo bar"}, | |
32 // Mixed cases. | |
33 {"\tfoo\nbar\t", "foo bar"}, | |
34 {"\tfoo\r\nbar\t", "foo bar"}, | |
35 {" foo\tbar\n", "foo bar"}, | |
36 {"\t foo \t bar \t", "foo bar"}, | |
37 {"\n foo\r\n\tbar\n \t", "foo bar"}, | |
38 }; | |
39 | |
40 enum ObserverCounts { | |
sky
2013/10/11 21:57:41
Same nit about naming.
noyau (Ping after 24h)
2013/10/14 23:59:39
Done.
| |
41 ADDED_COUNT = 0, | |
42 BEFORE_REMOVE_COUNT, | |
43 REMOVE_COUNT, | |
44 BEFORE_CHANGE_COUNT, | |
45 CHANGE_COUNT, | |
46 BEFORE_TAG_CHANGE_COUNT, | |
47 TAG_CHANGE_COUNT, | |
48 FAVICON_CHANGE_COUNT, | |
49 EXTENSIVE_CHANGE_BEGIN_COUNT, | |
50 EXTENSIVE_CHANGE_END_COUNT, | |
51 BEFORE_REMOVE_ALL_COUNT, | |
52 REMOVE_ALL_COUNT, | |
53 TOTAL_NUMBER_OF_COUNTS | |
54 }; | |
55 | |
56 const std::string count_name[] = { | |
57 "ADDED_COUNT", | |
58 "BEFORE_REMOVE_COUNT", | |
59 "REMOVE_COUNT", | |
60 "BEFORE_CHANGE_COUNT", | |
61 "CHANGE_COUNT", | |
62 "BEFORE_TAG_CHANGE_COUNT", | |
63 "TAG_CHANGE_COUNT", | |
64 "FAVICON_CHANGE_COUNT", | |
65 "EXTENSIVE_CHANGE_BEGIN_COUNT", | |
66 "EXTENSIVE_CHANGE_END_COUNT", | |
67 "BEFORE_REMOVE_ALL_COUNT", | |
68 "REMOVE_ALL_COUNT" | |
69 }; | |
70 | |
71 | |
72 class BookmarkTagModelTest | |
73 : public testing::Test, public BookmarkTagModelObserver { | |
74 | |
sky
2013/10/11 21:57:41
nit: no newline here.
noyau (Ping after 24h)
2013/10/14 23:59:39
Done.
| |
75 public: | |
76 struct ObserverDetails { | |
77 ObserverDetails() : bookmark_(NULL) {} | |
78 | |
79 void Set(const BookmarkNode* bookmark, | |
80 const std::set<BookmarkTag>& tags) { | |
81 bookmark_ = bookmark; | |
82 tags_ = tags; | |
83 } | |
84 | |
85 void ExpectEquals(const BookmarkNode* bookmark, | |
86 const std::set<BookmarkTag>& tags) { | |
87 EXPECT_EQ(bookmark_, bookmark); | |
88 EXPECT_EQ(tags_, tags); | |
89 } | |
90 | |
91 private: | |
92 const BookmarkNode* bookmark_; | |
93 std::set<BookmarkTag> tags_; | |
94 }; | |
95 | |
96 BookmarkTagModelTest() : model_(NULL), | |
97 tag_model_(new BookmarkTagModel(&model_)) { | |
98 tag_model_->AddObserver(this); | |
99 ClearCounts(); | |
100 } | |
101 | |
102 virtual ~BookmarkTagModelTest() { | |
103 } | |
104 | |
105 // BookmarkTagModelObserver methods. | |
106 | |
107 virtual void Loaded(BookmarkTagModel* model) OVERRIDE { | |
108 // We never load from the db, so that this should never get invoked. | |
109 NOTREACHED(); | |
110 } | |
111 | |
112 // Invoked when a node has been added. | |
113 virtual void BookmarkNodeAdded(BookmarkTagModel* model, | |
114 const BookmarkNode* bookmark) OVERRIDE { | |
115 ++counts_[ADDED_COUNT]; | |
116 observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); | |
117 } | |
118 | |
119 // Invoked before a node is removed. | |
120 // |node| is the node to be removed. | |
121 virtual void OnWillRemoveBookmarks(BookmarkTagModel* model, | |
122 const BookmarkNode* bookmark) OVERRIDE { | |
123 ++counts_[BEFORE_REMOVE_COUNT]; | |
124 } | |
125 | |
126 // Invoked when a node has been removed, the item may still be starred though. | |
127 // |node| is the node that was removed. | |
128 virtual void BookmarkNodeRemoved(BookmarkTagModel* model, | |
129 const BookmarkNode* bookmark) OVERRIDE { | |
130 ++counts_[REMOVE_COUNT]; | |
131 } | |
132 | |
133 // Invoked before the title or url of a node is changed. | |
134 virtual void OnWillChangeBookmarkNode(BookmarkTagModel* model, | |
135 const BookmarkNode* bookmark) OVERRIDE { | |
136 ++counts_[BEFORE_CHANGE_COUNT]; | |
137 } | |
138 | |
139 // Invoked when the title or url of a node changes. | |
140 virtual void BookmarkNodeChanged(BookmarkTagModel* model, | |
141 const BookmarkNode* bookmark) OVERRIDE { | |
142 ++counts_[CHANGE_COUNT]; | |
143 observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); | |
144 }; | |
lpromero-g
2013/10/14 09:18:17
nit: Sometimes there is a semi colon, sometimes no
noyau (Ping after 24h)
2013/10/14 23:59:39
Done.
| |
145 | |
146 virtual void OnWillChangeBookmarkTags(BookmarkTagModel* model, | |
147 const BookmarkNode* bookmark) OVERRIDE { | |
148 ++counts_[BEFORE_TAG_CHANGE_COUNT]; | |
149 } | |
150 | |
151 virtual void BookmarkTagsChanged(BookmarkTagModel* model, | |
152 const BookmarkNode* bookmark) OVERRIDE { | |
153 ++counts_[TAG_CHANGE_COUNT]; | |
154 observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); | |
155 } | |
156 | |
157 virtual void BookmarkNodeFaviconChanged(BookmarkTagModel* model, | |
158 const BookmarkNode* node) OVERRIDE { | |
159 ++counts_[FAVICON_CHANGE_COUNT]; | |
160 }; | |
161 | |
162 virtual void ExtensiveBookmarkChangesBeginning(BookmarkTagModel* model) | |
163 OVERRIDE { | |
164 ++counts_[EXTENSIVE_CHANGE_BEGIN_COUNT]; | |
165 } | |
166 | |
167 virtual void ExtensiveBookmarkChangesEnded(BookmarkTagModel* model) OVERRIDE { | |
168 ++counts_[EXTENSIVE_CHANGE_END_COUNT]; | |
169 } | |
170 | |
171 virtual void OnWillRemoveAllBookmarks(BookmarkTagModel* model) OVERRIDE { | |
172 ++counts_[BEFORE_REMOVE_ALL_COUNT]; | |
173 } | |
174 | |
175 virtual void BookmarkAllNodesRemoved(BookmarkTagModel* model) OVERRIDE { | |
176 ++counts_[REMOVE_ALL_COUNT]; | |
177 }; | |
178 | |
179 void ClearCounts() { | |
180 for (unsigned int i = 0; i < TOTAL_NUMBER_OF_COUNTS; ++i) | |
181 counts_[i] = 0; | |
182 } | |
183 | |
184 void AssertAndClearObserverCount(ObserverCounts count, int expected) { | |
185 ASSERT_EQ(expected, counts_[count]) << count_name[count]; | |
186 counts_[count] = 0; | |
187 } | |
188 | |
189 void AssertAllCountsClear() { | |
190 for (unsigned int i = 0; i < TOTAL_NUMBER_OF_COUNTS; ++i) | |
191 ASSERT_EQ(0, counts_[i]) << count_name[i]; | |
192 } | |
193 | |
194 const BookmarkNode* AddURLWithTags( | |
195 const std::string& name, | |
196 const std::set<BookmarkTag>& tags) { | |
197 const string16 title(ASCIIToUTF16(name)); | |
198 const GURL url("http://" + name + ".com"); | |
199 | |
200 return tag_model_->AddURL(title, url, tags); | |
201 } | |
202 | |
203 protected: | |
204 BookmarkModel model_; | |
205 scoped_ptr<BookmarkTagModel> tag_model_; | |
206 ObserverDetails observer_details_; | |
207 | |
208 private: | |
209 int counts_[TOTAL_NUMBER_OF_COUNTS]; | |
210 | |
211 DISALLOW_COPY_AND_ASSIGN(BookmarkTagModelTest); | |
212 }; | |
213 | |
214 TEST_F(BookmarkTagModelTest, InitialState) { | |
215 std::vector<BookmarkTag> tags(tag_model_->TagsRelatedToTag( | |
216 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
217 EXPECT_EQ(0UL, tags.size()); | |
218 } | |
219 | |
220 TEST_F(BookmarkTagModelTest, AddURL) { | |
221 std::set<BookmarkTag> tags; | |
222 tags.insert(ASCIIToUTF16("bar")); | |
223 tags.insert(ASCIIToUTF16("baz")); | |
224 | |
225 AddURLWithTags("orly", tags); | |
226 const BookmarkNode* new_node = AddURLWithTags("foo", tags); | |
227 AssertAndClearObserverCount(ADDED_COUNT, 2); | |
228 AssertAllCountsClear(); | |
229 | |
230 observer_details_.ExpectEquals(new_node, tags); | |
231 | |
232 EXPECT_EQ(2UL, tag_model_->BookmarksForTag( | |
233 ASCIIToUTF16("bar"), | |
234 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
235 | |
236 EXPECT_EQ(2UL, tag_model_->BookmarksForTag( | |
237 ASCIIToUTF16("baz"), | |
238 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
239 | |
240 EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(new_node)); | |
241 | |
242 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
243 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
244 EXPECT_EQ(2UL, alltags.size()); | |
245 } | |
246 | |
247 TEST_F(BookmarkTagModelTest, RelatedTo) { | |
248 std::set<BookmarkTag> tags; | |
249 tags.insert(ASCIIToUTF16("bar")); | |
250 tags.insert(ASCIIToUTF16("baz")); | |
251 | |
252 AddURLWithTags("orly", tags); | |
253 AddURLWithTags("foo", tags); | |
254 AssertAndClearObserverCount(ADDED_COUNT, 2); | |
255 AssertAllCountsClear(); | |
256 | |
257 std::vector<BookmarkTag> bartags(tag_model_->TagsRelatedToTag( | |
258 ASCIIToUTF16("bar"), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
259 EXPECT_EQ(1UL, bartags.size()); | |
260 std::vector<BookmarkTag> baztags(tag_model_->TagsRelatedToTag( | |
261 ASCIIToUTF16("baz"), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
262 EXPECT_EQ(1UL, baztags.size()); | |
263 } | |
264 | |
265 TEST_F(BookmarkTagModelTest, AddURLWithWhitespaceTitle) { | |
266 std::set<BookmarkTag> tags; | |
267 | |
268 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) { | |
269 const BookmarkNode* new_node = AddURLWithTags( | |
270 whitespace_test_cases[i].input_tag, tags); | |
271 | |
272 EXPECT_EQ(ASCIIToUTF16(whitespace_test_cases[i].expected_tag), | |
273 new_node->GetTitle()); | |
274 EXPECT_EQ(BookmarkNode::URL, new_node->type()); | |
275 } | |
276 } | |
277 | |
278 TEST_F(BookmarkTagModelTest, CheckTagsWithWhitespace) { | |
279 std::set<BookmarkTag> tags; | |
280 | |
281 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) | |
282 tags.insert(ASCIIToUTF16(whitespace_test_cases[i].input_tag)); | |
283 | |
284 AddURLWithTags("foo", tags); | |
285 | |
286 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
287 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
288 | |
289 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) { | |
290 EXPECT_EQ(0UL, tag_model_->BookmarksForTag( | |
291 ASCIIToUTF16(whitespace_test_cases[i].input_tag), | |
292 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
293 EXPECT_EQ(1UL, tag_model_->BookmarksForTag( | |
294 ASCIIToUTF16(whitespace_test_cases[i].expected_tag), | |
295 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
296 } | |
297 } | |
298 | |
299 TEST_F(BookmarkTagModelTest, RemoveURL) { | |
300 std::set<BookmarkTag> tags; | |
301 tags.insert(ASCIIToUTF16("bar")); | |
302 tags.insert(ASCIIToUTF16("baz")); | |
303 | |
304 const BookmarkNode* new_node = AddURLWithTags("foo", tags); | |
305 const BookmarkNode* new_node2 = AddURLWithTags("flou", tags); | |
306 ClearCounts(); | |
307 | |
308 tag_model_->Remove(new_node); | |
309 tag_model_->Remove(new_node2); | |
310 AssertAndClearObserverCount(BEFORE_REMOVE_COUNT, 2); | |
311 AssertAndClearObserverCount(REMOVE_COUNT, 2); | |
312 AssertAllCountsClear(); | |
313 | |
314 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
315 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
316 EXPECT_EQ(0UL, alltags.size()); | |
317 } | |
318 | |
319 TEST_F(BookmarkTagModelTest, AddTagToBookmarks) { | |
320 std::set<BookmarkTag> tags; | |
321 tags.insert(ASCIIToUTF16("bar")); | |
322 tags.insert(ASCIIToUTF16("baz")); | |
323 | |
324 std::set<const BookmarkNode*> bookmarks; | |
325 bookmarks.insert(AddURLWithTags("foo", tags)); | |
326 bookmarks.insert(AddURLWithTags("flou", tags)); | |
327 ClearCounts(); | |
328 | |
329 std::set<BookmarkTag> new_tags; | |
330 new_tags.insert(ASCIIToUTF16("new_bar")); | |
331 new_tags.insert(ASCIIToUTF16("new_baz")); | |
332 | |
333 tag_model_->AddTagsToBookmarks(new_tags, bookmarks); | |
334 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 2); | |
335 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 2); | |
336 AssertAllCountsClear(); | |
337 | |
338 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
339 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
340 EXPECT_EQ(4UL, alltags.size()); | |
341 } | |
342 | |
343 TEST_F(BookmarkTagModelTest, AddTagToBookmark) { | |
344 std::set<BookmarkTag> tags; | |
345 tags.insert(ASCIIToUTF16("bar")); | |
346 tags.insert(ASCIIToUTF16("baz")); | |
347 | |
348 const BookmarkNode* bookmark = AddURLWithTags("foo", tags); | |
349 ClearCounts(); | |
350 | |
351 std::set<BookmarkTag> new_tags; | |
352 new_tags.insert(ASCIIToUTF16("new_bar")); | |
353 new_tags.insert(ASCIIToUTF16("new_baz")); | |
354 | |
355 tag_model_->AddTagsToBookmark(new_tags, bookmark); | |
356 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); | |
357 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); | |
358 AssertAllCountsClear(); | |
359 | |
360 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
361 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
362 EXPECT_EQ(4UL, alltags.size()); | |
363 } | |
364 | |
365 TEST_F(BookmarkTagModelTest, RemoveTagFromBookmarks) { | |
366 std::set<BookmarkTag> tags; | |
367 tags.insert(ASCIIToUTF16("bar")); | |
368 tags.insert(ASCIIToUTF16("baz")); | |
369 | |
370 std::set<const BookmarkNode*> bookmarks; | |
371 | |
372 bookmarks.insert(AddURLWithTags("foo", tags)); | |
373 bookmarks.insert(AddURLWithTags("flou", tags)); | |
374 ClearCounts(); | |
375 | |
376 tag_model_->RemoveTagsFromBookmarks(tags, bookmarks); | |
377 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 2); | |
378 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 2); | |
379 AssertAllCountsClear(); | |
380 | |
381 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
382 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
383 EXPECT_EQ(0UL, alltags.size()); | |
384 } | |
385 | |
386 TEST_F(BookmarkTagModelTest, RemoveTagFromBookmark) { | |
387 std::set<BookmarkTag> tags; | |
388 tags.insert(ASCIIToUTF16("bar")); | |
389 tags.insert(ASCIIToUTF16("baz")); | |
390 | |
391 const BookmarkNode* bookmark = AddURLWithTags("foo", tags); | |
392 ClearCounts(); | |
393 | |
394 tag_model_->RemoveTagsFromBookmark(tags, bookmark); | |
395 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); | |
396 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); | |
397 AssertAllCountsClear(); | |
398 | |
399 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
400 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
401 EXPECT_EQ(0UL, alltags.size()); | |
402 } | |
403 | |
404 TEST_F(BookmarkTagModelTest, RemoveAll) { | |
405 std::set<BookmarkTag> tags; | |
406 tags.insert(ASCIIToUTF16("bar")); | |
407 tags.insert(ASCIIToUTF16("baz")); | |
408 | |
409 AddURLWithTags("foo", tags); | |
410 ClearCounts(); | |
411 | |
412 model_.RemoveAll(); | |
413 AssertAndClearObserverCount(EXTENSIVE_CHANGE_BEGIN_COUNT, 1); | |
414 AssertAndClearObserverCount(BEFORE_REMOVE_ALL_COUNT, 1); | |
415 AssertAndClearObserverCount(REMOVE_ALL_COUNT, 1); | |
416 AssertAndClearObserverCount(EXTENSIVE_CHANGE_END_COUNT, 1); | |
417 AssertAllCountsClear(); | |
418 | |
419 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
420 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
421 EXPECT_EQ(0UL, alltags.size()); | |
422 } | |
423 | |
424 class PreloadedBookmarkTagModelTest : public BookmarkTagModelTest { | |
425 public: | |
426 PreloadedBookmarkTagModelTest() : BookmarkTagModelTest() { | |
427 PopulateUnderlyingModel(); | |
428 } | |
429 | |
430 void PopulateUnderlyingModel() { | |
431 ClearCounts(); | |
432 top_node_ = model_.AddURL(model_.bookmark_bar_node(), 0, | |
433 ASCIIToUTF16("Tagless"), GURL("http://example.com")); | |
434 folder_1_ = model_.AddFolder(model_.bookmark_bar_node(), 0, | |
435 ASCIIToUTF16("folder1")); | |
436 one_tag_ = model_.AddURL(folder_1_, 0, ASCIIToUTF16("OneTag"), | |
437 GURL("http://random.com")); | |
438 folder_2_ = model_.AddFolder(folder_1_, 0, ASCIIToUTF16("folder2")); | |
439 two_tags_ = model_.AddURL(folder_2_, 0, ASCIIToUTF16("TwoTags"), | |
440 GURL("http://moveit.com")); | |
441 AssertAndClearObserverCount(ADDED_COUNT, 3); | |
442 AssertAllCountsClear(); | |
443 } | |
444 | |
445 void AssertModelMatches() { | |
446 EXPECT_EQ(2UL, tag_model_->BookmarksForTag( | |
447 ASCIIToUTF16("folder1"), | |
448 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
449 | |
450 EXPECT_EQ(1UL, tag_model_->BookmarksForTag( | |
451 ASCIIToUTF16("folder2"), | |
452 BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); | |
453 | |
454 std::set<BookmarkTag> tags; | |
455 tags.insert(ASCIIToUTF16("folder1")); | |
456 const BookmarkNode* one_tag = tag_model_-> | |
457 GetMostRecentlyAddedBookmarkForURL(GURL("http://random.com")); | |
458 EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(one_tag)); | |
459 | |
460 tags.insert(ASCIIToUTF16("folder2")); | |
461 const BookmarkNode* two_tags = tag_model_-> | |
462 GetMostRecentlyAddedBookmarkForURL(GURL("http://moveit.com")); | |
463 EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(two_tags)); | |
464 | |
465 std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( | |
466 base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); | |
467 EXPECT_EQ(2UL, alltags.size()); | |
468 } | |
469 | |
470 protected: | |
471 const BookmarkNode* folder_1_; | |
472 const BookmarkNode* folder_2_; | |
473 const BookmarkNode* top_node_; | |
474 const BookmarkNode* one_tag_; | |
475 const BookmarkNode* two_tags_; | |
476 | |
477 DISALLOW_COPY_AND_ASSIGN(PreloadedBookmarkTagModelTest); | |
478 }; | |
479 | |
480 TEST_F(PreloadedBookmarkTagModelTest, InitialState) { | |
481 AssertAllCountsClear(); | |
482 AssertModelMatches(); | |
483 } | |
484 | |
485 TEST_F(PreloadedBookmarkTagModelTest, FromExistingState) { | |
486 tag_model_.reset(new BookmarkTagModel(&model_)); | |
487 tag_model_->AddObserver(this); | |
488 AssertAllCountsClear(); | |
489 AssertModelMatches(); | |
490 } | |
491 | |
492 TEST_F(PreloadedBookmarkTagModelTest, BookmarkChange) { | |
493 AssertAllCountsClear(); | |
494 tag_model_->SetTitle(top_node_, ASCIIToUTF16("newname")); | |
495 AssertAndClearObserverCount(BEFORE_CHANGE_COUNT, 1); | |
496 AssertAndClearObserverCount(CHANGE_COUNT, 1); | |
497 AssertAllCountsClear(); | |
498 } | |
499 | |
500 TEST_F(PreloadedBookmarkTagModelTest, UnchangedBookmarkMove) { | |
501 AssertAllCountsClear(); | |
502 model_.Move(top_node_, folder_2_, 0); | |
503 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); | |
504 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); | |
505 AssertAllCountsClear(); | |
506 } | |
507 | |
508 TEST_F(PreloadedBookmarkTagModelTest, ChangedBookmarkMove) { | |
509 std::set<BookmarkTag> tags; | |
510 tags.insert(ASCIIToUTF16("bar")); | |
511 | |
512 AssertAllCountsClear(); | |
513 tag_model_->AddTagsToBookmark(tags, top_node_); | |
514 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); | |
515 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); | |
516 AssertAllCountsClear(); | |
517 | |
518 model_.Move(top_node_, folder_2_, 0); | |
519 AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 0); | |
520 AssertAndClearObserverCount(TAG_CHANGE_COUNT, 0); | |
521 AssertAllCountsClear(); | |
522 } | |
523 | |
524 TEST_F(PreloadedBookmarkTagModelTest, BoormarkSortTitle) { | |
525 std::vector<const BookmarkNode*> expected; | |
526 expected.push_back(one_tag_); | |
527 expected.push_back(two_tags_); | |
528 | |
529 std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( | |
530 folder_1_->GetTitle(), | |
531 BookmarkTagModel::TITLE_BOOKMARK_ORDERING)); | |
532 | |
533 EXPECT_EQ(expected, bookmarks); | |
534 } | |
535 | |
536 TEST_F(PreloadedBookmarkTagModelTest, BookmarkSortUrl) { | |
537 std::vector<const BookmarkNode*> expected; | |
538 expected.push_back(two_tags_); | |
539 expected.push_back(one_tag_); | |
540 | |
541 std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( | |
542 folder_1_->GetTitle(), | |
543 BookmarkTagModel::URL_BOOKMARK_ORDERING)); | |
544 | |
545 EXPECT_EQ(expected, bookmarks); | |
546 } | |
547 | |
548 TEST_F(PreloadedBookmarkTagModelTest, BookmarkSortCreation) { | |
549 std::vector<const BookmarkNode*> expected; | |
550 expected.push_back(one_tag_); | |
551 expected.push_back(two_tags_); | |
552 | |
553 std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( | |
554 folder_1_->GetTitle(), | |
555 BookmarkTagModel::CREATION_TIME_BOOKMARK_ORDERING)); | |
556 | |
557 EXPECT_EQ(expected, bookmarks); | |
558 } | |
559 | |
560 | |
561 TEST_F(PreloadedBookmarkTagModelTest, TagSort) { | |
562 std::vector<BookmarkTag> expected; | |
563 expected.push_back(folder_1_->GetTitle()); | |
564 expected.push_back(folder_2_->GetTitle()); | |
565 | |
566 std::vector<BookmarkTag> tags(tag_model_->TagsRelatedToTag( | |
567 BookmarkTag(), BookmarkTagModel::ALPHABETICAL_TAG_ORDERING)); | |
568 | |
569 EXPECT_EQ(expected, tags); | |
570 } | |
571 | |
572 } // namespace | |
OLD | NEW |