Experimental bookmark model based on tags.

chrome/browser/bookmarks/bookmark_tag_model_unittest.cc

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..13c1168da4f918c312d8dec5a0bf3d9da3afd69b
--- /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 {
+  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 {
+
+ 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() {
+  }
+
+#pragma mark BookmarkTagModelObserver
+
+  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));
+  };
+
+  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