Index: chrome/browser/bookmarks/bookmark_tag_model_unittest.cc |
diff --git a/chrome/browser/bookmarks/bookmark_tag_model_unittest.cc b/chrome/browser/bookmarks/bookmark_tag_model_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..54a9254306bb856cab59a27078c20e440ccdcb97 |
--- /dev/null |
+++ b/chrome/browser/bookmarks/bookmark_tag_model_unittest.cc |
@@ -0,0 +1,572 @@ |
+// Copyright (c) 2013 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "chrome/browser/bookmarks/bookmark_tag_model.h" |
+ |
+#include "base/strings/utf_string_conversions.h" |
+#include "chrome/browser/bookmarks/bookmark_tag_model_observer.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+ |
+namespace { |
+ |
+static struct { |
+ const std::string input_tag; |
+ const std::string expected_tag; |
+} whitespace_test_cases[] = { |
+ // Newlines. |
+ {"foo\nbar", "foo bar"}, |
+ {"foo\n\nbar", "foo bar"}, |
+ {"foo\n\n\nbar", "foo bar"}, |
+ {"foo\r\nbar", "foo bar"}, |
+ {"foo\r\n\r\nbar", "foo bar"}, |
+ {"\nfoo\nbar\n", "foo bar"}, |
+ // Spaces. |
+ {"foo bar", "foo bar"}, |
+ {" foo bar ", "foo bar"}, |
+ {" foo bar ", "foo bar"}, |
+ // Tabs. |
+ {"\tfoo\tbar\t", "foo bar"}, |
+ {"\tfoo bar\t", "foo bar"}, |
+ // Mixed cases. |
+ {"\tfoo\nbar\t", "foo bar"}, |
+ {"\tfoo\r\nbar\t", "foo bar"}, |
+ {" foo\tbar\n", "foo bar"}, |
+ {"\t foo \t bar \t", "foo bar"}, |
+ {"\n foo\r\n\tbar\n \t", "foo bar"}, |
+}; |
+ |
+enum ObserverCounts { |
sky
2013/10/11 21:57:41
Same nit about naming.
noyau (Ping after 24h)
2013/10/14 23:59:39
Done.
|
+ ADDED_COUNT = 0, |
+ BEFORE_REMOVE_COUNT, |
+ REMOVE_COUNT, |
+ BEFORE_CHANGE_COUNT, |
+ CHANGE_COUNT, |
+ BEFORE_TAG_CHANGE_COUNT, |
+ TAG_CHANGE_COUNT, |
+ FAVICON_CHANGE_COUNT, |
+ EXTENSIVE_CHANGE_BEGIN_COUNT, |
+ EXTENSIVE_CHANGE_END_COUNT, |
+ BEFORE_REMOVE_ALL_COUNT, |
+ REMOVE_ALL_COUNT, |
+ TOTAL_NUMBER_OF_COUNTS |
+}; |
+ |
+const std::string count_name[] = { |
+ "ADDED_COUNT", |
+ "BEFORE_REMOVE_COUNT", |
+ "REMOVE_COUNT", |
+ "BEFORE_CHANGE_COUNT", |
+ "CHANGE_COUNT", |
+ "BEFORE_TAG_CHANGE_COUNT", |
+ "TAG_CHANGE_COUNT", |
+ "FAVICON_CHANGE_COUNT", |
+ "EXTENSIVE_CHANGE_BEGIN_COUNT", |
+ "EXTENSIVE_CHANGE_END_COUNT", |
+ "BEFORE_REMOVE_ALL_COUNT", |
+ "REMOVE_ALL_COUNT" |
+}; |
+ |
+ |
+class BookmarkTagModelTest |
+ : public testing::Test, public BookmarkTagModelObserver { |
+ |
sky
2013/10/11 21:57:41
nit: no newline here.
noyau (Ping after 24h)
2013/10/14 23:59:39
Done.
|
+ public: |
+ struct ObserverDetails { |
+ ObserverDetails() : bookmark_(NULL) {} |
+ |
+ void Set(const BookmarkNode* bookmark, |
+ const std::set<BookmarkTag>& tags) { |
+ bookmark_ = bookmark; |
+ tags_ = tags; |
+ } |
+ |
+ void ExpectEquals(const BookmarkNode* bookmark, |
+ const std::set<BookmarkTag>& tags) { |
+ EXPECT_EQ(bookmark_, bookmark); |
+ EXPECT_EQ(tags_, tags); |
+ } |
+ |
+ private: |
+ const BookmarkNode* bookmark_; |
+ std::set<BookmarkTag> tags_; |
+ }; |
+ |
+ BookmarkTagModelTest() : model_(NULL), |
+ tag_model_(new BookmarkTagModel(&model_)) { |
+ tag_model_->AddObserver(this); |
+ ClearCounts(); |
+ } |
+ |
+ virtual ~BookmarkTagModelTest() { |
+ } |
+ |
+ // BookmarkTagModelObserver methods. |
+ |
+ virtual void Loaded(BookmarkTagModel* model) OVERRIDE { |
+ // We never load from the db, so that this should never get invoked. |
+ NOTREACHED(); |
+ } |
+ |
+ // Invoked when a node has been added. |
+ virtual void BookmarkNodeAdded(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[ADDED_COUNT]; |
+ observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); |
+ } |
+ |
+ // Invoked before a node is removed. |
+ // |node| is the node to be removed. |
+ virtual void OnWillRemoveBookmarks(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[BEFORE_REMOVE_COUNT]; |
+ } |
+ |
+ // Invoked when a node has been removed, the item may still be starred though. |
+ // |node| is the node that was removed. |
+ virtual void BookmarkNodeRemoved(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[REMOVE_COUNT]; |
+ } |
+ |
+ // Invoked before the title or url of a node is changed. |
+ virtual void OnWillChangeBookmarkNode(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[BEFORE_CHANGE_COUNT]; |
+ } |
+ |
+ // Invoked when the title or url of a node changes. |
+ virtual void BookmarkNodeChanged(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[CHANGE_COUNT]; |
+ observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); |
+ }; |
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.
|
+ |
+ virtual void OnWillChangeBookmarkTags(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[BEFORE_TAG_CHANGE_COUNT]; |
+ } |
+ |
+ virtual void BookmarkTagsChanged(BookmarkTagModel* model, |
+ const BookmarkNode* bookmark) OVERRIDE { |
+ ++counts_[TAG_CHANGE_COUNT]; |
+ observer_details_.Set(bookmark, model->AllTagsForBookmark(bookmark)); |
+ } |
+ |
+ virtual void BookmarkNodeFaviconChanged(BookmarkTagModel* model, |
+ const BookmarkNode* node) OVERRIDE { |
+ ++counts_[FAVICON_CHANGE_COUNT]; |
+ }; |
+ |
+ virtual void ExtensiveBookmarkChangesBeginning(BookmarkTagModel* model) |
+ OVERRIDE { |
+ ++counts_[EXTENSIVE_CHANGE_BEGIN_COUNT]; |
+ } |
+ |
+ virtual void ExtensiveBookmarkChangesEnded(BookmarkTagModel* model) OVERRIDE { |
+ ++counts_[EXTENSIVE_CHANGE_END_COUNT]; |
+ } |
+ |
+ virtual void OnWillRemoveAllBookmarks(BookmarkTagModel* model) OVERRIDE { |
+ ++counts_[BEFORE_REMOVE_ALL_COUNT]; |
+ } |
+ |
+ virtual void BookmarkAllNodesRemoved(BookmarkTagModel* model) OVERRIDE { |
+ ++counts_[REMOVE_ALL_COUNT]; |
+ }; |
+ |
+ void ClearCounts() { |
+ for (unsigned int i = 0; i < TOTAL_NUMBER_OF_COUNTS; ++i) |
+ counts_[i] = 0; |
+ } |
+ |
+ void AssertAndClearObserverCount(ObserverCounts count, int expected) { |
+ ASSERT_EQ(expected, counts_[count]) << count_name[count]; |
+ counts_[count] = 0; |
+ } |
+ |
+ void AssertAllCountsClear() { |
+ for (unsigned int i = 0; i < TOTAL_NUMBER_OF_COUNTS; ++i) |
+ ASSERT_EQ(0, counts_[i]) << count_name[i]; |
+ } |
+ |
+ const BookmarkNode* AddURLWithTags( |
+ const std::string& name, |
+ const std::set<BookmarkTag>& tags) { |
+ const string16 title(ASCIIToUTF16(name)); |
+ const GURL url("http://" + name + ".com"); |
+ |
+ return tag_model_->AddURL(title, url, tags); |
+ } |
+ |
+ protected: |
+ BookmarkModel model_; |
+ scoped_ptr<BookmarkTagModel> tag_model_; |
+ ObserverDetails observer_details_; |
+ |
+ private: |
+ int counts_[TOTAL_NUMBER_OF_COUNTS]; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BookmarkTagModelTest); |
+}; |
+ |
+TEST_F(BookmarkTagModelTest, InitialState) { |
+ std::vector<BookmarkTag> tags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(0UL, tags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, AddURL) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ AddURLWithTags("orly", tags); |
+ const BookmarkNode* new_node = AddURLWithTags("foo", tags); |
+ AssertAndClearObserverCount(ADDED_COUNT, 2); |
+ AssertAllCountsClear(); |
+ |
+ observer_details_.ExpectEquals(new_node, tags); |
+ |
+ EXPECT_EQ(2UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16("bar"), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ |
+ EXPECT_EQ(2UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16("baz"), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ |
+ EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(new_node)); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(2UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, RelatedTo) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ AddURLWithTags("orly", tags); |
+ AddURLWithTags("foo", tags); |
+ AssertAndClearObserverCount(ADDED_COUNT, 2); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> bartags(tag_model_->TagsRelatedToTag( |
+ ASCIIToUTF16("bar"), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(1UL, bartags.size()); |
+ std::vector<BookmarkTag> baztags(tag_model_->TagsRelatedToTag( |
+ ASCIIToUTF16("baz"), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(1UL, baztags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, AddURLWithWhitespaceTitle) { |
+ std::set<BookmarkTag> tags; |
+ |
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) { |
+ const BookmarkNode* new_node = AddURLWithTags( |
+ whitespace_test_cases[i].input_tag, tags); |
+ |
+ EXPECT_EQ(ASCIIToUTF16(whitespace_test_cases[i].expected_tag), |
+ new_node->GetTitle()); |
+ EXPECT_EQ(BookmarkNode::URL, new_node->type()); |
+ } |
+} |
+ |
+TEST_F(BookmarkTagModelTest, CheckTagsWithWhitespace) { |
+ std::set<BookmarkTag> tags; |
+ |
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) |
+ tags.insert(ASCIIToUTF16(whitespace_test_cases[i].input_tag)); |
+ |
+ AddURLWithTags("foo", tags); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ |
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) { |
+ EXPECT_EQ(0UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16(whitespace_test_cases[i].input_tag), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ EXPECT_EQ(1UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16(whitespace_test_cases[i].expected_tag), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ } |
+} |
+ |
+TEST_F(BookmarkTagModelTest, RemoveURL) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ const BookmarkNode* new_node = AddURLWithTags("foo", tags); |
+ const BookmarkNode* new_node2 = AddURLWithTags("flou", tags); |
+ ClearCounts(); |
+ |
+ tag_model_->Remove(new_node); |
+ tag_model_->Remove(new_node2); |
+ AssertAndClearObserverCount(BEFORE_REMOVE_COUNT, 2); |
+ AssertAndClearObserverCount(REMOVE_COUNT, 2); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(0UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, AddTagToBookmarks) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ std::set<const BookmarkNode*> bookmarks; |
+ bookmarks.insert(AddURLWithTags("foo", tags)); |
+ bookmarks.insert(AddURLWithTags("flou", tags)); |
+ ClearCounts(); |
+ |
+ std::set<BookmarkTag> new_tags; |
+ new_tags.insert(ASCIIToUTF16("new_bar")); |
+ new_tags.insert(ASCIIToUTF16("new_baz")); |
+ |
+ tag_model_->AddTagsToBookmarks(new_tags, bookmarks); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 2); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 2); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(4UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, AddTagToBookmark) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ const BookmarkNode* bookmark = AddURLWithTags("foo", tags); |
+ ClearCounts(); |
+ |
+ std::set<BookmarkTag> new_tags; |
+ new_tags.insert(ASCIIToUTF16("new_bar")); |
+ new_tags.insert(ASCIIToUTF16("new_baz")); |
+ |
+ tag_model_->AddTagsToBookmark(new_tags, bookmark); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(4UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, RemoveTagFromBookmarks) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ std::set<const BookmarkNode*> bookmarks; |
+ |
+ bookmarks.insert(AddURLWithTags("foo", tags)); |
+ bookmarks.insert(AddURLWithTags("flou", tags)); |
+ ClearCounts(); |
+ |
+ tag_model_->RemoveTagsFromBookmarks(tags, bookmarks); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 2); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 2); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(0UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, RemoveTagFromBookmark) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ const BookmarkNode* bookmark = AddURLWithTags("foo", tags); |
+ ClearCounts(); |
+ |
+ tag_model_->RemoveTagsFromBookmark(tags, bookmark); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(0UL, alltags.size()); |
+} |
+ |
+TEST_F(BookmarkTagModelTest, RemoveAll) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ tags.insert(ASCIIToUTF16("baz")); |
+ |
+ AddURLWithTags("foo", tags); |
+ ClearCounts(); |
+ |
+ model_.RemoveAll(); |
+ AssertAndClearObserverCount(EXTENSIVE_CHANGE_BEGIN_COUNT, 1); |
+ AssertAndClearObserverCount(BEFORE_REMOVE_ALL_COUNT, 1); |
+ AssertAndClearObserverCount(REMOVE_ALL_COUNT, 1); |
+ AssertAndClearObserverCount(EXTENSIVE_CHANGE_END_COUNT, 1); |
+ AssertAllCountsClear(); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(0UL, alltags.size()); |
+} |
+ |
+class PreloadedBookmarkTagModelTest : public BookmarkTagModelTest { |
+ public: |
+ PreloadedBookmarkTagModelTest() : BookmarkTagModelTest() { |
+ PopulateUnderlyingModel(); |
+ } |
+ |
+ void PopulateUnderlyingModel() { |
+ ClearCounts(); |
+ top_node_ = model_.AddURL(model_.bookmark_bar_node(), 0, |
+ ASCIIToUTF16("Tagless"), GURL("http://example.com")); |
+ folder_1_ = model_.AddFolder(model_.bookmark_bar_node(), 0, |
+ ASCIIToUTF16("folder1")); |
+ one_tag_ = model_.AddURL(folder_1_, 0, ASCIIToUTF16("OneTag"), |
+ GURL("http://random.com")); |
+ folder_2_ = model_.AddFolder(folder_1_, 0, ASCIIToUTF16("folder2")); |
+ two_tags_ = model_.AddURL(folder_2_, 0, ASCIIToUTF16("TwoTags"), |
+ GURL("http://moveit.com")); |
+ AssertAndClearObserverCount(ADDED_COUNT, 3); |
+ AssertAllCountsClear(); |
+ } |
+ |
+ void AssertModelMatches() { |
+ EXPECT_EQ(2UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16("folder1"), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ |
+ EXPECT_EQ(1UL, tag_model_->BookmarksForTag( |
+ ASCIIToUTF16("folder2"), |
+ BookmarkTagModel::UNSORTED_BOOKMARK_ORDERING).size()); |
+ |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("folder1")); |
+ const BookmarkNode* one_tag = tag_model_-> |
+ GetMostRecentlyAddedBookmarkForURL(GURL("http://random.com")); |
+ EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(one_tag)); |
+ |
+ tags.insert(ASCIIToUTF16("folder2")); |
+ const BookmarkNode* two_tags = tag_model_-> |
+ GetMostRecentlyAddedBookmarkForURL(GURL("http://moveit.com")); |
+ EXPECT_EQ(tags, tag_model_->AllTagsForBookmark(two_tags)); |
+ |
+ std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag( |
+ base::string16(), BookmarkTagModel::UNSORTED_TAG_ORDERING)); |
+ EXPECT_EQ(2UL, alltags.size()); |
+ } |
+ |
+ protected: |
+ const BookmarkNode* folder_1_; |
+ const BookmarkNode* folder_2_; |
+ const BookmarkNode* top_node_; |
+ const BookmarkNode* one_tag_; |
+ const BookmarkNode* two_tags_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(PreloadedBookmarkTagModelTest); |
+}; |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, InitialState) { |
+ AssertAllCountsClear(); |
+ AssertModelMatches(); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, FromExistingState) { |
+ tag_model_.reset(new BookmarkTagModel(&model_)); |
+ tag_model_->AddObserver(this); |
+ AssertAllCountsClear(); |
+ AssertModelMatches(); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, BookmarkChange) { |
+ AssertAllCountsClear(); |
+ tag_model_->SetTitle(top_node_, ASCIIToUTF16("newname")); |
+ AssertAndClearObserverCount(BEFORE_CHANGE_COUNT, 1); |
+ AssertAndClearObserverCount(CHANGE_COUNT, 1); |
+ AssertAllCountsClear(); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, UnchangedBookmarkMove) { |
+ AssertAllCountsClear(); |
+ model_.Move(top_node_, folder_2_, 0); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); |
+ AssertAllCountsClear(); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, ChangedBookmarkMove) { |
+ std::set<BookmarkTag> tags; |
+ tags.insert(ASCIIToUTF16("bar")); |
+ |
+ AssertAllCountsClear(); |
+ tag_model_->AddTagsToBookmark(tags, top_node_); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 1); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 1); |
+ AssertAllCountsClear(); |
+ |
+ model_.Move(top_node_, folder_2_, 0); |
+ AssertAndClearObserverCount(BEFORE_TAG_CHANGE_COUNT, 0); |
+ AssertAndClearObserverCount(TAG_CHANGE_COUNT, 0); |
+ AssertAllCountsClear(); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, BoormarkSortTitle) { |
+ std::vector<const BookmarkNode*> expected; |
+ expected.push_back(one_tag_); |
+ expected.push_back(two_tags_); |
+ |
+ std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( |
+ folder_1_->GetTitle(), |
+ BookmarkTagModel::TITLE_BOOKMARK_ORDERING)); |
+ |
+ EXPECT_EQ(expected, bookmarks); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, BookmarkSortUrl) { |
+ std::vector<const BookmarkNode*> expected; |
+ expected.push_back(two_tags_); |
+ expected.push_back(one_tag_); |
+ |
+ std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( |
+ folder_1_->GetTitle(), |
+ BookmarkTagModel::URL_BOOKMARK_ORDERING)); |
+ |
+ EXPECT_EQ(expected, bookmarks); |
+} |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, BookmarkSortCreation) { |
+ std::vector<const BookmarkNode*> expected; |
+ expected.push_back(one_tag_); |
+ expected.push_back(two_tags_); |
+ |
+ std::vector<const BookmarkNode*> bookmarks(tag_model_->BookmarksForTag( |
+ folder_1_->GetTitle(), |
+ BookmarkTagModel::CREATION_TIME_BOOKMARK_ORDERING)); |
+ |
+ EXPECT_EQ(expected, bookmarks); |
+} |
+ |
+ |
+TEST_F(PreloadedBookmarkTagModelTest, TagSort) { |
+ std::vector<BookmarkTag> expected; |
+ expected.push_back(folder_1_->GetTitle()); |
+ expected.push_back(folder_2_->GetTitle()); |
+ |
+ std::vector<BookmarkTag> tags(tag_model_->TagsRelatedToTag( |
+ BookmarkTag(), BookmarkTagModel::ALPHABETICAL_TAG_ORDERING)); |
+ |
+ EXPECT_EQ(expected, tags); |
+} |
+ |
+} // namespace |