Store AppItems as pages in AppListModel.

ui/app_list/test/app_list_model_unittest.cc

Index: ui/app_list/test/app_list_model_unittest.cc
diff --git a/ui/app_list/test/app_list_model_unittest.cc b/ui/app_list/test/app_list_model_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7abc879c1771b0c41c13826841c607961958f46c
--- /dev/null
+++ b/ui/app_list/test/app_list_model_unittest.cc
@@ -0,0 +1,223 @@
+// Copyright (c) 2012 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 "ui/app_list/app_list_model.h"
+
+#include <map>
+
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/app_list/app_list_item_model.h"
+#include "ui/app_list/app_list_model_observer.h"
+#include "ui/app_list/test/app_list_test_model.h"
+
+namespace app_list {
+
+namespace {
+
+class TestObserver : public AppListModelObserver {
+ public:
+  TestObserver()
+      : status_changed_count_(0),
+        users_changed_count_(0),
+        signin_changed_count_(0) {
+  }
+  virtual ~TestObserver() {
+  }
+
+  virtual void OnAppListModelStatusChanged() OVERRIDE {
+    ++status_changed_count_;
+  }
+
+  virtual void OnAppListModelUsersChanged() OVERRIDE {
+    ++users_changed_count_;
+  }
+
+  virtual void OnAppListModelSigninStatusChanged() OVERRIDE {
+    ++signin_changed_count_;
+  }
+
+  virtual void OnListItemsAdded(size_t page_index,
+                                size_t start, size_t count) OVERRIDE {
+    items_added_[page_index] += count;
+  }
+
+  virtual void OnListItemsRemoved(size_t page_index,
+                                  size_t start, size_t count) OVERRIDE {
+    items_removed_[page_index] += count;
+  }
+
+  virtual void OnListItemMoved(size_t page_index,
+                               size_t index, size_t target_index) OVERRIDE {
+    items_moved_[page_index]++;
+  }
+
+  int status_changed_count() const { return status_changed_count_; }
+  int users_changed_count() const { return users_changed_count_; }
+  int signin_changed_count() const { return signin_changed_count_; }
+  size_t items_added(int page) { return items_added_[page]; }
+  size_t items_removed(int page) { return items_removed_[page]; }
+  size_t items_moved(int page) { return items_moved_[page]; }
+
+ private:
+  int status_changed_count_;
+  int users_changed_count_;
+  int signin_changed_count_;
+  std::map<size_t, size_t> items_added_;
+  std::map<size_t, size_t> items_removed_;
+  std::map<size_t, size_t> items_moved_;
+  base::MessageLoop message_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestObserver);
+};
+
+}  // namespace
+
+class AppListModelTest : public testing::Test {
+ public:
+  AppListModelTest() {}
+  virtual ~AppListModelTest() {}
+
+  // testing::Test overrides:
+  virtual void SetUp() OVERRIDE {
+    model_.AddObserver(&observer_);
+  }
+  virtual void TearDown() OVERRIDE {
+    model_.RemoveObserver(&observer_);
+  }
+
+ protected:
+  void Run() {
+    base::RunLoop run_loop;

[koz (OOO until 15th September), 2013/10/18 05:17:17]

Why do we need to have a message loop in this test? I thought model changes
propagated synchronously.

[stevenjb, 2013/10/18 22:14:26]

I suppose that's true. I tend to assume that an Observer might be asynchrnous,
but in this case it is not. Removed.

+    run_loop.RunUntilIdle();
+  }
+
+  test::AppListTestModel model_;
+  TestObserver observer_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AppListModelTest);
+};
+
+TEST_F(AppListModelTest, SetStatus) {
+  EXPECT_EQ(AppListModel::STATUS_NORMAL, model_.status());
+  model_.SetStatus(AppListModel::STATUS_SYNCING);
+  Run();
+  EXPECT_EQ(1, observer_.status_changed_count());
+  EXPECT_EQ(AppListModel::STATUS_SYNCING, model_.status());
+  model_.SetStatus(AppListModel::STATUS_NORMAL);
+  Run();
+  EXPECT_EQ(2, observer_.status_changed_count());
+  // Set the same status, no change is expected.
+  model_.SetStatus(AppListModel::STATUS_NORMAL);
+  Run();
+  EXPECT_EQ(2, observer_.status_changed_count());
+}
+
+TEST_F(AppListModelTest, SetUsers) {
+  EXPECT_EQ(0u, model_.users().size());
+  AppListModel::Users users;
+  users.push_back(AppListModel::User());
+  users[0].name = UTF8ToUTF16("test");
+  model_.SetUsers(users);
+  Run();
+  EXPECT_EQ(1, observer_.users_changed_count());
+  ASSERT_EQ(1u, model_.users().size());
+  EXPECT_EQ(UTF8ToUTF16("test"), model_.users()[0].name);
+}
+
+TEST_F(AppListModelTest, SetSignedIn) {
+  EXPECT_TRUE(model_.signed_in());
+  model_.SetSignedIn(false);
+  Run();
+  EXPECT_EQ(1, observer_.signin_changed_count());
+  EXPECT_FALSE(model_.signed_in());
+  model_.SetSignedIn(true);
+  Run();
+  EXPECT_EQ(2, observer_.signin_changed_count());
+  EXPECT_TRUE(model_.signed_in());
+  // Set the same signin state, no change is expected.
+  model_.SetSignedIn(true);
+  Run();
+  EXPECT_EQ(2, observer_.signin_changed_count());
+}
+
+TEST_F(AppListModelTest, ModelOnePage) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage();
+  model_.PopulateApps(num_apps);
+  EXPECT_EQ(1u, model_.GetNumAppPages());
+  EXPECT_EQ(num_apps, model_.GetAppItems(0).item_count());
+  EXPECT_EQ(num_apps, observer_.items_added(0));
+}
+
+TEST_F(AppListModelTest, ModelTwoPages) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage() + 1;
+  model_.PopulateApps(num_apps);
+  ASSERT_EQ(2u, model_.GetNumAppPages());
+  EXPECT_EQ(AppListModel::GetNumAppsPerPage(),
+            model_.GetAppItems(0).item_count());
+  EXPECT_EQ(AppListModel::GetNumAppsPerPage(), observer_.items_added(0));
+  EXPECT_EQ(num_apps - AppListModel::GetNumAppsPerPage(),
+            model_.GetAppItems(1).item_count());
+  EXPECT_EQ(num_apps - AppListModel::GetNumAppsPerPage(),
+            observer_.items_added(1));
+}
+
+TEST_F(AppListModelTest, ModelThreePages) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage() * 3;
+  model_.PopulateApps(num_apps);
+  ASSERT_EQ(3u, model_.GetNumAppPages());
+  EXPECT_EQ(AppListModel::GetNumAppsPerPage(),
+            model_.GetAppItems(2).item_count());
+  EXPECT_EQ(AppListModel::GetNumAppsPerPage(), observer_.items_added(2));
+}
+
+TEST_F(AppListModelTest, ModelFindItem) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage() + 2;
+  model_.PopulateApps(num_apps);
+  // Check finding an item on the first page.
+  std::string item_name = model_.GetItemName(0);
+  AppListItemModel* item = model_.FindItem(item_name);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(item_name, item->id());
+  // Check finding an item on the second page.
+  item_name = model_.GetItemName(AppListModel::GetNumAppsPerPage() + 1);
+  item = model_.FindItem(item_name);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(item_name, item->id());
+}
+
+TEST_F(AppListModelTest, ModelGetItem) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage() + 2;
+  model_.PopulateApps(num_apps);
+  AppListItemModel* item = model_.GetItemAt(0, 0);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(model_.GetItemName(0), item->id());
+  item = model_.GetItemAt(1, 0);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(model_.GetItemName(AppListModel::GetNumAppsPerPage()), item->id());
+}
+
+TEST_F(AppListModelTest, ModelMoveItem) {
+  const size_t num_apps = AppListModel::GetNumAppsPerPage();
+  model_.PopulateApps(num_apps);
+  // Adding another item will add it to the end and create a new page.
+  model_.CreateAndAddItem("Inserted Item");
+  ASSERT_EQ(2u, model_.GetNumAppPages());
+  // Move it to the beginning.
+  model_.MoveItem(1, 0, 0, 0);
+  AppListItemModel* item = model_.GetItemAt(0, 0);
+  ASSERT_TRUE(item);
+  EXPECT_EQ("Inserted Item", item->id());
+  item = model_.GetItemAt(0, 1);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(model_.GetItemName(0), item->id());
+  item = model_.GetItemAt(1, 0);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(model_.GetItemName(num_apps - 1), item->id());
+}
+
+}  // namespace app_list