Skip to content

Commit

Permalink
highlevel: add integer border tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@kodebach
kodebach committed Feb 20, 2019
1 parent 67e26c1 commit f42bb34
Showing 1 changed file with 142 additions and 1 deletion.
143 changes: 142 additions & 1 deletion tests/kdb/testkdb_highlevel.cpp
View file
Expand Up @@ -140,7 +140,8 @@ class Highlevel : public ::testing::Test
elektraFatalErrorHandler (elektra, &fatalErrorHandler);
}

void setValues (std::initializer_list<kdb::Key> values)
template <class T>
void setValues (T values)
{
using namespace kdb;
KDB kdb;
Expand All @@ -154,6 +155,11 @@ class Highlevel : public ::testing::Test
kdb.set (config, testRoot);
}

void setValues (std::initializer_list<kdb::Key> values)
{
setValues<std::initializer_list<kdb::Key>> (values);
}

void setArrays (std::initializer_list<std::vector<kdb::Key>> arrays)
{
using namespace kdb;
Expand Down Expand Up @@ -194,6 +200,141 @@ class Highlevel : public ::testing::Test
const std::string Highlevel::configFile = "kdbFileHighlevel.dump";
const std::string Highlevel::testRoot = "/tests/highlevel/"; // DO NOT use namespace here, namespace would break testing::Mountpoint

TEST_F (Highlevel, CharTestGet)
{
std::vector<kdb::Key> keys;
for (int i = 0x01; i <= 0xFF; ++i)
{
auto c = static_cast<kdb_char_t> (i);
char s[] = { static_cast<char> (c), '\0' };
auto name = "char/_" + std::to_string (c);
keys.push_back (makeKey (KDB_TYPE_CHAR, name.c_str (), s));
}
setValues (keys);

createElektra ();

for (int i = 0x01; i <= 0xFF; ++i)
{
auto c = static_cast<kdb_char_t> (i);
auto name = "char/_" + std::to_string (c);
try
{
EXPECT_EQ (elektraGetChar (elektra, name.c_str ()), c) << "char " + name + " wrong";
}
catch (std::runtime_error &)
{
ADD_FAILURE () << "unexpected std::runtime_error thrown for " + name;
}
}
}

TEST_F (Highlevel, CharTestSet)
{
std::vector<kdb::Key> keys;
for (int i = 0x01; i <= 0xFF; ++i)
{
auto c = static_cast<kdb_char_t> (i);
auto name = "char/_" + std::to_string (c);
keys.push_back (makeKey (KDB_TYPE_CHAR, name.c_str (), c == '_' ? "0" : "_"));
}
setValues (keys);

createElektra ();

ElektraError * error = nullptr;

for (int i = 0x01; i <= 0xFF; ++i)
{
auto c = static_cast<kdb_char_t> (i);
auto name = "char/_" + std::to_string (c);
elektraSetChar (elektra, name.c_str (), c, &error);
if (error != nullptr)
{
ADD_FAILURE () << "error for char " + name;
}
}

using namespace kdb;
KDB kdb;
KeySet config;

kdb.get (config, testRoot);
for (int i = 0x01; i <= 0xFF; ++i)
{
auto c = static_cast<kdb_char_t> (i);
auto name = "char/_" + std::to_string (c);
char s[] = { static_cast<char> (c), '\0' };
EXPECT_KEYVALUE (config.lookup (testRoot + name), s) << "Wrong key value. for char " + name;
}
}

TEST_F (Highlevel, IntegerBordersGet)
{
setValues ({
makeKey (KDB_TYPE_OCTET, "octet/below", "-1"),
makeKey (KDB_TYPE_OCTET, "octet/min", "0"),
makeKey (KDB_TYPE_OCTET, "octet/max", "255"),
makeKey (KDB_TYPE_OCTET, "octet/above", "256"),
makeKey (KDB_TYPE_SHORT, "short/below", "-32769"),
makeKey (KDB_TYPE_SHORT, "short/min", "-32768"),
makeKey (KDB_TYPE_SHORT, "short/max", "32767"),
makeKey (KDB_TYPE_SHORT, "short/above", "32768"),
makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/below", "-1"),
makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/min", "0"),
makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/max", "65535"),
makeKey (KDB_TYPE_UNSIGNED_SHORT, "unsignedshort/above", "65536"),
makeKey (KDB_TYPE_LONG, "long/below", "-2147483649"),
makeKey (KDB_TYPE_LONG, "long/min", "-2147483648"),
makeKey (KDB_TYPE_LONG, "long/max", "2147483647"),
makeKey (KDB_TYPE_LONG, "long/above", "2147483648"),
makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/below", "-1"),
makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/min", "0"),
makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/max", "4294967295"),
makeKey (KDB_TYPE_UNSIGNED_LONG, "unsignedlong/above", "4294967296"),
makeKey (KDB_TYPE_LONG_LONG, "longlong/below", "-9223372036854775809"),
makeKey (KDB_TYPE_LONG_LONG, "longlong/min", "-9223372036854775808"),
makeKey (KDB_TYPE_LONG_LONG, "longlong/max", "9223372036854775807"),
makeKey (KDB_TYPE_LONG_LONG, "longlong/above", "9223372036854775808"),
makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/below", "-1"),
makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/min", "0"),
makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/max", "18446744073709551615"),
makeKey (KDB_TYPE_UNSIGNED_LONG_LONG, "unsignedlonglong/above", "18446744073709551616"),
});

createElektra ();

EXPECT_EQ (elektraGetOctet (elektra, "octet/min"), 0) << "octet/min wrong";
EXPECT_EQ (elektraGetOctet (elektra, "octet/max"), 0xff) << "octet/max wrong";
EXPECT_EQ (elektraGetShort (elektra, "short/min"), -0x8000) << "short/min wrong";
EXPECT_EQ (elektraGetShort (elektra, "short/max"), 0x7fFF) << "short/max wrong";
EXPECT_EQ (elektraGetUnsignedShort (elektra, "unsignedshort/min"), 0) << "unsignedshort/min wrong";
EXPECT_EQ (elektraGetUnsignedShort (elektra, "unsignedshort/max"), 0xffFF) << "unsignedshort/max wrong";
EXPECT_EQ (elektraGetLong (elektra, "long/min"), -0x80000000) << "long/min wrong";
EXPECT_EQ (elektraGetLong (elektra, "long/max"), 0x7fFFffFF) << "long/max wrong";
EXPECT_EQ (elektraGetUnsignedLong (elektra, "unsignedlong/min"), 0) << "unsignedlong/min wrong";
EXPECT_EQ (elektraGetUnsignedLong (elektra, "unsignedlong/max"), 0xffFFffFF) << "unsignedlong/max wrong";
EXPECT_EQ (elektraGetLongLong (elektra, "longlong/min"), -0x8000000000000000) << "longlong/min wrong";
EXPECT_EQ (elektraGetLongLong (elektra, "longlong/max"), 0x7fFFffFFffFFffFF) << "longlong/max wrong";
EXPECT_EQ (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/min"), 0) << "unsignedlonglong/min wrong";
EXPECT_EQ (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/max"), 0xffFFffFFffFFffFF) << "unsignedlonglong/max wrong";

EXPECT_THROW (elektraGetOctet (elektra, "octet/below"), std::runtime_error) << "octet/below accepted";
EXPECT_THROW (elektraGetOctet (elektra, "octet/above"), std::runtime_error) << "octet/above accepted";
EXPECT_THROW (elektraGetShort (elektra, "short/below"), std::runtime_error) << "short/below wrong";
EXPECT_THROW (elektraGetShort (elektra, "short/above"), std::runtime_error) << "short/above wrong";
EXPECT_THROW (elektraGetUnsignedShort (elektra, "unsignedshort/below"), std::runtime_error) << "unsignedshort/below wrong";
EXPECT_THROW (elektraGetUnsignedShort (elektra, "unsignedshort/above"), std::runtime_error) << "unsignedshort/above wrong";
EXPECT_THROW (elektraGetLong (elektra, "long/below"), std::runtime_error) << "long/below wrong";
EXPECT_THROW (elektraGetLong (elektra, "long/above"), std::runtime_error) << "long/above wrong";
EXPECT_THROW (elektraGetUnsignedLong (elektra, "unsignedlong/below"), std::runtime_error) << "unsignedlong/below wrong";
EXPECT_THROW (elektraGetUnsignedLong (elektra, "unsignedlong/above"), std::runtime_error) << "unsignedlong/above wrong";
EXPECT_THROW (elektraGetLongLong (elektra, "longlong/below"), std::runtime_error) << "longlong/below wrong";
EXPECT_THROW (elektraGetLongLong (elektra, "longlong/above"), std::runtime_error) << "longlong/above wrong";
EXPECT_THROW (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/below"), std::runtime_error) << "unsignedlonglong/below wrong";
EXPECT_THROW (elektraGetUnsignedLongLong (elektra, "unsignedlonglong/above"), std::runtime_error) << "unsignedlonglong/above wrong";
}

TEST_F (Highlevel, PrimitveGetters)
{
setValues ({
Expand Down

0 comments on commit f42bb34

Please sign in to comment.