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