src/mojo/services/public/cpp/view_manager/tests/view_tree_node_unittest.cc

   1 // Copyright 2014 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 "mojo/services/public/cpp/view_manager/view_tree_node.h"
   6
   7 #include "base/logging.h"
   8 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
   9 #include "mojo/services/public/cpp/view_manager/view_tree_node_observer.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace mojo {
  13 namespace services {
  14 namespace view_manager {
  15
  16 // ViewTreeNode ----------------------------------------------------------------
  17
  18 typedef testing::Test ViewTreeNodeTest;
  19
  20 // Subclass with public ctor/dtor.
  21 class TestViewTreeNode : public ViewTreeNode {
  22  public:
  23   TestViewTreeNode() {}
  24   ~TestViewTreeNode() {}
  25
  26  private:
  27   DISALLOW_COPY_AND_ASSIGN(TestViewTreeNode);
  28 };
  29
  30 TEST_F(ViewTreeNodeTest, AddChild) {
  31   TestViewTreeNode v1;
  32   TestViewTreeNode v11;
  33   v1.AddChild(&v11);
  34   EXPECT_EQ(1U, v1.children().size());
  35 }
  36
  37 TEST_F(ViewTreeNodeTest, RemoveChild) {
  38   TestViewTreeNode v1;
  39   TestViewTreeNode v11;
  40   v1.AddChild(&v11);
  41   EXPECT_EQ(1U, v1.children().size());
  42   v1.RemoveChild(&v11);
  43   EXPECT_EQ(0U, v1.children().size());
  44 }
  45
  46 TEST_F(ViewTreeNodeTest, Reparent) {
  47   TestViewTreeNode v1;
  48   TestViewTreeNode v2;
  49   TestViewTreeNode v11;
  50   v1.AddChild(&v11);
  51   EXPECT_EQ(1U, v1.children().size());
  52   v2.AddChild(&v11);
  53   EXPECT_EQ(1U, v2.children().size());
  54   EXPECT_EQ(0U, v1.children().size());
  55 }
  56
  57 TEST_F(ViewTreeNodeTest, Contains) {
  58   TestViewTreeNode v1;
  59
  60   // Direct descendant.
  61   TestViewTreeNode v11;
  62   v1.AddChild(&v11);
  63   EXPECT_TRUE(v1.Contains(&v11));
  64
  65   // Indirect descendant.
  66   TestViewTreeNode v111;
  67   v11.AddChild(&v111);
  68   EXPECT_TRUE(v1.Contains(&v111));
  69 }
  70
  71 TEST_F(ViewTreeNodeTest, GetChildById) {
  72   TestViewTreeNode v1;
  73   ViewTreeNodePrivate(&v1).set_id(1);
  74   TestViewTreeNode v11;
  75   ViewTreeNodePrivate(&v11).set_id(11);
  76   v1.AddChild(&v11);
  77   TestViewTreeNode v111;
  78   ViewTreeNodePrivate(&v111).set_id(111);
  79   v11.AddChild(&v111);
  80
  81   // Find direct & indirect descendents.
  82   EXPECT_EQ(&v11, v1.GetChildById(v11.id()));
  83   EXPECT_EQ(&v111, v1.GetChildById(v111.id()));
  84 }
  85
  86 // ViewTreeNodeObserver --------------------------------------------------------
  87
  88 typedef testing::Test ViewTreeNodeObserverTest;
  89
  90 bool TreeChangeParamsMatch(const ViewTreeNodeObserver::TreeChangeParams& lhs,
  91                            const ViewTreeNodeObserver::TreeChangeParams& rhs) {
  92   return lhs.target == rhs.target &&  lhs.old_parent == rhs.old_parent &&
  93       lhs.new_parent == rhs.new_parent && lhs.receiver == rhs.receiver &&
  94       lhs.phase == rhs.phase;
  95 }
  96
  97 class TreeChangeObserver : public ViewTreeNodeObserver {
  98  public:
  99   explicit TreeChangeObserver(ViewTreeNode* observee) : observee_(observee) {
 100     observee_->AddObserver(this);
 101   }
 102   virtual ~TreeChangeObserver() {
 103     observee_->RemoveObserver(this);
 104   }
 105
 106   void Reset() {
 107     received_params_.clear();
 108   }
 109
 110   const std::vector<TreeChangeParams>& received_params() {
 111     return received_params_;
 112   }
 113
 114  private:
 115   // Overridden from ViewTreeNodeObserver:
 116   virtual void OnTreeChange(const TreeChangeParams& params) OVERRIDE {
 117     received_params_.push_back(params);
 118   }
 119
 120   ViewTreeNode* observee_;
 121   std::vector<TreeChangeParams> received_params_;
 122
 123   DISALLOW_COPY_AND_ASSIGN(TreeChangeObserver);
 124 };
 125
 126 // Adds/Removes v11 to v1.
 127 TEST_F(ViewTreeNodeObserverTest, TreeChange_SimpleAddRemove) {
 128   TestViewTreeNode v1;
 129   TreeChangeObserver o1(&v1);
 130   EXPECT_TRUE(o1.received_params().empty());
 131
 132   TestViewTreeNode v11;
 133   TreeChangeObserver o11(&v11);
 134   EXPECT_TRUE(o11.received_params().empty());
 135
 136   // Add.
 137
 138   v1.AddChild(&v11);
 139
 140   EXPECT_EQ(1U, o1.received_params().size());
 141   ViewTreeNodeObserver::TreeChangeParams p1;
 142   p1.target = &v11;
 143   p1.receiver = &v1;
 144   p1.old_parent = NULL;
 145   p1.new_parent = &v1;
 146   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 147   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back()));
 148
 149   EXPECT_EQ(2U, o11.received_params().size());
 150   ViewTreeNodeObserver::TreeChangeParams p11 = p1;
 151   p11.receiver = &v11;
 152   p11.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 153   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front()));
 154   p11.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 155   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back()));
 156
 157   o1.Reset();
 158   o11.Reset();
 159   EXPECT_TRUE(o1.received_params().empty());
 160   EXPECT_TRUE(o11.received_params().empty());
 161
 162   // Remove.
 163
 164   v1.RemoveChild(&v11);
 165
 166   EXPECT_EQ(1U, o1.received_params().size());
 167   p1.target = &v11;
 168   p1.receiver = &v1;
 169   p1.old_parent = &v1;
 170   p1.new_parent = NULL;
 171   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 172   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back()));
 173
 174   EXPECT_EQ(2U, o11.received_params().size());
 175   p11 = p1;
 176   p11.receiver = &v11;
 177   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front()));
 178   p11.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 179   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back()));
 180 }
 181
 182 // Creates these two trees:
 183 // v1
 184 //  +- v11
 185 // v111
 186 //  +- v1111
 187 //  +- v1112
 188 // Then adds/removes v111 from v11.
 189 TEST_F(ViewTreeNodeObserverTest, TreeChange_NestedAddRemove) {
 190   TestViewTreeNode v1, v11, v111, v1111, v1112;
 191
 192   // Root tree.
 193   v1.AddChild(&v11);
 194
 195   // Tree to be attached.
 196   v111.AddChild(&v1111);
 197   v111.AddChild(&v1112);
 198
 199   TreeChangeObserver o1(&v1), o11(&v11), o111(&v111), o1111(&v1111),
 200       o1112(&v1112);
 201   ViewTreeNodeObserver::TreeChangeParams p1, p11, p111, p1111, p1112;
 202
 203   // Add.
 204
 205   v11.AddChild(&v111);
 206
 207   EXPECT_EQ(1U, o1.received_params().size());
 208   p1.target = &v111;
 209   p1.receiver = &v1;
 210   p1.old_parent = NULL;
 211   p1.new_parent = &v11;
 212   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 213   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back()));
 214
 215   EXPECT_EQ(1U, o11.received_params().size());
 216   p11 = p1;
 217   p11.receiver = &v11;
 218   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back()));
 219
 220   EXPECT_EQ(2U, o111.received_params().size());
 221   p111 = p11;
 222   p111.receiver = &v111;
 223   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 224   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front()));
 225   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 226   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back()));
 227
 228   EXPECT_EQ(2U, o1111.received_params().size());
 229   p1111 = p111;
 230   p1111.receiver = &v1111;
 231   p1111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 232   EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front()));
 233   p1111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 234   EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back()));
 235
 236   EXPECT_EQ(2U, o1112.received_params().size());
 237   p1112 = p111;
 238   p1112.receiver = &v1112;
 239   p1112.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 240   EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front()));
 241   p1112.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 242   EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back()));
 243
 244   // Remove.
 245   o1.Reset();
 246   o11.Reset();
 247   o111.Reset();
 248   o1111.Reset();
 249   o1112.Reset();
 250   EXPECT_TRUE(o1.received_params().empty());
 251   EXPECT_TRUE(o11.received_params().empty());
 252   EXPECT_TRUE(o111.received_params().empty());
 253   EXPECT_TRUE(o1111.received_params().empty());
 254   EXPECT_TRUE(o1112.received_params().empty());
 255
 256   v11.RemoveChild(&v111);
 257
 258   EXPECT_EQ(1U, o1.received_params().size());
 259   p1.target = &v111;
 260   p1.receiver = &v1;
 261   p1.old_parent = &v11;
 262   p1.new_parent = NULL;
 263   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 264   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back()));
 265
 266   EXPECT_EQ(1U, o11.received_params().size());
 267   p11 = p1;
 268   p11.receiver = &v11;
 269   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back()));
 270
 271   EXPECT_EQ(2U, o111.received_params().size());
 272   p111 = p11;
 273   p111.receiver = &v111;
 274   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 275   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front()));
 276   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 277   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back()));
 278
 279   EXPECT_EQ(2U, o1111.received_params().size());
 280   p1111 = p111;
 281   p1111.receiver = &v1111;
 282   p1111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 283   EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front()));
 284   p1111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 285   EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back()));
 286
 287   EXPECT_EQ(2U, o1112.received_params().size());
 288   p1112 = p111;
 289   p1112.receiver = &v1112;
 290   p1112.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 291   EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front()));
 292   p1112.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 293   EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back()));
 294 }
 295
 296 TEST_F(ViewTreeNodeObserverTest, TreeChange_Reparent) {
 297   TestViewTreeNode v1, v11, v12, v111;
 298   v1.AddChild(&v11);
 299   v1.AddChild(&v12);
 300   v11.AddChild(&v111);
 301
 302   TreeChangeObserver o1(&v1), o11(&v11), o12(&v12), o111(&v111);
 303
 304   // Reparent.
 305   v12.AddChild(&v111);
 306
 307   // v1 (root) should see both changing and changed notifications.
 308   EXPECT_EQ(2U, o1.received_params().size());
 309   ViewTreeNodeObserver::TreeChangeParams p1;
 310   p1.target = &v111;
 311   p1.receiver = &v1;
 312   p1.old_parent = &v11;
 313   p1.new_parent = &v12;
 314   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 315   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().front()));
 316   p1.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 317   EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back()));
 318
 319   // v11 should see changing notifications.
 320   EXPECT_EQ(1U, o11.received_params().size());
 321   ViewTreeNodeObserver::TreeChangeParams p11;
 322   p11 = p1;
 323   p11.receiver = &v11;
 324   p11.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 325   EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back()));
 326
 327   // v12 should see changed notifications.
 328   EXPECT_EQ(1U, o12.received_params().size());
 329   ViewTreeNodeObserver::TreeChangeParams p12;
 330   p12 = p1;
 331   p12.receiver = &v12;
 332   p12.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 333   EXPECT_TRUE(TreeChangeParamsMatch(p12, o12.received_params().back()));
 334
 335   // v111 should see both changing and changed notifications.
 336   EXPECT_EQ(2U, o111.received_params().size());
 337   ViewTreeNodeObserver::TreeChangeParams p111;
 338   p111 = p1;
 339   p111.receiver = &v111;
 340   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGING;
 341   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front()));
 342   p111.phase = ViewTreeNodeObserver::DISPOSITION_CHANGED;
 343   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back()));
 344 }
 345
 346 }  // namespace view_manager
 347 }  // namespace services
 348 }  // namespace mojo