blob: 936235e41abba47126fc56d5866dde6dcd51f71b [file] [log] [blame] [edit]
// Copyright 2014 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 <algorithm>
#include <functional>
#include <string>
#include <utility>
#include <vector>
#include <brillo/any.h>
#include <gtest/gtest.h>
using brillo::Any;
TEST(Any, Empty) {
Any val;
EXPECT_TRUE(val.IsEmpty());
Any val2 = val;
EXPECT_TRUE(val.IsEmpty());
EXPECT_TRUE(val2.IsEmpty());
Any val3 = std::move(val);
EXPECT_TRUE(val.IsEmpty());
EXPECT_TRUE(val3.IsEmpty());
}
TEST(Any, SimpleTypes) {
Any val(20);
EXPECT_FALSE(val.IsEmpty());
EXPECT_TRUE(val.IsTypeCompatible<int>());
EXPECT_EQ(20, val.Get<int>());
Any val2(3.1415926);
EXPECT_FALSE(val2.IsEmpty());
EXPECT_TRUE(val2.IsTypeCompatible<double>());
EXPECT_FALSE(val2.IsTypeCompatible<int>());
EXPECT_DOUBLE_EQ(3.1415926, val2.Get<double>());
Any val3(std::string("blah"));
EXPECT_TRUE(val3.IsTypeCompatible<std::string>());
EXPECT_EQ("blah", val3.Get<std::string>());
}
TEST(Any, Clear) {
Any val('x');
EXPECT_FALSE(val.IsEmpty());
EXPECT_EQ('x', val.Get<char>());
val.Clear();
EXPECT_TRUE(val.IsEmpty());
}
TEST(Any, Assignments) {
Any val(20);
EXPECT_EQ(20, val.Get<int>());
val = 3.1415926;
EXPECT_FALSE(val.IsEmpty());
EXPECT_TRUE(val.IsTypeCompatible<double>());
EXPECT_DOUBLE_EQ(3.1415926, val.Get<double>());
val = std::string("blah");
EXPECT_EQ("blah", val.Get<std::string>());
Any val2;
EXPECT_TRUE(val2.IsEmpty());
val2 = val;
EXPECT_FALSE(val.IsEmpty());
EXPECT_FALSE(val2.IsEmpty());
EXPECT_EQ("blah", val.Get<std::string>());
EXPECT_EQ("blah", val2.Get<std::string>());
val.Clear();
EXPECT_TRUE(val.IsEmpty());
EXPECT_EQ("blah", val2.Get<std::string>());
val2.Clear();
EXPECT_TRUE(val2.IsEmpty());
val = std::vector<int>{100, 20, 3};
auto v = val.Get<std::vector<int>>();
EXPECT_EQ(100, v[0]);
EXPECT_EQ(20, v[1]);
EXPECT_EQ(3, v[2]);
val2 = std::move(val);
EXPECT_TRUE(val.IsEmpty());
EXPECT_TRUE(val2.IsTypeCompatible<std::vector<int>>());
EXPECT_EQ(3, val2.Get<std::vector<int>>().size());
val = val2;
EXPECT_TRUE(val.IsTypeCompatible<std::vector<int>>());
EXPECT_TRUE(val2.IsTypeCompatible<std::vector<int>>());
EXPECT_EQ(3, val.Get<std::vector<int>>().size());
EXPECT_EQ(3, val2.Get<std::vector<int>>().size());
}
TEST(Any, Enums) {
enum class Dummy { foo, bar, baz };
Any val(Dummy::bar);
EXPECT_FALSE(val.IsEmpty());
EXPECT_TRUE(val.IsConvertibleToInteger());
EXPECT_EQ(Dummy::bar, val.Get<Dummy>());
EXPECT_EQ(1, val.GetAsInteger());
val = Dummy::baz;
EXPECT_EQ(2, val.GetAsInteger());
val = Dummy::foo;
EXPECT_EQ(0, val.GetAsInteger());
}
TEST(Any, Integers) {
Any val(14);
EXPECT_TRUE(val.IsConvertibleToInteger());
EXPECT_EQ(14, val.Get<int>());
EXPECT_EQ(14, val.GetAsInteger());
val = '\x40';
EXPECT_TRUE(val.IsConvertibleToInteger());
EXPECT_EQ(64, val.Get<char>());
EXPECT_EQ(64, val.GetAsInteger());
val = static_cast<uint16_t>(65535);
EXPECT_TRUE(val.IsConvertibleToInteger());
EXPECT_EQ(65535, val.Get<uint16_t>());
EXPECT_EQ(65535, val.GetAsInteger());
val = static_cast<uint64_t>(0xFFFFFFFFFFFFFFFFULL);
EXPECT_TRUE(val.IsConvertibleToInteger());
EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, val.Get<uint64_t>());
EXPECT_EQ(-1, val.GetAsInteger());
val = "abc";
EXPECT_FALSE(val.IsConvertibleToInteger());
int a = 5;
val = &a;
EXPECT_FALSE(val.IsConvertibleToInteger());
}
TEST(Any, Pointers) {
Any val("abc"); // const char*
EXPECT_FALSE(val.IsTypeCompatible<char*>());
EXPECT_TRUE(val.IsTypeCompatible<const char*>());
EXPECT_FALSE(val.IsTypeCompatible<volatile char*>());
EXPECT_TRUE(val.IsTypeCompatible<volatile const char*>());
EXPECT_STREQ("abc", val.Get<const char*>());
int a = 10;
val = &a;
EXPECT_TRUE(val.IsTypeCompatible<int*>());
EXPECT_TRUE(val.IsTypeCompatible<const int*>());
EXPECT_TRUE(val.IsTypeCompatible<volatile int*>());
EXPECT_TRUE(val.IsTypeCompatible<volatile const int*>());
EXPECT_EQ(10, *val.Get<const int*>());
*val.Get<int*>() = 3;
EXPECT_EQ(3, a);
}
TEST(Any, Arrays) {
// The following test are here to validate the array-to-pointer decay rules.
// Since Any does not store the contents of a C-style array, just a pointer
// to the data, putting array data into Any could be dangerous.
// Make sure the array's lifetime exceeds that of an Any containing the
// pointer to the array data.
// If you want to store the array with data, use corresponding value types
// such as std::vector or a struct containing C-style array as a member.
int int_array[] = {1, 2, 3}; // int*
Any val = int_array;
EXPECT_TRUE(val.IsTypeCompatible<int*>());
EXPECT_TRUE(val.IsTypeCompatible<const int*>());
EXPECT_TRUE(val.IsTypeCompatible<int[]>());
EXPECT_TRUE(val.IsTypeCompatible<const int[]>());
EXPECT_EQ(3, val.Get<int*>()[2]);
const int const_int_array[] = {10, 20, 30}; // const int*
val = const_int_array;
EXPECT_FALSE(val.IsTypeCompatible<int*>());
EXPECT_TRUE(val.IsTypeCompatible<const int*>());
EXPECT_FALSE(val.IsTypeCompatible<int[]>());
EXPECT_TRUE(val.IsTypeCompatible<const int[]>());
EXPECT_EQ(30, val.Get<const int*>()[2]);
}
TEST(Any, References) {
// Passing references to object via Any might be error-prone or the
// semantics could be unfamiliar to other developers. In many cases,
// using pointers instead of references are more conventional and easier
// to understand. Even though the cases of passing references are quite
// explicit on both storing and retrieving ends, you might want to
// use pointers instead anyway.
int a = 5;
Any val(std::ref(a)); // int&
EXPECT_EQ(5, val.Get<std::reference_wrapper<int>>().get());
val.Get<std::reference_wrapper<int>>().get() = 7;
EXPECT_EQ(7, val.Get<std::reference_wrapper<int>>().get());
EXPECT_EQ(7, a);
Any val2(std::cref(a)); // const int&
EXPECT_EQ(7, val2.Get<std::reference_wrapper<const int>>().get());
a = 10;
EXPECT_EQ(10, val.Get<std::reference_wrapper<int>>().get());
EXPECT_EQ(10, val2.Get<std::reference_wrapper<const int>>().get());
}
TEST(Any, CustomTypes) {
struct Person {
std::string name;
int age;
};
Any val(Person{"Jack", 40});
Any val2 = val;
EXPECT_EQ("Jack", val.Get<Person>().name);
val.GetPtr<Person>()->name = "Joe";
val.GetPtr<Person>()->age /= 2;
EXPECT_EQ("Joe", val.Get<Person>().name);
EXPECT_EQ(20, val.Get<Person>().age);
EXPECT_EQ("Jack", val2.Get<Person>().name);
EXPECT_EQ(40, val2.Get<Person>().age);
}
TEST(Any, Swap) {
Any val(12);
Any val2(2.7);
EXPECT_EQ(12, val.Get<int>());
EXPECT_EQ(2.7, val2.Get<double>());
val.Swap(val2);
EXPECT_EQ(2.7, val.Get<double>());
EXPECT_EQ(12, val2.Get<int>());
std::swap(val, val2);
EXPECT_EQ(12, val.Get<int>());
EXPECT_EQ(2.7, val2.Get<double>());
}
TEST(Any, TypeMismatch) {
Any val(12);
EXPECT_DEATH(val.Get<double>(),
"Requesting value of type 'double' from variant containing "
"'int'");
val = std::string("123");
EXPECT_DEATH(val.GetAsInteger(),
"Unable to convert value of type 'std::.*' to integer");
Any empty;
EXPECT_DEATH(empty.GetAsInteger(), "Must not be called on an empty Any");
}
TEST(Any, TryGet) {
Any val(12);
Any empty;
EXPECT_EQ("dummy", val.TryGet<std::string>("dummy"));
EXPECT_EQ(12, val.TryGet<int>(17));
EXPECT_EQ(17, empty.TryGet<int>(17));
}
TEST(Any, Compare_Int) {
Any int1{12};
Any int2{12};
Any int3{20};
EXPECT_EQ(int1, int2);
EXPECT_NE(int2, int3);
}
TEST(Any, Compare_String) {
Any str1{std::string{"foo"}};
Any str2{std::string{"foo"}};
Any str3{std::string{"bar"}};
EXPECT_EQ(str1, str2);
EXPECT_NE(str2, str3);
}
TEST(Any, Compare_Array) {
Any vec1{std::vector<int>{1, 2}};
Any vec2{std::vector<int>{1, 2}};
Any vec3{std::vector<int>{1, 2, 3}};
EXPECT_EQ(vec1, vec2);
EXPECT_NE(vec2, vec3);
}
TEST(Any, Compare_Empty) {
Any empty1;
Any empty2;
Any int1{1};
EXPECT_EQ(empty1, empty2);
EXPECT_NE(int1, empty1);
EXPECT_NE(empty2, int1);
}
TEST(Any, Compare_NonComparable) {
struct Person {
std::string name;
int age;
};
Any person1(Person{"Jack", 40});
Any person2 = person1;
Any person3(Person{"Jill", 20});
EXPECT_NE(person1, person2);
EXPECT_NE(person1, person3);
EXPECT_NE(person2, person3);
}
TEST(Any, GetUndecoratedTypeName) {
Any val;
EXPECT_TRUE(val.GetUndecoratedTypeName().empty());
val = 1;
EXPECT_EQ(brillo::GetUndecoratedTypeName<int>(),
val.GetUndecoratedTypeName());
val = 3.1415926;
EXPECT_EQ(brillo::GetUndecoratedTypeName<double>(),
val.GetUndecoratedTypeName());
val = std::string("blah");
EXPECT_EQ(brillo::GetUndecoratedTypeName<std::string>(),
val.GetUndecoratedTypeName());
}