Create a new print backend for the updated CUPS APIs

printing/backend/cups_ipp_util_unittest.cc

Index: printing/backend/cups_ipp_util_unittest.cc
diff --git a/printing/backend/cups_ipp_util_unittest.cc b/printing/backend/cups_ipp_util_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c30eff9f14b37a52a836ca074a1c58e221bcec82
--- /dev/null
+++ b/printing/backend/cups_ipp_util_unittest.cc
@@ -0,0 +1,191 @@
+// Copyright 2016 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 <cups/cups.h>
+
+#include <map>
+
+#include "base/logging.h"
+#include "printing/backend/cups_ipp_util.h"
+#include "printing/backend/cups_printer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+class MockCupsOptionProvider : public printing::CupsOptionProvider {
+ public:
+  ~MockCupsOptionProvider() override {}
+
+  ipp_attribute_t* GetSupportedOptionValues(
+      base::StringPiece option_name) const override {
+    const auto attr = supported_attributes_.find(option_name);
+    return attr != supported_attributes_.end() ? attr->second : nullptr;
+  }
+
+  std::vector<base::StringPiece> GetSupportedOptionValueStrings(
+      base::StringPiece option_name) const override {
+    ipp_attribute_t* attr = GetSupportedOptionValues(option_name);
+    if (!attr)
+      return std::vector<base::StringPiece>();
+
+    std::vector<base::StringPiece> strings;
+    int size = ippGetCount(attr);
+    for (int i = 0; i < size; ++i) {
+      strings.emplace_back(ippGetString(attr, i, NULL));

[Lei Zhang, 2016/07/21 00:46:19]

nullptr, more below. :-P

[skau, 2016/07/21 20:07:31]

I'll break this habit soon!

+    }
+
+    return strings;
+  }
+
+  ipp_attribute_t* GetDefaultOptionValue(
+      base::StringPiece option_name) const override {
+    const auto attr = default_attributes_.find(option_name);
+    return attr != default_attributes_.end() ? attr->second : nullptr;
+  }
+
+  bool CheckOptionSupported(base::StringPiece name,
+                            base::StringPiece value) const override {
+    NOTREACHED();
+    return false;
+  }
+
+  void SetSupportedOptions(base::StringPiece name, ipp_attribute_t* attribute) {
+    supported_attributes_[name] = attribute;
+  }
+
+  void SetOptionDefault(base::StringPiece name, ipp_attribute_t* attribute) {
+    default_attributes_[name] = attribute;
+  }
+
+ private:
+  std::map<base::StringPiece, ipp_attribute_t*> supported_attributes_;
+  std::map<base::StringPiece, ipp_attribute_t*> default_attributes_;
+};
+
+class PrintBackendCupsIppUtilTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    ipp_ = ippNew();
+    printer_ = new MockCupsOptionProvider();
+  }
+
+  void TearDown() override {
+    ippDelete(ipp_);
+    delete printer_;

[Lei Zhang, 2016/07/21 00:46:19]

unique_ptr, reset() here.

[skau, 2016/07/21 20:07:31]

Done.

+  }
+
+  ipp_t* ipp_;
+  MockCupsOptionProvider* printer_;
+};
+
+ipp_attribute_t* MakeRange(ipp_t* ipp, int lower_bound, int upper_bound) {
+  return ippAddRange(ipp, IPP_TAG_PRINTER, "TEST_DATA", lower_bound,
+                     upper_bound);
+}
+
+ipp_attribute_t* MakeString(ipp_t* ipp, const char* value) {
+  return ippAddString(ipp, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "TEST_DATA", NULL,
+                      value);
+}
+
+ipp_attribute_t* MakeStringCollection(ipp_t* ipp,
+                                      std::vector<const char*> strings) {
+  return ippAddStrings(ipp, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "TEST_DATA",
+                       strings.size(), NULL, strings.data());
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, CopiesCapable) {
+  printer_->SetSupportedOptions("copies", MakeRange(ipp_, 1, 2));
+
+  printing::PrinterSemanticCapsAndDefaults caps;

[Lei Zhang, 2016/07/21 00:46:19]

Put the entire thing in namespace printing and save yourself some typing.

[skau, 2016/07/21 20:07:31]

Done.

+

[Lei Zhang, 2016/07/21 00:46:19]

too

many

blank spaces.

[skau, 2016/07/21 20:07:31]

lol

+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_TRUE(caps.copies_capable);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, CopiesNotCapable) {
+  // copies missing, no setup
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.copies_capable);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, ColorPrinter) {
+  printer_->SetSupportedOptions(
+      "print-color-mode", MakeStringCollection(ipp_, {"color", "monochrome"}));
+  printer_->SetOptionDefault("print-color-mode", MakeString(ipp_, "color"));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_TRUE(caps.color_changeable);
+  EXPECT_TRUE(caps.color_default);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, BWPrinter) {
+  printer_->SetSupportedOptions("print-color-mode",
+                                MakeStringCollection(ipp_, {"monochrome"}));
+  printer_->SetOptionDefault("print-color-mode",
+                             MakeString(ipp_, "monochrome"));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.color_changeable);
+  EXPECT_FALSE(caps.color_default);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, DuplexSupported) {
+  printer_->SetSupportedOptions(
+      "sides",
+      MakeStringCollection(ipp_, {"two-sided-long-edge", "one-sided"}));
+  printer_->SetOptionDefault("sides", MakeString(ipp_, "one-sided"));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_TRUE(caps.duplex_capable);
+  EXPECT_FALSE(caps.duplex_default);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, DuplexNotSupported) {
+  printer_->SetSupportedOptions("sides",
+                                MakeStringCollection(ipp_, {"one-sided"}));
+  printer_->SetOptionDefault("sides", MakeString(ipp_, "one-sided"));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.duplex_capable);
+  EXPECT_FALSE(caps.duplex_default);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, A4PaperSupported) {
+  printer_->SetSupportedOptions(
+      "media", MakeStringCollection(ipp_, {"iso_a4_210x297mm"}));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  printing::PrinterSemanticCapsAndDefaults::Paper paper = caps.papers[0];
+
+  EXPECT_EQ(paper.display_name, "iso a4");

[Lei Zhang, 2016/07/21 00:46:20]

EXPECT_EQ(expected_value, actual_value);

[skau, 2016/07/21 20:07:32]

Done.

+  EXPECT_EQ(paper.vendor_id, "iso_a4_210x297mm");
+  EXPECT_EQ(paper.size_um.width(), 210000);
+  EXPECT_EQ(paper.size_um.height(), 297000);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, LegalPaperDefault) {
+  printer_->SetOptionDefault("media", MakeString(ipp_, "na_legal_8.5x14in"));
+
+  printing::PrinterSemanticCapsAndDefaults caps;
+  printing::CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_EQ(caps.default_paper.display_name, "na legal");
+  EXPECT_EQ(caps.default_paper.vendor_id, "na_legal_8.5x14in");
+  EXPECT_EQ(caps.default_paper.size_um.width(), 215900);
+  EXPECT_EQ(caps.default_paper.size_um.height(), 355600);
+}