libipp/ipp_attribute_test.cc

// Copyright 2019 The Chromium OS 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 "libipp/ipp_attribute.h"

#include <limits>

#include <gtest/gtest.h>

namespace ipp {

static bool operator==(const ipp::RangeOfInteger& a,
                       const ipp::RangeOfInteger& b) {
  return (a.min_value == b.min_value && a.max_value == b.max_value);
}

namespace {

void TestNewAttribute(Attribute* attr,
                      const std::string& name,
                      bool is_a_set,
                      AttrType type) {
  EXPECT_TRUE(attr != nullptr);
  EXPECT_EQ(attr->GetName(), name);
  if (attr->GetNameAsEnum() != AttrName::_unknown) {
    EXPECT_EQ(ToString(attr->GetNameAsEnum()), name);
  }
  EXPECT_EQ(attr->IsASet(), is_a_set);
  EXPECT_EQ(attr->GetType(), type);
  // default state after creation
  EXPECT_EQ(attr->GetState(), AttrState::unset);
  EXPECT_EQ(attr->GetSize(), 0);
}

class TestSubcollection : public Collection {
 public:
  SingleValue<bool> hi{this, AttrName::job_id};
  TestSubcollection() : Collection(&defs_) {}

 private:
  std::vector<Attribute*> GetKnownAttributes() override { return {&hi}; }
  std::vector<const Attribute*> GetKnownAttributes() const override {
    return {&hi};
  }
  static const std::map<AttrName, AttrDef> defs_;
};
const std::map<AttrName, AttrDef> TestSubcollection::defs_ = {
    {AttrName::job_id, {AttrType::boolean, InternalType::kInteger, false}}};

struct TestCollection : public Collection {
  SingleValue<int> attr1{this, AttrName::attributes_charset};
  SetOfValues<RangeOfInteger> attr2{this, AttrName::auth_info};
  OpenSetOfValues<int> attr3{this, AttrName::baling};
  SingleCollection<TestSubcollection> attr4{
      this, AttrName::printer_supply_description};
  SetOfCollections<TestSubcollection> attr5{this, AttrName::punching_locations};
  std::vector<Attribute*> GetKnownAttributes() override {
    return {&attr1, &attr2, &attr3, &attr4, &attr5};
  }
  std::vector<const Attribute*> GetKnownAttributes() const override {
    return {&attr1, &attr2, &attr3, &attr4, &attr5};
  }
  static const std::map<AttrName, AttrDef> defs_;
  TestCollection() : Collection(&defs_) {}
};
const std::map<AttrName, AttrDef> TestCollection::defs_ = {
    {AttrName::attributes_charset,
     {AttrType::integer, InternalType::kInteger, false}},
    {AttrName::auth_info,
     {AttrType::rangeOfInteger, InternalType::kRangeOfInteger, true}},
    {AttrName::baling, {AttrType::integer, InternalType::kString, true}},
    {AttrName::printer_supply_description,
     {AttrType::collection, InternalType::kCollection, false,
      []() -> Collection* { return new TestSubcollection(); }}},
    {AttrName::punching_locations,
     {AttrType::collection, InternalType::kCollection, true,
      []() -> Collection* { return new TestSubcollection(); }}}};

TEST(attribute, SingleValue) {
  TestCollection coll;
  TestNewAttribute(&coll.attr1, "attributes-charset", false, AttrType::integer);
  coll.attr1.Set(123);
  EXPECT_EQ(coll.attr1.Get(), 123);
  EXPECT_EQ(coll.attr1.GetState(), AttrState::set);
}

TEST(attribute, SetOfValues) {
  TestCollection coll;
  TestNewAttribute(&coll.attr2, "auth-info", true, AttrType::rangeOfInteger);
  RangeOfInteger r1{123, 234};
  RangeOfInteger r2{123, 234};
  RangeOfInteger r3{123, 234};
  coll.attr2.Set({r1, r2, r3});
  EXPECT_EQ(coll.attr2.Get(), std::vector<RangeOfInteger>({r1, r2, r3}));
  EXPECT_EQ(coll.attr2.GetState(), AttrState::set);
  EXPECT_EQ(coll.attr2.GetSize(), 3);
  coll.attr2.Resize(2);
  EXPECT_EQ(coll.attr2.Get(), std::vector<RangeOfInteger>({r1, r2}));
  EXPECT_EQ(coll.attr2.GetSize(), 2);
}

TEST(attribute, OpenSetOfValues) {
  TestCollection coll;
  TestNewAttribute(&coll.attr3, "baling", true, AttrType::integer);
  coll.attr3.Set({11, 22, 33});
  coll.attr3.Add(std::vector<std::string>({"aaa", "bbb"}));
  coll.attr3.Add({44, 55});
  EXPECT_EQ(coll.attr3.Get(), std::vector<std::string>({"11", "22", "33", "aaa",
                                                        "bbb", "44", "55"}));
  EXPECT_EQ(coll.attr3.GetState(), AttrState::set);
  EXPECT_EQ(coll.attr3.GetSize(), 7);
  coll.attr3.Resize(2);
  EXPECT_EQ(coll.attr3.Get(), std::vector<std::string>({"11", "22"}));
  EXPECT_EQ(coll.attr3.GetSize(), 2);
  coll.attr3.Set(std::vector<std::string>({"xx", "yy", "zz"}));
  EXPECT_EQ(coll.attr3.GetSize(), 3);
  EXPECT_EQ(coll.attr3.Get(), std::vector<std::string>({"xx", "yy", "zz"}));
}

TEST(attribute, SingleCollection) {
  TestCollection coll;
  TestNewAttribute(&coll.attr4, "printer-supply-description", false,
                   AttrType::collection);
  EXPECT_EQ(coll.attr4->hi.GetState(), AttrState::unset);
  EXPECT_EQ(coll.attr4.GetState(), AttrState::set);
  coll.attr4->hi.Set(false);
  EXPECT_EQ(coll.attr4->hi.Get(), false);
  EXPECT_EQ(coll.attr4->hi.GetState(), AttrState::set);
}

TEST(attribute, SetOfCollections) {
  TestCollection coll;
  TestNewAttribute(&coll.attr5, "punching-locations", true,
                   AttrType::collection);
  coll.attr5[3].hi.SetState(AttrState::not_settable);
  EXPECT_EQ(coll.attr5.GetState(), AttrState::set);
  EXPECT_EQ(coll.attr5.GetSize(), 4);
  EXPECT_EQ(coll.attr5[3].hi.GetState(), AttrState::not_settable);
}

TEST(attribute, UnknownValueAttribute) {
  TestCollection coll;
  Attribute* attr = coll.AddUnknownAttribute("abc", false, AttrType::name);
  TestNewAttribute(attr, "abc", false, AttrType::name);
  ASSERT_TRUE(attr->SetValue("val"));
  StringWithLanguage sl;
  ASSERT_TRUE(attr->GetValue(&sl));
  EXPECT_EQ(sl.language, "");
  EXPECT_EQ(sl.value, "val");
}

TEST(attribute, UnknownCollectionAttribute) {
  TestCollection coll;
  Attribute* attr =
      coll.AddUnknownAttribute("abcd", true, AttrType::collection);
  TestNewAttribute(attr, "abcd", true, AttrType::collection);
  EXPECT_EQ(attr->GetCollection(), nullptr);
  attr->Resize(3);
  EXPECT_NE(attr->GetCollection(), nullptr);
  EXPECT_NE(attr->GetCollection(2), nullptr);
  EXPECT_EQ(attr->GetCollection(3), nullptr);
  const Attribute* attr_const = attr;
  EXPECT_NE(attr_const->GetCollection(), nullptr);
  EXPECT_NE(attr_const->GetCollection(2), nullptr);
  EXPECT_EQ(attr_const->GetCollection(3), nullptr);
}

TEST(attribute, FromStringToInt) {
  int val = 123456;
  // incorrect values: return false, no changes to val
  EXPECT_FALSE(FromString("123", static_cast<int*>(nullptr)));
  EXPECT_FALSE(FromString("12341s", &val));
  EXPECT_EQ(123456, val);
  EXPECT_FALSE(FromString("-", &val));
  EXPECT_EQ(123456, val);
  EXPECT_FALSE(FromString("", &val));
  EXPECT_EQ(123456, val);
  // correct values: return true
  EXPECT_TRUE(FromString("-239874", &val));
  EXPECT_EQ(-239874, val);
  EXPECT_TRUE(FromString("9238", &val));
  EXPECT_EQ(9238, val);
  EXPECT_TRUE(FromString("0", &val));
  EXPECT_EQ(0, val);
  const int int_min = std::numeric_limits<int>::min();
  const int int_max = std::numeric_limits<int>::max();
  EXPECT_TRUE(FromString(ToString(int_min), &val));
  EXPECT_EQ(int_min, val);
  EXPECT_TRUE(FromString(ToString(int_max), &val));
  EXPECT_EQ(int_max, val);
}

}  // end of namespace

}  // end of namespace ipp