facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,208 +0,0 @@
-#include <catch.hpp>
-#include <internal/config_document_parser.hpp>
-#include <hocon/parser/config_document_factory.hpp>
-
-#include "test_utils.hpp"
-
-using namespace std;
-using namespace hocon;
-using namespace hocon::test_utils;
-
-shared_ptr<config_node_root> conf_parse(string original_text) {
-    return config_document_parser::parse(
-            token_iterator(fake_origin(),
-                           unique_ptr<istringstream>(new istringstream(original_text)),
-                           true),
-            fake_origin(),
-            config_parse_options());
-}
-
-shared_ptr<config_node_root> json_parse(string original_text) {
-    return config_document_parser::parse(
-            token_iterator(fake_origin(),
-                           unique_ptr<istringstream>(new istringstream(original_text)),
-                           false),
-            fake_origin(),
-            config_parse_options().set_syntax(config_syntax::JSON));
-}
-
-shared_node_value parse_value_conf(string original_text) {
-    return config_document_parser::parse_value(
-            token_iterator(fake_origin(),
-                           unique_ptr<istringstream>(new istringstream(original_text)),
-                           true),
-            fake_origin(),
-            config_parse_options());
-}
-
-shared_node_value parse_value_json(string original_text) {
-    return config_document_parser::parse_value(
-            token_iterator(fake_origin(),
-                           unique_ptr<istringstream>(new istringstream(original_text)),
-                           false),
-            fake_origin(),
-            config_parse_options().set_syntax(config_syntax::JSON));
-}
-
-void parse_values_test(string original_text, bool simple = true, string final_text = "") {
-    string expected = final_text.empty() ? original_text : final_text;
-    auto node = parse_value_conf(original_text);
-    REQUIRE(expected == node->render());
-    if (simple) {
-        REQUIRE(dynamic_pointer_cast<const config_node_simple_value>(node));
-    } else {
-        REQUIRE(dynamic_pointer_cast<const config_node_complex_value>(node));
-    }
-
-    auto json_node = parse_value_json(original_text);
-    REQUIRE(expected == json_node->render());
-    if (simple) {
-        REQUIRE(dynamic_pointer_cast<const config_node_simple_value>(node));
-    } else {
-        REQUIRE(dynamic_pointer_cast<const config_node_complex_value>(node));
-    }
-}
-
-TEST_CASE("parse values", "[doc-parser]") {
-    SECTION("parse simple values") {
-        parse_values_test("123");
-        parse_values_test("123.456");
-        parse_values_test("\"a string\"");
-        parse_values_test("true");
-        parse_values_test("false");
-        parse_values_test("null");
-    }
-
-    SECTION("parse complex values") {
-        parse_values_test("{\"a\": \"b\"}", false);
-        parse_values_test("[\"a\", \"b\", \"c\"]", false);
-    }
-
-    SECTION("parse concatenations in CONF mode") {
-        string original_text = "123 456 \"abc\"";
-        auto node = parse_value_conf(original_text);
-        REQUIRE(original_text == node->render());
-    }
-
-    SECTION("parse keys with no separators and object values in CONF mode") {
-        string original_text = "{\"foo\" { \"bar\" : 12 } }";
-        auto node = parse_value_conf(original_text);
-        REQUIRE(original_text == node->render());
-    }
-}
-
-void invalid_json_test(string const& original_text, string const& message) {
-    try {
-        json_parse(original_text);
-    } catch (parse_exception& ex) {
-        REQUIRE(string(ex.what()).find(message) != string::npos);
-    }
-}
-
-TEST_CASE("parse single value errors", "[doc-parser]") {
-    SECTION("illegal leading and trailing whitespace and comments") {
-        REQUIRE_THROWS(parse_value_conf("   123"));
-        REQUIRE_THROWS(parse_value_conf("123   "));
-        REQUIRE_THROWS(parse_value_conf(" 123 "));
-        REQUIRE_THROWS(parse_value_conf("\n123"));
-        REQUIRE_THROWS(parse_value_conf("123\n"));
-        REQUIRE_THROWS(parse_value_conf("\n123\n"));
-        REQUIRE_THROWS(parse_value_conf("#this is a comment\n123#comment"));
-    }
-
-    SECTION("illegal whitespace after concatenation") {
-        REQUIRE_THROWS(parse_value_conf("123 456 789   "));
-    }
-}
-
-TEST_CASE("invalid JSON parse errors", "[doc-parser]") {
-    invalid_json_test("unquotedtext", "Token not allowed in valid JSON");
-
-    SECTION("no substitutions in JSON") {
-        invalid_json_test("${a.b}", "Substitutions (${} syntax) not allowed in JSON");
-    }
-
-    SECTION("no concatenations in JSON") {
-        invalid_json_test("{ \"foo\": 123 456 789 } ", "Expecting close brace '}' or a comma");
-    }
-
-    SECTION("value separators required in JSON") {
-        invalid_json_test("{\"foo\" { \"bar\" : 12 } }", "may not be followed by token: '{'");
-    }
-
-    SECTION("require root element in JSON") {
-        invalid_json_test("\"a\": 123, \"b\": 456", "Document must have an object or array at root");
-    }
-}
-
-TEST_CASE("parse empty document", "[doc-parser]") {
-    auto node = conf_parse("");
-    REQUIRE(dynamic_pointer_cast<const config_node_object>(node->value()));
-    REQUIRE(node->value()->children().empty());
-
-    auto node2 = conf_parse("#comment\n#comment\n\n");
-    REQUIRE(dynamic_pointer_cast<const config_node_object>(node2->value()));
-}
-
-void parse_test_string(string const& original_text) {
-    auto node = conf_parse(original_text);
-    REQUIRE(original_text == node->render());
-}
-
-TEST_CASE("comprehensive parse test") {
-    SECTION("without curly braces") {
-        parse_test_string("foo:bar");
-        parse_test_string(" foo : bar ");
-        parse_test_string("include \"foo.conf\" ");
-        parse_test_string("   \nfoo:bar\n   ");
-        parse_test_string("aUnquoted: bar\naString = \"qux\"\naNumb:123\naDouble=123.456\naTrue=true\naFalse=false\n"
-                          "aNull=null\naSub =  ${a.b}\ninclude \"foo.conf\"");
-    }
-
-    SECTION("with curly braces") {
-        parse_test_string("{}");
-        parse_test_string("{foo:bar}");
-        parse_test_string("{  foo  :  bar  }");
-        parse_test_string("{foo:bar}    ");
-        parse_test_string("{include \"foo.conf\"}");
-        parse_test_string("  \n{foo:bar}\n  ");
-        parse_test_string("{\naUnquoted: bar\naString = \"qux\"\naNumb:123\naDouble=123.456\naTrue=true\naFalse=false\n"
-                          "aNull=null\naSub =  ${a.b}\ninclude \"foo.conf\"\n}");
-    }
-
-    SECTION("nested maps") {
-        parse_test_string("\nfoo.bar.baz : {\n\tqux : \"abcdefg\"\n\t\"abc\".def.\"ghi\" : 123\n\tabc = "
-                          "{ food:bar }\n}\nqux = 123.456\n");
-    }
-
-    SECTION("comments in maps") {
-        parse_test_string("{\nfoo: bar\n// this is a comment\nbaz:qux // this is another comment\n}");
-    }
-
-    SECTION("arrays") {
-        parse_test_string("[]");
-        parse_test_string("[foo]");
-        parse_test_string("[foo,]");
-        parse_test_string("[foo,]   ");
-        parse_test_string("   \n[]\n   ");
-        parse_test_string("[foo, bar,\"qux\", 123,123.456, true,false, null, ${a.b}]");
-        parse_test_string("[foo,   bar,\"qux\"   , 123  123.456, true,false, null,   ${a.b}   ]");
-    }
-
-    SECTION("basic concatenation") {
-        parse_test_string("[foo bar baz qux]");
-        parse_test_string("{foo: foo bar baz qux}");
-        parse_test_string("[abc 123 123.456 null true false [1, 2, 3] {a:b}, 2]");
-    }
-
-    SECTION("all together now") {
-        parse_test_string("{\nfoo: bar baz   qux    ernie\n// The above was a concatenation\n\nbaz  =  [ abc 123, {a:12\n"
-        "\t\t\t\tb: {\n\t\t\t\t\tc: 13\n\t\t\t\t\td: {\n\t\t\t\t\t\ta: 22\n\t\t\t\t\t\tb: \"abcdefg\" # this is a "
-        "comment\n\t\t\t\t\t\tc: [1, 2, 3]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t}, # this was an object in an array\n"
-        "\t\t\t\t//The above value is a map containing a map containing a map, all in an array\n\t\t\t\t22,\n"
-        "\t\t\t\t// The below is an array contained in another array\n\t\t\t\t[1,2,3]]\n//This is a map with some "
-        "nested maps and array within it, as well as as some concatenations\nqux {\n\tbaz: abc 123\n\tbar: {\n\t\t"
-        "baz: abcdefg\n\t\tbar: {\n\t\t\ta: null\n\t\t\tb: true\n\t\t\tc: [true false 123, null, [1, 2, 3]]\n\t\t}"
-        "\n\t}\n}\n// Did I cover everything?\n}");
-    }
-}

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

@@ -1,110 +0,0 @@
-#include <catch.hpp>
-#include <hocon/parser/config_document_factory.hpp>
-#include <internal/simple_config_document.hpp>
-#include "fixtures.hpp"
-
-using namespace hocon;
-using namespace std;
-
-void replace_test(string const& original_text, string const& final_text, string const& new_value,
-                  string const& replace_path, config_syntax syntax) {
-    auto config_doc = config_document_factory::parse_string(original_text,
-                                                            config_parse_options().set_syntax(syntax));
-    REQUIRE(original_text == config_doc->render());
-    auto new_doc = config_doc->with_value_text(replace_path, new_value);
-    REQUIRE(final_text == new_doc->render());
-}
-
-TEST_CASE("replacement of elements in a document", "[config-doc]") {
-    SECTION("replacements in a simple map") {
-        replace_test("{\"a\":1}", "{\"a\":2}", "2", "a", config_syntax::JSON);
-        replace_test("{\"a\":1}", "{\"a\":2}", "2", "a", config_syntax::CONF);
-    }
-
-    SECTION("replacement in a map without braces") {
-        replace_test("a: b\nc = d", "a: b\nc = 12", "12", "c", config_syntax::CONF);
-    }
-
-    string original_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
-        "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": 12\n\t},\n"
-        "\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
-    SECTION("replacements in a complex map") {
-        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
-                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
-                "\"i am now a string\"\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
-        replace_test(original_text, final_text, "\"i am now a string\"", "h.b.a", config_syntax::JSON);
-        replace_test(original_text, final_text, "\"i am now a string\"", "h.b.a", config_syntax::CONF);
-    }
-
-    SECTION("replace a value with a map") {
-        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
-                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
-                "{\"a\":\"b\", \"c\":\"d\"}\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
-        replace_test(original_text, final_text, "{\"a\":\"b\", \"c\":\"d\"}", "h.b.a", config_syntax::JSON);
-        replace_test(original_text, final_text, "{\"a\":\"b\", \"c\":\"d\"}", "h.b.a", config_syntax::CONF);
-    }
-
-    SECTION("replace a value with an array") {
-        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
-                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
-                "[1,2,3,4,5]\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
-        replace_test(original_text, final_text, "[1,2,3,4,5]", "h.b.a", config_syntax::JSON);
-        replace_test(original_text, final_text, "[1,2,3,4,5]", "h.b.a", config_syntax::CONF);
-    }
-
-    SECTION("replace a value with a concatenation") {
-        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
-                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
-                "this is a concatenation 123 456 {a:b} [1,2,3] {a: this is another 123 concatenation null true}\n\t},\n"
-                "\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
-        replace_test(original_text, final_text, "this is a concatenation 123 456 {a:b} [1,2,3] "
-                "{a: this is another 123 concatenation null true}", "h.b.a", config_syntax::CONF);
-    }
-}
-
-TEST_CASE("removal of duplicates", "[config-doc]") {
-    string original_text = "{a: b, a.b.c: d, a: e}";
-    auto config_doc = config_document_factory::parse_string(original_text);
-    REQUIRE("{a: 2}" == config_doc->with_value_text("a", "2")->render());
-
-    original_text = "{a: b, a: e, a.b.c:d}";
-    config_doc = config_document_factory::parse_string(original_text);
-    REQUIRE("{a: 2, }" == config_doc->with_value_text("a", "2")->render());
-
-    original_text = "{a.b.c: d}";
-    config_doc = config_document_factory::parse_string(original_text);
-    REQUIRE("{ a : 2}" == config_doc->with_value_text("a", "2")->render());
-}
-
-TEST_CASE("set new value", "[config-doc]") {
-    SECTION("braced root node") {
-        string original_text = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\"\n}";
-        string final_text_conf = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\"\n\t\"e\" : \"f\"\n}";
-        string final_text_json = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\",\n\t\"e\" : \"f\"\n}";
-        replace_test(original_text, final_text_json, "\"f\"", "\"e\"", config_syntax::JSON);
-        replace_test(original_text, final_text_conf, "\"f\"", "\"e\"", config_syntax::CONF);
-    }
-
-    SECTION("no brace at root node") {
-        string original_text = "\"a\":\"b\",\n\"c\":\"d\"\n";
-        string final_text = "\"a\":\"b\",\n\"c\":\"d\"\n\"e\" : \"f\"\n";
-        replace_test(original_text, final_text, "\"f\"", "\"e\"", config_syntax::CONF);
-    }
-
-    SECTION("multi-level") {
-        string original_text = "a:b\nc:d";
-        string final_text = "a:b\nc:d\ne : {\n  f : {\n    g : 12\n  }\n}";
-        replace_test(original_text, final_text, "12", "e.f.g", config_syntax::CONF);
-
-        original_text = "{\"a\":\"b\",\n\"c\":\"d\"}";
-        final_text = "{\"a\":\"b\",\n\"c\":\"d\",\n  \"e\" : {\n    \"f\" : {\n      \"g\" : 12\n    }\n  }}";
-        replace_test(original_text, final_text, "12", "e.f.g", config_syntax::JSON);
-    }
-}
-
-TEST_CASE("parse from file", "[doc-parser]") {
-    string original_text = "{ a : b }";
-    string directory = TEST_FILE_DIR;
-    auto doc = config_document_factory::parse_file(directory + "/test.conf");
-    REQUIRE(doc->render() == original_text);
-}

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

@@ -1,338 +0,0 @@
-#include <catch.hpp>
-
-#include "test_utils.hpp"
-
-#include <limits>
-#include <internal/path_parser.hpp>
-#include <internal/nodes/config_node_object.hpp>
-#include <internal/nodes/config_node_array.hpp>
-#include <internal/nodes/config_node_concatenation.hpp>
-
-using namespace std;
-using namespace hocon;
-using namespace hocon::test_utils;
-
-/*  This test implementation of abstract_config_node allows
- *  shallow testing of its basic methods.
- */
-class concrete_config_node : public abstract_config_node {
-public:
-    token_list get_tokens() const { return _tokens; };
-    token_list _tokens;
-};
-
-TEST_CASE("abstract_config_node") {
-    concrete_config_node node;
-    shared_token token1 = hash_comment_token("token1");
-    shared_token token2 = hash_comment_token("token2");
-
-    SECTION("render should return all tokens concatenated together") {
-        node._tokens.push_back(token1);
-        node._tokens.push_back(token2);
-        REQUIRE(node.render() == "#token1#token2");
-    }
-
-    SECTION("render should return an empty string when there are no tokens") {
-        REQUIRE(node.render() == "");
-    }
-
-    SECTION("== operator when objects are equivalent") {
-        concrete_config_node another_node;
-        node._tokens.push_back(token1);
-        another_node._tokens.push_back(token1);
-        REQUIRE(node == another_node);
-    }
-
-    SECTION("== operator when objects are not equivalent") {
-        concrete_config_node another_node;
-        node._tokens.push_back(token1);
-        another_node._tokens.push_back(token2);
-        REQUIRE_FALSE(node == another_node);
-    }
-}
-
-void single_token_test(shared_token t) {
-    config_node_single_token node(t);
-    REQUIRE(node.render() == t->token_text());
-}
-
-TEST_CASE("single tokens", "[config-node]") {
-    SECTION("basic config nodes") {
-        single_token_test(tokens::start_token());
-        single_token_test(tokens::end_token());
-        single_token_test(tokens::open_curly_token());
-        single_token_test(tokens::close_curly_token());
-        single_token_test(tokens::open_square_token());
-        single_token_test(tokens::close_square_token());
-        single_token_test(tokens::comma_token());
-        single_token_test(tokens::colon_token());
-        single_token_test(tokens::plus_equals_token());
-        single_token_test(tokens::equals_token());
-
-        single_token_test(unquoted_text_token("foo"));
-        single_token_test(whitespace_token("   "));
-        single_token_test(line_token(1));
-        single_token_test(double_slash_comment_token("slash comment"));
-        single_token_test(hash_comment_token("hash comment"));
-    }
-}
-
-void simple_value_test(shared_token t, config_value::type type) {
-    config_node_simple_value node(t);
-    // We pass UNSPECIFIED for substitutions, which do not have a config_value::type
-    if (type != config_value::type::UNSPECIFIED) {
-        REQUIRE(type == node.get_value()->value_type());
-    }
-    REQUIRE(node.render() == t->token_text());
-}
-
-TEST_CASE("simple values", "[config-node]") {
-    SECTION("basic value nodes") {
-        simple_value_test(int_token(10, "10"), config_value::type::NUMBER);
-        simple_value_test(double_token(2.5, "2.5"), config_value::type::NUMBER);
-        simple_value_test(bool_token(false), config_value::type::BOOLEAN);
-        simple_value_test(bool_token(true), config_value::type::BOOLEAN);
-        simple_value_test(null_token(), config_value::type::CONFIG_NULL);
-        simple_value_test(string_token("A string."), config_value::type::STRING);
-        simple_value_test(unquoted_text_token("unquoted"), config_value::type::STRING);
-        simple_value_test(substitution_token(string_token("c.d"), false), config_value::type::UNSPECIFIED);
-        simple_value_test(substitution_token(string_token("x.y"), true), config_value::type::UNSPECIFIED);
-        simple_value_test(substitution_token(unquoted_text_token("a.b"), false), config_value::type::UNSPECIFIED);
-    }
-}
-
-TEST_CASE("key nodes", "[config-node]") {
-    REQUIRE(node_key("foo")->render() == "foo");
-    REQUIRE(node_key("\"Hello how are you today?\"")->render() == "\"Hello how are you today?\"");
-}
-
-TEST_CASE("node subpath", "[config-node]") {
-    string original_path = "a.b.c.\"@$%@!#$\".\"\".1234.5678";
-    auto path_node = node_key(original_path);
-
-    REQUIRE(original_path == path_node->render());
-    REQUIRE("c.\"@$%@!#$\".\"\".1234.5678" == path_node->sub_path(2).render());
-    REQUIRE("5678" == path_node->sub_path(6).render());
-}
-
-void field_node_test(shared_ptr<config_node_path> key, shared_node_value value, shared_node_value new_value) {
-    auto key_value_node = node_key_value_pair(key, value);
-    REQUIRE((key->render() + " : " + value->render()) == key_value_node->render());
-    REQUIRE(key->render() == key_value_node->path()->render());
-    REQUIRE(value->render() == key_value_node->get_value()->render());
-
-    auto new_key_value = key_value_node->replace_value(new_value);
-    REQUIRE((key->render() + " : " + new_value->render()) == new_key_value->render());
-    REQUIRE(new_value->render() == new_key_value->get_value()->render());
-}
-
-TEST_CASE("node fields", "[config-node]") {
-    SECTION("supports quoted and unquoted keys") {
-        field_node_test(node_key("\"abc\""), int_node(123), int_node(345));
-        field_node_test(node_key("abc"), int_node(123), int_node(345));
-    }
-
-    SECTION("can replace value with values of different types") {
-        field_node_test(node_key("\"abc\""), int_node(123), string_node("I am a string"));
-        field_node_test(node_key("\"abc\""), int_node(123), make_shared<config_node_object>(
-        shared_node_list { open_brace_node(), close_brace_node() }));
-    }
-}
-
-void top_level_value_replace_test(shared_node_value value,
-                                  shared_node_value new_value,
-                                  string key = "foo")
-{
-    shared_node_list children { open_brace_node(),
-                                node_key_value_pair(node_key(key), value),
-                                close_brace_node() };
-    config_node_object complex { children };
-    auto new_node = complex.set_value_on_path(key, new_value);
-    string original_text = "{" + key + " : " + value->render() + "}";
-    string final_text = "{" + key + " : " + new_value->render() + "}";
-
-    REQUIRE(original_text == complex.render());
-    REQUIRE(final_text == new_node->render());
-}
-
-TEST_CASE("replace nodes", "[config-node]") {
-    SECTION("simple values can be replaced") {
-        top_level_value_replace_test(int_node(10), int_node(15));
-        top_level_value_replace_test(long_node(numeric_limits<int>::max() + 1ll), int_node(1));
-        top_level_value_replace_test(double_node(3.14), int_node(2));
-        top_level_value_replace_test(bool_node(false), bool_node(false));
-        top_level_value_replace_test(bool_node(true), null_node());
-        top_level_value_replace_test(null_node(), string_node("I am a string"));
-        top_level_value_replace_test(string_node("string here!"), unquoted_text_node("thisisunquoted"));
-        top_level_value_replace_test(unquoted_text_node("unquotedtext"), substitution_node(string_token("c.d"), false));
-        top_level_value_replace_test(int_node(10), substitution_node(unquoted_text_token("x.y"), true));
-        top_level_value_replace_test(int_node(10), substitution_node(unquoted_text_token("a.b"), false));
-        top_level_value_replace_test(substitution_node(unquoted_text_token("c.d"), false), int_node(10));
-    }
-
-    auto node_array = make_shared<config_node_array>(shared_node_list {
-            open_brace_node(),
-            int_node(10),
-            space_node(),
-            comma_node(),
-            space_node(),
-            int_node(15),
-            close_brace_node()
-    });
-
-    SECTION("arrays can be replaced") {
-        top_level_value_replace_test(int_node(10), node_array);
-        top_level_value_replace_test(node_array, int_node(10));
-        top_level_value_replace_test(node_array, make_shared<config_node_object>(shared_node_list {
-                open_brace_node(),
-                close_brace_node()
-        }));
-    }
-
-    auto nested_map = make_shared<config_node_object>(
-            shared_node_list { open_brace_node(),
-                               node_key_value_pair(node_key("abc"), string_node("a string")),
-                               close_brace_node()
-            });
-
-    SECTION("objects can be replaced") {
-        top_level_value_replace_test(nested_map, int_node(10));
-        top_level_value_replace_test(int_node(10), nested_map);
-        top_level_value_replace_test(node_array, nested_map);
-        top_level_value_replace_test(nested_map, node_array);
-        top_level_value_replace_test(nested_map,
-                                     make_shared<config_node_object>(shared_node_list { open_brace_node(),
-                                                                                        close_brace_node() }));
-    }
-
-    SECTION("concatenations can be replaced") {
-        auto concat = make_shared<config_node_concatenation>(shared_node_list {
-                int_node(10),
-                space_node(),
-                string_node("hello")
-        });
-
-        top_level_value_replace_test(concat, int_node(10));
-        top_level_value_replace_test(int_node(12), concat);
-        top_level_value_replace_test(nested_map, concat);
-        top_level_value_replace_test(concat, nested_map);
-        top_level_value_replace_test(concat, node_array);
-        top_level_value_replace_test(node_array, concat);
-    }
-
-    SECTION("a.b key format") {
-        top_level_value_replace_test(int_node(10), nested_map, "foo.bar");
-    }
-}
-
-void remove_duplicates_test(shared_node_value value1, shared_node_value value2, shared_node_value value3) {
-    auto key = node_key("foo");
-    auto key_val1 = node_key_value_pair(key, value1);
-    auto key_val2 = node_key_value_pair(key, value2);
-    auto key_val3 = node_key_value_pair(key, value3);
-
-    auto complex = make_shared<config_node_object>(shared_node_list { key_val1, key_val2, key_val3 });
-    string original_text = key_val1->render() + key_val2->render() + key_val3->render();
-    string final_text = key->render() + " : 15";
-
-    REQUIRE(original_text == complex->render());
-    REQUIRE(final_text == complex->set_value_on_path("foo", int_node(15))->render());
-}
-
-TEST_CASE("duplicates of a key are removed from a map", "[config-node]") {
-    auto empty_map_node = make_shared<config_node_object>(shared_node_list { open_brace_node(), close_brace_node() });
-    auto empty_array = make_shared<config_node_array>(shared_node_list { open_brace_node(), close_brace_node() });
-
-    remove_duplicates_test(int_node(10), bool_node(true), null_node());
-    remove_duplicates_test(empty_map_node, empty_map_node, empty_map_node);
-    remove_duplicates_test(empty_array, empty_array, empty_array);
-    remove_duplicates_test(int_node(10), empty_map_node, empty_array);
-}
-
-void nonexistent_path_test(shared_node_value value) {
-    auto node = make_shared<config_node_object>(
-            shared_node_list { node_key_value_pair(node_key("bar"), int_node(15)) });
-    REQUIRE("bar : 15" == node->render());
-    auto new_node = node->set_value_on_path("foo", value);
-    string final_text = "bar : 15, foo : " + value->render();
-    REQUIRE(final_text == new_node->render());
-}
-
-TEST_CASE("creates non-existent paths", "[config-node]") {
-    nonexistent_path_test(int_node(10));
-    nonexistent_path_test(make_shared<config_node_object>(
-            shared_node_list { open_brace_node(),
-                               node_key_value_pair(node_key("foo"), double_node(3.14)),
-                               close_brace_node() }));
-    nonexistent_path_test(make_shared<config_node_array>(shared_node_list {
-            open_brace_node(),
-            int_node(15),
-            close_brace_node()
-    }));
-}
-
-TEST_CASE("replace nested nodes") {
-    string orig_text = "foo : bar\nbaz : {\n\t\"abc.def\" : 123\n\t"
-                       "//this is a comment about the below setting"
-                       "\n\n\tabc : {\n\t\tdef : \"this is a string\""
-                       "\n\t\tghi : ${\"a.b\"}\n\t}\n}\nbaz.abc.ghi "
-                       ": 52\nbaz.abc.ghi : 53\n}";
-    auto lowest_level_map = make_shared<config_node_object>(shared_node_list {
-          open_brace_node(),
-          line_node(6),
-          whitespace_node("\t\t"),
-          node_key_value_pair(node_key("def"), string_node("\"this is a string\"")),
-          line_node(7),
-          whitespace_node("\t\t"),
-          node_key_value_pair(node_key("ghi"), substitution_node(string_token("\"a.b\""), false)),
-          line_node(8),
-          whitespace_node("\t"),
-          close_brace_node()
-    });
-    auto higher_level_map = make_shared<config_node_object>(shared_node_list {
-            open_brace_node(),
-            line_node(2),
-            whitespace_node("\t"),
-            node_key_value_pair(node_key("\"abc.def\""), int_node(123)),
-            line_node(3),
-            whitespace_node("\t"),
-            double_slash_comment_node("this is a comment about the below setting"),
-            line_node(4),
-            line_node(5),
-            whitespace_node("\t"),
-            node_key_value_pair(node_key("abc"), lowest_level_map),
-            line_node(9),
-            close_brace_node()
-    });
-    auto original_node = make_shared<config_node_object>(shared_node_list {
-            node_key_value_pair(node_key("foo"), unquoted_text_node("bar")),
-            line_node(1),
-            node_key_value_pair(node_key("baz"), higher_level_map),
-            line_node(10),
-            node_key_value_pair(node_key("baz.abc.ghi"), int_node(52)),
-            line_node(11),
-            node_key_value_pair(node_key("baz.abc.ghi"), int_node(53)),
-            line_node(12),
-            close_brace_node()
-    });
-    REQUIRE(orig_text == original_node->render());
-
-    string final_text = "foo : bar\nbaz : {\n\t\"abc.def\" : true\n\t"
-            "//this is a comment about the below setting"
-            "\n\n\tabc : {\n\t\tdef : false\n\t\t\n\t\t\"this.does.not.exist@@@+$#\""
-            " : {\n\t\t  end : doesnotexist\n\t\t}\n\t}\n}\n\nbaz.abc.ghi : randomunquotedString\n}";
-
-    // Paths with quotes in the name are treated as a single path rather than multiple subpaths
-    auto new_node = original_node->set_value_on_path("baz.\"abc.def\"", bool_node(true));
-    new_node = new_node->set_value_on_path("baz.abc.def", bool_node(false));
-
-    // Repeats are removed from nested maps
-    new_node = new_node->set_value_on_path("baz.abc.ghi", unquoted_text_node("randomunquotedString"));
-
-    // Missing paths are added to the top level if they don't appear anywhere, including in nested maps
-    new_node = new_node->set_value_on_path("baz.abc.\"this.does.not.exist@@@+$#\".end",
-                                           unquoted_text_node("doesnotexist"));
-
-    REQUIRE(final_text == new_node->render());
-}
-