ui/views/bubble/bubble_border_unittest.cc

   1 // Copyright (c) 2012 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 "ui/views/bubble/bubble_border.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "ui/gfx/geometry/rect.h"
  10 #include "ui/views/test/views_test_base.h"
  11
  12 namespace views {
  13
  14 typedef views::ViewsTestBase BubbleBorderTest;
  15
  16 TEST_F(BubbleBorderTest, GetMirroredArrow) {
  17   // Horizontal mirroring.
  18   EXPECT_EQ(BubbleBorder::TOP_RIGHT,
  19             BubbleBorder::horizontal_mirror(BubbleBorder::TOP_LEFT));
  20   EXPECT_EQ(BubbleBorder::TOP_LEFT,
  21             BubbleBorder::horizontal_mirror(BubbleBorder::TOP_RIGHT));
  22
  23   EXPECT_EQ(BubbleBorder::BOTTOM_RIGHT,
  24             BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_LEFT));
  25   EXPECT_EQ(BubbleBorder::BOTTOM_LEFT,
  26             BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_RIGHT));
  27
  28   EXPECT_EQ(BubbleBorder::RIGHT_TOP,
  29             BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_TOP));
  30   EXPECT_EQ(BubbleBorder::LEFT_TOP,
  31             BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_TOP));
  32
  33   EXPECT_EQ(BubbleBorder::RIGHT_BOTTOM,
  34             BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_BOTTOM));
  35   EXPECT_EQ(BubbleBorder::LEFT_BOTTOM,
  36             BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_BOTTOM));
  37
  38   EXPECT_EQ(BubbleBorder::TOP_CENTER,
  39             BubbleBorder::horizontal_mirror(BubbleBorder::TOP_CENTER));
  40   EXPECT_EQ(BubbleBorder::BOTTOM_CENTER,
  41             BubbleBorder::horizontal_mirror(BubbleBorder::BOTTOM_CENTER));
  42
  43   EXPECT_EQ(BubbleBorder::RIGHT_CENTER,
  44             BubbleBorder::horizontal_mirror(BubbleBorder::LEFT_CENTER));
  45   EXPECT_EQ(BubbleBorder::LEFT_CENTER,
  46             BubbleBorder::horizontal_mirror(BubbleBorder::RIGHT_CENTER));
  47
  48   EXPECT_EQ(BubbleBorder::NONE,
  49             BubbleBorder::horizontal_mirror(BubbleBorder::NONE));
  50   EXPECT_EQ(BubbleBorder::FLOAT,
  51             BubbleBorder::horizontal_mirror(BubbleBorder::FLOAT));
  52
  53   // Vertical mirroring.
  54   EXPECT_EQ(BubbleBorder::BOTTOM_LEFT,
  55             BubbleBorder::vertical_mirror(BubbleBorder::TOP_LEFT));
  56   EXPECT_EQ(BubbleBorder::BOTTOM_RIGHT,
  57             BubbleBorder::vertical_mirror(BubbleBorder::TOP_RIGHT));
  58
  59   EXPECT_EQ(BubbleBorder::TOP_LEFT,
  60             BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_LEFT));
  61   EXPECT_EQ(BubbleBorder::TOP_RIGHT,
  62             BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_RIGHT));
  63
  64   EXPECT_EQ(BubbleBorder::LEFT_BOTTOM,
  65             BubbleBorder::vertical_mirror(BubbleBorder::LEFT_TOP));
  66   EXPECT_EQ(BubbleBorder::RIGHT_BOTTOM,
  67             BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_TOP));
  68
  69   EXPECT_EQ(BubbleBorder::LEFT_TOP,
  70             BubbleBorder::vertical_mirror(BubbleBorder::LEFT_BOTTOM));
  71   EXPECT_EQ(BubbleBorder::RIGHT_TOP,
  72             BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_BOTTOM));
  73
  74   EXPECT_EQ(BubbleBorder::BOTTOM_CENTER,
  75             BubbleBorder::vertical_mirror(BubbleBorder::TOP_CENTER));
  76   EXPECT_EQ(BubbleBorder::TOP_CENTER,
  77             BubbleBorder::vertical_mirror(BubbleBorder::BOTTOM_CENTER));
  78
  79   EXPECT_EQ(BubbleBorder::LEFT_CENTER,
  80             BubbleBorder::vertical_mirror(BubbleBorder::LEFT_CENTER));
  81   EXPECT_EQ(BubbleBorder::RIGHT_CENTER,
  82             BubbleBorder::vertical_mirror(BubbleBorder::RIGHT_CENTER));
  83
  84   EXPECT_EQ(BubbleBorder::NONE,
  85             BubbleBorder::vertical_mirror(BubbleBorder::NONE));
  86   EXPECT_EQ(BubbleBorder::FLOAT,
  87             BubbleBorder::vertical_mirror(BubbleBorder::FLOAT));
  88 }
  89
  90 TEST_F(BubbleBorderTest, HasArrow) {
  91   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_LEFT));
  92   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_RIGHT));
  93
  94   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_LEFT));
  95   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_RIGHT));
  96
  97   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_TOP));
  98   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_TOP));
  99
 100   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_BOTTOM));
 101   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_BOTTOM));
 102
 103   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::TOP_CENTER));
 104   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::BOTTOM_CENTER));
 105
 106   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::LEFT_CENTER));
 107   EXPECT_TRUE(BubbleBorder::has_arrow(BubbleBorder::RIGHT_CENTER));
 108
 109   EXPECT_FALSE(BubbleBorder::has_arrow(BubbleBorder::NONE));
 110   EXPECT_FALSE(BubbleBorder::has_arrow(BubbleBorder::FLOAT));
 111 }
 112
 113 TEST_F(BubbleBorderTest, IsArrowOnLeft) {
 114   EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_LEFT));
 115   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_RIGHT));
 116
 117   EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_LEFT));
 118   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_RIGHT));
 119
 120   EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_TOP));
 121   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_TOP));
 122
 123   EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_BOTTOM));
 124   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_BOTTOM));
 125
 126   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::TOP_CENTER));
 127   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::BOTTOM_CENTER));
 128
 129   EXPECT_TRUE(BubbleBorder::is_arrow_on_left(BubbleBorder::LEFT_CENTER));
 130   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::RIGHT_CENTER));
 131
 132   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::NONE));
 133   EXPECT_FALSE(BubbleBorder::is_arrow_on_left(BubbleBorder::FLOAT));
 134 }
 135
 136 TEST_F(BubbleBorderTest, IsArrowOnTop) {
 137   EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_LEFT));
 138   EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_RIGHT));
 139
 140   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_LEFT));
 141   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_RIGHT));
 142
 143   EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_TOP));
 144   EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_TOP));
 145
 146   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_BOTTOM));
 147   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_BOTTOM));
 148
 149   EXPECT_TRUE(BubbleBorder::is_arrow_on_top(BubbleBorder::TOP_CENTER));
 150   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::BOTTOM_CENTER));
 151
 152   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::LEFT_CENTER));
 153   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::RIGHT_CENTER));
 154
 155   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::NONE));
 156   EXPECT_FALSE(BubbleBorder::is_arrow_on_top(BubbleBorder::FLOAT));
 157 }
 158
 159 TEST_F(BubbleBorderTest, IsArrowOnHorizontal) {
 160   EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_LEFT));
 161   EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_RIGHT));
 162
 163   EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_LEFT));
 164   EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_RIGHT));
 165
 166   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_TOP));
 167   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_TOP));
 168
 169   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_BOTTOM));
 170   EXPECT_FALSE(
 171       BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_BOTTOM));
 172
 173   EXPECT_TRUE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::TOP_CENTER));
 174   EXPECT_TRUE(
 175       BubbleBorder::is_arrow_on_horizontal(BubbleBorder::BOTTOM_CENTER));
 176
 177   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::LEFT_CENTER));
 178   EXPECT_FALSE(
 179       BubbleBorder::is_arrow_on_horizontal(BubbleBorder::RIGHT_CENTER));
 180
 181   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::NONE));
 182   EXPECT_FALSE(BubbleBorder::is_arrow_on_horizontal(BubbleBorder::FLOAT));
 183 }
 184
 185 TEST_F(BubbleBorderTest, IsArrowAtCenter) {
 186   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_LEFT));
 187   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_RIGHT));
 188
 189   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_LEFT));
 190   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_RIGHT));
 191
 192   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_TOP));
 193   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_TOP));
 194
 195   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_BOTTOM));
 196   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_BOTTOM));
 197
 198   EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::TOP_CENTER));
 199   EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::BOTTOM_CENTER));
 200
 201   EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::LEFT_CENTER));
 202   EXPECT_TRUE(BubbleBorder::is_arrow_at_center(BubbleBorder::RIGHT_CENTER));
 203
 204   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::NONE));
 205   EXPECT_FALSE(BubbleBorder::is_arrow_at_center(BubbleBorder::FLOAT));
 206 }
 207
 208 TEST_F(BubbleBorderTest, GetSizeForContentsSizeTest) {
 209   views::BubbleBorder border(BubbleBorder::NONE,
 210                              BubbleBorder::NO_SHADOW,
 211                              SK_ColorWHITE);
 212
 213   const views::internal::BorderImages* kImages = border.GetImagesForTest();
 214
 215   // kSmallSize is smaller than the minimum allowable size and does not
 216   // contribute to the resulting size.
 217   const gfx::Size kSmallSize = gfx::Size(1, 2);
 218   // kMediumSize is larger than the minimum allowable size and contributes to
 219   // the resulting size.
 220   const gfx::Size kMediumSize = gfx::Size(50, 60);
 221
 222   const gfx::Size kSmallHorizArrow(
 223       2 * kImages->border_thickness + kImages->top_arrow.width(),
 224       kImages->border_thickness + kImages->arrow_thickness +
 225           kImages->border_interior_thickness);
 226
 227   const gfx::Size kSmallVertArrow(kSmallHorizArrow.height(),
 228                                   kSmallHorizArrow.width());
 229
 230   const gfx::Size kSmallNoArrow(2 * kImages->border_thickness,
 231                                 2 * kImages->border_thickness);
 232
 233   const gfx::Size kMediumHorizArrow(
 234       kMediumSize.width() + 2 * border.GetBorderThickness(),
 235       kMediumSize.height() + border.GetBorderThickness() +
 236           kImages->arrow_thickness);
 237
 238   const gfx::Size kMediumVertArrow(
 239       kMediumSize.width() + border.GetBorderThickness() +
 240           kImages->arrow_thickness,
 241       kMediumSize.height() + 2 * border.GetBorderThickness());
 242
 243   const gfx::Size kMediumNoArrow(
 244       kMediumSize.width() + 2 * border.GetBorderThickness(),
 245       kMediumSize.height() + 2 * border.GetBorderThickness());
 246
 247   struct TestCase {
 248     BubbleBorder::Arrow arrow;
 249     gfx::Size content;
 250     gfx::Size expected_with_arrow;
 251     gfx::Size expected_without_arrow;
 252   };
 253
 254   TestCase cases[] = {
 255     // Content size: kSmallSize
 256     { BubbleBorder::TOP_LEFT, kSmallSize, kSmallHorizArrow, kSmallNoArrow },
 257     { BubbleBorder::TOP_CENTER, kSmallSize, kSmallHorizArrow, kSmallNoArrow },
 258     { BubbleBorder::TOP_RIGHT, kSmallSize, kSmallHorizArrow, kSmallNoArrow },
 259     { BubbleBorder::BOTTOM_LEFT, kSmallSize, kSmallHorizArrow, kSmallNoArrow },
 260     { BubbleBorder::BOTTOM_CENTER, kSmallSize, kSmallHorizArrow,
 261       kSmallNoArrow },
 262     { BubbleBorder::BOTTOM_RIGHT, kSmallSize, kSmallHorizArrow, kSmallNoArrow },
 263     { BubbleBorder::LEFT_TOP, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 264     { BubbleBorder::LEFT_CENTER, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 265     { BubbleBorder::LEFT_BOTTOM, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 266     { BubbleBorder::RIGHT_TOP, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 267     { BubbleBorder::RIGHT_CENTER, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 268     { BubbleBorder::RIGHT_BOTTOM, kSmallSize, kSmallVertArrow, kSmallNoArrow },
 269     { BubbleBorder::NONE, kSmallSize, kSmallNoArrow, kSmallNoArrow },
 270     { BubbleBorder::FLOAT, kSmallSize, kSmallNoArrow, kSmallNoArrow },
 271
 272     // Content size: kMediumSize
 273     { BubbleBorder::TOP_LEFT, kMediumSize, kMediumHorizArrow, kMediumNoArrow },
 274     { BubbleBorder::TOP_CENTER, kMediumSize, kMediumHorizArrow,
 275       kMediumNoArrow },
 276     { BubbleBorder::TOP_RIGHT, kMediumSize, kMediumHorizArrow, kMediumNoArrow },
 277     { BubbleBorder::BOTTOM_LEFT, kMediumSize, kMediumHorizArrow,
 278       kMediumNoArrow },
 279     { BubbleBorder::BOTTOM_CENTER, kMediumSize, kMediumHorizArrow,
 280       kMediumNoArrow },
 281     { BubbleBorder::BOTTOM_RIGHT, kMediumSize, kMediumHorizArrow,
 282       kMediumNoArrow },
 283     { BubbleBorder::LEFT_TOP, kMediumSize, kMediumVertArrow, kMediumNoArrow },
 284     { BubbleBorder::LEFT_CENTER, kMediumSize, kMediumVertArrow,
 285       kMediumNoArrow },
 286     { BubbleBorder::LEFT_BOTTOM, kMediumSize, kMediumVertArrow,
 287       kMediumNoArrow },
 288     { BubbleBorder::RIGHT_TOP, kMediumSize, kMediumVertArrow, kMediumNoArrow },
 289     { BubbleBorder::RIGHT_CENTER, kMediumSize, kMediumVertArrow,
 290       kMediumNoArrow },
 291     { BubbleBorder::RIGHT_BOTTOM, kMediumSize, kMediumVertArrow,
 292       kMediumNoArrow },
 293     { BubbleBorder::NONE, kMediumSize, kMediumNoArrow, kMediumNoArrow },
 294     { BubbleBorder::FLOAT, kMediumSize, kMediumNoArrow, kMediumNoArrow }
 295   };
 296
 297   for (size_t i = 0; i < arraysize(cases); ++i) {
 298     SCOPED_TRACE(base::StringPrintf("i=%d arrow=%d",
 299         static_cast<int>(i), cases[i].arrow));
 300
 301     border.set_arrow(cases[i].arrow);
 302
 303     border.set_paint_arrow(BubbleBorder::PAINT_NORMAL);
 304     EXPECT_EQ(cases[i].expected_with_arrow,
 305               border.GetSizeForContentsSize(cases[i].content));
 306
 307     border.set_paint_arrow(BubbleBorder::PAINT_TRANSPARENT);
 308     EXPECT_EQ(cases[i].expected_with_arrow,
 309               border.GetSizeForContentsSize(cases[i].content));
 310
 311     border.set_paint_arrow(BubbleBorder::PAINT_NONE);
 312     EXPECT_EQ(cases[i].expected_without_arrow,
 313               border.GetSizeForContentsSize(cases[i].content));
 314   }
 315 }
 316
 317 TEST_F(BubbleBorderTest, GetBoundsOriginTest) {
 318   views::BubbleBorder border(BubbleBorder::TOP_LEFT,
 319                              BubbleBorder::NO_SHADOW,
 320                              SK_ColorWHITE);
 321
 322   const gfx::Rect kAnchor(100, 100, 20, 30);
 323   const gfx::Size kContentSize(50, 60);
 324
 325   const views::internal::BorderImages* kImages = border.GetImagesForTest();
 326
 327   border.set_arrow(BubbleBorder::TOP_LEFT);
 328   const gfx::Size kTotalSizeWithHorizArrow =
 329       border.GetSizeForContentsSize(kContentSize);
 330
 331   border.set_arrow(BubbleBorder::RIGHT_BOTTOM);
 332   const gfx::Size kTotalSizeWithVertArrow =
 333       border.GetSizeForContentsSize(kContentSize);
 334
 335   border.set_arrow(BubbleBorder::NONE);
 336   const gfx::Size kTotalSizeWithNoArrow =
 337       border.GetSizeForContentsSize(kContentSize);
 338
 339   const int kBorderThickness = border.GetBorderThickness();
 340
 341   const int kArrowOffsetForHorizCenter = kTotalSizeWithHorizArrow.width() / 2;
 342   const int kArrowOffsetForVertCenter = kTotalSizeWithVertArrow.height() / 2;
 343   const int kArrowOffsetForNotCenter =
 344       kImages->border_thickness + (kImages->top_arrow.width() / 2);
 345
 346   const int kArrowSize =
 347       kImages->arrow_interior_thickness + BubbleBorder::kStroke -
 348           kImages->arrow_thickness;
 349
 350   const int kTopHorizArrowY = kAnchor.y() + kAnchor.height() + kArrowSize;
 351   const int kBottomHorizArrowY =
 352       kAnchor.y() - kArrowSize - kTotalSizeWithHorizArrow.height();
 353
 354   const int kLeftVertArrowX = kAnchor.x() + kAnchor.width() + kArrowSize;
 355   const int kRightVertArrowX =
 356       kAnchor.x() - kArrowSize - kTotalSizeWithVertArrow.width();
 357
 358   struct TestCase {
 359     BubbleBorder::Arrow arrow;
 360     BubbleBorder::BubbleAlignment alignment;
 361     int expected_x;
 362     int expected_y;
 363   };
 364
 365   TestCase cases[] = {
 366     // Horizontal arrow tests.
 367     { BubbleBorder::TOP_LEFT, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 368       kAnchor.CenterPoint().x() - kArrowOffsetForNotCenter, kTopHorizArrowY },
 369     { BubbleBorder::TOP_LEFT, BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE,
 370       kAnchor.x() + BubbleBorder::kStroke - kBorderThickness, kTopHorizArrowY },
 371     { BubbleBorder::TOP_CENTER, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 372       kAnchor.CenterPoint().x() - kArrowOffsetForHorizCenter, kTopHorizArrowY },
 373     { BubbleBorder::BOTTOM_RIGHT, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 374       kAnchor.CenterPoint().x() + kArrowOffsetForNotCenter -
 375           kTotalSizeWithHorizArrow.width(), kBottomHorizArrowY },
 376     { BubbleBorder::BOTTOM_RIGHT, BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE,
 377       kAnchor.x() + kAnchor.width() - kTotalSizeWithHorizArrow.width() +
 378           kBorderThickness - BubbleBorder::kStroke, kBottomHorizArrowY },
 379
 380     // Vertical arrow tests.
 381     { BubbleBorder::LEFT_TOP, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 382       kLeftVertArrowX, kAnchor.CenterPoint().y() - kArrowOffsetForNotCenter },
 383     { BubbleBorder::LEFT_TOP, BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE,
 384       kLeftVertArrowX, kAnchor.y() + BubbleBorder::kStroke - kBorderThickness },
 385     { BubbleBorder::LEFT_CENTER, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 386       kLeftVertArrowX, kAnchor.CenterPoint().y() - kArrowOffsetForVertCenter },
 387     { BubbleBorder::RIGHT_BOTTOM, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 388       kRightVertArrowX, kAnchor.CenterPoint().y() + kArrowOffsetForNotCenter -
 389           kTotalSizeWithVertArrow.height() },
 390     { BubbleBorder::RIGHT_BOTTOM, BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE,
 391       kRightVertArrowX, kAnchor.y() + kAnchor.height() -
 392           kTotalSizeWithVertArrow.height() + kBorderThickness -
 393           BubbleBorder::kStroke },
 394
 395     // No arrow tests.
 396     { BubbleBorder::NONE, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 397       kAnchor.x() + (kAnchor.width() - kTotalSizeWithNoArrow.width()) / 2,
 398       kAnchor.y() + kAnchor.height() },
 399     { BubbleBorder::FLOAT, BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR,
 400       kAnchor.x() + (kAnchor.width() - kTotalSizeWithNoArrow.width()) / 2,
 401       kAnchor.y() + (kAnchor.height() - kTotalSizeWithNoArrow.height()) / 2 },
 402   };
 403
 404   for (size_t i = 0; i < arraysize(cases); ++i) {
 405     SCOPED_TRACE(base::StringPrintf("i=%d arrow=%d alignment=%d",
 406         static_cast<int>(i), cases[i].arrow, cases[i].alignment));
 407     border.set_arrow(cases[i].arrow);
 408     border.set_alignment(cases[i].alignment);
 409
 410     gfx::Point origin = border.GetBounds(kAnchor, kContentSize).origin();
 411     EXPECT_EQ(cases[i].expected_x, origin.x());
 412     EXPECT_EQ(cases[i].expected_y, origin.y());
 413   }
 414 }
 415
 416 }  // namespace views