OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 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/memory/ptr_util.h" |
| 6 #include "base/values.h" |
| 7 #include "headless/lib/browser/headless_devtools_manager_delegate.h" |
| 8 #include "headless/lib/browser/headless_print_manager.h" |
| 9 #include "printing/features/features.h" |
| 10 #include "testing/gtest/include/gtest/gtest.h" |
| 11 |
| 12 namespace headless { |
| 13 |
| 14 TEST(ParsePrintSettingsTest, Landscape) { |
| 15 printing::HeadlessPrintSettings settings; |
| 16 EXPECT_FALSE(settings.landscape); |
| 17 |
| 18 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 19 params->SetBoolean("landscape", true); |
| 20 std::unique_ptr<base::DictionaryValue> response = |
| 21 ParsePrintSettings(0, params.get(), &settings); |
| 22 EXPECT_TRUE(settings.landscape); |
| 23 EXPECT_EQ(nullptr, response); |
| 24 } |
| 25 |
| 26 TEST(ParsePrintSettingsTest, HeaderFooter) { |
| 27 printing::HeadlessPrintSettings settings; |
| 28 EXPECT_FALSE(settings.display_header_footer); |
| 29 |
| 30 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 31 params->SetBoolean("displayHeaderFooter", true); |
| 32 std::unique_ptr<base::DictionaryValue> response = |
| 33 ParsePrintSettings(0, params.get(), &settings); |
| 34 EXPECT_TRUE(settings.display_header_footer); |
| 35 EXPECT_EQ(nullptr, response); |
| 36 } |
| 37 |
| 38 TEST(ParsePrintSettingsTest, PrintBackgrounds) { |
| 39 printing::HeadlessPrintSettings settings; |
| 40 EXPECT_FALSE(settings.should_print_backgrounds); |
| 41 |
| 42 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 43 params->SetBoolean("printBackgrounds", true); |
| 44 std::unique_ptr<base::DictionaryValue> response = |
| 45 ParsePrintSettings(0, params.get(), &settings); |
| 46 EXPECT_TRUE(settings.should_print_backgrounds); |
| 47 EXPECT_EQ(nullptr, response); |
| 48 } |
| 49 |
| 50 TEST(ParsePrintSettingsTest, Scale) { |
| 51 printing::HeadlessPrintSettings settings; |
| 52 EXPECT_DOUBLE_EQ(1, settings.scale); |
| 53 |
| 54 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 55 params->SetDouble("scale", 0.5); |
| 56 std::unique_ptr<base::DictionaryValue> response = |
| 57 ParsePrintSettings(0, params.get(), &settings); |
| 58 EXPECT_DOUBLE_EQ(0.5, settings.scale); |
| 59 EXPECT_EQ(nullptr, response); |
| 60 |
| 61 params->SetDouble("scale", -1); |
| 62 response = ParsePrintSettings(0, params.get(), &settings); |
| 63 EXPECT_NE(nullptr, response); |
| 64 |
| 65 params->SetDouble("scale", 10); |
| 66 response = ParsePrintSettings(0, params.get(), &settings); |
| 67 EXPECT_NE(nullptr, response); |
| 68 } |
| 69 |
| 70 TEST(ParsePrintSettingsTest, PageRanges) { |
| 71 printing::HeadlessPrintSettings settings; |
| 72 EXPECT_EQ("", settings.page_ranges); |
| 73 |
| 74 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 75 params->SetString("pageRanges", "abcd"); |
| 76 std::unique_ptr<base::DictionaryValue> response = |
| 77 ParsePrintSettings(0, params.get(), &settings); |
| 78 EXPECT_EQ("abcd", settings.page_ranges); |
| 79 EXPECT_EQ(nullptr, response); |
| 80 } |
| 81 |
| 82 TEST(ParsePrintSettingsTest, PaperType) { |
| 83 printing::HeadlessPrintSettings settings; |
| 84 EXPECT_EQ(printing::HeadlessPrintSettings::NA_LETTER, settings.paper_type); |
| 85 |
| 86 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 87 params->SetString("paperType", "NA_LETTER"); |
| 88 std::unique_ptr<base::DictionaryValue> response = |
| 89 ParsePrintSettings(0, params.get(), &settings); |
| 90 EXPECT_EQ(printing::HeadlessPrintSettings::NA_LETTER, settings.paper_type); |
| 91 EXPECT_EQ(nullptr, response); |
| 92 |
| 93 params->SetString("paperType", "NA_LEGAL"); |
| 94 response = ParsePrintSettings(0, params.get(), &settings); |
| 95 EXPECT_EQ(printing::HeadlessPrintSettings::NA_LEGAL, settings.paper_type); |
| 96 EXPECT_EQ(nullptr, response); |
| 97 |
| 98 params->SetString("paperType", "ISO_A4"); |
| 99 response = ParsePrintSettings(0, params.get(), &settings); |
| 100 EXPECT_EQ(printing::HeadlessPrintSettings::ISO_A4, settings.paper_type); |
| 101 EXPECT_EQ(nullptr, response); |
| 102 |
| 103 params->SetString("paperType", "ISO_A3"); |
| 104 response = ParsePrintSettings(0, params.get(), &settings); |
| 105 EXPECT_EQ(printing::HeadlessPrintSettings::ISO_A3, settings.paper_type); |
| 106 EXPECT_EQ(nullptr, response); |
| 107 |
| 108 params->SetString("paperType", "CUSTOM"); |
| 109 params->SetDouble("paperWidth", 1); |
| 110 params->SetDouble("paperHeight", 2); |
| 111 response = ParsePrintSettings(0, params.get(), &settings); |
| 112 EXPECT_EQ(printing::HeadlessPrintSettings::CUSTOM, settings.paper_type); |
| 113 EXPECT_DOUBLE_EQ(1, settings.paper_width_in_inch); |
| 114 EXPECT_DOUBLE_EQ(2, settings.paper_height_in_inch); |
| 115 EXPECT_EQ(nullptr, response); |
| 116 |
| 117 params->SetString("paperType", "abcd"); |
| 118 response = ParsePrintSettings(0, params.get(), &settings); |
| 119 EXPECT_NE(nullptr, response); |
| 120 } |
| 121 |
| 122 TEST(ParsePrintSettingsTest, Margin) { |
| 123 printing::HeadlessPrintSettings settings; |
| 124 EXPECT_EQ(printing::DEFAULT_MARGINS, settings.margin_type); |
| 125 |
| 126 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 127 std::unique_ptr<base::DictionaryValue> response = |
| 128 ParsePrintSettings(0, params.get(), &settings); |
| 129 EXPECT_EQ(printing::DEFAULT_MARGINS, settings.margin_type); |
| 130 EXPECT_EQ(nullptr, response); |
| 131 |
| 132 params->SetDouble("marginTop", 1); |
| 133 params->SetDouble("marginBottom", 2); |
| 134 params->SetDouble("marginLeft", 3); |
| 135 params->SetDouble("marginRight", 4); |
| 136 response = ParsePrintSettings(0, params.get(), &settings); |
| 137 EXPECT_EQ(printing::CUSTOM_MARGINS, settings.margin_type); |
| 138 EXPECT_DOUBLE_EQ(1, settings.margin_top_in_inch); |
| 139 EXPECT_DOUBLE_EQ(2, settings.margin_bottom_in_inch); |
| 140 EXPECT_DOUBLE_EQ(3, settings.margin_left_in_inch); |
| 141 EXPECT_DOUBLE_EQ(4, settings.margin_right_in_inch); |
| 142 EXPECT_EQ(nullptr, response); |
| 143 } |
| 144 |
| 145 TEST(ParsePrintSettingsTest, Unit) { |
| 146 printing::HeadlessPrintSettings settings; |
| 147 auto params = base::MakeUnique<base::DictionaryValue>(); |
| 148 params->SetString("unit", "MM"); |
| 149 params->SetString("paperType", "CUSTOM"); |
| 150 params->SetDouble("paperWidth", 1); |
| 151 params->SetDouble("paperHeight", 2); |
| 152 params->SetDouble("marginTop", 3); |
| 153 params->SetDouble("marginBottom", 4); |
| 154 params->SetDouble("marginLeft", 5); |
| 155 params->SetDouble("marginRight", 6); |
| 156 |
| 157 std::unique_ptr<base::DictionaryValue> response = |
| 158 ParsePrintSettings(0, params.get(), &settings); |
| 159 EXPECT_EQ(printing::HeadlessPrintSettings::CUSTOM, settings.paper_type); |
| 160 EXPECT_DOUBLE_EQ(1 / 25.4, settings.paper_width_in_inch); |
| 161 EXPECT_DOUBLE_EQ(2 / 25.4, settings.paper_height_in_inch); |
| 162 EXPECT_EQ(printing::CUSTOM_MARGINS, settings.margin_type); |
| 163 EXPECT_DOUBLE_EQ(3 / 25.4, settings.margin_top_in_inch); |
| 164 EXPECT_DOUBLE_EQ(4 / 25.4, settings.margin_bottom_in_inch); |
| 165 EXPECT_DOUBLE_EQ(5 / 25.4, settings.margin_left_in_inch); |
| 166 EXPECT_DOUBLE_EQ(6 / 25.4, settings.margin_right_in_inch); |
| 167 EXPECT_EQ(nullptr, response); |
| 168 |
| 169 params->SetString("unit", "abcd"); |
| 170 response = ParsePrintSettings(0, params.get(), &settings); |
| 171 EXPECT_NE(nullptr, response); |
| 172 } |
| 173 |
| 174 TEST(PageRangeTextToPagesTest, General) { |
| 175 using PM = printing::HeadlessPrintManager; |
| 176 std::vector<int> pages, expected_pages; |
| 177 |
| 178 PM::PageRangeStatus status = PM::PageRangeTextToPages("-", 10, &pages); |
| 179 expected_pages = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; |
| 180 EXPECT_EQ(expected_pages, pages); |
| 181 EXPECT_EQ(PM::NO_ERROR, status); |
| 182 |
| 183 status = PM::PageRangeTextToPages("-5", 10, &pages); |
| 184 expected_pages = {0, 1, 2, 3, 4}; |
| 185 EXPECT_EQ(expected_pages, pages); |
| 186 EXPECT_EQ(PM::NO_ERROR, status); |
| 187 |
| 188 status = PM::PageRangeTextToPages("5-", 10, &pages); |
| 189 expected_pages = {4, 5, 6, 7, 8, 9}; |
| 190 EXPECT_EQ(expected_pages, pages); |
| 191 EXPECT_EQ(PM::NO_ERROR, status); |
| 192 |
| 193 status = PM::PageRangeTextToPages("1-3,9-10,4-6", 10, &pages); |
| 194 expected_pages = {0, 1, 2, 3, 4, 5, 8, 9}; |
| 195 EXPECT_EQ(expected_pages, pages); |
| 196 EXPECT_EQ(PM::NO_ERROR, status); |
| 197 |
| 198 status = PM::PageRangeTextToPages("1- 3, 9-10,4 -6", 10, &pages); |
| 199 expected_pages = {0, 1, 2, 3, 4, 5, 8, 9}; |
| 200 EXPECT_EQ(expected_pages, pages); |
| 201 EXPECT_EQ(PM::NO_ERROR, status); |
| 202 |
| 203 status = PM::PageRangeTextToPages("1-3,9-10,4-6", 5, &pages); |
| 204 EXPECT_EQ(PM::LIMIT_ERROR, status); |
| 205 |
| 206 status = PM::PageRangeTextToPages("abcd", 10, &pages); |
| 207 EXPECT_EQ(PM::SYNTAX_ERROR, status); |
| 208 |
| 209 status = PM::PageRangeTextToPages("1-3,9-a10,4-6", 10, &pages); |
| 210 EXPECT_EQ(PM::SYNTAX_ERROR, status); |
| 211 } |
| 212 |
| 213 } // namespace headless |
OLD | NEW |