// 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 "chromeos/printing/ppd_metadata_parser.h"
#include <string_view>
#include "base/json/json_reader.h"
#include "chromeos/printing/ppd_metadata_matchers.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chromeos {
namespace {
using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::ExplainMatchResult;
using ::testing::Field;
using ::testing::Ne;
using ::testing::Optional;
using ::testing::Pair;
using ::testing::StrEq;
using ::testing::UnorderedElementsAre;
constexpr std::string_view kInvalidJson = "blah blah invalid JSON";
// Verifies that ParseLocales() can parse locales metadata.
TEST(PpdMetadataParserTest, CanParseLocales) {
constexpr std::string_view kLocalesJson = R"(
{
"locales": [ "de", "en", "es", "jp" ]
}
)";
const auto parsed = ParseLocales(kLocalesJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
ElementsAre(StrEq("de"), StrEq("en"), StrEq("es"), StrEq("jp")));
}
// Verifies that ParseLocales() can parse locales and return a partial
// list even when it encounters unexpected values.
TEST(PpdMetadataParserTest, CanPartiallyParseLocales) {
// The values "0.0" and "78" are gibberish that ParseLocales() shall
// ignore; however, these don't structurally foul the JSON, so it can
// still return the other locales.
constexpr std::string_view kLocalesJson = R"(
{
"locales": [ 0.0, "de", 78, "en", "es", "jp" ]
}
)";
const auto parsed = ParseLocales(kLocalesJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
ElementsAre(StrEq("de"), StrEq("en"), StrEq("es"), StrEq("jp")));
}
// Verifies that ParseLocales() returns std::nullopt rather than an
// empty container.
TEST(PpdMetadataParserTest, ParseLocalesDoesNotReturnEmptyContainer) {
// The values "0.0" and "78" are gibberish that ParseLocales() shall
// ignore; while the JSON is still well-formed, the parsed list of
// locales contains no values.
constexpr std::string_view kLocalesJson = R"(
{
"locales": [ 0.0, 78 ]
}
)";
EXPECT_FALSE(ParseLocales(kLocalesJson).has_value());
}
// Verifies that ParseLocales() returns std::nullopt on irrecoverable
// parse error.
TEST(PpdMetadataParserTest, ParseLocalesFailsGracefully) {
EXPECT_FALSE(ParseLocales(kInvalidJson).has_value());
}
// Verifies that ParseManufacturers() can parse manufacturers metadata.
TEST(PpdMetadataParserTest, CanParseManufacturers) {
constexpr std::string_view kManufacturersJson = R"(
{
"filesMap": {
"Andante": "andante-en.json",
"Sostenuto": "sostenuto-en.json"
}
}
)";
const auto parsed = ParseManufacturers(kManufacturersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
UnorderedElementsAre(
Pair(StrEq("Andante"), StrEq("andante-en.json")),
Pair(StrEq("Sostenuto"), StrEq("sostenuto-en.json"))));
}
// Verifies that ParseManufacturers() can parse manufacturers and return
// a partial list even when it encounters unexpected values.
TEST(PpdMetadataParserTest, CanPartiallyParseManufacturers) {
// Contains an embedded dictionary keyed on "Dearie me."
// ParseManufacturers() shall ignore this.
constexpr std::string_view kManufacturersJson = R"(
{
"filesMap": {
"Dearie me": {
"I didn't": "expect",
"to go": "deeper"
},
"Andante": "andante-en.json",
"Sostenuto": "sostenuto-en.json"
}
}
)";
const auto parsed = ParseManufacturers(kManufacturersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
UnorderedElementsAre(
Pair(StrEq("Andante"), StrEq("andante-en.json")),
Pair(StrEq("Sostenuto"), StrEq("sostenuto-en.json"))));
}
// Verifies that ParseManufacturers() returns std::nullopt rather than
// an empty container.
TEST(PpdMetadataParserTest, ParseManufacturersDoesNotReturnEmptyContainer) {
// Contains an embedded dictionary keyed on "Dearie me."
// ParseManufacturers() shall ignore this, but in doing so shall leave
// its ParsedManufacturers return value empty.
constexpr std::string_view kManufacturersJson = R"(
{
"filesMap": {
"Dearie me": {
"I didn't": "expect",
"to go": "deeper"
}
}
}
)";
EXPECT_FALSE(ParseManufacturers(kManufacturersJson).has_value());
}
// Verifies that ParseManufacturers() returns std::nullopt on
// irrecoverable parse error.
TEST(PpdMetadataParserTest, ParseManufacturersFailsGracefully) {
EXPECT_FALSE(ParseManufacturers(kInvalidJson).has_value());
}
// Verifies that ParsePrinters() can parse printers metadata.
TEST(PpdMetadataParserTest, CanParsePrinters) {
constexpr std::string_view kPrintersJson = R"(
{
"printers": [ {
"emm": "d 547b",
"name": "An die Musik"
}, {
"emm": "d 553",
"name": "Auf der Donau"
} ]
}
)";
const auto parsed = ParsePrinters(kPrintersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed, UnorderedElementsAre(
ParsedPrinterLike("An die Musik", "d 547b"),
ParsedPrinterLike("Auf der Donau", "d 553")));
}
// Verifies that ParsePrinters() can parse printers and return a partial
// list even when it encounters unexpected values.
TEST(PpdMetadataParserTest, CanPartiallyParsePrinters) {
// Contains an extra value keyed on "hello" in an otherwise valid leaf
// value in Printers metadata. ParsePrinters() shall ignore this.
constexpr std::string_view kPrintersJson = R"(
{
"printers": [ {
"emm": "d 552",
"name": "Hänflings Liebeswerbung",
"hello": "there!"
}, {
"emm": "d 553",
"name": "Auf der Donau"
} ]
}
)";
const auto parsed = ParsePrinters(kPrintersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
UnorderedElementsAre(
ParsedPrinterLike("Hänflings Liebeswerbung", "d 552"),
ParsedPrinterLike("Auf der Donau", "d 553")));
}
// Verifies that ParsePrinters() can parse printers and their
// well-formed restrictions (if any are specified).
TEST(PpdMetadataParserTest, CanParsePrintersWithRestrictions) {
// Specifies
// * a printer with a minimum milestone,
// * a printer with a maximum milestone, and
// * a printer with both minimum and maximum milestones.
constexpr std::string_view kPrintersJson = R"(
{
"printers": [ {
"emm": "d 121",
"name": "Schäfers Klagelied",
"restriction": {
"minMilestone": 121
}
}, {
"emm": "d 216",
"name": "Meeres Stille",
"restriction": {
"maxMilestone": 216
}
}, {
"emm": "d 257",
"name": "Heidenröslein",
"restriction": {
"minMilestone": 216,
"maxMilestone": 257
}
} ]
}
)";
const auto parsed = ParsePrinters(kPrintersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed,
UnorderedElementsAre(
AllOf(ParsedPrinterLike("Schäfers Klagelied", "d 121"),
Field(&ParsedPrinter::restrictions,
RestrictionsWithMinMilestone(121))),
AllOf(ParsedPrinterLike("Meeres Stille", "d 216"),
Field(&ParsedPrinter::restrictions,
RestrictionsWithMaxMilestone(216))),
AllOf(ParsedPrinterLike("Heidenröslein", "d 257"),
Field(&ParsedPrinter::restrictions,
RestrictionsWithMinAndMaxMilestones(216, 257)))));
}
// Verifies that ParsePrinters() can parse printers and ignore
// malformed restrictions.
TEST(PpdMetadataParserTest, CanParsePrintersWithMalformedRestrictions) {
// Specifies a printer with invalid restrictions.
constexpr std::string_view kPrintersJson = R"(
{
"printers": [ {
"emm": "d 368",
"name": "Jägers Abendlied",
"restriction": {
"hello": "there!"
}
} ]
}
)";
const auto parsed = ParsePrinters(kPrintersJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
*parsed,
UnorderedElementsAre(
AllOf(ParsedPrinterLike("Jägers Abendlied", "d 368"),
Field(&ParsedPrinter::restrictions, UnboundedRestrictions()))));
}
// Verifies that ParsePrinters() returns std::nullopt rather than an
// empty container.
TEST(PpdMetadataParserTest, ParsePrintersDoesNotReturnEmptyContainer) {
// No printers are specified in this otherwise valid JSON dictionary.
EXPECT_FALSE(ParsePrinters("{}").has_value());
}
// Verifies that ParsePrinters() returns std::nullopt on irrecoverable
// parse error.
TEST(PpdMetadataParserTest, ParsePrintersFailsGracefully) {
EXPECT_FALSE(ParsePrinters(kInvalidJson).has_value());
}
// Verifies that ParseForwardIndex() can parse forward index metadata.
TEST(PpdMetadataParserTest, CanParseForwardIndex) {
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"der wanderer": {
"ppdMetadata": [ {
"name": "d-489.ppd.gz"
} ]
},
"morgenlied": {
"ppdMetadata": [ {
"name": "d-685.ppd.gz"
} ]
},
"wandrers nachtlied": {
"ppdMetadata": [ {
"name": "d-224.ppd.gz"
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
parsed.value(),
UnorderedElementsAre(
ParsedIndexEntryLike(
"der wanderer",
UnorderedElementsAre(
ParsedIndexLeafWithPpdBasename("d-489.ppd.gz"))),
ParsedIndexEntryLike(
"morgenlied", UnorderedElementsAre(ParsedIndexLeafWithPpdBasename(
"d-685.ppd.gz"))),
ParsedIndexEntryLike(
"wandrers nachtlied",
UnorderedElementsAre(
ParsedIndexLeafWithPpdBasename("d-224.ppd.gz")))));
}
// Verifies that ParseForwardIndex() can parse forward index metadata
// and return a partial list even when it encounters unexpected values.
TEST(PpdMetadataParserTest, CanPartiallyParseForwardIndex) {
// Uses the same value as the CanParseForwardIndex test, but
// with garbage values mixed in.
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"garbage": "unused value",
"more garbage": [ "more", "unused", "values" ],
"der wanderer": {
"ppdMetadata": [ {
"name": "d-489.ppd.gz",
"more garbage still": "unused value"
}, {
"also garbage": "unused value"
} ],
"unending garbage": "unused value"
},
"morgenlied": {
"ppdMetadata": [ {
"name": "d-685.ppd.gz"
} ]
},
"wandrers nachtlied": {
"ppdMetadata": [ {
"name": "d-224.ppd.gz"
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
parsed.value(),
UnorderedElementsAre(
ParsedIndexEntryLike(
"der wanderer",
UnorderedElementsAre(
ParsedIndexLeafWithPpdBasename("d-489.ppd.gz"))),
ParsedIndexEntryLike(
"morgenlied", UnorderedElementsAre(ParsedIndexLeafWithPpdBasename(
"d-685.ppd.gz"))),
ParsedIndexEntryLike(
"wandrers nachtlied",
UnorderedElementsAre(
ParsedIndexLeafWithPpdBasename("d-224.ppd.gz")))));
}
// Verifies that ParseForwardIndex() can parse forward index metadata
// in which leaf values have multiple ppdMetadata key-value pairs.
TEST(PpdMetadataParserTest, CanParseForwardIndexWithMultiplePpdMetadataLeafs) {
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"rastlose liebe": {
"ppdMetadata": [ {
"name": "d-138.ppd.gz"
}, {
"name": "1815.ppd.gz"
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(parsed.value(),
UnorderedElementsAre(ParsedIndexEntryLike(
"rastlose liebe",
UnorderedElementsAre(
ParsedIndexLeafWithPpdBasename("d-138.ppd.gz"),
ParsedIndexLeafWithPpdBasename("1815.ppd.gz")))));
}
// Verifies that ParseForwardIndex() can parse forward index metadata
// and its well-formed restrictions (if any are specified).
TEST(PpdMetadataParserTest, CanParseForwardIndexWithRestrictions) {
// Specifies
// * a PPD metadata leaf with a minimum milestone,
// * a PPD metadata leaf with a maximum milestone, and
// * a PPD metadata leaf with both minimum and maximum milestones.
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"nähe des geliebten": {
"ppdMetadata": [ {
"name": "d-162.ppd.gz",
"restriction": {
"minMilestone": 25
}
} ]
},
"der fischer": {
"ppdMetadata": [ {
"name": "d-225.ppd.gz",
"restriction": {
"maxMilestone": 35
}
} ]
},
"erster verlust": {
"ppdMetadata": [ {
"name": "d-226.ppd.gz",
"restriction": {
"minMilestone": 45,
"maxMilestone": 46
}
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
parsed.value(),
UnorderedElementsAre(
ParsedIndexEntryLike(
"nähe des geliebten",
UnorderedElementsAre(
AllOf(ParsedIndexLeafWithPpdBasename("d-162.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
RestrictionsWithMinMilestone(25))))),
ParsedIndexEntryLike(
"der fischer", UnorderedElementsAre(AllOf(
ParsedIndexLeafWithPpdBasename("d-225.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
RestrictionsWithMaxMilestone(35))))),
ParsedIndexEntryLike(
"erster verlust",
UnorderedElementsAre(
AllOf(ParsedIndexLeafWithPpdBasename("d-226.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
RestrictionsWithMinAndMaxMilestones(45, 46)))))));
}
// Verifies that ParseForwardIndex() can parse forward index metadata
// and ignore malformed restrictions.
TEST(PpdMetadataParserTest, CanParseForwardIndexWithMalformedRestrictions) {
// Same test data as the CanParseForwardIndexWithRestrictions test
// above, but defines
// * a PPD metadata leaf with a malformed minimum milestone,
// * a PPD metadata leaf with a malformed maximum milestone, and
// * a PPD metadata leaf with malformed minimum and maximum
// milestones.
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"nähe des geliebten": {
"ppdMetadata": [ {
"name": "d-162.ppd.gz",
"restriction": {
"minMilestone": "garbage value",
"maxMilestone": 25
}
} ]
},
"der fischer": {
"ppdMetadata": [ {
"name": "d-225.ppd.gz",
"restriction": {
"minMilestone": 35,
"maxMilestone": "garbage value"
}
} ]
},
"erster verlust": {
"ppdMetadata": [ {
"name": "d-226.ppd.gz",
"restriction": {
"minMilestone": "garbage value",
"maxMilestone": "garbage value"
}
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
parsed.value(),
UnorderedElementsAre(
ParsedIndexEntryLike(
"nähe des geliebten",
UnorderedElementsAre(
AllOf(ParsedIndexLeafWithPpdBasename("d-162.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
RestrictionsWithMaxMilestone(25))))),
ParsedIndexEntryLike(
"der fischer", UnorderedElementsAre(AllOf(
ParsedIndexLeafWithPpdBasename("d-225.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
RestrictionsWithMinMilestone(35))))),
ParsedIndexEntryLike(
"erster verlust",
UnorderedElementsAre(
AllOf(ParsedIndexLeafWithPpdBasename("d-226.ppd.gz"),
Field(&ParsedIndexLeaf::restrictions,
UnboundedRestrictions()))))));
}
// Verifies that ParseForwardIndex() can parse forward index metadata
// specifying PPD licenses.
TEST(PpdMetadataParserTest, CanParseForwardIndexWithLicenses) {
// Specifies two PPDs, each with a license associated.
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"der fischer": {
"ppdMetadata": [ {
"name": "d-225.ppd.gz",
"license": "two two five license"
} ]
},
"erster verlust": {
"ppdMetadata": [ {
"name": "d-226.ppd.gz",
"license": "two two six license"
} ]
}
}
})";
const auto parsed = ParseForwardIndex(kJsonForwardIndex);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(
parsed.value(),
UnorderedElementsAre(
ParsedIndexEntryLike(
"der fischer", UnorderedElementsAre(AllOf(
ParsedIndexLeafWithPpdBasename("d-225.ppd.gz"),
Field(&ParsedIndexLeaf::license,
StrEq("two two five license"))))),
ParsedIndexEntryLike(
"erster verlust",
UnorderedElementsAre(
AllOf(ParsedIndexLeafWithPpdBasename("d-226.ppd.gz"),
Field(&ParsedIndexLeaf::license,
StrEq("two two six license")))))));
}
// Verifies that ParseForwardIndex() returns std::nullopt rather than
// an empty container.
TEST(PpdMetadataParserTest, ParseForwardIndexDoesNotReturnEmptyContainer) {
// Specifies a forward index that is valid JSON but which has
// no PPDs whose leaf values are non-empty.
constexpr std::string_view kJsonForwardIndex = R"({
"ppdIndex": {
"der könig in thule": {
"ppdMetadata": [ {
"garbage": "unused value"
} ]
}
}
})";
EXPECT_FALSE(ParseForwardIndex(kJsonForwardIndex).has_value());
}
// Verifies that ParseForwardIndex() returns std::nullopt on
// irrecoverable parse error.
TEST(PpdMetadataParserTest, ParseForwardIndexFailsGracefully) {
EXPECT_FALSE(ParseForwardIndex(kInvalidJson).has_value());
}
// Verifies that ParseUsbIndex() can parse USB index metadata.
TEST(PpdMetadataParserTest, CanParseUsbIndex) {
constexpr std::string_view kJsonUsbIndex = R"({
"usbIndex": {
"1": {
"effectiveMakeAndModel": "d 541"
},
"10": {
"effectiveMakeAndModel": "d 504"
}
}
})";
EXPECT_THAT(ParseUsbIndex(kJsonUsbIndex),
Optional(UnorderedElementsAre(Pair(1, StrEq("d 541")),
Pair(10, StrEq("d 504")))));
}
// Verifies that ParseUsbIndex() can parse USB index metadata and return
// a partial ParsedUsbIndex even when it encounters garbage values.
TEST(PpdMetadataParserTest, CanPartiallyParseUsbIndex) {
constexpr std::string_view kJsonUsbIndex = R"({
"usbIndex": {
"garbage key": {
"effectiveMakeAndModel": "garbage value"
},
"1": {
"effectiveMakeAndModel": "d 541"
},
"10": {
"effectiveMakeAndModel": "d 504"
}
}
})";
EXPECT_THAT(ParseUsbIndex(kJsonUsbIndex),
Optional(UnorderedElementsAre(Pair(1, StrEq("d 541")),
Pair(10, StrEq("d 504")))));
}
// Verifies that ParseUsbIndex() returns std::nullopt rather than an
// empty container.
TEST(PpdMetadataParserTest, ParseUsbIndexDoesNotReturnEmptyContainer) {
constexpr std::string_view kEmptyJsonUsbIndex = R"({
"usbIndex": { }
})";
ASSERT_THAT(base::JSONReader::Read(kEmptyJsonUsbIndex), Ne(std::nullopt));
EXPECT_THAT(ParseUsbIndex(kEmptyJsonUsbIndex), Eq(std::nullopt));
constexpr std::string_view kJsonUsbIndexWithBadStringKeys = R"({
"usbIndex": {
"non-integral key": { }
}
})";
ASSERT_THAT(base::JSONReader::Read(kJsonUsbIndexWithBadStringKeys),
Ne(std::nullopt));
EXPECT_THAT(ParseUsbIndex(kJsonUsbIndexWithBadStringKeys), Eq(std::nullopt));
constexpr std::string_view kJsonUsbIndexWithoutEmmAtLeaf = R"({
"usbIndex": {
"1": {
"some key that is not ``effectiveMakeAndModel''": "d 504"
}
}
})";
ASSERT_THAT(base::JSONReader::Read(kJsonUsbIndexWithoutEmmAtLeaf),
Ne(std::nullopt));
EXPECT_THAT(ParseUsbIndex(kJsonUsbIndexWithoutEmmAtLeaf), Eq(std::nullopt));
constexpr std::string_view kJsonUsbIndexWithEmptyEmmAtLeaf = R"({
"usbIndex": {
"1": {
"effectiveMakeAndModel": ""
}
}
})";
ASSERT_THAT(base::JSONReader::Read(kJsonUsbIndexWithEmptyEmmAtLeaf),
Ne(std::nullopt));
EXPECT_THAT(ParseUsbIndex(kJsonUsbIndexWithEmptyEmmAtLeaf), Eq(std::nullopt));
}
// Verifies that ParseUsbIndex() returns std::nullopt on irrecoverable
// parse error.
TEST(PpdMetadataParserTest, ParseUsbIndexFailsGracefully) {
EXPECT_THAT(ParseUsbIndex(kInvalidJson), Eq(std::nullopt));
}
// Verifies that ParseUsbvendorIdMap() can parse USB vendor ID maps.
TEST(PpdMetadataParserTest, CanParseUsbVendorIdMap) {
constexpr std::string_view kJsonUsbVendorIdMap = R"({
"entries": [ {
"vendorId": 1111,
"vendorName": "One One One One"
}, {
"vendorId": 2222,
"vendorName": "Two Two Two Two"
}, {
"vendorId": 3333,
"vendorName": "Three Three Three Three"
} ]
})";
EXPECT_THAT(ParseUsbVendorIdMap(kJsonUsbVendorIdMap),
Optional(UnorderedElementsAre(
Pair(1111, StrEq("One One One One")),
Pair(2222, StrEq("Two Two Two Two")),
Pair(3333, StrEq("Three Three Three Three")))));
}
// Verifies that ParseUsbvendorIdMap() can parse USB vendor ID maps and
// return partial results even when it encounters garbage values.
TEST(PpdMetadataParserTest, CanPartiallyParseUsbVendorIdMap) {
// This USB vendor ID map has garbage values in it.
// ParseUsbVendorIdMap() shall ignore these.
constexpr std::string_view kJsonUsbVendorIdMap = R"({
"garbage key": "garbage value",
"entries": [
"garbage value",
{
"vendorId": 1111,
"garbage key": "garbage value",
"vendorName": "One One One One"
}, {
"vendorId": 2222,
"vendorName": "Two Two Two Two"
}, {
"vendorId": 3333,
"vendorName": "Three Three Three Three"
} ]
})";
EXPECT_THAT(ParseUsbVendorIdMap(kJsonUsbVendorIdMap),
Optional(UnorderedElementsAre(
Pair(1111, StrEq("One One One One")),
Pair(2222, StrEq("Two Two Two Two")),
Pair(3333, StrEq("Three Three Three Three")))));
}
// Verifies that ParseUsbvendorIdMap() returns std::nullopt rather
// than an empty container.
TEST(PpdMetadataParserTest, ParseUsbVendorIdMapDoesNotReturnEmptyContainer) {
// Defines a USB vendor ID map that is empty; it's valid JSON, but
// has no values worth returning.
constexpr std::string_view kJsonUsbVendorIdMap = "{}";
EXPECT_THAT(ParseUsbVendorIdMap(kJsonUsbVendorIdMap), Eq(std::nullopt));
}
// Verifies that ParseUsbvendorIdMap() returns std::nullopt on
// irrecoverable parse error.
TEST(PpdMetadataParserTest, ParseUsbVendorIdMapFailsGracefully) {
EXPECT_THAT(ParseUsbVendorIdMap(kInvalidJson), Eq(std::nullopt));
}
// Verifies that ParseReverseIndex() can parse reverse index metadata.
TEST(PpdMetadataParserTest, CanParseReverseIndex) {
constexpr std::string_view kReverseIndexJson = R"(
{
"reverseIndex": {
"Die Forelle D 550d": {
"manufacturer": "metsukabi",
"model": "kimebe"
},
"Gruppe aus dem Tartarus D 583": {
"manufacturer": "teiga",
"model": "dahuho"
}
}
}
)";
const auto parsed = ParseReverseIndex(kReverseIndexJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed, UnorderedElementsAre(
Pair(StrEq("Die Forelle D 550d"),
ReverseIndexLeafLike("metsukabi", "kimebe")),
Pair(StrEq("Gruppe aus dem Tartarus D 583"),
ReverseIndexLeafLike("teiga", "dahuho"))));
}
// Verifies that ParseReverseIndex() can parse reverse index metadata
// and return a partial list even when it encounters unexpected values.
TEST(PpdMetadataParserTest, CanPartiallyParseReverseIndex) {
// Contains two unexpected values (keyed on "Dearie me" and "to go").
// ParseReverseIndex() shall ignore these.
constexpr std::string_view kReverseIndexJson = R"(
{
"reverseIndex": {
"Dearie me": "one doesn't expect",
"to go": "any deeper",
"Elysium D 584": {
"manufacturer": "nahopenu",
"model": "sapudo"
},
"An den Tod D 518": {
"manufacturer": "suwaka",
"model": "zogegi"
}
}
}
)";
const auto parsed = ParseReverseIndex(kReverseIndexJson);
ASSERT_TRUE(parsed.has_value());
EXPECT_THAT(*parsed, UnorderedElementsAre(
Pair(StrEq("Elysium D 584"),
ReverseIndexLeafLike("nahopenu", "sapudo")),
Pair(StrEq("An den Tod D 518"),
ReverseIndexLeafLike("suwaka", "zogegi"))));
}
// Verifies that ParseReverseIndex() returns std::nullopt rather than
// an empty container.
TEST(PpdMetadataParserTest, ParseReverseIndexDoesNotReturnEmptyContainer) {
// Contains two unexpected values (keyed on "Dearie me" and "to go").
// ParseReverseIndex() shall ignore this, but in doing so shall make the
// returned ParsedReverseIndex empty.
constexpr std::string_view kReverseIndexJson = R"(
{
"reverseIndex": {
"Dearie me": "one doesn't expect",
"to go": "any deeper"
}
}
)";
EXPECT_FALSE(ParseReverseIndex(kReverseIndexJson).has_value());
}
// Verifies that ParseReverseIndex() returns std::nullopt on
// irrecoverable parse error.
TEST(PpdMetadataParserTest, ParseReverseIndexFailsGracefully) {
EXPECT_FALSE(ParseReverseIndex(kInvalidJson).has_value());
}
} // namespace
} // namespace chromeos
Codebase Browser
chromium