src/ui/views/controls/single_split_view_unittest.cc

   1 // Copyright (c) 2011 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 "base/logging.h"
   6 #include "testing/gmock/include/gmock/gmock.h"
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "ui/views/controls/single_split_view.h"
   9 #include "ui/views/controls/single_split_view_listener.h"
  10
  11 using ::testing::_;
  12 using ::testing::Return;
  13
  14 namespace {
  15
  16 static void VerifySplitViewLayout(const views::SingleSplitView& split) {
  17   ASSERT_EQ(2, split.child_count());
  18
  19   const views::View* leading = split.child_at(0);
  20   const views::View* trailing = split.child_at(1);
  21
  22   if (split.bounds().IsEmpty()) {
  23     EXPECT_TRUE(leading->bounds().IsEmpty());
  24     EXPECT_TRUE(trailing->bounds().IsEmpty());
  25     return;
  26   }
  27
  28   EXPECT_FALSE(leading->bounds().IsEmpty());
  29   EXPECT_FALSE(trailing->bounds().IsEmpty());
  30   EXPECT_FALSE(leading->bounds().Intersects(trailing->bounds()));
  31
  32   if (split.orientation() == views::SingleSplitView::HORIZONTAL_SPLIT) {
  33     EXPECT_EQ(leading->bounds().height(), split.bounds().height());
  34     EXPECT_EQ(trailing->bounds().height(), split.bounds().height());
  35     EXPECT_LT(leading->bounds().width() + trailing->bounds().width(),
  36               split.bounds().width());
  37   } else if (split.orientation() == views::SingleSplitView::VERTICAL_SPLIT) {
  38     EXPECT_EQ(leading->bounds().width(), split.bounds().width());
  39     EXPECT_EQ(trailing->bounds().width(), split.bounds().width());
  40     EXPECT_LT(leading->bounds().height() + trailing->bounds().height(),
  41               split.bounds().height());
  42   } else {
  43     NOTREACHED();
  44   }
  45 }
  46
  47 class MockObserver : public views::SingleSplitViewListener {
  48  public:
  49   MOCK_METHOD1(SplitHandleMoved, bool(views::SingleSplitView*));
  50 };
  51
  52 class MinimumSizedView: public views::View {
  53  public:
  54   MinimumSizedView(gfx::Size min_size) : min_size_(min_size) {}
  55
  56  private:
  57   gfx::Size min_size_;
  58   virtual gfx::Size GetMinimumSize() OVERRIDE;
  59 };
  60
  61 gfx::Size MinimumSizedView::GetMinimumSize() {
  62   return min_size_;
  63 }
  64
  65 }  // namespace
  66
  67 namespace views {
  68
  69 TEST(SingleSplitViewTest, Resize) {
  70   // Test cases to iterate through for horizontal and vertical split views.
  71   struct TestCase {
  72     // Split view resize policy for this test case.
  73     bool resize_leading_on_bounds_change;
  74     // Split view size to set.
  75     int primary_axis_size;
  76     int secondary_axis_size;
  77     // Expected divider offset.
  78     int divider_offset;
  79   } test_cases[] = {
  80     // The initial split size is 100x100, divider at 33.
  81     { true, 100, 100, 33 },
  82     // Grow the split view, leading view should grow.
  83     { true, 1000, 100, 933 },
  84     // Shrink the split view, leading view should shrink.
  85     { true, 200, 100, 133 },
  86     // Minimize the split view, divider should not move.
  87     { true, 0, 0, 133 },
  88     // Restore the split view, divider should not move.
  89     { false, 500, 100, 133 },
  90     // Resize the split view by secondary axis, divider should not move.
  91     { false,  500, 600, 133 }
  92   };
  93
  94   SingleSplitView::Orientation orientations[] = {
  95     SingleSplitView::HORIZONTAL_SPLIT,
  96     SingleSplitView::VERTICAL_SPLIT
  97   };
  98
  99   for (size_t orientation = 0; orientation < arraysize(orientations);
 100        ++orientation) {
 101     // Create a split view.
 102     SingleSplitView split(
 103         new View(), new View(), orientations[orientation], NULL);
 104
 105     // Set initial size and divider offset.
 106     EXPECT_EQ(test_cases[0].primary_axis_size,
 107               test_cases[0].secondary_axis_size);
 108     split.SetBounds(0, 0, test_cases[0].primary_axis_size,
 109                     test_cases[0].secondary_axis_size);
 110     split.set_divider_offset(test_cases[0].divider_offset);
 111     split.Layout();
 112
 113     // Run all test cases.
 114     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 115       split.set_resize_leading_on_bounds_change(
 116           test_cases[i].resize_leading_on_bounds_change);
 117       if (split.orientation() == SingleSplitView::HORIZONTAL_SPLIT) {
 118         split.SetBounds(0, 0, test_cases[i].primary_axis_size,
 119                         test_cases[i].secondary_axis_size);
 120       } else {
 121         split.SetBounds(0, 0, test_cases[i].secondary_axis_size,
 122                         test_cases[i].primary_axis_size);
 123       }
 124
 125       EXPECT_EQ(test_cases[i].divider_offset, split.divider_offset());
 126       VerifySplitViewLayout(split);
 127     }
 128
 129     // Special cases, one of the child views is hidden.
 130     split.child_at(0)->SetVisible(false);
 131     split.Layout();
 132
 133     EXPECT_EQ(split.size(), split.child_at(1)->size());
 134
 135     split.child_at(0)->SetVisible(true);
 136     split.child_at(1)->SetVisible(false);
 137     split.Layout();
 138
 139     EXPECT_EQ(split.size(), split.child_at(0)->size());
 140   }
 141 }
 142
 143 TEST(SingleSplitViewTest, MouseDrag) {
 144   MockObserver observer;
 145   const int kMinimumChildSize = 25;
 146   MinimumSizedView *child0 =
 147       new MinimumSizedView(gfx::Size(5, kMinimumChildSize));
 148   MinimumSizedView *child1 =
 149       new MinimumSizedView(gfx::Size(5, kMinimumChildSize));
 150   SingleSplitView split(
 151       child0, child1, SingleSplitView::VERTICAL_SPLIT, &observer);
 152
 153   ON_CALL(observer, SplitHandleMoved(_))
 154       .WillByDefault(Return(true));
 155   // SplitHandleMoved is called for two mouse moves and one mouse capture loss.
 156   EXPECT_CALL(observer, SplitHandleMoved(_))
 157       .Times(5);
 158
 159   const int kTotalSplitSize = 100;
 160   split.SetBounds(0, 0, 10, kTotalSplitSize);
 161   const int kInitialDividerOffset = 33;
 162   const int kMouseOffset = 2;  // Mouse offset in the divider.
 163   const int kMouseMoveDelta = 7;
 164   split.set_divider_offset(kInitialDividerOffset);
 165   split.Layout();
 166
 167   gfx::Point press_point(7, kInitialDividerOffset + kMouseOffset);
 168   ui::MouseEvent mouse_pressed(
 169       ui::ET_MOUSE_PRESSED, press_point, press_point, 0);
 170   ASSERT_TRUE(split.OnMousePressed(mouse_pressed));
 171   EXPECT_EQ(kInitialDividerOffset, split.divider_offset());
 172
 173   // Drag divider to the bottom.
 174   gfx::Point drag_1_point(
 175       5, kInitialDividerOffset + kMouseOffset + kMouseMoveDelta);
 176   ui::MouseEvent mouse_dragged_1(
 177       ui::ET_MOUSE_DRAGGED, drag_1_point, drag_1_point, 0);
 178   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_1));
 179   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta, split.divider_offset());
 180
 181   // Drag divider to the top, beyond first child minimum size.
 182   gfx::Point drag_2_point(
 183       7, kMinimumChildSize - 5);
 184   ui::MouseEvent mouse_dragged_2(
 185       ui::ET_MOUSE_DRAGGED, drag_2_point, drag_2_point, 0);
 186   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_2));
 187   EXPECT_EQ(kMinimumChildSize,
 188             split.divider_offset());
 189
 190   // Drag divider to the bottom, beyond second child minimum size.
 191   gfx::Point drag_3_point(
 192       7, kTotalSplitSize - kMinimumChildSize + 5);
 193   ui::MouseEvent mouse_dragged_3(
 194       ui::ET_MOUSE_DRAGGED, drag_3_point, drag_3_point, 0);
 195   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_3));
 196   EXPECT_EQ(kTotalSplitSize - kMinimumChildSize - split.GetDividerSize(),
 197             split.divider_offset());
 198
 199   // Drag divider between childs' minimum sizes.
 200   gfx::Point drag_4_point(
 201       6, kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2);
 202   ui::MouseEvent mouse_dragged_4(
 203       ui::ET_MOUSE_DRAGGED, drag_4_point, drag_4_point, 0);
 204   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_4));
 205   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
 206             split.divider_offset());
 207
 208   gfx::Point release_point(
 209       7, kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2);
 210   ui::MouseEvent mouse_released(
 211       ui::ET_MOUSE_RELEASED, release_point, release_point, 0);
 212   split.OnMouseReleased(mouse_released);
 213   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
 214             split.divider_offset());
 215
 216   // Expect intial offset after a system/user gesture cancels the drag.
 217   // This shouldn't occur after mouse release, but it's sufficient for testing.
 218   split.OnMouseCaptureLost();
 219   EXPECT_EQ(kInitialDividerOffset, split.divider_offset());
 220 }
 221
 222 }  // namespace views