ui/message_center/views/message_center_view_unittest.cc

   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 <map>
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/utf_string_conversions.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "ui/message_center/notification.h"
  12 #include "ui/message_center/notification_change_observer.h"
  13 #include "ui/message_center/notification_list.h"
  14 #include "ui/message_center/notification_types.h"
  15 #include "ui/message_center/views/message_center_view.h"
  16 #include "ui/message_center/views/notification_view.h"
  17
  18 namespace message_center {
  19
  20 /* Types **********************************************************************/
  21
  22 enum CallType {
  23   GET_PREFERRED_SIZE,
  24   GET_HEIGHT_FOR_WIDTH,
  25   LAYOUT
  26 };
  27
  28 /* Dummy NotificationChangeObserver *******************************************/
  29
  30 class DummyObserver : public NotificationChangeObserver {
  31  public:
  32   DummyObserver();
  33   virtual ~DummyObserver();
  34
  35  private:
  36   DISALLOW_COPY_AND_ASSIGN(DummyObserver);
  37 };
  38
  39 DummyObserver::DummyObserver() {
  40 }
  41
  42 DummyObserver::~DummyObserver() {
  43 }
  44
  45 /* Instrumented/Mock NotificationView subclass ********************************/
  46
  47 class MockNotificationView : public NotificationView {
  48  public:
  49   class Test {
  50    public:
  51     virtual void RegisterCall(int receiver_id, CallType type) = 0;
  52   };
  53
  54   explicit MockNotificationView(const Notification& notification,
  55                                 NotificationChangeObserver* observer,
  56                                 Test* test,
  57                                 int view_id);
  58   virtual ~MockNotificationView();
  59
  60   virtual gfx::Size GetPreferredSize();
  61   virtual int GetHeightForWidth(int w);
  62   virtual void Layout();
  63
  64   int get_id() { return id_; };
  65
  66  private:
  67   void RegisterCall(CallType type);
  68
  69   Test* test_;
  70   int id_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(MockNotificationView);
  73 };
  74
  75 MockNotificationView::MockNotificationView(const Notification& notification,
  76                                            NotificationChangeObserver* observer,
  77                                            Test* test,
  78                                            int view_id)
  79     : NotificationView(notification, observer, true),
  80       test_(test),
  81       id_(view_id) {
  82 }
  83
  84 MockNotificationView::~MockNotificationView() {
  85 }
  86
  87 gfx::Size MockNotificationView::GetPreferredSize() {
  88   RegisterCall(GET_PREFERRED_SIZE);
  89   return child_count() ? NotificationView::GetPreferredSize() :
  90                          gfx::Size(id_, id_);
  91 }
  92
  93 int MockNotificationView::GetHeightForWidth(int width) {
  94   RegisterCall(GET_HEIGHT_FOR_WIDTH);
  95   return child_count() ? NotificationView::GetHeightForWidth(width) : (id_);
  96 }
  97
  98 void MockNotificationView::Layout() {
  99   RegisterCall(LAYOUT);
 100   if (child_count())
 101     NotificationView::Layout();
 102 }
 103
 104 void MockNotificationView::RegisterCall(CallType type) {
 105   if (test_)
 106     test_->RegisterCall(id_, type);
 107 }
 108
 109 /* Test fixture ***************************************************************/
 110
 111 class MessageCenterViewTest : public testing::Test,
 112                               public MockNotificationView::Test {
 113  public:
 114   MessageCenterViewTest();
 115   virtual ~MessageCenterViewTest();
 116
 117   virtual void SetUp() OVERRIDE;
 118
 119   MessageCenterView* GetMessageCenterView();
 120   int GetNotificationCount();
 121   int GetCallCount(CallType type);
 122
 123   void RegisterCall(int receiver_id, CallType type);
 124
 125   void LogBounds(int depth, views::View* view);
 126
 127  private:
 128   views::View* MakeParent(views::View* child1, views::View* child2);
 129
 130
 131   scoped_ptr<MessageCenterView> message_center_view_;
 132   DummyObserver observer;
 133   std::map<CallType,int> callCounts_;
 134
 135   DISALLOW_COPY_AND_ASSIGN(MessageCenterViewTest);
 136 };
 137
 138 MessageCenterViewTest::MessageCenterViewTest() {
 139 }
 140
 141 MessageCenterViewTest::~MessageCenterViewTest() {
 142 }
 143
 144 void MessageCenterViewTest::SetUp() {
 145   // Create a dummy notification.
 146   Notification notification(
 147         NOTIFICATION_TYPE_SIMPLE,
 148         std::string("notification id"),
 149         UTF8ToUTF16("title"),
 150         UTF8ToUTF16("message"),
 151         UTF8ToUTF16("display source"),
 152         std::string("extension id"),
 153         NULL);
 154
 155   // ...and a list for it.
 156   NotificationList::Notifications notifications;
 157   notifications.insert(&notification);
 158
 159   // Then create a new MessageCenterView with that single notification.
 160   message_center_view_.reset(new MessageCenterView(&observer, 100));
 161   message_center_view_->SetNotifications(notifications);
 162
 163   // Remove and delete the NotificationView now owned by the MessageCenterView's
 164   // MessageListView and replace it with an instrumented MockNotificationView
 165   // that will become owned by the MessageListView.
 166   MockNotificationView* mock;
 167   mock = new MockNotificationView(notification, &observer, this, 42);
 168   message_center_view_->message_views_[notification.id()] = mock;
 169   message_center_view_->message_list_view_->RemoveAllChildViews(true);
 170   message_center_view_->message_list_view_->AddChildView(mock);
 171 }
 172
 173 MessageCenterView* MessageCenterViewTest::GetMessageCenterView() {
 174   return message_center_view_.get();
 175 }
 176
 177 int MessageCenterViewTest::GetNotificationCount() {
 178   return 1;
 179 }
 180
 181 int MessageCenterViewTest::GetCallCount(CallType type) {
 182   return callCounts_[type];
 183 }
 184
 185 void MessageCenterViewTest::RegisterCall(int receiver_id, CallType type) {
 186   callCounts_[type] += 1;
 187 }
 188
 189 void MessageCenterViewTest::LogBounds(int depth, views::View* view) {
 190   string16 inset;
 191   for (int i = 0; i < depth; ++i)
 192     inset.append(UTF8ToUTF16("  "));
 193   gfx::Rect bounds = view->bounds();
 194   DVLOG(0) << inset << bounds.width() << " x " << bounds.height()
 195            << " @ " << bounds.x() << ", " << bounds.y();
 196   for (int i = 0; i < view->child_count(); ++i)
 197     LogBounds(depth + 1, view->child_at(i));
 198 }
 199
 200 /* Unit tests *****************************************************************/
 201
 202 TEST_F(MessageCenterViewTest, CallTest) {
 203   // Exercise (with size values that just need to be large enough).
 204   GetMessageCenterView()->SetBounds(0, 0, 100, 100);
 205
 206   // Verify that this didn't generate more than 1 Layout() call per descendant
 207   // NotificationView or more than a total of 14 GetPreferredSize() and
 208   // GetHeightForWidth() calls per descendant NotificationView. 14 is a very
 209   // large number corresponding to the current reality. That number will be
 210   // ratcheted down over time as the code improves.
 211   EXPECT_LE(GetCallCount(LAYOUT), GetNotificationCount());
 212   EXPECT_LE(GetCallCount(GET_PREFERRED_SIZE) +
 213             GetCallCount(GET_HEIGHT_FOR_WIDTH),
 214             GetNotificationCount() * 14);
 215 }
 216
 217 }  // namespace message_center