document_layout_unittest.cc 14 KB

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