pdf/document_layout_unittest.cc

   1 // Copyright 2019 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 "pdf/document_layout.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace chrome_pdf {
  10
  11 namespace {
  12
  13 class DocumentLayoutOptionsTest : public testing::Test {
  14  protected:
  15   DocumentLayout::Options options_;
  16 };
  17
  18 class DocumentLayoutTest : public testing::Test {
  19  protected:
  20   DocumentLayout layout_;
  21 };
  22
  23 // TODO(kmoon): Need to use this with EXPECT_PRED2 instead of just using
  24 // EXPECT_EQ, due to ADL issues with pp::Size's operator== (defined in global
  25 // namespace, instead of in "pp").
  26 inline bool PpSizeEq(const pp::Size& lhs, const pp::Size& rhs) {
  27   return lhs == rhs;
  28 }
  29
  30 inline bool PpRectEq(const pp::Rect& lhs, const pp::Rect& rhs) {
  31   return lhs == rhs;
  32 }
  33
  34 TEST_F(DocumentLayoutOptionsTest, DefaultConstructor) {
  35   EXPECT_EQ(options_.default_page_orientation(), PageOrientation::kOriginal);
  36   EXPECT_FALSE(options_.two_up_view_enabled());
  37 }
  38
  39 TEST_F(DocumentLayoutOptionsTest, CopyConstructor) {
  40   options_.RotatePagesClockwise();
  41   options_.set_two_up_view_enabled(true);
  42
  43   DocumentLayout::Options copy(options_);
  44   EXPECT_EQ(copy.default_page_orientation(), PageOrientation::kClockwise90);
  45   EXPECT_TRUE(copy.two_up_view_enabled());
  46
  47   options_.RotatePagesClockwise();
  48   options_.set_two_up_view_enabled(false);
  49   EXPECT_EQ(copy.default_page_orientation(), PageOrientation::kClockwise90);
  50   EXPECT_TRUE(copy.two_up_view_enabled());
  51 }
  52
  53 TEST_F(DocumentLayoutOptionsTest, CopyAssignment) {
  54   options_.RotatePagesClockwise();
  55   options_.set_two_up_view_enabled(true);
  56
  57   DocumentLayout::Options copy = options_;
  58   EXPECT_EQ(copy.default_page_orientation(), PageOrientation::kClockwise90);
  59   EXPECT_TRUE(copy.two_up_view_enabled());
  60
  61   options_.RotatePagesClockwise();
  62   options_.set_two_up_view_enabled(false);
  63   EXPECT_EQ(copy.default_page_orientation(), PageOrientation::kClockwise90);
  64   EXPECT_TRUE(copy.two_up_view_enabled());
  65 }
  66
  67 TEST_F(DocumentLayoutOptionsTest, Equals) {
  68   EXPECT_TRUE(options_ == options_);
  69
  70   DocumentLayout::Options copy;
  71   EXPECT_TRUE(copy == options_);
  72
  73   options_.RotatePagesClockwise();
  74   EXPECT_FALSE(copy == options_);
  75
  76   copy.RotatePagesClockwise();
  77   EXPECT_TRUE(copy == options_);
  78
  79   options_.RotatePagesCounterclockwise();
  80   EXPECT_FALSE(copy == options_);
  81
  82   copy.RotatePagesCounterclockwise();
  83   EXPECT_TRUE(copy == options_);
  84
  85   options_.set_two_up_view_enabled(true);
  86   EXPECT_FALSE(copy == options_);
  87
  88   copy.set_two_up_view_enabled(true);
  89   EXPECT_TRUE(copy == options_);
  90
  91   options_.set_two_up_view_enabled(false);
  92   EXPECT_FALSE(copy == options_);
  93
  94   copy.set_two_up_view_enabled(false);
  95   EXPECT_TRUE(copy == options_);
  96 }
  97
  98 TEST_F(DocumentLayoutOptionsTest, NotEquals) {
  99   // Given that "!=" is defined as "!(==)", minimal tests should be sufficient
 100   // here.
 101   EXPECT_FALSE(options_ != options_);
 102
 103   DocumentLayout::Options copy;
 104   EXPECT_FALSE(copy != options_);
 105
 106   options_.RotatePagesClockwise();
 107   EXPECT_TRUE(copy != options_);
 108
 109   copy.RotatePagesClockwise();
 110   EXPECT_FALSE(copy != options_);
 111 }
 112
 113 TEST_F(DocumentLayoutOptionsTest, RotatePagesClockwise) {
 114   options_.RotatePagesClockwise();
 115   EXPECT_EQ(options_.default_page_orientation(), PageOrientation::kClockwise90);
 116
 117   options_.RotatePagesClockwise();
 118   EXPECT_EQ(options_.default_page_orientation(),
 119             PageOrientation::kClockwise180);
 120
 121   options_.RotatePagesClockwise();
 122   EXPECT_EQ(options_.default_page_orientation(),
 123             PageOrientation::kClockwise270);
 124
 125   options_.RotatePagesClockwise();
 126   EXPECT_EQ(options_.default_page_orientation(), PageOrientation::kOriginal);
 127 }
 128
 129 TEST_F(DocumentLayoutOptionsTest, RotatePagesCounterclockwise) {
 130   options_.RotatePagesCounterclockwise();
 131   EXPECT_EQ(options_.default_page_orientation(),
 132             PageOrientation::kClockwise270);
 133
 134   options_.RotatePagesCounterclockwise();
 135   EXPECT_EQ(options_.default_page_orientation(),
 136             PageOrientation::kClockwise180);
 137
 138   options_.RotatePagesCounterclockwise();
 139   EXPECT_EQ(options_.default_page_orientation(), PageOrientation::kClockwise90);
 140
 141   options_.RotatePagesCounterclockwise();
 142   EXPECT_EQ(options_.default_page_orientation(), PageOrientation::kOriginal);
 143 }
 144
 145 TEST_F(DocumentLayoutTest, DefaultConstructor) {
 146   EXPECT_EQ(layout_.options().default_page_orientation(),
 147             PageOrientation::kOriginal);
 148   EXPECT_FALSE(layout_.options().two_up_view_enabled());
 149   EXPECT_FALSE(layout_.dirty());
 150   EXPECT_PRED2(PpSizeEq, layout_.size(), pp::Size(0, 0));
 151   EXPECT_EQ(layout_.page_count(), 0u);
 152 }
 153
 154 TEST_F(DocumentLayoutTest, SetOptionsDoesNotRecomputeLayout) {
 155   layout_.ComputeSingleViewLayout({pp::Size(100, 200)});
 156   EXPECT_PRED2(PpSizeEq, layout_.size(), pp::Size(100, 200));
 157
 158   DocumentLayout::Options options;
 159   options.RotatePagesClockwise();
 160   layout_.SetOptions(options);
 161   EXPECT_EQ(layout_.options().default_page_orientation(),
 162             PageOrientation::kClockwise90);
 163   EXPECT_PRED2(PpSizeEq, layout_.size(), pp::Size(100, 200));
 164 }
 165
 166 TEST_F(DocumentLayoutTest, DirtySetOnOptionsChange) {
 167   DocumentLayout::Options options;
 168   layout_.SetOptions(options);
 169   EXPECT_FALSE(layout_.dirty());
 170
 171   options.RotatePagesClockwise();
 172   layout_.SetOptions(options);
 173   EXPECT_TRUE(layout_.dirty());
 174
 175   layout_.clear_dirty();
 176
 177   options.set_two_up_view_enabled(true);
 178   layout_.SetOptions(options);
 179   EXPECT_TRUE(layout_.dirty());
 180 }
 181
 182 TEST_F(DocumentLayoutTest, DirtyNotSetOnSameOptions) {
 183   DocumentLayout::Options options;
 184   options.set_two_up_view_enabled(true);
 185   layout_.SetOptions(options);
 186   EXPECT_TRUE(layout_.dirty());
 187
 188   layout_.clear_dirty();
 189
 190   options.set_two_up_view_enabled(true);
 191   layout_.SetOptions(options);
 192   EXPECT_FALSE(layout_.dirty());
 193 }
 194
 195 TEST_F(DocumentLayoutTest, ComputeSingleViewLayout) {
 196   std::vector<pp::Size> page_sizes{
 197       {300, 400}, {400, 500}, {300, 400}, {200, 300}};
 198   layout_.ComputeSingleViewLayout(page_sizes);
 199   ASSERT_EQ(4u, layout_.page_count());
 200   EXPECT_PRED2(PpRectEq, pp::Rect(50, 0, 300, 400), layout_.page_rect(0));
 201   EXPECT_PRED2(PpRectEq, pp::Rect(0, 404, 400, 500), layout_.page_rect(1));
 202   EXPECT_PRED2(PpRectEq, pp::Rect(50, 908, 300, 400), layout_.page_rect(2));
 203   EXPECT_PRED2(PpRectEq, pp::Rect(100, 1312, 200, 300), layout_.page_rect(3));
 204   EXPECT_PRED2(PpRectEq, pp::Rect(55, 3, 290, 390),
 205                layout_.page_bounds_rect(0));
 206   EXPECT_PRED2(PpRectEq, pp::Rect(5, 407, 390, 490),
 207                layout_.page_bounds_rect(1));
 208   EXPECT_PRED2(PpRectEq, pp::Rect(55, 911, 290, 390),
 209                layout_.page_bounds_rect(2));
 210   EXPECT_PRED2(PpRectEq, pp::Rect(105, 1315, 190, 290),
 211                layout_.page_bounds_rect(3));
 212   EXPECT_PRED2(PpSizeEq, pp::Size(400, 1612), layout_.size());
 213
 214   page_sizes = {{240, 300}, {320, 400}, {250, 360}, {300, 600}, {270, 555}};
 215   layout_.ComputeSingleViewLayout(page_sizes);
 216   ASSERT_EQ(5u, layout_.page_count());
 217   EXPECT_PRED2(PpRectEq, pp::Rect(40, 0, 240, 300), layout_.page_rect(0));
 218   EXPECT_PRED2(PpRectEq, pp::Rect(0, 304, 320, 400), layout_.page_rect(1));
 219   EXPECT_PRED2(PpRectEq, pp::Rect(35, 708, 250, 360), layout_.page_rect(2));
 220   EXPECT_PRED2(PpRectEq, pp::Rect(10, 1072, 300, 600), layout_.page_rect(3));
 221   EXPECT_PRED2(PpRectEq, pp::Rect(25, 1676, 270, 555), layout_.page_rect(4));
 222   EXPECT_PRED2(PpRectEq, pp::Rect(45, 3, 230, 290),
 223                layout_.page_bounds_rect(0));
 224   EXPECT_PRED2(PpRectEq, pp::Rect(5, 307, 310, 390),
 225                layout_.page_bounds_rect(1));
 226   EXPECT_PRED2(PpRectEq, pp::Rect(40, 711, 240, 350),
 227                layout_.page_bounds_rect(2));
 228   EXPECT_PRED2(PpRectEq, pp::Rect(15, 1075, 290, 590),
 229                layout_.page_bounds_rect(3));
 230   EXPECT_PRED2(PpRectEq, pp::Rect(30, 1679, 260, 545),
 231                layout_.page_bounds_rect(4));
 232   EXPECT_PRED2(PpSizeEq, pp::Size(320, 2231), layout_.size());
 233 }
 234
 235 TEST_F(DocumentLayoutTest, ComputeTwoUpViewLayout) {
 236   // Test case where the widest page is on the right.
 237   std::vector<pp::Size> page_sizes{
 238       {826, 1066}, {1066, 826}, {826, 1066}, {826, 900}};
 239   layout_.ComputeTwoUpViewLayout(page_sizes);
 240   ASSERT_EQ(4u, layout_.page_count());
 241   EXPECT_PRED2(PpRectEq, pp::Rect(240, 0, 826, 1066), layout_.page_rect(0));
 242   EXPECT_PRED2(PpRectEq, pp::Rect(1066, 0, 1066, 826), layout_.page_rect(1));
 243   EXPECT_PRED2(PpRectEq, pp::Rect(240, 1066, 826, 1066), layout_.page_rect(2));
 244   EXPECT_PRED2(PpRectEq, pp::Rect(1066, 1066, 826, 900), layout_.page_rect(3));
 245   EXPECT_PRED2(PpRectEq, pp::Rect(245, 3, 820, 1056),
 246                layout_.page_bounds_rect(0));
 247   EXPECT_PRED2(PpRectEq, pp::Rect(1067, 3, 1060, 816),
 248                layout_.page_bounds_rect(1));
 249   EXPECT_PRED2(PpRectEq, pp::Rect(245, 1069, 820, 1056),
 250                layout_.page_bounds_rect(2));
 251   EXPECT_PRED2(PpRectEq, pp::Rect(1067, 1069, 820, 890),
 252                layout_.page_bounds_rect(3));
 253   EXPECT_PRED2(PpSizeEq, pp::Size(2132, 2132), layout_.size());
 254
 255   // Test case where the widest page is on the left.
 256   page_sizes = {{1066, 826}, {820, 1056}, {820, 890}, {826, 1066}};
 257   layout_.ComputeTwoUpViewLayout(page_sizes);
 258   ASSERT_EQ(4u, layout_.page_count());
 259   EXPECT_PRED2(PpRectEq, pp::Rect(0, 0, 1066, 826), layout_.page_rect(0));
 260   EXPECT_PRED2(PpRectEq, pp::Rect(1066, 0, 820, 1056), layout_.page_rect(1));
 261   EXPECT_PRED2(PpRectEq, pp::Rect(246, 1056, 820, 890), layout_.page_rect(2));
 262   EXPECT_PRED2(PpRectEq, pp::Rect(1066, 1056, 826, 1066), layout_.page_rect(3));
 263   EXPECT_PRED2(PpRectEq, pp::Rect(5, 3, 1060, 816),
 264                layout_.page_bounds_rect(0));
 265   EXPECT_PRED2(PpRectEq, pp::Rect(1067, 3, 814, 1046),
 266                layout_.page_bounds_rect(1));
 267   EXPECT_PRED2(PpRectEq, pp::Rect(251, 1059, 814, 880),
 268                layout_.page_bounds_rect(2));
 269   EXPECT_PRED2(PpRectEq, pp::Rect(1067, 1059, 820, 1056),
 270                layout_.page_bounds_rect(3));
 271   EXPECT_PRED2(PpSizeEq, pp::Size(2132, 2122), layout_.size());
 272
 273   // Test case where there's an odd # of pages.
 274   page_sizes = {{200, 300}, {400, 200}, {300, 600}, {250, 500}, {300, 400}};
 275   layout_.ComputeTwoUpViewLayout(page_sizes);
 276   ASSERT_EQ(5u, layout_.page_count());
 277   EXPECT_PRED2(PpRectEq, pp::Rect(200, 0, 200, 300), layout_.page_rect(0));
 278   EXPECT_PRED2(PpRectEq, pp::Rect(400, 0, 400, 200), layout_.page_rect(1));
 279   EXPECT_PRED2(PpRectEq, pp::Rect(100, 300, 300, 600), layout_.page_rect(2));
 280   EXPECT_PRED2(PpRectEq, pp::Rect(400, 300, 250, 500), layout_.page_rect(3));
 281   EXPECT_PRED2(PpRectEq, pp::Rect(100, 900, 300, 400), layout_.page_rect(4));
 282   EXPECT_PRED2(PpRectEq, pp::Rect(205, 3, 194, 290),
 283                layout_.page_bounds_rect(0));
 284   EXPECT_PRED2(PpRectEq, pp::Rect(401, 3, 394, 190),
 285                layout_.page_bounds_rect(1));
 286   EXPECT_PRED2(PpRectEq, pp::Rect(105, 303, 294, 590),
 287                layout_.page_bounds_rect(2));
 288   EXPECT_PRED2(PpRectEq, pp::Rect(401, 303, 244, 490),
 289                layout_.page_bounds_rect(3));
 290   EXPECT_PRED2(PpRectEq, pp::Rect(105, 903, 290, 390),
 291                layout_.page_bounds_rect(4));
 292   EXPECT_PRED2(PpSizeEq, pp::Size(800, 1300), layout_.size());
 293 }
 294
 295 TEST_F(DocumentLayoutTest, DirtySetOnSingleViewLayoutInputChange) {
 296   layout_.ComputeSingleViewLayout({pp::Size(100, 200)});
 297   EXPECT_TRUE(layout_.dirty());
 298   layout_.clear_dirty();
 299   EXPECT_FALSE(layout_.dirty());
 300
 301   layout_.ComputeSingleViewLayout({pp::Size(100, 200)});
 302   EXPECT_FALSE(layout_.dirty());
 303
 304   layout_.ComputeSingleViewLayout({pp::Size(200, 100)});
 305   EXPECT_TRUE(layout_.dirty());
 306   layout_.clear_dirty();
 307
 308   layout_.ComputeSingleViewLayout({pp::Size(200, 100), pp::Size(300, 300)});
 309   EXPECT_TRUE(layout_.dirty());
 310   layout_.clear_dirty();
 311
 312   layout_.ComputeSingleViewLayout({pp::Size(200, 100)});
 313   EXPECT_TRUE(layout_.dirty());
 314 }
 315
 316 TEST_F(DocumentLayoutTest, DirtySetOnTwoUpViewLayoutInputChange) {
 317   layout_.ComputeTwoUpViewLayout({pp::Size(100, 200), pp::Size(200, 100)});
 318   EXPECT_TRUE(layout_.dirty());
 319   layout_.clear_dirty();
 320   EXPECT_FALSE(layout_.dirty());
 321
 322   layout_.ComputeTwoUpViewLayout({pp::Size(100, 200), pp::Size(200, 100)});
 323   EXPECT_FALSE(layout_.dirty());
 324
 325   layout_.ComputeTwoUpViewLayout({pp::Size(200, 100), pp::Size(100, 200)});
 326   EXPECT_TRUE(layout_.dirty());
 327   layout_.clear_dirty();
 328
 329   layout_.ComputeTwoUpViewLayout(
 330       {pp::Size(200, 100), pp::Size(100, 200), pp::Size(300, 300)});
 331   EXPECT_TRUE(layout_.dirty());
 332   layout_.clear_dirty();
 333
 334   layout_.ComputeTwoUpViewLayout({pp::Size(200, 100), pp::Size(100, 200)});
 335   EXPECT_TRUE(layout_.dirty());
 336 }
 337
 338 }  // namespace
 339
 340 }  // namespace chrome_pdf