| // Copyright 2021 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "mojo/public/cpp/test_support/test_utils.h" |
| #include "printing/mojom/print.mojom.h" |
| #include "printing/mojom/printing_context.mojom.h" |
| #include "printing/page_range.h" |
| #include "printing/page_setup.h" |
| #include "printing/print_settings.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/gfx/geometry/size.h" |
| |
| namespace printing { |
| |
| namespace { |
| |
| // Values for PageMargins, just want non-zero and all different. |
| const PageMargins kPageMarginNonzero(/*header=*/1, |
| /*footer=*/2, |
| /*left=*/3, |
| /*right=*/4, |
| /*top=*/5, |
| /*bottom=*/6); |
| |
| constexpr int kPageSetupTextHeight = 1; |
| constexpr gfx::Size kPageSetupPhysicalSize = |
| gfx::Size(/*width=*/100, /*height=*/200); |
| constexpr gfx::Rect kPageSetupPrintableArea = |
| gfx::Rect(/*x=*/5, /*y=*/10, /*width=*/80, /*height=*/170); |
| const PageMargins kPageSetupRequestedMargins( |
| /*header=*/10, |
| /*footer=*/20, |
| /*left=*/5, |
| /*right=*/15, |
| /*top=*/10 + kPageSetupTextHeight, |
| /*bottom=*/20 + kPageSetupTextHeight); |
| |
| const PageSetup kPageSetupAsymmetricalMargins(kPageSetupPhysicalSize, |
| kPageSetupPrintableArea, |
| kPageSetupRequestedMargins, |
| /*forced_margins=*/false, |
| kPageSetupTextHeight); |
| const PageSetup kPageSetupForcedMargins(kPageSetupPhysicalSize, |
| kPageSetupPrintableArea, |
| kPageSetupRequestedMargins, |
| /*forced_margins=*/true, |
| kPageSetupTextHeight); |
| |
| constexpr gfx::Size kRequestedMediaSize = |
| gfx::Size(/*width=*/25, /*height=*/75); |
| const char kRequestedMediaVendorId[] = "iso-foo"; |
| |
| PrintSettings::RequestedMedia GenerateSampleRequestedMedia() { |
| PrintSettings::RequestedMedia media; |
| media.size_microns = kRequestedMediaSize; |
| media.vendor_id = kRequestedMediaVendorId; |
| return media; |
| } |
| |
| // Support two possible sample `PrintSettings`, to ensure that certain fields |
| // get definitively tested for coverage (e.g., booleans). Note that not all |
| // fields need distinct values between the two. A key difference between them |
| // is custom vs. default margins, as this has significant implications |
| // internally on printable area. |
| const PageRanges kPrintSettingsPageRanges{{/*from=*/1, /*to=*/2}, |
| {/*from=*/5, /*to=*/8}, |
| {/*from=*/10, /*to=*/10}}; |
| constexpr char16_t kPrintSettingsTitle[] = u"Title"; |
| constexpr char16_t kPrintSettingsUrl[] = u"//url"; |
| constexpr int kPrintSettingsCopies = 99; |
| constexpr char16_t kPrintSettingsDeviceName[] = u"device"; |
| const PrintSettings::RequestedMedia kPrintSettingsRequestedMedia{ |
| /*size_microns=*/gfx::Size(/*width=*/215900, /*height=*/279400), |
| /*vendor_id=*/"vendor"}; |
| const PageMargins kPrintSettingsCustomMarginsInPoints(/*header=*/10, |
| /*footer=*/15, |
| /*left=*/20, |
| /*right=*/25, |
| /*top=*/30, |
| /*bottom=*/35); |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| PrintSettings::AdvancedSettings GenerateSampleAdvancedSettings() { |
| PrintSettings::AdvancedSettings advanced_settings; |
| advanced_settings.emplace("advanced-setting-A", base::Value("setting-A")); |
| advanced_settings.emplace("advanced-setting-B", base::Value(42)); |
| return advanced_settings; |
| } |
| |
| const PrintSettings::AdvancedSettings kPrintSettingsAdvancedSettings = |
| GenerateSampleAdvancedSettings(); |
| #endif // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| constexpr char kPrintSettingsUsername[] = "username"; |
| constexpr char kPrintSettingsPinValue[] = "pin-value"; |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| constexpr bool kPrintSettingsSetSelection1 = false; |
| constexpr bool kPrintSettingsSetSelection2 = true; |
| |
| constexpr mojom::MarginType kPrintSettingsMarginType1 = |
| mojom::MarginType::kDefaultMargins; |
| constexpr mojom::MarginType kPrintSettingsMarginType2 = |
| mojom::MarginType::kCustomMargins; |
| |
| constexpr bool kPrintSettingsDisplayHeaderFooter1 = true; |
| constexpr bool kPrintSettingsDisplayHeaderFooter2 = false; |
| |
| constexpr bool kPrintSettingsShouldPrintBackgrounds1 = false; |
| constexpr bool kPrintSettingsShouldPrintBackgrounds2 = true; |
| |
| constexpr bool kPrintSettingsCollate1 = false; |
| constexpr bool kPrintSettingsCollate2 = true; |
| |
| constexpr mojom::ColorModel kPrintSettingsColorModel1 = |
| mojom::ColorModel::kGrayscale; |
| constexpr mojom::ColorModel kPrintSettingsColorModel2 = mojom::ColorModel::kRGB; |
| |
| constexpr mojom::DuplexMode kPrintSettingsDuplexMode1 = |
| mojom::DuplexMode::kSimplex; |
| constexpr mojom::DuplexMode kPrintSettingsDuplexMode2 = |
| mojom::DuplexMode::kLongEdge; |
| |
| constexpr gfx::Size kPrintSettingsDpi1(600, 600); |
| constexpr gfx::Size kPrintSettingsDpi2(1200, 600); |
| |
| constexpr double kPrintSettingsScaleFactor1 = 1.0; |
| constexpr double kPrintSettingsScaleFactor2 = 1.25; |
| |
| constexpr bool kPrintSettingsRasterizePdf1 = true; |
| constexpr bool kPrintSettingsRasterizePdf2 = false; |
| |
| constexpr bool kPrintSettingsLandscape1 = false; |
| constexpr bool kPrintSettingsLandscape2 = true; |
| |
| constexpr bool kPrintSettingsSupportsAlphaBlend1 = false; |
| constexpr bool kPrintSettingsSupportsAlphaBlend2 = true; |
| |
| #if BUILDFLAG(IS_WIN) |
| constexpr mojom::PrinterLanguageType kPrintSettingsPrinterLanguageType1 = |
| mojom::PrinterLanguageType::kTextOnly; |
| constexpr mojom::PrinterLanguageType kPrintSettingsPrinterLanguageType2 = |
| mojom::PrinterLanguageType::kXps; |
| #endif // BUILDFLAG(IS_WIN) |
| |
| constexpr bool kPrintSettingsModifiable1 = true; |
| constexpr bool kPrintSettingsModifiable2 = false; |
| |
| constexpr int kPrintSettingsPagesPerSheet1 = 1; |
| constexpr int kPrintSettingsPagesPerSheet2 = 2; |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| constexpr bool kPrintSettingsSendUserInfo1 = true; |
| constexpr bool kPrintSettingsSendUserInfo2 = false; |
| #endif |
| |
| PrintSettings GenerateSamplePrintSettingsCommon() { |
| PrintSettings settings; |
| |
| settings.set_ranges(kPrintSettingsPageRanges); |
| settings.set_title(kPrintSettingsTitle); |
| settings.set_url(kPrintSettingsUrl); |
| settings.set_copies(kPrintSettingsCopies); |
| settings.set_device_name(kPrintSettingsDeviceName); |
| settings.set_requested_media(kPrintSettingsRequestedMedia); |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| PrintSettings::AdvancedSettings& advanced_settings = |
| settings.advanced_settings(); |
| for (const auto& item : kPrintSettingsAdvancedSettings) |
| advanced_settings.emplace(item.first, item.second.Clone()); |
| #endif |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| settings.set_username(kPrintSettingsUsername); |
| settings.set_pin_value(kPrintSettingsPinValue); |
| #endif |
| |
| return settings; |
| } |
| |
| PrintSettings GenerateSamplePrintSettingsDefaultMargins() { |
| PrintSettings settings = GenerateSamplePrintSettingsCommon(); |
| |
| settings.set_selection_only(kPrintSettingsSetSelection1); |
| settings.set_margin_type(kPrintSettingsMarginType1); |
| settings.set_display_header_footer(kPrintSettingsDisplayHeaderFooter1); |
| settings.set_should_print_backgrounds(kPrintSettingsShouldPrintBackgrounds1); |
| settings.set_collate(kPrintSettingsCollate1); |
| settings.set_color(kPrintSettingsColorModel1); |
| settings.set_duplex_mode(kPrintSettingsDuplexMode1); |
| settings.set_dpi( |
| kPrintSettingsDpi1.width()); // Same resolution for both axes. |
| settings.set_scale_factor(kPrintSettingsScaleFactor1); |
| settings.set_rasterize_pdf(kPrintSettingsRasterizePdf1); |
| settings.SetOrientation(kPrintSettingsLandscape1); |
| settings.set_supports_alpha_blend(kPrintSettingsSupportsAlphaBlend1); |
| |
| #if BUILDFLAG(IS_WIN) |
| settings.set_printer_language_type(kPrintSettingsPrinterLanguageType1); |
| #endif |
| |
| settings.set_is_modifiable(kPrintSettingsModifiable1); |
| settings.set_pages_per_sheet(kPrintSettingsPagesPerSheet1); |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| settings.set_send_user_info(kPrintSettingsSendUserInfo1); |
| #endif |
| |
| return settings; |
| } |
| |
| PrintSettings GenerateSamplePrintSettingsCustomMargins() { |
| PrintSettings settings = GenerateSamplePrintSettingsCommon(); |
| |
| settings.set_selection_only(kPrintSettingsSetSelection2); |
| settings.set_margin_type(kPrintSettingsMarginType2); |
| settings.set_display_header_footer(kPrintSettingsDisplayHeaderFooter2); |
| settings.set_should_print_backgrounds(kPrintSettingsShouldPrintBackgrounds2); |
| settings.set_collate(kPrintSettingsCollate2); |
| settings.set_color(kPrintSettingsColorModel2); |
| settings.set_duplex_mode(kPrintSettingsDuplexMode2); |
| settings.set_dpi_xy(kPrintSettingsDpi2.width(), kPrintSettingsDpi2.height()); |
| settings.set_scale_factor(kPrintSettingsScaleFactor2); |
| settings.set_rasterize_pdf(kPrintSettingsRasterizePdf2); |
| settings.SetOrientation(kPrintSettingsLandscape2); |
| settings.set_supports_alpha_blend(kPrintSettingsSupportsAlphaBlend2); |
| |
| settings.SetCustomMargins(kPrintSettingsCustomMarginsInPoints); |
| |
| #if BUILDFLAG(IS_WIN) |
| settings.set_printer_language_type(kPrintSettingsPrinterLanguageType2); |
| #endif |
| |
| settings.set_is_modifiable(kPrintSettingsModifiable2); |
| settings.set_pages_per_sheet(kPrintSettingsPagesPerSheet2); |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| settings.set_send_user_info(kPrintSettingsSendUserInfo2); |
| #endif |
| |
| return settings; |
| } |
| |
| bool RequestedMediasEqual(const PrintSettings::RequestedMedia& lhs, |
| const PrintSettings::RequestedMedia& rhs) { |
| return lhs.size_microns == rhs.size_microns && lhs.vendor_id == rhs.vendor_id; |
| } |
| |
| bool PageMarginsEqual(const PageMargins& lhs, const PageMargins& rhs) { |
| return lhs.header == rhs.header && lhs.footer == rhs.footer && |
| lhs.left == rhs.left && lhs.right == rhs.right && lhs.top == rhs.top && |
| lhs.bottom == rhs.bottom; |
| } |
| |
| } // namespace |
| |
| TEST(PrintingContextMojomTraitsTest, TestSerializeAndDeserializePageMargins) { |
| PageMargins input = kPageMarginNonzero; |
| PageMargins output; |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| |
| EXPECT_EQ(kPageMarginNonzero.header, output.header); |
| EXPECT_EQ(kPageMarginNonzero.footer, output.footer); |
| EXPECT_EQ(kPageMarginNonzero.left, output.left); |
| EXPECT_EQ(kPageMarginNonzero.right, output.right); |
| EXPECT_EQ(kPageMarginNonzero.top, output.top); |
| EXPECT_EQ(kPageMarginNonzero.bottom, output.bottom); |
| } |
| |
| // Test that no margins is valid. |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageMarginsNoMargins) { |
| // Default constructor is all members zero. |
| PageMargins input; |
| // Ensure `output` doesn't start out with all zeroes. |
| PageMargins output = kPageMarginNonzero; |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| |
| EXPECT_EQ(0, output.header); |
| EXPECT_EQ(0, output.footer); |
| EXPECT_EQ(0, output.left); |
| EXPECT_EQ(0, output.right); |
| EXPECT_EQ(0, output.top); |
| EXPECT_EQ(0, output.bottom); |
| } |
| |
| // Test that negative margin values are allowed. |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageMarginsNegativeValues) { |
| PageMargins input = kPageMarginNonzero; |
| PageMargins output; |
| |
| input.header = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.header); |
| |
| input = kPageMarginNonzero; |
| input.footer = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.footer); |
| |
| input = kPageMarginNonzero; |
| input.left = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.left); |
| |
| input = kPageMarginNonzero; |
| input.right = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.right); |
| |
| input = kPageMarginNonzero; |
| input.top = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.top); |
| |
| input = kPageMarginNonzero; |
| input.bottom = -1; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageMargins>(input, output)); |
| EXPECT_EQ(-1, output.bottom); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, TestSerializeAndDeserializePageSetup) { |
| PageSetup input = kPageSetupAsymmetricalMargins; |
| PageSetup output; |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageSetup>(input, output)); |
| |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.physical_size(), |
| output.physical_size()); |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.printable_area(), |
| output.printable_area()); |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.overlay_area(), |
| output.overlay_area()); |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.content_area(), |
| output.content_area()); |
| EXPECT_TRUE(kPageSetupAsymmetricalMargins.effective_margins().Equals( |
| output.effective_margins())); |
| EXPECT_TRUE(kPageSetupAsymmetricalMargins.requested_margins().Equals( |
| output.requested_margins())); |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.forced_margins(), |
| output.forced_margins()); |
| EXPECT_EQ(kPageSetupAsymmetricalMargins.text_height(), output.text_height()); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageSetupForcedMargins) { |
| PageSetup input = kPageSetupForcedMargins; |
| PageSetup output; |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageSetup>(input, output)); |
| |
| EXPECT_EQ(kPageSetupForcedMargins.physical_size(), output.physical_size()); |
| EXPECT_EQ(kPageSetupForcedMargins.printable_area(), output.printable_area()); |
| EXPECT_EQ(kPageSetupForcedMargins.overlay_area(), output.overlay_area()); |
| EXPECT_EQ(kPageSetupForcedMargins.content_area(), output.content_area()); |
| EXPECT_TRUE(kPageSetupForcedMargins.effective_margins().Equals( |
| output.effective_margins())); |
| EXPECT_TRUE(kPageSetupForcedMargins.requested_margins().Equals( |
| output.requested_margins())); |
| EXPECT_EQ(kPageSetupForcedMargins.forced_margins(), output.forced_margins()); |
| EXPECT_EQ(kPageSetupForcedMargins.text_height(), output.text_height()); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageRangeMultiPage) { |
| PageRange input; |
| PageRange output; |
| |
| input.from = 0u; |
| input.to = 5u; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageRange>(input, output)); |
| |
| EXPECT_EQ(0u, output.from); |
| EXPECT_EQ(5u, output.to); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageRangeSinglePage) { |
| PageRange input; |
| PageRange output; |
| |
| input.from = 1u; |
| input.to = 1u; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageRange>(input, output)); |
| |
| EXPECT_EQ(1u, output.from); |
| EXPECT_EQ(1u, output.to); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePageRangeReverseRange) { |
| PageRange input; |
| PageRange output; |
| |
| // Verify that reverse ranges are not allowed (e.g., not a mechanism to print |
| // the range backwards). |
| input.from = 5u; |
| input.to = 1u; |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::PageRange>(input, output)); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializeRequestedMedia) { |
| PrintSettings::RequestedMedia input = GenerateSampleRequestedMedia(); |
| PrintSettings::RequestedMedia output; |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::RequestedMedia>( |
| input, output)); |
| |
| EXPECT_EQ(kRequestedMediaSize, output.size_microns); |
| EXPECT_EQ(kRequestedMediaVendorId, output.vendor_id); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializeRequestedMediaEmpty) { |
| PrintSettings::RequestedMedia input; |
| PrintSettings::RequestedMedia output; |
| |
| // The default is empty. |
| EXPECT_TRUE(input.IsDefault()); |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::RequestedMedia>( |
| input, output)); |
| |
| EXPECT_TRUE(output.IsDefault()); |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePrintSettingsDefaultMargins) { |
| PrintSettings input = GenerateSamplePrintSettingsDefaultMargins(); |
| PrintSettings output; |
| |
| // `page_setup_device_units` is set programmatically by PrintSettings based |
| // upon all other parameters. Capture its initial value before letting |
| // `input` be touched by the serializer. |
| const PageSetup kPageSetupDeviceUnits = input.page_setup_device_units(); |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PrintSettings>(input, output)); |
| |
| EXPECT_EQ(output.ranges(), kPrintSettingsPageRanges); |
| EXPECT_EQ(output.selection_only(), kPrintSettingsSetSelection1); |
| EXPECT_EQ(output.margin_type(), kPrintSettingsMarginType1); |
| EXPECT_EQ(output.title(), kPrintSettingsTitle); |
| EXPECT_EQ(output.url(), kPrintSettingsUrl); |
| EXPECT_EQ(output.display_header_footer(), kPrintSettingsDisplayHeaderFooter1); |
| EXPECT_EQ(output.should_print_backgrounds(), |
| kPrintSettingsShouldPrintBackgrounds1); |
| EXPECT_EQ(output.collate(), kPrintSettingsCollate1); |
| EXPECT_EQ(output.color(), kPrintSettingsColorModel1); |
| EXPECT_EQ(output.copies(), kPrintSettingsCopies); |
| EXPECT_EQ(output.duplex_mode(), kPrintSettingsDuplexMode1); |
| EXPECT_EQ(output.device_name(), kPrintSettingsDeviceName); |
| EXPECT_TRUE(RequestedMediasEqual(output.requested_media(), |
| kPrintSettingsRequestedMedia)); |
| EXPECT_TRUE(output.page_setup_device_units().Equals(kPageSetupDeviceUnits)); |
| EXPECT_EQ(output.dpi_size(), kPrintSettingsDpi1); |
| EXPECT_EQ(output.scale_factor(), kPrintSettingsScaleFactor1); |
| EXPECT_EQ(output.rasterize_pdf(), kPrintSettingsRasterizePdf1); |
| EXPECT_EQ(output.landscape(), kPrintSettingsLandscape1); |
| EXPECT_EQ(output.supports_alpha_blend(), kPrintSettingsSupportsAlphaBlend1); |
| |
| #if BUILDFLAG(IS_WIN) |
| EXPECT_EQ(output.printer_language_type(), kPrintSettingsPrinterLanguageType1); |
| #endif |
| |
| EXPECT_EQ(output.is_modifiable(), kPrintSettingsModifiable1); |
| |
| // Since `kPrintSettingsMarginType1` is not `kCustomMargins` then expect the |
| // custom margins to be default values. |
| EXPECT_TRUE(PageMarginsEqual(output.requested_custom_margins_in_points(), |
| PageMargins())); |
| |
| EXPECT_EQ(output.pages_per_sheet(), kPrintSettingsPagesPerSheet1); |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(output.advanced_settings(), kPrintSettingsAdvancedSettings); |
| #endif |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(output.send_user_info(), kPrintSettingsSendUserInfo1); |
| EXPECT_EQ(output.username(), kPrintSettingsUsername); |
| EXPECT_EQ(output.pin_value(), kPrintSettingsPinValue); |
| #endif |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePrintSettingsCustomMargins) { |
| PrintSettings input = GenerateSamplePrintSettingsCustomMargins(); |
| PrintSettings output; |
| |
| // `page_setup_device_units` is set programmatically by PrintSettings based |
| // upon all other parameters. Capture its initial value before letting |
| // `input` be touched by the serializer. |
| const PageSetup kPageSetupDeviceUnits = input.page_setup_device_units(); |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PrintSettings>(input, output)); |
| |
| EXPECT_EQ(output.ranges(), kPrintSettingsPageRanges); |
| EXPECT_EQ(output.selection_only(), kPrintSettingsSetSelection2); |
| EXPECT_EQ(output.margin_type(), kPrintSettingsMarginType2); |
| EXPECT_EQ(output.title(), kPrintSettingsTitle); |
| EXPECT_EQ(output.url(), kPrintSettingsUrl); |
| EXPECT_EQ(output.display_header_footer(), kPrintSettingsDisplayHeaderFooter2); |
| EXPECT_EQ(output.should_print_backgrounds(), |
| kPrintSettingsShouldPrintBackgrounds2); |
| EXPECT_EQ(output.collate(), kPrintSettingsCollate2); |
| EXPECT_EQ(output.color(), kPrintSettingsColorModel2); |
| EXPECT_EQ(output.copies(), kPrintSettingsCopies); |
| EXPECT_EQ(output.duplex_mode(), kPrintSettingsDuplexMode2); |
| EXPECT_EQ(output.device_name(), kPrintSettingsDeviceName); |
| EXPECT_TRUE(RequestedMediasEqual(output.requested_media(), |
| kPrintSettingsRequestedMedia)); |
| EXPECT_TRUE(output.page_setup_device_units().Equals(kPageSetupDeviceUnits)); |
| EXPECT_EQ(output.dpi_size(), kPrintSettingsDpi2); |
| EXPECT_EQ(output.scale_factor(), kPrintSettingsScaleFactor2); |
| EXPECT_EQ(output.rasterize_pdf(), kPrintSettingsRasterizePdf2); |
| EXPECT_EQ(output.landscape(), kPrintSettingsLandscape2); |
| EXPECT_EQ(output.supports_alpha_blend(), kPrintSettingsSupportsAlphaBlend2); |
| |
| #if BUILDFLAG(IS_WIN) |
| EXPECT_EQ(output.printer_language_type(), kPrintSettingsPrinterLanguageType2); |
| #endif |
| |
| EXPECT_EQ(output.is_modifiable(), kPrintSettingsModifiable2); |
| EXPECT_TRUE(PageMarginsEqual(output.requested_custom_margins_in_points(), |
| kPrintSettingsCustomMarginsInPoints)); |
| EXPECT_EQ(output.pages_per_sheet(), kPrintSettingsPagesPerSheet2); |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(output.advanced_settings(), kPrintSettingsAdvancedSettings); |
| #endif |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(output.send_user_info(), kPrintSettingsSendUserInfo2); |
| EXPECT_EQ(output.username(), kPrintSettingsUsername); |
| EXPECT_EQ(output.pin_value(), kPrintSettingsPinValue); |
| #endif |
| } |
| |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePrintSettingsEmptyPageRanges) { |
| PrintSettings input = GenerateSamplePrintSettingsDefaultMargins(); |
| PrintSettings output; |
| |
| // Empty page ranges are allowed in settings. |
| const PageRanges kEmptyPageRanges; |
| input.set_ranges(kEmptyPageRanges); |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PrintSettings>(input, output)); |
| |
| EXPECT_EQ(output.ranges(), kEmptyPageRanges); |
| } |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| TEST(PrintingContextMojomTraitsTest, |
| TestSerializeAndDeserializePrintSettingsEmptyAdvancedSettings) { |
| PrintSettings input = GenerateSamplePrintSettingsDefaultMargins(); |
| PrintSettings output; |
| |
| // Empty advanced settings is allowed. |
| input.advanced_settings().clear(); |
| |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PrintSettings>(input, output)); |
| |
| EXPECT_TRUE(output.advanced_settings().empty()); |
| } |
| #endif // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| |
| } // namespace printing |