| // Copyright 2020 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <map> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "build/build_config.h" |
| #include "mojo/public/cpp/test_support/test_utils.h" |
| #include "printing/backend/mojom/print_backend.mojom.h" |
| #include "printing/backend/print_backend.h" |
| #include "printing/backend/print_backend_test_constants.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/gfx/geometry/size.h" |
| |
| namespace printing { |
| |
| TEST(PrintBackendMojomTraitsTest, TestSerializeAndDeserializePrinterBasicInfo) { |
| static const PrinterBasicInfo kPrinterBasicInfo1( |
| /*printer_name=*/"test printer name 1", |
| /*display_name=*/"test display name 1", |
| /*printer_description=*/"This is printer #1 for unit testing.", |
| /*printer_status=*/0, |
| /*is_default=*/true, |
| /*options=*/{{"opt1", "123"}, {"opt2", "456"}}); |
| static const PrinterBasicInfo kPrinterBasicInfo2( |
| /*printer_name=*/"test printer name 2", |
| /*display_name=*/"test display name 2", |
| /*printer_description=*/"This is printer #2 for unit testing.", |
| /*printer_status=*/1, |
| /*is_default=*/false, |
| /*options=*/{}); |
| static const PrinterBasicInfo kPrinterBasicInfo3( |
| /*printer_name=*/"test printer name 2", |
| /*display_name=*/"test display name 2", |
| /*printer_description=*/"", |
| /*printer_status=*/9, |
| /*is_default=*/false, |
| /*options=*/{}); |
| static const PrinterList kPrinterList{kPrinterBasicInfo1, kPrinterBasicInfo2, |
| kPrinterBasicInfo3}; |
| |
| for (const auto& info : kPrinterList) { |
| PrinterBasicInfo input = info; |
| PrinterBasicInfo output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::PrinterBasicInfo>( |
| input, output)); |
| EXPECT_EQ(info, output); |
| } |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterBasicInfoEmptyNames) { |
| static const PrinterBasicInfo kPrinterBasicInfoEmptyPrinterName( |
| /*printer_name=*/"", |
| /*display_name=*/"test display name", |
| /*printer_description=*/"", |
| /*printer_status=*/0, |
| /*is_default=*/true, |
| /*options=*/{}); |
| static const PrinterBasicInfo kPrinterBasicInfoEmptyDisplayName( |
| /*printer_name=*/"test printer name", |
| /*display_name=*/"", |
| /*printer_description=*/"", |
| /*printer_status=*/0, |
| /*is_default=*/true, |
| /*options=*/{}); |
| static const PrinterList kPrinterList{kPrinterBasicInfoEmptyPrinterName, |
| kPrinterBasicInfoEmptyDisplayName}; |
| |
| for (const auto& info : kPrinterList) { |
| PrinterBasicInfo input = info; |
| PrinterBasicInfo output; |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize<mojom::PrinterBasicInfo>( |
| input, output)); |
| } |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestSerializeAndDeserializePaper) { |
| PrinterSemanticCapsAndDefaults::Papers test_papers = kPapers; |
| test_papers.push_back(kPaperCustom); |
| |
| for (const auto& paper : test_papers) { |
| PrinterSemanticCapsAndDefaults::Paper input = paper; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| EXPECT_EQ(paper, output); |
| } |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperCtors) { |
| // All constructors should be able to generate valid papers. |
| constexpr gfx::Size kNonEmptySize(100, 200); |
| constexpr gfx::Rect kNonEmptyPrintableArea(kNonEmptySize); |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| PrinterSemanticCapsAndDefaults::Paper input; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| |
| input = PrinterSemanticCapsAndDefaults::Paper("display_name", "vendor_id", |
| kNonEmptySize); |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| |
| input = PrinterSemanticCapsAndDefaults::Paper( |
| "display_name", "vendor_id", kNonEmptySize, kNonEmptyPrintableArea); |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| |
| input = PrinterSemanticCapsAndDefaults::Paper( |
| "display_name", "vendor_id", kNonEmptySize, kNonEmptyPrintableArea, |
| /*max_height_um=*/200); |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| |
| input = PrinterSemanticCapsAndDefaults::Paper( |
| "display_name", "vendor_id", kNonEmptySize, kNonEmptyPrintableArea, |
| /*max_height_um=*/200, /*has_borderless_variant=*/true); |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperEmpty) { |
| // Empty Papers should be valid. |
| PrinterSemanticCapsAndDefaults::Paper input; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| EXPECT_EQ(input, output); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperInvalidCustomSize) { |
| // The min height is larger than the max height, so it should be invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", |
| /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(0, 0, 4000, 7000), |
| /*max_height_um=*/6000, |
| /*has_borderless_variant=*/true, |
| }; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperEmptyPrintableArea) { |
| // The printable area is empty, but the other fields are not, so it should be |
| // invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(0, 100, 0, 0)}; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperPrintableAreaLargerThanSize) { |
| // The printable area is larger than the size, so it should be invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(0, 100, 4100, 7200)}; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperPrintableAreaLargerThanCustomSize) { |
| // The printable area is larger than the custom size, so it should be invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", |
| /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(0, 100, 4100, 7200), |
| /*max_height_um=*/8000}; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperPrintableAreaOutOfBounds) { |
| // The printable area is out of bounds of the size, so it should be invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(4050, 6950, 100, 100)}; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, TestPaperNegativePrintableArea) { |
| // The printable area has negative x and y values, so it should be invalid. |
| PrinterSemanticCapsAndDefaults::Paper input{ |
| /*display_name=*/"display_name", /*vendor_id=*/"vendor_id", |
| /*size_um=*/gfx::Size(4000, 7000), |
| /*printable_area_um=*/gfx::Rect(-10, -10, 2800, 6000)}; |
| PrinterSemanticCapsAndDefaults::Paper output; |
| |
| EXPECT_FALSE( |
| mojo::test::SerializeAndDeserialize<mojom::Paper>(input, output)); |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializeAdvancedCapability) { |
| for (const auto& advanced_capability : kAdvancedCapabilities) { |
| AdvancedCapability input = advanced_capability; |
| AdvancedCapability output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::AdvancedCapability>( |
| input, output)); |
| EXPECT_EQ(advanced_capability, output); |
| } |
| } |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaults) { |
| OptionalSampleCapabilities caps; |
| #if BUILDFLAG(IS_CHROMEOS) |
| caps = SampleWithPinAndAdvancedCapabilities(); |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults(std::move(caps)); |
| PrinterSemanticCapsAndDefaults output; |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kCollateCapable, output.collate_capable); |
| EXPECT_EQ(kCollateDefault, output.collate_default); |
| EXPECT_EQ(kCopiesMax, output.copies_max); |
| EXPECT_EQ(kDuplexModes, output.duplex_modes); |
| EXPECT_EQ(kDuplexDefault, output.duplex_default); |
| EXPECT_EQ(kColorChangeable, output.color_changeable); |
| EXPECT_EQ(kColorDefault, output.color_default); |
| EXPECT_EQ(kColorModel, output.color_model); |
| EXPECT_EQ(kBwModel, output.bw_model); |
| EXPECT_EQ(kPapers, output.papers); |
| EXPECT_EQ(kUserDefinedPapers, output.user_defined_papers); |
| EXPECT_TRUE(kDefaultPaper == output.default_paper); |
| EXPECT_EQ(kDpis, output.dpis); |
| EXPECT_EQ(kDefaultDpi, output.default_dpi); |
| EXPECT_EQ(kMediaTypes, output.media_types); |
| EXPECT_EQ(kDefaultMediaType, output.default_media_type); |
| #if BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(kPinSupported, output.pin_supported); |
| EXPECT_EQ(kAdvancedCapabilities, output.advanced_capabilities); |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsCopiesMax) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with no copies. |
| input.copies_max = 0; |
| |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsAllowableEmptyArrays) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with arrays which are allowed to be empty: |
| // `duplex_modes`, `user_defined_papers`, `dpis`, `advanced_capabilities`. |
| const std::vector<mojom::DuplexMode> kEmptyDuplexModes; |
| const PrinterSemanticCapsAndDefaults::Papers kEmptyUserDefinedPapers; |
| const std::vector<gfx::Size> kEmptyDpis; |
| #if BUILDFLAG(IS_CHROMEOS) |
| const AdvancedCapabilities kEmptyAdvancedCapabilities; |
| #endif |
| |
| input.duplex_modes = kEmptyDuplexModes; |
| input.user_defined_papers = kEmptyUserDefinedPapers; |
| input.dpis = kEmptyDpis; |
| #if BUILDFLAG(IS_CHROMEOS) |
| input.advanced_capabilities = kEmptyAdvancedCapabilities; |
| #endif |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kEmptyDuplexModes, output.duplex_modes); |
| EXPECT_EQ(kEmptyUserDefinedPapers, output.user_defined_papers); |
| EXPECT_EQ(kEmptyDpis, output.dpis); |
| #if BUILDFLAG(IS_CHROMEOS) |
| EXPECT_EQ(kEmptyAdvancedCapabilities, output.advanced_capabilities); |
| #endif |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsEmptyPapers) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with empty `papers`. This is known to be possible, seen |
| // with Epson PX660 series driver. |
| const PrinterSemanticCapsAndDefaults::Papers kEmptyPapers; |
| input.papers.clear(); |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kEmptyPapers, output.papers); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsEmptyMediaTypes) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with empty `media_types`. |
| const PrinterSemanticCapsAndDefaults::MediaTypes kEmptyMediaTypes; |
| input.media_types.clear(); |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kEmptyMediaTypes, output.media_types); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsNoDuplicatesInArrays) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with arrays containing duplicates, which is not allowed. |
| input.duplex_modes = {mojom::DuplexMode::kLongEdge, |
| mojom::DuplexMode::kSimplex, |
| mojom::DuplexMode::kSimplex}; |
| |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| input = GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| input.user_defined_papers = {kPaperLetter, kPaperLetter}; |
| |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| // Use an advanced capability with same name but different other fields. |
| AdvancedCapability advanced_capability1_prime = kAdvancedCapability1; |
| advanced_capability1_prime.type = AdvancedCapability::Type::kInteger; |
| advanced_capability1_prime.default_value = "42"; |
| input = GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| input.advanced_capabilities = {kAdvancedCapability1, |
| advanced_capability1_prime}; |
| |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| #endif |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsAllowedDuplicatesInArrays) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| PrinterSemanticCapsAndDefaults output; |
| |
| // Override sample with arrays containing duplicates where it is allowed. |
| // Duplicate DPIs are known to be possible, seen with the Kyocera KX driver. |
| const std::vector<gfx::Size> kDuplicateDpis{kDpi600, kDpi600, kDpi1200}; |
| input.dpis = kDuplicateDpis; |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kDuplicateDpis, output.dpis); |
| |
| // Duplicate papers are known to be possible, seen with the Konica Minolta |
| // 4750 Series PS driver. |
| // Use a paper with same name but different size. |
| PrinterSemanticCapsAndDefaults::Paper paper_a4_prime( |
| kPaperA4.display_name(), kPaperA4.vendor_id(), kPaperLetter.size_um(), |
| kPaperA4.printable_area_um()); |
| input = GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| const PrinterSemanticCapsAndDefaults::Papers kDuplicatePapers{ |
| kPaperA4, kPaperLetter, kPaperLedger, paper_a4_prime}; |
| input.papers = kDuplicatePapers; |
| |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| |
| EXPECT_EQ(kDuplicatePapers, output.papers); |
| } |
| |
| #if BUILDFLAG(IS_WIN) |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePageOutputQualityAttribute) { |
| PageOutputQualityAttribute input = kPageOutputQualityAttribute1; |
| PageOutputQualityAttribute output; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::PageOutputQualityAttribute>( |
| input, output)); |
| EXPECT_EQ(kPageOutputQualityAttribute1.display_name, output.display_name); |
| EXPECT_EQ(kPageOutputQualityAttribute1.name, output.name); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePageOutputQuality) { |
| PageOutputQuality input = kPageOutputQuality; |
| PageOutputQuality output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize<mojom::PageOutputQuality>( |
| input, output)); |
| EXPECT_EQ(kPageOutputQuality.qualities, output.qualities); |
| EXPECT_EQ(kPageOutputQuality.default_quality, output.default_quality); |
| } |
| |
| TEST(PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsXpsCapabilities) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults( |
| SampleWithPageOutputQuality()); |
| PrinterSemanticCapsAndDefaults output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| ASSERT_TRUE(output.page_output_quality); |
| EXPECT_EQ(kPageOutputQuality.qualities, |
| output.page_output_quality->qualities); |
| EXPECT_EQ(kPageOutputQuality.default_quality, |
| output.page_output_quality->default_quality); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsAllowableEmptyArraysXpsCapabilities) { |
| const PageOutputQualityAttributes kEmptyQualities; |
| PageOutputQuality quality(kEmptyQualities, /*default_quality=*/absl::nullopt); |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| input.page_output_quality = quality; |
| |
| PrinterSemanticCapsAndDefaults output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| ASSERT_TRUE(output.page_output_quality); |
| EXPECT_EQ(kEmptyQualities, output.page_output_quality->qualities); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsDefaultQualityInArraysXpsCapabilities) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults( |
| SampleWithPageOutputQuality()); |
| input.page_output_quality->default_quality = kDefaultQuality; |
| PrinterSemanticCapsAndDefaults output; |
| EXPECT_TRUE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| ASSERT_TRUE(output.page_output_quality); |
| EXPECT_EQ(kPageOutputQuality.qualities, |
| output.page_output_quality->qualities); |
| EXPECT_EQ(kDefaultQuality, output.page_output_quality->default_quality); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsMissingDefaultQualityInArraysXpsCapabilities) { |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults( |
| SampleWithPageOutputQuality()); |
| |
| // Default quality is non-null, but there is no quality with same name as |
| // default quality, which is not allowed. |
| input.page_output_quality->default_quality = "ns000:MissingDefault"; |
| PrinterSemanticCapsAndDefaults output; |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| } |
| |
| TEST( |
| PrintBackendMojomTraitsTest, |
| TestSerializeAndDeserializePrinterSemanticCapsAndDefaultsNoDuplicatesInArraysXpsCapabilities) { |
| // `kPageOutputQualityAttributePrime` has same display_name and name with |
| // `kPageOutputQualityAttribute1`, which is not allowed. |
| const PageOutputQualityAttribute kPageOutputQualityAttributePrime( |
| /*display_name=*/"Normal", |
| /*name=*/"ns000:Normal"); |
| PageOutputQuality page_output_quality( |
| {kPageOutputQualityAttribute1, kPageOutputQualityAttributePrime, |
| kPageOutputQualityAttribute2}, |
| /*default_quality=*/absl::nullopt); |
| PrinterSemanticCapsAndDefaults input = |
| GenerateSamplePrinterSemanticCapsAndDefaults({}); |
| input.page_output_quality = page_output_quality; |
| PrinterSemanticCapsAndDefaults output; |
| EXPECT_FALSE(mojo::test::SerializeAndDeserialize< |
| mojom::PrinterSemanticCapsAndDefaults>(input, output)); |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| |
| } // namespace printing |