| // Copyright 2022 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "attribute.h" |
| |
| #include <iterator> |
| #include <string> |
| #include <type_traits> |
| #include <vector> |
| |
| #include "frame.h" |
| #include <gtest/gtest.h> |
| |
| namespace ipp { |
| namespace { |
| |
| class CollectionTest : public testing::Test { |
| public: |
| CollectionTest() : frame_(Operation::Print_Job, Version::_1_1, 1) { |
| frame_.AddGroup(GroupTag::operation_attributes, coll_); |
| } |
| |
| protected: |
| Frame frame_; |
| CollsView::iterator coll_; |
| }; |
| |
| TEST_F(CollectionTest, AddAttrOutOfBand) { |
| auto err = coll_->AddAttr("test", ValueTag::not_settable); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::not_settable); |
| } |
| |
| TEST_F(CollectionTest, AddAttrEnumAsInt) { |
| auto err = coll_->AddAttr("test-enum", ValueTag::enum_, 1234); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test-enum"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::enum_); |
| int value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value, 1234); |
| } |
| |
| TEST_F(CollectionTest, AddAttrString) { |
| auto err = coll_->AddAttr("abc123", ValueTag::mimeMediaType, "abc&123 DEF"); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("abc123"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::mimeMediaType); |
| std::string value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value, "abc&123 DEF"); |
| } |
| |
| TEST_F(CollectionTest, AddAttrStringWithLanguage) { |
| StringWithLanguage sl; |
| sl.language = "lang_def"; |
| sl.value = "str value"; |
| auto err = coll_->AddAttr("lang", ValueTag::textWithLanguage, sl); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("lang"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::textWithLanguage); |
| StringWithLanguage value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value.language, "lang_def"); |
| EXPECT_EQ(value.value, "str value"); |
| } |
| |
| TEST_F(CollectionTest, AddAttrBool) { |
| auto err = coll_->AddAttr("test", true); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::boolean); |
| int value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value, 1); |
| } |
| |
| TEST_F(CollectionTest, AddAttrInteger) { |
| auto err = coll_->AddAttr("test", -1234567890); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::integer); |
| int32_t value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value, -1234567890); |
| } |
| |
| TEST_F(CollectionTest, AddAttrDateTime) { |
| DateTime dt; |
| dt.year = 2034; |
| dt.month = 6; |
| dt.day = 23; |
| dt.hour = 19; |
| dt.minutes = 59; |
| dt.deci_seconds = 7; |
| dt.UTC_hours = 5; |
| dt.UTC_minutes = 44; |
| auto err = coll_->AddAttr("test", dt); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::dateTime); |
| DateTime value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value.year, 2034); |
| EXPECT_EQ(value.month, 6); |
| EXPECT_EQ(value.day, 23); |
| EXPECT_EQ(value.hour, 19); |
| EXPECT_EQ(value.minutes, 59); |
| EXPECT_EQ(value.seconds, 0); |
| EXPECT_EQ(value.deci_seconds, 7); |
| EXPECT_EQ(value.UTC_direction, '+'); |
| EXPECT_EQ(value.UTC_hours, 5); |
| EXPECT_EQ(value.UTC_minutes, 44); |
| } |
| |
| TEST_F(CollectionTest, AddAttrResolution) { |
| Resolution res(123, 456, Resolution::Units::kDotsPerInch); |
| auto err = coll_->AddAttr("test", res); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::resolution); |
| Resolution value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value.xres, 123); |
| EXPECT_EQ(value.yres, 456); |
| EXPECT_EQ(value.units, Resolution::Units::kDotsPerInch); |
| } |
| |
| TEST_F(CollectionTest, AddAttrRangeOfInteger) { |
| RangeOfInteger roi(-123, 456); |
| auto err = coll_->AddAttr("test", roi); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::rangeOfInteger); |
| RangeOfInteger value; |
| EXPECT_EQ(Code::kOK, attr->GetValue(0, value)); |
| EXPECT_EQ(value.min_value, -123); |
| EXPECT_EQ(value.max_value, 456); |
| } |
| |
| TEST_F(CollectionTest, AddAttrCollection) { |
| CollsView::iterator attr_coll; |
| auto err = coll_->AddAttr("test", attr_coll); |
| EXPECT_EQ(err, Code::kOK); |
| auto attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::collection); |
| EXPECT_EQ(attr->Colls().begin(), attr_coll); |
| } |
| |
| TEST_F(CollectionTest, AddAttrCollections) { |
| CollsView colls; |
| Code err = coll_->AddAttr("test", 3, colls); |
| EXPECT_EQ(err, Code::kOK); |
| EXPECT_EQ(colls.size(), 3); |
| Collection::iterator attr = coll_->GetAttr("test"); |
| ASSERT_NE(attr, coll_->end()); |
| EXPECT_EQ(attr->Tag(), ValueTag::collection); |
| EXPECT_EQ(attr->Colls().begin(), colls.begin()); |
| } |
| |
| TEST_F(CollectionTest, AddAttrInvalidName) { |
| auto err = coll_->AddAttr("", true); |
| EXPECT_EQ(err, Code::kInvalidName); |
| } |
| |
| TEST_F(CollectionTest, AddAttrNameConflict) { |
| auto err = coll_->AddAttr("test", true); |
| EXPECT_EQ(err, Code::kOK); |
| EXPECT_EQ(coll_->AddAttr("test", true), Code::kNameConflict); |
| EXPECT_EQ(coll_->AddAttr("test", ValueTag::unknown), Code::kNameConflict); |
| } |
| |
| TEST_F(CollectionTest, AddAttrValueOutOfRange) { |
| auto err = coll_->AddAttr("aaa", ValueTag::boolean, -1); |
| EXPECT_EQ(err, Code::kValueOutOfRange); |
| EXPECT_EQ(coll_->GetAttr("aaa"), coll_->end()); |
| } |
| |
| TEST_F(CollectionTest, AddAttrInvalidValueTag) { |
| auto err = coll_->AddAttr("xxx", static_cast<ValueTag>(0x0f)); |
| EXPECT_EQ(err, Code::kInvalidValueTag); |
| } |
| |
| TEST_F(CollectionTest, AttributesOrder) { |
| EXPECT_EQ(coll_->AddAttr("a3", true), Code::kOK); |
| EXPECT_EQ(coll_->AddAttr("a1", false), Code::kOK); |
| EXPECT_EQ(coll_->AddAttr("a5", 1234), Code::kOK); |
| EXPECT_EQ(coll_->AddAttr("a4", ValueTag::no_value), Code::kOK); |
| EXPECT_EQ(coll_->AddAttr("a2", ValueTag::uri, "abcde"), Code::kOK); |
| Collection::const_iterator attr = coll_->cbegin(); |
| EXPECT_EQ(attr->Name(), "a3"); |
| ++attr; |
| EXPECT_EQ(attr->Name(), "a1"); |
| ++attr; |
| EXPECT_EQ(attr->Name(), "a5"); |
| ++attr; |
| EXPECT_EQ(attr->Name(), "a4"); |
| ++attr; |
| EXPECT_EQ(attr->Name(), "a2"); |
| ++attr; |
| EXPECT_EQ(attr, coll_->cend()); |
| } |
| |
| TEST_F(CollectionTest, GetAttrFail) { |
| Collection::iterator it = coll_->GetAttr("abc"); |
| EXPECT_EQ(it, coll_->end()); |
| Collection::const_iterator itc = |
| static_cast<Collection::const_iterator>(coll_->GetAttr("abc")); |
| EXPECT_EQ(itc, coll_->end()); |
| CollsView::const_iterator coll_const = |
| static_cast<CollsView::const_iterator>(coll_); |
| EXPECT_EQ(coll_const->GetAttr("abc"), coll_->end()); |
| } |
| |
| TEST_F(CollectionTest, GetAttrSuccess) { |
| coll_->AddAttr("abc", std::vector{true, false}); |
| Collection::iterator it = coll_->GetAttr("abc"); |
| ASSERT_NE(it, coll_->end()); |
| EXPECT_EQ(it->Name(), "abc"); |
| EXPECT_EQ(it->Tag(), ValueTag::boolean); |
| EXPECT_EQ(it->Size(), 2); |
| } |
| |
| TEST_F(CollectionTest, GetAttrSuccessConst) { |
| coll_->AddAttr("abc", std::vector{true, false}); |
| Collection::const_iterator it; |
| it = coll_->GetAttr("abc"); |
| ASSERT_NE(it, coll_->end()); |
| EXPECT_EQ(it->Name(), "abc"); |
| EXPECT_EQ(it->Tag(), ValueTag::boolean); |
| EXPECT_EQ(it->Size(), 2); |
| } |
| |
| TEST_F(CollectionTest, IteratorsForEmptyCollection) { |
| EXPECT_EQ(coll_->begin(), coll_->end()); |
| EXPECT_EQ(coll_->cbegin(), coll_->cend()); |
| CollsView::const_iterator coll_const = |
| static_cast<CollsView::const_iterator>(coll_); |
| EXPECT_EQ(coll_const->begin(), coll_const->end()); |
| } |
| |
| TEST_F(CollectionTest, IteratorsTwoElements) { |
| coll_->AddAttr("test", ValueTag::not_settable); |
| coll_->AddAttr("test2", ValueTag::keyword, |
| std::vector<std::string>{"ala", "ma", "kota"}); |
| std::vector<Collection::iterator> v; |
| v.push_back(coll_->GetAttr("test")); |
| v.push_back(coll_->GetAttr("test2")); |
| size_t index = 0; |
| for (Attribute& attr : *coll_) { |
| ASSERT_LE(index, v.size()); |
| EXPECT_EQ(&attr, &*v[index]); |
| ++index; |
| } |
| EXPECT_EQ(index, v.size()); |
| } |
| |
| TEST_F(CollectionTest, IteratorsTwoElementsConst) { |
| coll_->AddAttr("test", ValueTag::not_settable); |
| coll_->AddAttr("test2", ValueTag::keyword, |
| std::vector<std::string>{"ala", "ma", "kota"}); |
| const Collection& coll_const = *coll_; |
| std::vector<Collection::const_iterator> v; |
| v.push_back(coll_const.GetAttr("test")); |
| v.push_back(coll_const.GetAttr("test2")); |
| size_t index = 0; |
| for (const Attribute& attr : coll_const) { |
| ASSERT_LE(index, v.size()); |
| EXPECT_EQ(&attr, &*v[index]); |
| ++index; |
| } |
| EXPECT_EQ(index, v.size()); |
| } |
| |
| TEST_F(CollectionTest, IteratorTraits) { |
| using it_traits = std::iterator_traits<Collection::iterator>; |
| EXPECT_TRUE((std::is_same<it_traits::iterator_category, |
| std::bidirectional_iterator_tag>::value)); |
| EXPECT_TRUE((std::is_same<it_traits::value_type, Attribute>::value)); |
| EXPECT_TRUE((std::is_same<it_traits::difference_type, int>::value)); |
| EXPECT_TRUE((std::is_same<it_traits::pointer, Attribute*>::value)); |
| EXPECT_TRUE((std::is_same<it_traits::reference, Attribute&>::value)); |
| using itc_traits = std::iterator_traits<Collection::const_iterator>; |
| EXPECT_TRUE((std::is_same<itc_traits::iterator_category, |
| std::bidirectional_iterator_tag>::value)); |
| EXPECT_TRUE((std::is_same<itc_traits::value_type, const Attribute>::value)); |
| EXPECT_TRUE((std::is_same<itc_traits::difference_type, int>::value)); |
| EXPECT_TRUE((std::is_same<itc_traits::pointer, const Attribute*>::value)); |
| EXPECT_TRUE((std::is_same<itc_traits::reference, const Attribute&>::value)); |
| } |
| |
| class AttributeTest : public testing::Test { |
| public: |
| AttributeTest() { frame_.AddGroup(GroupTag::operation_attributes, coll_); } |
| |
| protected: |
| Frame frame_; |
| CollsView::iterator coll_; |
| }; |
| |
| TEST_F(AttributeTest, CollsWrongType) { |
| coll_->AddAttr("out-of-band", ValueTag::not_settable); |
| Attribute& attr = *coll_->GetAttr("out-of-band"); |
| EXPECT_TRUE(attr.Colls().empty()); |
| EXPECT_EQ(attr.Colls().size(), 0); |
| const Attribute& attr_const = attr; |
| EXPECT_TRUE(attr_const.Colls().empty()); |
| EXPECT_EQ(attr_const.Colls().size(), 0); |
| } |
| |
| TEST_F(AttributeTest, AddAttrWithLongName) { |
| Code code = coll_->AddAttr(std::string(32768, 'x'), ValueTag::no_value); |
| EXPECT_EQ(code, Code::kInvalidName); |
| code = coll_->AddAttr(std::string(32767, 'x'), ValueTag::no_value); |
| EXPECT_EQ(code, Code::kOK); |
| } |
| |
| TEST_F(AttributeTest, AddAttrWithLongString) { |
| Code code = coll_->AddAttr("max_length", ValueTag::octetString, |
| std::string(32767, 'x')); |
| EXPECT_EQ(code, Code::kOK); |
| code = coll_->AddAttr("too_large", ValueTag::octetString, |
| std::string(32768, 'x')); |
| EXPECT_EQ(code, Code::kValueOutOfRange); |
| Collection::iterator it = coll_->begin(); |
| ASSERT_NE(it, coll_->end()); |
| EXPECT_EQ(it->Name(), "max_length"); |
| ++it; |
| EXPECT_EQ(it, coll_->end()); |
| } |
| |
| TEST_F(AttributeTest, SetValueLongString) { |
| coll_->AddAttr("test", ValueTag::nameWithoutLanguage, ""); |
| Collection::iterator it = coll_->GetAttr("test"); |
| ASSERT_NE(it, coll_->end()); |
| EXPECT_EQ(it->SetValues(std::string(32768, 'x')), Code::kValueOutOfRange); |
| EXPECT_EQ(it->SetValues(std::string(32767, 'x')), Code::kOK); |
| EXPECT_EQ( |
| it->SetValues(std::vector<std::string>{"", std::string(32768, 'x')}), |
| Code::kValueOutOfRange); |
| EXPECT_EQ( |
| it->SetValues(std::vector<std::string>{"", std::string(32767, 'x')}), |
| Code::kOK); |
| } |
| |
| TEST_F(AttributeTest, AddAttrWithLongStringWithLanguage) { |
| StringWithLanguage strlang_ok = {std::string(32763, 'x'), ""}; |
| StringWithLanguage strlang_too_long = {std::string(32760, 'x'), |
| std::string(4, 'x')}; |
| Code code = |
| coll_->AddAttr("max_length", ValueTag::nameWithLanguage, strlang_ok); |
| EXPECT_EQ(code, Code::kOK); |
| code = |
| coll_->AddAttr("too_large", ValueTag::nameWithLanguage, strlang_too_long); |
| EXPECT_EQ(code, Code::kValueOutOfRange); |
| } |
| |
| TEST_F(AttributeTest, SetValueLongStringWithLanguage) { |
| coll_->AddAttr("test", ValueTag::textWithLanguage, |
| std::vector<StringWithLanguage>(2)); |
| Collection::iterator it = coll_->GetAttr("test"); |
| ASSERT_NE(it, coll_->end()); |
| StringWithLanguage strlang_ok = {"", std::string(32763, 'x')}; |
| StringWithLanguage strlang_too_long = {std::string(4, 'x'), |
| std::string(32760, 'x')}; |
| EXPECT_EQ(it->SetValues(strlang_too_long), Code::kValueOutOfRange); |
| EXPECT_EQ(it->SetValues(strlang_ok), Code::kOK); |
| EXPECT_EQ(it->SetValues( |
| std::vector<StringWithLanguage>{strlang_ok, strlang_too_long}), |
| Code::kValueOutOfRange); |
| EXPECT_EQ( |
| it->SetValues(std::vector<StringWithLanguage>{strlang_ok, strlang_ok}), |
| Code::kOK); |
| } |
| |
| class AttributeValuesTest : public AttributeTest { |
| public: |
| AttributeValuesTest() { |
| coll_->AddAttr("out_of_band", ValueTag::not_settable); |
| coll_->AddAttr("bool", ValueTag::boolean, true); |
| coll_->AddAttr("int32", ValueTag::integer, 123); |
| coll_->AddAttr("string", ValueTag::octetString, "str"); |
| coll_->AddAttr("name", ValueTag::nameWithoutLanguage, "name"); |
| coll_->AddAttr("string_lang", ValueTag::nameWithLanguage, |
| StringWithLanguage("val", "lang")); |
| coll_->AddAttr("date_time", ValueTag::dateTime, DateTime()); |
| coll_->AddAttr("resolution", ValueTag::resolution, Resolution{123, 456}); |
| coll_->AddAttr("range", ValueTag::rangeOfInteger, RangeOfInteger(0, 2)); |
| attr_out_of_band_ = coll_->GetAttr("out_of_band"); |
| attr_bool_ = coll_->GetAttr("bool"); |
| attr_int32_ = coll_->GetAttr("int32"); |
| attr_string_ = coll_->GetAttr("string"); |
| attr_name_ = coll_->GetAttr("name"); |
| attr_string_lang_ = coll_->GetAttr("string_lang"); |
| attr_date_time_ = coll_->GetAttr("date_time"); |
| attr_resolution_ = coll_->GetAttr("resolution"); |
| attr_range_ = coll_->GetAttr("range"); |
| } |
| |
| protected: |
| template <typename ApiType> |
| void CompareGetValueWithGetValues(); |
| |
| Collection::iterator attr_out_of_band_; |
| Collection::iterator attr_bool_; |
| Collection::iterator attr_int32_; |
| Collection::iterator attr_name_; |
| Collection::iterator attr_string_; |
| Collection::iterator attr_string_lang_; |
| Collection::iterator attr_date_time_; |
| Collection::iterator attr_resolution_; |
| Collection::iterator attr_range_; |
| }; |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorBool) { |
| std::vector<bool> v; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, std::vector<bool>{true}); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorInt32) { |
| std::vector<int32_t> v; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kOK); |
| EXPECT_EQ(v, std::vector<int32_t>{1}); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, std::vector<int32_t>{123}); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorString) { |
| std::vector<std::string> v, v2; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(attr_string_lang_->GetValues(v2), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, std::vector<std::string>{"name"}); |
| EXPECT_EQ(v2, std::vector<std::string>{"str"}); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorStringWithLanguage) { |
| std::vector<StringWithLanguage> v, v2; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, std::vector<StringWithLanguage>{StringWithLanguage("name", "")}); |
| EXPECT_EQ(v2, |
| std::vector<StringWithLanguage>{StringWithLanguage("val", "lang")}); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorDateTime) { |
| std::vector<DateTime> v; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, std::vector<DateTime>(1)); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorResolution) { |
| std::vector<Resolution> v; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_range_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(v, (std::vector<Resolution>{Resolution{123, 456}})); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValuesVectorRangeOfInteger) { |
| std::vector<RangeOfInteger> v, v2; |
| EXPECT_EQ(attr_out_of_band_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->GetValues(v), Code::kOK); |
| EXPECT_EQ(attr_name_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->GetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v, (std::vector<RangeOfInteger>{RangeOfInteger(123, 123)})); |
| EXPECT_EQ(v2, (std::vector<RangeOfInteger>{RangeOfInteger(0, 2)})); |
| } |
| |
| template <typename ApiType> |
| void AttributeValuesTest::CompareGetValueWithGetValues() { |
| const std::vector<ipp::Collection::iterator> attrs = { |
| attr_out_of_band_, attr_bool_, attr_int32_, |
| attr_name_, attr_string_, attr_string_lang_, |
| attr_date_time_, attr_resolution_, attr_range_}; |
| for (ipp::Collection::iterator attr : attrs) { |
| ApiType x; |
| std::vector<ApiType> vx; |
| ipp::Code code = attr->GetValue(0, x); |
| ipp::Code vcode = attr->GetValues(vx); |
| EXPECT_EQ(code, vcode); |
| if (vcode == ipp::Code::kOK) { |
| EXPECT_EQ(x, vx[0]); |
| } |
| } |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueBool) { |
| CompareGetValueWithGetValues<bool>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueInt32) { |
| CompareGetValueWithGetValues<int32_t>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueString) { |
| CompareGetValueWithGetValues<std::string>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueStringWithLanguage) { |
| CompareGetValueWithGetValues<StringWithLanguage>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueDateTime) { |
| CompareGetValueWithGetValues<DateTime>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueResolution) { |
| CompareGetValueWithGetValues<Resolution>(); |
| } |
| |
| TEST_F(AttributeValuesTest, GetValueRangeOfInteger) { |
| CompareGetValueWithGetValues<RangeOfInteger>(); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesBool) { |
| const bool v = true; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<bool> v2; |
| EXPECT_EQ(attr_bool_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<bool>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesInt32) { |
| const int32_t v = 1234; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kValueOutOfRange); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<int32_t> v2; |
| EXPECT_EQ(attr_int32_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<int32_t>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesString) { |
| const std::string v = "test"; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<std::string> v2; |
| EXPECT_EQ(attr_string_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<std::string>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesStringWithLanguage) { |
| const StringWithLanguage v = {"testval", "testlang"}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<StringWithLanguage> v2; |
| EXPECT_EQ(attr_string_lang_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<StringWithLanguage>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesDateTime) { |
| const DateTime v = {2022, 1, 2, 3, 4, 5}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<DateTime> v2; |
| EXPECT_EQ(attr_date_time_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<DateTime>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesResolution) { |
| const Resolution v = {12, 34, Resolution::Units::kDotsPerCentimeter}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<Resolution> v2; |
| EXPECT_EQ(attr_resolution_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<Resolution>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesRangeOfInteger) { |
| const RangeOfInteger v = {12, 34}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kOK); |
| std::vector<RangeOfInteger> v2; |
| EXPECT_EQ(attr_range_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, std::vector<RangeOfInteger>{v}); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorBool) { |
| const std::vector<bool> v = {true, false, true}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<bool> v2; |
| EXPECT_EQ(attr_bool_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorInt32) { |
| const std::vector<int32_t> v = {1, 2, 3, 4}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kValueOutOfRange); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<int32_t> v2; |
| EXPECT_EQ(attr_int32_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorString) { |
| const std::vector<std::string> v = {"test1", "test2", "test3"}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<std::string> v2; |
| EXPECT_EQ(attr_string_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorStringWithLanguage) { |
| const std::vector<StringWithLanguage> v = {{"v1", "l1"}, {"v2", "l2"}}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<StringWithLanguage> v2; |
| EXPECT_EQ(attr_string_lang_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorDateTime) { |
| const std::vector<DateTime> v = {{2022, 1, 2}, {2021, 3, 4}, {2023, 7, 8}}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<DateTime> v2; |
| EXPECT_EQ(attr_date_time_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorResolution) { |
| const std::vector<Resolution> v = {{12, 34}, {56, 78}, {90, 11}}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kOK); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kIncompatibleType); |
| std::vector<Resolution> v2; |
| EXPECT_EQ(attr_resolution_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST_F(AttributeValuesTest, SetValuesVectorRangeOfInteger) { |
| const std::vector<RangeOfInteger> v = {{0, 0}, {12, 34}, {999, 33}}; |
| EXPECT_EQ(attr_out_of_band_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_bool_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_int32_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_string_lang_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_date_time_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_resolution_->SetValues(v), Code::kIncompatibleType); |
| EXPECT_EQ(attr_range_->SetValues(v), Code::kOK); |
| std::vector<RangeOfInteger> v2; |
| EXPECT_EQ(attr_range_->GetValues(v2), Code::kOK); |
| EXPECT_EQ(v2, v); |
| } |
| |
| TEST(ToStrView, ValueTag) { |
| EXPECT_EQ(ToStrView(ValueTag::keyword), "keyword"); |
| EXPECT_EQ(ToStrView(ValueTag::delete_attribute), "delete-attribute"); |
| EXPECT_EQ(ToStrView(ValueTag::enum_), "enum"); |
| EXPECT_EQ(ToStrView(ValueTag::nameWithoutLanguage), "nameWithoutLanguage"); |
| } |
| |
| } // namespace |
| } // namespace ipp |