cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/tests/config_test.cc

@@ -0,0 +1,151 @@
+#include <catch.hpp>
+
+#include <hocon/config.hpp>
+#include "fixtures.hpp"
+#include "test_utils.hpp"
+
+using namespace std;
+using namespace hocon;
+using namespace hocon::test_utils;
+
+TEST_CASE("should be able to get bare C++ types from a config", "[config]") {
+
+    SECTION("get single values") {
+        auto conf = config::parse_file_any_syntax(TEST_FILE_DIR + string("/fixtures/test01.conf"))->resolve();
+
+        REQUIRE(42 == conf->get_int("ints.fortyTwo"));
+        REQUIRE(42 == conf->get_long("ints.fortyTwoAgain"));
+        REQUIRE(42.1 == conf->get_double("floats.fortyTwoPointOne"));
+        REQUIRE(0.33 == conf->get_double("floats.pointThirtyThree"));
+        REQUIRE("abcd" == conf->get_string("strings.abcd"));
+        REQUIRE("null bar 42 baz true 3.14 hi" == conf->get_string("strings.concatenated"));
+        REQUIRE(true == conf->get_bool("booleans.trueAgain"));
+        REQUIRE(false == conf->get_bool("booleans.falseAgain"));
+
+        REQUIRE(nullptr == conf->root()->get("not_a_setting"));
+    }
+
+    SECTION("get list values") {
+        auto conf = config::parse_file_any_syntax(TEST_FILE_DIR + string("/fixtures/test01.conf"))->resolve();
+
+        vector<int> ints { 1, 2, 3 };
+        REQUIRE(ints == conf->get_int_list("arrays.ofInt"));
+
+        vector<int64_t> longs { 1, 2, 3 };
+        REQUIRE(longs == conf->get_long_list("arrays.ofInt"));
+
+        vector<string> strings { "a", "b", "c" };
+        REQUIRE(strings == conf->get_string_list("arrays.ofString"));
+
+        vector<double> doubles { 3.14, 4.14, 5.14 };
+        REQUIRE(doubles == conf->get_double_list("arrays.ofDouble"));
+
+        vector<bool> bools { true, false };
+        REQUIRE(bools == conf->get_bool_list("arrays.ofBoolean"));
+
+        REQUIRE(3 == conf->get_object_list("arrays.ofObject").size());
+
+        auto bad_list = "bad : [ 1, \"a string\", 4.5 ]";
+        auto string_conf = config::parse_string(bad_list);
+        REQUIRE_THROWS(string_conf->get_int_list("bad"));
+    };
+}
+
+TEST_CASE("correct exceptions should be thrown", "[config]") {
+    SECTION("missing exception should be thrown when the value is not in the config") {
+        bool thrown = false;
+        try {
+            auto conf = config::parse_file_any_syntax(TEST_FILE_DIR + string("/fixtures/test01.conf"))->resolve();
+            conf->get_int("badSetting");
+        } catch (const config_exception& e) {
+            thrown = true;
+            REQUIRE_STRING_CONTAINS(e.what(), "No configuration setting found");
+            REQUIRE_STRING_CONTAINS(e.what(), "badSetting");
+        }
+        REQUIRE(thrown);
+    }
+
+    SECTION("a missing exception should be thrown when single-quoted strings are queried incorrectly") {
+        bool thrown = false;
+        try {
+            auto conf = config::parse_string("object : { 'key' : value }");
+            conf->get_string("key");
+        } catch (const config_exception& e) {
+            thrown = true;
+            REQUIRE_STRING_CONTAINS(e.what(), "No configuration setting found");
+            REQUIRE_STRING_CONTAINS(e.what(), "'key'");
+        }
+        REQUIRE(thrown);
+    }
+
+    SECTION("null exception should be thrown when a null value is queried with a different type") {
+        bool thrown = false;
+        try {
+            auto conf = config::parse_string("object : null");
+            conf->get_int("object");
+        } catch (const config_exception& e) {
+            thrown = true;
+            REQUIRE_STRING_CONTAINS(e.what(), "Configuration key \"object\" is null");
+        }
+        REQUIRE(thrown);
+    }
+
+    SECTION("wrong type exception should be thrown when a value cannot be converted to the queried type") {
+        bool thrown = false;
+        try {
+            auto conf = config::parse_string("object : { key : value }");
+            conf->get_string("object");
+        } catch (const config_exception& e) {
+            thrown = true;
+            REQUIRE_STRING_CONTAINS(e.what(), "object could not be converted");
+        }
+        REQUIRE(thrown);
+    }
+
+    SECTION("not resolved error message should display when config has not been resolved") {
+        bool thrown = false;
+        try {
+            auto conf = config::parse_string("a : b\nc : ${a}");
+            conf->get_string("c");
+        } catch (const config_exception& e) {
+            thrown = true;
+            REQUIRE_STRING_CONTAINS(e.what(), "c has not been resolved");
+        }
+        REQUIRE(thrown);
+    }
+}
+
+TEST_CASE("should correctly parse durations", "[config]") {
+    auto conf = config::parse_file_any_syntax(TEST_FILE_DIR + string("/fixtures/test01.conf"))->resolve();
+
+    SECTION("should be able to fetch number nodes as durations", "[config]") {
+        REQUIRE(1 == conf->get_duration("durations.secondAsNumber", time_unit::SECONDS));
+    }
+
+    SECTION("should be able to get durations in specific units", "[config]") {
+        // Get as a long
+        REQUIRE(1 == conf->get_duration("durations.second", time_unit::SECONDS));
+        REQUIRE(500 == conf->get_duration("durations.halfSecond", time_unit::MILLISECONDS));
+        REQUIRE(1 == conf->get_duration("durations.millis", time_unit::MILLISECONDS));
+        REQUIRE(1000 == conf->get_duration("durations.second", time_unit::MILLISECONDS));
+        REQUIRE(60 == conf->get_duration("durations.minute", time_unit::SECONDS));
+        REQUIRE(60 == conf->get_duration("durations.hour", time_unit::MINUTES));
+        REQUIRE(24 == conf->get_duration("durations.day", time_unit::HOURS));
+        REQUIRE(-4 == conf->get_duration("durations.minusSeconds", time_unit::SECONDS));
+        REQUIRE(43 == conf->get_duration("durations.secondWithFractional", time_unit::SECONDS));
+        REQUIRE(43200 == conf->get_duration("durations.secondWithFractional", time_unit::MILLISECONDS));
+        REQUIRE(9223372036854775807 == conf->get_duration("durations.largeNanos", time_unit::NANOSECONDS));
+        REQUIRE(-9223372036854775807 == conf->get_duration("durations.minusLargeNanos", time_unit::NANOSECONDS));
+        // getting as a long truncates when casting to a larger value
+        REQUIRE(0 == conf->get_duration("durations.minute", time_unit::HOURS));
+        REQUIRE(9223372036 == conf->get_duration("durations.largeNanos", time_unit::SECONDS));
+        REQUIRE(153722867 == conf->get_duration("durations.largeNanos", time_unit::MINUTES));
+        REQUIRE(2562047 == conf->get_duration("durations.largeNanos", time_unit::HOURS));
+        REQUIRE(106751 == conf->get_duration("durations.largeNanos", time_unit::DAYS));
+    }
+
+    SECTION("should throw an exception when overflow occurs", "[config]") {
+        REQUIRE_THROWS(conf->get_duration("durations.largeDays", time_unit::DAYS));
+        REQUIRE_THROWS(conf->get_duration("durations.largeDays", time_unit::NANOSECONDS));
+    }
+}

data/ext/facter/cpp-hocon/lib/tests/config_value_factory_test.cc

@@ -0,0 +1,60 @@
+#include <catch.hpp>
+#include "test_utils.hpp"
+
+#include <hocon/config_value_factory.hpp>
+#include <internal/values/simple_config_object.hpp>
+
+using namespace hocon;
+using namespace std;
+
+TEST_CASE("convert various types to config values", "[config_value_factory]") {
+    SECTION("true should convert to config_boolean") {
+        auto value = config_value_factory::from_any_ref(true, "");
+        REQUIRE(dynamic_pointer_cast<const config_boolean>(value));
+        REQUIRE(boost::get<bool>(value->unwrapped()) == true);
+    }
+
+    SECTION("false should convert to config_boolean") {
+        auto value = config_value_factory::from_any_ref(false, "");
+        REQUIRE(dynamic_pointer_cast<const config_boolean>(value));
+        REQUIRE(boost::get<bool>(value->unwrapped()) == false);
+    }
+
+    SECTION("a null value should convert to config_null") {
+        auto value = config_value_factory::from_any_ref(boost::blank(), "");
+        REQUIRE(dynamic_pointer_cast<const config_null>(value));
+        REQUIRE(boost::get<boost::blank>(value->unwrapped()) == boost::blank());
+    }
+
+    SECTION("string should convert to config_string") {
+        auto value = config_value_factory::from_any_ref(string("test"), "");
+        REQUIRE(dynamic_pointer_cast<const config_string>(value));
+        REQUIRE(boost::get<string>(value->unwrapped()) == "test");
+    }
+
+    SECTION("int should convert to config_int") {
+        auto value = config_value_factory::from_any_ref(2, "");
+        REQUIRE(dynamic_pointer_cast<const config_int>(value));
+        REQUIRE(boost::get<int>(value->unwrapped()) == 2);
+    }
+
+    SECTION("double should covert to config_double") {
+        auto value = config_value_factory::from_any_ref(4.5, "");
+        REQUIRE(dynamic_pointer_cast<const config_double>(value));
+        REQUIRE(boost::get<double>(value->unwrapped()) == 4.5);
+    }
+
+    SECTION("long (int64_t) should convert to config_long") {
+        auto value = config_value_factory::from_any_ref(int64_t(19), "");
+        REQUIRE(dynamic_pointer_cast<const config_long>(value));
+        REQUIRE(boost::get<int64_t>(value->unwrapped()) == 19);
+    }
+
+    SECTION("map should convert to simple_config_object") {
+        unordered_map<string, unwrapped_value> map {{ "a", 1 }, { "b", "string" }, { "c", false }};
+        auto value = config_value_factory::from_any_ref(map, "");
+        REQUIRE(dynamic_pointer_cast<const simple_config_object>(value));
+        auto unwrapped = boost::get<unordered_map<string, unwrapped_value>>(value->unwrapped());
+        REQUIRE(unwrapped == map);
+    }
+}

data/ext/facter/cpp-hocon/lib/tests/config_value_test.cc

@@ -0,0 +1,111 @@
+#include <catch.hpp>
+
+#include <internal/values/simple_config_object.hpp>
+#include <internal/values/simple_config_list.hpp>
+
+#include "test_utils.hpp"
+
+using namespace hocon;
+using namespace std;
+using namespace hocon::test_utils;
+
+TEST_CASE("simple_config_origin equality", "[config_values]") {
+    auto org1 = simple_config_origin("foo");
+    auto org2 = simple_config_origin("foo");
+    auto org3 = simple_config_origin("bar");
+
+    SECTION("different origins with the same name should be equal") {
+        REQUIRE(org1 == org2);
+        REQUIRE(org1 != org3);
+    }
+}
+
+TEST_CASE("config_number equality", "[config_values]") {
+
+    SECTION("config_long equality") {
+        config_long a { fake_origin("fake"), 3, "3" };
+        config_long a2 { fake_origin("fake"), 3, "3" };
+        config_long b { fake_origin("fake"), 4, "4" };
+
+        REQUIRE(a == a2);
+        REQUIRE(a != b);
+    }
+
+    SECTION("config_double equality") {
+        config_double a { fake_origin("fake"), 3.0, "3.0" };
+        config_double a2 { fake_origin("fake"), 3.0, "3.0" };
+        config_double b { fake_origin("fake"), 4.5, "4.5" };
+
+        REQUIRE(a == a2);
+        REQUIRE(a != b);
+    }
+
+    SECTION("Int can equal double") {
+        config_long an_int { fake_origin("fake"), 3, "3" };
+        config_double a_double { fake_origin("fake"), 3.0, "3.0" };
+        config_double another_double { fake_origin("fake"), 3.5, "3.5" };
+
+        REQUIRE(an_int == a_double);
+        REQUIRE_FALSE(an_int == another_double);
+    }
+}
+
+TEST_CASE("config numbers ints vs longs vs doubles", "[tokenizer]") {
+    SECTION("creates a config_int from an int") {
+        shared_ptr<config_number> num = config_number::new_number(fake_origin(), int64_t(2), "2");
+        REQUIRE(dynamic_pointer_cast<config_int>(num));
+        REQUIRE_FALSE(dynamic_pointer_cast<config_long>(num));
+    }
+
+    SECTION("creates config_long from a large long") {
+        int64_t definitely_a_long = numeric_limits<int64_t>::max();
+        shared_ptr<config_number> num = config_number::new_number(fake_origin(),
+            definitely_a_long, to_string(definitely_a_long));
+        REQUIRE(dynamic_pointer_cast<config_long>(num));
+        REQUIRE_FALSE(dynamic_pointer_cast<config_int>(num));
+    }
+
+    SECTION("creates config_int from small whole-number double") {
+        shared_ptr<config_number> num = config_number::new_number(fake_origin(), 2.0, "2.0");
+        REQUIRE(dynamic_pointer_cast<config_int>(num));
+        REQUIRE_FALSE(dynamic_pointer_cast<config_double>(num));
+    }
+
+    SECTION("creates config_long from large whole-number double") {
+        double big_double = numeric_limits<int>::max() + 1.0;
+        shared_ptr<config_number> num = config_number::new_number(
+                fake_origin(), big_double, to_string(big_double));
+        REQUIRE(dynamic_pointer_cast<config_long>(num));
+        REQUIRE_FALSE(dynamic_pointer_cast<config_double>(num));
+    }
+
+    SECTION("creates config_double for non-whole number") {
+        shared_ptr<config_number> num = config_number::new_number(fake_origin(), 2.5, "2.5");
+        REQUIRE(dynamic_pointer_cast<config_double>(num));
+        REQUIRE_FALSE(dynamic_pointer_cast<config_int>(num));
+    }
+}
+
+TEST_CASE("config object unwraps") {
+    auto value1 = config_int::new_number(fake_origin(), int64_t(1), "1");
+    auto value2 = config_int::new_number(fake_origin(), int64_t(2), "2");
+    auto value3 = config_int::new_number(fake_origin(), int64_t(3), "3");
+    unordered_map<string, shared_value> org {{"a", value1}, {"b", value2}, {"c", value3}};
+    auto obj = make_shared<simple_config_object>(fake_origin(), org);
+    unordered_map<string, unwrapped_value> map {{"a", 1}, {"b", 2}, {"c", 3}};
+    unwrapped_value expected(map);
+    bool test = expected == obj->unwrapped();
+    REQUIRE(test);
+}
+
+TEST_CASE("config list unwraps") {
+    auto value1 = config_int::new_number(fake_origin(), int64_t(1), "1");
+    auto value2 = config_int::new_number(fake_origin(), int64_t(2), "2");
+    auto value3 = config_int::new_number(fake_origin(), int64_t(3), "3");
+    vector<shared_value> data { value1, value2, value3 };
+    auto list = make_shared<simple_config_list>(fake_origin(), data);
+    vector<unwrapped_value> v { 1,2,3 };
+    unwrapped_value expected(v);
+    bool test = expected == list->unwrapped();
+    REQUIRE(test);
+};

data/ext/facter/cpp-hocon/lib/tests/fixtures.hpp.in

@@ -0,0 +1,3 @@
+#pragma once
+
+#define TEST_FILE_DIR "@CMAKE_CURRENT_SOURCE_DIR@"

data/ext/facter/cpp-hocon/lib/tests/fixtures/test01.conf

@@ -0,0 +1,91 @@
+{
+    "ints" : {
+        "fortyTwo" : 42,
+        "fortyTwoAgain" : ${ints.fortyTwo}
+    },
+
+    "floats" : {
+        "fortyTwoPointOne" : 42.1,
+        "fortyTwoPointOneAgain" : ${floats.fortyTwoPointOne},
+        "pointThirtyThree": .33
+        "pointThirtyThreeAgain": ${floats.pointThirtyThree}
+    },
+
+    "strings" : {
+        "abcd" : "abcd",
+        "abcdAgain" : ${strings.a}${strings.b}${strings.c}${strings.d},
+        "a" : "a",
+        "b" : "b",
+        "c" : "c",
+        "d" : "d",
+        "concatenated" : null bar 42 baz true 3.14 hi,
+        "double" : "3.14",
+        "doubleStartingWithDot": ".33",
+        "number" : "57",
+        "null" : "null",
+        "true" : "true",
+        "yes" : "yes",
+        "false" : "false",
+        "no" : "no"
+    },
+
+    "arrays" : {
+        "empty" : [],
+        "ofInt" : [1, 2, 3],
+        "ofString" : [ ${strings.a}, ${strings.b}, ${strings.c} ],
+        "ofDouble" : [3.14, 4.14, 5.14],
+        "ofNull" : [null, null, null],
+        "ofBoolean" : [true, false],
+        "ofArray" : [${arrays.ofString}, ${arrays.ofString}, ${arrays.ofString}],
+        "ofObject" : [${ints}, ${booleans}, ${strings}],
+        "firstElementNotASubst" : [ "a", ${strings.b} ]
+    },
+
+    "booleans" : {
+        "true" : true,
+        "trueAgain" : ${booleans.true},
+        "false" : false,
+        "falseAgain" : ${booleans.false}
+    },
+
+    "nulls" : {
+        "null" : null,
+        "nullAgain" : ${nulls.null}
+    },
+
+    "durations" : {
+        "second" : 1s,
+        "minute" : 1 minute,
+        "hour" : 1hour,
+        "day" : 1 day,
+        "secondWithFractional" : 43.2s
+        "secondsList" : [1s,2seconds,3 s, 4000],
+        "secondAsNumber" : 1000,
+        "halfSecond" : 0.5s,
+        "millis" : 1 milli,
+        "micros" : 2000 micros,
+        "minusSeconds" : -4seconds,
+        "largeNanos" : 9223372036854775807ns,
+        "minusLargeNanos" : -9223372036854775807ns,
+        "largeDays" : 9223372036854775807 days
+    },
+
+    "memsizes" : {
+        "meg" : 1M,
+        "megsList" : [1M, 1024K, 1048576],
+        "megAsNumber" : 1048576,
+        "halfMeg" : 0.5M
+    },
+
+    "system" : {
+        "javaversion" : ${?java.version},
+        "userhome" : ${?user.home},
+        "home" : ${?HOME},
+        "pwd" : ${?PWD},
+        "shell" : ${?SHELL},
+        "lang" : ${?LANG},
+        "path" : ${?PATH},
+        "not_here" : ${?NOT_HERE},
+        "concatenated" : Your Java version is ${?system.javaversion} and your user.home is ${?system.userhome}
+    }
+}

data/ext/facter/cpp-hocon/lib/tests/fixtures/test01.json

@@ -0,0 +1,4 @@
+{
+    "fromJson1" : 1,
+    "fromJsonA" : "A"
+}

data/ext/facter/cpp-hocon/lib/tests/main.cc

@@ -0,0 +1,8 @@
+#define CATCH_CONFIG_RUNNER
+#include <catch.hpp>
+
+int main(int argc, char **argv)
+{
+    return Catch::Session().run(argc, argv);
+}
+

data/ext/facter/cpp-hocon/lib/tests/path_test.cc

@@ -0,0 +1,129 @@
+#include <catch.hpp>
+#include <hocon/path.hpp>
+#include <internal/path_parser.hpp>
+#include "test_utils.hpp"
+
+using namespace hocon;
+using namespace std;
+using namespace hocon::test_utils;
+
+TEST_CASE("path equality", "[path]") {
+    SECTION("new_key creates a path with one element") {
+        path a = path::new_key("foo.bar");
+        REQUIRE(test_path({"foo.bar"}) == a);
+        path b = path::new_key("hello");
+        REQUIRE(a != b);
+    }
+
+    SECTION("new_path correctly splits elements") {
+        path a = path::new_path("foo.bar");
+        REQUIRE(test_path({ "foo", "bar" }) == a);
+        REQUIRE(a != path::new_key("foo.bar"));
+    }
+}
+
+TEST_CASE("path to string", "[path]") {
+    REQUIRE("Path(foo)" == test_path({ "foo" }).to_string());
+    REQUIRE("Path(foo.bar)" == test_path({ "foo", "bar" }).to_string());
+    REQUIRE("Path(foo.\"bar*\")" == test_path({ "foo", "bar*" }).to_string());
+    REQUIRE("Path(\"foo.bar\")" == test_path({ "foo.bar" }).to_string());
+}
+
+void render_test(path p, string expected) {
+    REQUIRE(p.render() == expected);
+    REQUIRE(p == path_parser::parse_path(expected));
+    REQUIRE(p == path_parser::parse_path(p.render()));
+}
+
+TEST_CASE("path render", "[path]") {
+    SECTION("one element") {
+        render_test(test_path({"foo"}), "foo");
+    }
+    SECTION("two elements") {
+        render_test(test_path({"foo", "bar"}), "foo.bar");
+    }
+    SECTION("non-safe character in an element") {
+        render_test(test_path({"foo", "bar*"}), "foo.\"bar*\"");
+    }
+    SECTION("period in an element") {
+        render_test(test_path({"foo.bar"}), "\"foo.bar\"");
+    }
+    SECTION("hyphen in an element") {
+        render_test(test_path({"foo-bar"}), "foo-bar");
+    }
+    SECTION("underscore in an element") {
+        render_test(test_path({"foo_bar"}), "foo_bar");
+    }
+    SECTION("starts with a hyphen") {
+        render_test(test_path({"-foo"}), "-foo");
+    }
+    SECTION("starts with a number") {
+        render_test(test_path({"10foo"}), "10foo");
+    }
+    SECTION("empty elements") {
+        render_test(test_path({"", ""}), "\"\".\"\"");
+    }
+    SECTION("internal space") {
+        render_test(test_path({"foo bar"}), "\"foo bar\"");
+    }
+    SECTION("leading and trailing spaces") {
+        render_test(test_path({" foo "}), "\" foo \"");
+    }
+    SECTION("trailing space only") {
+        render_test(test_path({"foo "}), "\"foo \"");
+    }
+    SECTION("numbers with decimal points") {
+        render_test(test_path({"1", "2"}), "1.2");
+        render_test(test_path({"1", "2", "3", "4"}), "1.2.3.4");
+    }
+}
+
+TEST_CASE("path from list", "[path]") {
+    REQUIRE(test_path({"foo"}) == path(vector<path> { test_path({"foo"}) }));
+    vector<path> paths { test_path({"foo", "bar"}), test_path({"baz", "bat" }) };
+    REQUIRE(test_path({"foo", "bar", "baz", "bat"}) == path(paths));
+}
+
+TEST_CASE("prepend a path", "[path]") {
+    REQUIRE(test_path({"foo", "bar"}) == test_path({"bar"}).prepend(test_path({"foo"})));
+    path first = test_path({"a", "b"});
+    path second = test_path({"c", "d"});
+    REQUIRE(test_path({"a", "b", "c", "d"}) == second.prepend(first));
+}
+
+TEST_CASE("path length", "[path]") {
+    REQUIRE(test_path({"foo"}).length() == 1);
+    REQUIRE(test_path({"foo", "bar", "baz"}).length() == 3);
+}
+
+TEST_CASE("path parent", "[path]") {
+    REQUIRE(path { } == test_path({"a"}).parent());
+    REQUIRE(test_path({"a"}) == test_path({"a", "b"}).parent());
+    REQUIRE(test_path({"a", "b"}) == test_path({"a", "b", "c"}).parent());
+}
+
+TEST_CASE("path last", "[path]") {
+    path empty = path { };
+    REQUIRE(empty.last() == nullptr);
+    REQUIRE("a" == *test_path({"a"}).last());
+    REQUIRE("b" == *test_path({"a", "b"}).last());
+}
+
+TEST_CASE("path starts with", "[path]") {
+    path full = test_path({"a", "b", "c", "d"});
+    REQUIRE(full.starts_with(test_path({"a"})));
+    REQUIRE(full.starts_with(test_path({"a", "b", "c"})));
+    REQUIRE_FALSE(full.starts_with(test_path({"c", "d"})));
+    REQUIRE_FALSE(full.starts_with(test_path({"not_in_full"})));
+}
+
+TEST_CASE("invalid paths throw excpetions") {
+    REQUIRE_THROWS(path::new_path(""));
+    REQUIRE_THROWS(path::new_path(".."));
+}
+
+TEST_CASE("can detect weird characters", "[path]") {
+    REQUIRE_FALSE(path::has_funky_chars(""));
+    REQUIRE(path::has_funky_chars("foo*"));
+    REQUIRE_FALSE(path::has_funky_chars("foo"));
+}