AuroraMiddleware/tomlplusplus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0f5d986df1
tomlplusplus/tests/path.cpp
Mark Gillard 3f4acc7c32 additonal path work 
- re-ordered most of the `.inl` implementations to match the declaration order in the class body
- fixed a few missing cases of `noexcept`
- added additional operator overloads for +=
- added `operator==` and `operator!=` to `path_component`
- changed parse method to "parse into" so it could be re-used in more places without creating a temporary vector
- changed all binary operators to be 'hidden friends'
- moved the "to string" logic to a "print_to" for streams to avoid creating a temporary string in the ostream<< operator
- made the string conversion operators `explicit`
- renamed `string()` to `str()` to be consistent with `toml::key` and `std::stringstream`
- renamed `wstring()` to `wide_str()` to be consistent with `toml::source_region`
- renamed `parent_path()` to `parent()`
- removed the `const (w)char*` operator overloads - these were already sufficiently covered by the `std::(w)string_view` ones
- removed the `operator/` overloads - since we aren't a file path the `/` doesn't have the same meaning (also `operator+` was doing the same thing)
2022-06-05 00:14:50 +03:00

595 lines
17 KiB
C++
Raw Blame History

// This file is a part of toml++ and is subject to the the terms of the MIT license.
// Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
// See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
// SPDX-License-Identifier: MIT
#include "tests.h"
TOML_DISABLE_SPAM_WARNINGS;
TEST_CASE("path - parsing")
{
SECTION("parsing")
{
CHECK(toml::path("").str() == "");
CHECK(toml::path("[1]").str() == "[1]");
CHECK(toml::path("[1][2]").str() == "[1][2]");
CHECK(toml::path(" [1][2]").str() == " [1][2]");
CHECK(toml::path("a. .b").str() == "a. .b");
CHECK(toml::path("test[23]").str() == "test[23]");
CHECK(toml::path("[ 120 ]").str() == "[120]");
CHECK(toml::path("test.value").str() == "test.value");
CHECK(toml::path("test[0].value").str() == "test[0].value");
CHECK(toml::path("test[1][2]\t .value").str() == "test[1][2].value");
CHECK(toml::path("test[1]\t[2].value").str() == "test[1][2].value");
CHECK(toml::path(".test[1][2]\t ..value").str() == ".test[1][2]..value");
#if TOML_ENABLE_WINDOWS_COMPAT
CHECK(toml::path(L"").str() == "");
CHECK(toml::path(L"[1]").str() == "[1]");
CHECK(toml::path(L"[1][2]").str() == "[1][2]");
CHECK(toml::path(L" [1][2]").str() == " [1][2]");
CHECK(toml::path(L"a. .b").str() == "a. .b");
CHECK(toml::path(L"test[23]").str() == "test[23]");
CHECK(toml::path(L"[ 120 ]").str() == "[120]");
CHECK(toml::path(L"test.value").str() == "test.value");
CHECK(toml::path(L"test[0].value").str() == "test[0].value");
CHECK(toml::path(L"test[1][2]\t .value").str() == "test[1][2].value");
CHECK(toml::path(L"test[1]\t[2].value").str() == "test[1][2].value");
CHECK(toml::path(L".test[1][2]\t ..value").str() == ".test[1][2]..value");
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
SECTION("parsing - errors")
{
CHECK(!toml::path("test[][2].value"));
CHECK(!toml::path("test[ "));
CHECK(!toml::path("test[1]a.b"));
CHECK(!toml::path("test[1] a.b"));
CHECK(!toml::path("test[1a]"));
CHECK(!toml::path("test[a1]"));
CHECK(!toml::path("test[1!]"));
CHECK(!toml::path("test[!1]"));
CHECK(!toml::path("test[1 2]"));
CHECK(!toml::path("test[1.2]"));
CHECK(!toml::path("test[0.2]"));
#if TOML_ENABLE_WINDOWS_COMPAT
CHECK(!toml::path(L"test[][2].value"));
CHECK(!toml::path(L"test[ "));
CHECK(!toml::path(L"test[1]a.b"));
CHECK(!toml::path(L"test[1] a.b"));
CHECK(!toml::path(L"test[1a]"));
CHECK(!toml::path(L"test[a1]"));
CHECK(!toml::path(L"test[1!]"));
CHECK(!toml::path(L"test[!1]"));
CHECK(!toml::path(L"test[1 2]"));
CHECK(!toml::path(L"test[1.2]"));
CHECK(!toml::path(L"test[0.2]"));
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
SECTION("parsing from literal")
{
auto p0 = "a.b.c[1][12]"_tpath;
CHECK(p0);
CHECK(p0.str() == "a.b.c[1][12]");
CHECK("ab.cd[1]"_tpath == toml::path("ab.cd[1]"));
CHECK(("an.invalid.path[a1]"_tpath).str() == "");
}
}
TEST_CASE("path - manipulating")
{
SECTION("parent_node and truncation")
{
toml::path p0("");
CHECK(p0.parent().str() == "");
toml::path p1("start.middle.end");
CHECK(p1.parent().str() == "start.middle");
CHECK(p1.parent().parent().str() == "start");
CHECK(p1.parent().parent().parent().str() == "");
CHECK(p1.parent().parent().parent().parent().str() == "");
toml::path p2("[1][2][3]");
CHECK(p2.parent().str() == "[1][2]");
CHECK(p2.parent().parent().str() == "[1]");
CHECK(p2.parent().parent().parent().str() == "");
toml::path p3(".test");
CHECK(p3.parent().str() == "");
toml::path p4("test..");
CHECK(p4.parent().str() == "test.");
CHECK(p4.parent().parent().str() == "test");
CHECK(p4.parent().parent().parent().str() == "");
toml::path p5("test.key[12].subkey");
CHECK(p5.parent().str() == "test.key[12]");
CHECK(p5.parent().parent().str() == "test.key");
CHECK(p5.parent().parent().parent().str() == "test");
CHECK(p5.parent().parent().parent().parent().str() == "");
toml::path p6("test.key1.key2.key3.key4");
CHECK(p6.truncated(0).str() == "test.key1.key2.key3.key4");
CHECK(p6.truncated(1).str() == "test.key1.key2.key3");
CHECK(p6.truncated(4).str() == "test");
CHECK(p6.truncated(5).str() == "");
CHECK(p6.truncated(20).str() == "");
CHECK(p6.str() == "test.key1.key2.key3.key4");
p6.truncate(0);
CHECK(p6.str() == "test.key1.key2.key3.key4");
p6.truncate(2);
CHECK(p6.str() == "test.key1.key2");
p6.truncate(3);
CHECK(p6.str() == "");
}
SECTION("subpath")
{
toml::path p0("a.simple[1].path[2].object");
CHECK(p0.subpath(p0.begin() + 1, p0.begin() + 4).str() == "simple[1].path");
CHECK(p0.subpath(p0.begin() + 1, p0.end() - 1).str() == "simple[1].path[2]");
CHECK(p0.subpath(p0.begin(), p0.begin()).str() == "");
CHECK(p0.subpath(p0.begin(), p0.end() - 5).str() == "a");
CHECK(p0.subpath(p0.begin() + 2, p0.end() - 1).str() == "[1].path[2]");
CHECK(p0.subpath(p0.begin() + 5, p0.end() - 5).str() == "");
CHECK(!p0.subpath(p0.end(), p0.begin()));
CHECK(p0.subpath(1, 4).str() == "simple[1].path[2]");
CHECK(p0.subpath(0, 0).str() == "");
CHECK(p0.subpath(2, 0).str() == "");
CHECK(p0.subpath(2, 1).str() == "[1]");
}
SECTION("leaf")
{
toml::path p0("one.two.three.four.five");
CHECK(p0.leaf(0).str() == "");
CHECK(p0.leaf().str() == "five");
CHECK(p0.leaf(3).str() == "three.four.five");
CHECK(p0.leaf(5).str() == "one.two.three.four.five");
CHECK(p0.leaf(10).str() == "one.two.three.four.five");
toml::path p1("[10][2][30][4][50]");
CHECK(p1.leaf(0).str() == "");
CHECK(p1.leaf().str() == "[50]");
CHECK(p1.leaf(3).str() == "[30][4][50]");
CHECK(p1.leaf(5).str() == "[10][2][30][4][50]");
CHECK(p1.leaf(10).str() == "[10][2][30][4][50]");
toml::path p2("one[1].two.three[3]");
CHECK(p2.leaf(0).str() == "");
CHECK(p2.leaf().str() == "[3]");
CHECK(p2.leaf(3).str() == "two.three[3]");
CHECK(p2.leaf(4).str() == "[1].two.three[3]");
CHECK(p2.leaf(10).str() == "one[1].two.three[3]");
}
SECTION("append - string")
{
toml::path p0("start");
CHECK(p0.size() == 1u);
CHECK(p0.append("middle.end").str() == "start.middle.end");
CHECK(p0.append("[12]").str() == "start.middle.end[12]");
toml::path p1("");
CHECK(p1.size() == 1u);
p1.append("[1].key"sv);
CHECK(p1.size() == 3u);
CHECK(p1.str() == "[1].key"sv);
#if TOML_ENABLE_WINDOWS_COMPAT
toml::path p2("start");
CHECK(p2.size() == 1u);
CHECK(p2.append(L"middle.end").str() == "start.middle.end");
CHECK(p2.append(L"[12]").str() == "start.middle.end[12]");
toml::path p3("");
CHECK(p3.append(L"[1].key").str() == "[1].key");
#endif // TOML_ENABLE_WINDOWS_COMPAT
toml::path p4;
CHECK(p4.size() == 0u);
CHECK(p4.append("[1].key").str() == "[1].key");
}
SECTION("append - toml::path copy")
{
toml::path p0("start");
toml::path appendee1("middle.end");
toml::path appendee2("[12]");
CHECK(p0.append(appendee1).str() == "start.middle.end");
CHECK(p0.append(appendee2).str() == "start.middle.end[12]");
// Ensure copies and not moves
CHECK(appendee1.str() == "middle.end");
CHECK(appendee2.str() == "[12]");
toml::path p1("");
toml::path appendee3("[1].key");
CHECK(p1.append(appendee3).str() == "[1].key");
// Ensure copies and not moves
CHECK(appendee3.str() == "[1].key");
}
SECTION("append - toml::path move")
{
toml::path p0("start");
CHECK(p0.append(toml::path{ "middle.end" }).str() == "start.middle.end");
CHECK(p0.append(toml::path{ "[12]" }).str() == "start.middle.end[12]");
toml::path p1("");
CHECK(p1.size() == 1u);
CHECK(p1.append(toml::path{ "[1].key" }).str() == "[1].key");
toml::path p2;
CHECK(p2.size() == 0u);
CHECK(p2.append(toml::path{ "[1].key" }).str() == "[1].key");
}
SECTION("prepend - string")
{
toml::path p0("start");
CHECK(p0.prepend("middle.end").str() == "middle.end.start");
CHECK(p0.prepend("[12]").str() == "[12].middle.end.start");
toml::path p1;
CHECK(p1.prepend("[1].key").str() == "[1].key");
toml::path p2("");
CHECK(p2.prepend("[1].key").str() == "[1].key.");
#if TOML_ENABLE_WINDOWS_COMPAT
toml::path p3("start");
CHECK(p3.prepend(L"middle.end").str() == "middle.end.start");
CHECK(p3.prepend(L"[12]").str() == "[12].middle.end.start");
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
SECTION("prepend - toml::path copy")
{
toml::path p0("start");
toml::path prependee1("middle.end");
toml::path prependee2("[12]");
CHECK(p0.prepend(prependee1).str() == "middle.end.start");
CHECK(p0.prepend(prependee2).str() == "[12].middle.end.start");
// Ensure copies and not moves
CHECK(prependee1.str() == "middle.end");
CHECK(prependee2.str() == "[12]");
toml::path p1;
toml::path prependee3("[1].key");
CHECK(p1.prepend(prependee3).str() == "[1].key");
// Ensure copies and not moves
CHECK(prependee3.str() == "[1].key");
}
SECTION("prepend - toml::path move")
{
toml::path p0("start");
CHECK(p0.prepend(toml::path("middle.end")).str() == "middle.end.start");
CHECK(p0.prepend(toml::path("[12]")).str() == "[12].middle.end.start");
toml::path p1;
CHECK(p1.prepend(toml::path("[1].key")).str() == "[1].key");
}
SECTION("alter components")
{
toml::path p0("start.mid[1][2].end");
p0[3].value = std::size_t{ 13 };
CHECK(p0.str() == "start.mid[1][13].end");
p0[3].type = path_component_type::key;
p0[3].value = "newkey";
CHECK(p0.str() == "start.mid[1].newkey.end");
p0[0].value = std::size_t{ 2 };
p0[0].type = path_component_type::array_index;
CHECK(p0.str() == "[2].mid[1].newkey.end");
}
SECTION("assign")
{
toml::path p0("start.mid[1][2].end");
p0.assign("test.key[1]");
CHECK(p0.str() == "test.key[1]");
p0.assign("");
CHECK(p0.str() == "");
toml::path p1("a.test.path[1]");
p1.assign("invalid[abc]");
CHECK(!p1);
CHECK(p1.str() == "");
toml::path p2("another[1].test.path");
p2.assign(toml::path("test"));
CHECK(p2.str() == "test");
p2.assign(toml::path(""));
CHECK(p2.str() == "");
toml::path p3("final.test[1]");
p3.assign(toml::path("invalid[abc"));
CHECK(!p3);
CHECK(p3.str() == "");
#if TOML_ENABLE_WINDOWS_COMPAT
toml::path p4("start.mid[1][2].end");
p4.assign(L"test.key[1]");
CHECK(p4.str() == "test.key[1]");
p4.assign("");
CHECK(p4.str() == "");
toml::path p5("a.test.path[1]");
p5.assign("invalid[abc]");
CHECK(!p5);
CHECK(p5.str() == "");
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
}
TEST_CASE("path - operators")
{
SECTION("object equality")
{
CHECK(toml::path("a.b.c") == toml::path("a.b.c"));
CHECK(toml::path("[1].a") == toml::path("[1].a"));
CHECK(toml::path("a.b.c") != toml::path("a.b"));
CHECK(toml::path("[1].b") != toml::path("[1].b.c"));
}
SECTION("string equality")
{
CHECK(toml::path("a.b.c") == "a.b.c");
CHECK(toml::path("[1].a") == "[1].a");
CHECK(toml::path("a.b.c") != "a.b");
CHECK(toml::path("[1].b") != "[1].b.c");
#if TOML_ENABLE_WINDOWS_COMPAT
CHECK(toml::path("a.b.c") == L"a.b.c");
CHECK(toml::path("[1].a") == L"[1].a");
CHECK(toml::path("a.b.c") != L"a.b");
CHECK(toml::path("[1].b") != L"[1].b.c");
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
SECTION("arithmetic")
{
CHECK(toml::path("a.b.c") + "a[1]" == "a.b.c.a[1]");
CHECK((toml::path("a.b.c") + "a[1]") == "a.b.c.a[1]");
CHECK(toml::path("a.b.c") + toml::path("a[1]") == "a.b.c.a[1]");
toml::path p1("a.b");
toml::path p2("c[1]");
CHECK(p1 + p2 == "a.b.c[1]");
CHECK(p1 + "c[1]" == "a.b.c[1]");
CHECK("a.b" + p2 == "a.b.c[1]");
#if TOML_ENABLE_WINDOWS_COMPAT
CHECK(toml::path("a.b.c") + L"a[1]" == "a.b.c.a[1]");
CHECK(p1 + L"c[1]" == "a.b.c[1]");
CHECK(L"a.b" + p2 == "a.b.c[1]");
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
}
TEST_CASE("path - misc")
{
CHECK(toml::path{ "" }.str() == "");
CHECK(toml::path{ "a" }.str() == "a");
CHECK(toml::path{ "a.b" }.str() == "a.b");
CHECK(toml::path{ "a.b.c" }.str() == "a.b.c");
CHECK(toml::path{ ".a.b.c" }.str() == ".a.b.c");
CHECK(toml::path{}.empty());
CHECK(!toml::path{ "" }.empty());
CHECK(!toml::path{ "a" }.empty());
CHECK(static_cast<std::string>(toml::path("a.b[1]")) == "a.b[1]");
CHECK(static_cast<bool>(toml::path("a.b[1]")));
CHECK(!static_cast<bool>(toml::path("a.b[a b]")));
#if TOML_ENABLE_WINDOWS_COMPAT
CHECK(static_cast<std::wstring>(toml::path("a.b[1]")) == L"a.b[1]");
#endif
}
TEST_CASE("path - accessing")
{
// clang-format off
const auto tbl = table
{
{ ""sv, 0 }, // blank key
{ "a"sv, 1 },
{
"b"sv,
array
{
2,
array{ 3 },
table { { "c", 4 } }
},
},
{ "d", table{ {"e", 5, }, {""sv, -1 } } }
};
// clang-format on
/*
# equivalent to the following TOML:
"" = 0
a = 1
b = [
2,
[ 3 ],
{ "c" = 4 }
]
d = { "e" = 5, "" = -1 }
*/
SECTION("table")
{
// this section uses the free function version of at_path
CHECK(tbl[""]);
CHECK(tbl[""] == at_path(tbl, toml::path("")));
CHECK(tbl["a"]);
CHECK(tbl["a"] == at_path(tbl, toml::path("a")));
CHECK(tbl["a"] != at_path(tbl, toml::path(".a"))); // equivalent to ""."a"
CHECK(!at_path(tbl, toml::path(".a")));
CHECK(tbl["b"]);
CHECK(tbl["b"] == at_path(tbl, toml::path("b")));
CHECK(tbl["b"][0]);
CHECK(tbl["b"][0] == at_path(tbl, toml::path("b[0]")));
CHECK(tbl["b"][0] == at_path(tbl, toml::path("b[0] ")));
CHECK(tbl["b"][0] == at_path(tbl, toml::path("b[ 0\t]"))); // whitespace is allowed inside array indexer
CHECK(tbl["b"][1]);
CHECK(tbl["b"][1] != tbl["b"][0]);
CHECK(tbl["b"][1] == at_path(tbl, toml::path("b[1]")));
CHECK(tbl["b"][1][0]);
CHECK(tbl["b"][1][0] == at_path(tbl, toml::path("b[1][0]")));
CHECK(tbl["b"][1][0] == at_path(tbl, toml::path("b[1] \t [0]"))); // whitespace is allowed after array
// indexers
CHECK(tbl["b"][2]["c"]);
CHECK(tbl["b"][2]["c"] == at_path(tbl, toml::path("b[2].c")));
CHECK(tbl["b"][2]["c"] == at_path(tbl, toml::path("b[2] \t.c"))); // whitespace is allowed after array
// indexers
CHECK(tbl["d"]);
CHECK(tbl["d"] == at_path(tbl, toml::path("d")));
CHECK(tbl["d"]["e"]);
CHECK(tbl["d"]["e"] == at_path(tbl, toml::path("d.e")));
CHECK(tbl["d"]["e"] != at_path(tbl, toml::path("d. e"))); // equivalent to "d"." e"
CHECK(!at_path(tbl, toml::path("d. e")));
CHECK(tbl["d"][""]);
CHECK(tbl["d"][""] == at_path(tbl, toml::path("d.")));
}
SECTION("array")
{
// this section uses the node_view member function version of at_path
auto arr = tbl["b"];
CHECK(tbl["b"][0]);
CHECK(tbl["b"][0] == arr.at_path(toml::path("[0]")));
CHECK(tbl["b"][0] == arr.at_path(toml::path("[0] ")));
CHECK(tbl["b"][0] == arr.at_path(toml::path("[ 0\t]"))); // whitespace is allowed inside array indexer
CHECK(tbl["b"][1]);
CHECK(tbl["b"][1].node() != arr[0].node());
CHECK(tbl["b"][1] == arr.at_path(toml::path("[1]")));
CHECK(tbl["b"][1][0]);
CHECK(tbl["b"][1][0] == arr.at_path(toml::path("[1][0]")));
CHECK(tbl["b"][1][0] == arr.at_path(toml::path("[1] \t [0]"))); // whitespace is allowed after array
// indexers
CHECK(tbl["b"][2]["c"]);
CHECK(tbl["b"][2]["c"] == arr.at_path(toml::path("[2].c")));
CHECK(tbl["b"][2]["c"] == arr.at_path(toml::path("[2] \t.c"))); // whitespace is allowed after array indexers
}
SECTION("indexing operator")
{
// this section uses the operator[] of table and node_view
CHECK(tbl[""]);
CHECK(tbl[""] == tbl[toml::path("")]);
CHECK(tbl["a"]);
CHECK(tbl["a"] == tbl[toml::path("a")]);
CHECK(tbl["a"] != tbl[toml::path(".a")]); // equivalent to ""."a"
CHECK(!tbl[toml::path(".a")]);
CHECK(tbl["b"]);
CHECK(tbl["b"] == tbl[toml::path("b")]);
CHECK(tbl["b"][0]);
CHECK(tbl["b"][0] == tbl[toml::path("b[0]")]);
CHECK(tbl["b"][0] == tbl[toml::path("b[0] ")]);
CHECK(tbl["b"][0] == tbl[toml::path("b[ 0\t]")]); // whitespace is allowed inside array indexer
CHECK(tbl["b"][1]);
CHECK(tbl["b"][1] != tbl[toml::path("b")][0]);
CHECK(tbl["b"][1] == tbl[toml::path("b[1]")]);
CHECK(tbl["b"][1][0]);
CHECK(tbl["b"][1][0] == tbl[toml::path("b[1]")][0]);
CHECK(tbl["b"][1][0] == tbl[toml::path("b[1] \t [0]")]); // whitespace is allowed after array
// indexers
CHECK(tbl["b"][2]["c"]);
CHECK(tbl["b"][2]["c"] == tbl[toml::path("b")][toml::path("[2].c")]);
CHECK(tbl["b"][2]["c"] == tbl[toml::path("b[2] \t.c")]); // whitespace is allowed after array
// indexers
CHECK(tbl["d"]);
CHECK(tbl["d"] == tbl[toml::path("d")]);
CHECK(tbl["d"]["e"]);
CHECK(tbl["d"]["e"] == tbl[toml::path("d.e")]);
CHECK(tbl["d"]["e"] != tbl[toml::path("d. e")]); // equivalent to "d"." e"
CHECK(!tbl[toml::path("d. e")]);
CHECK(tbl["d"][""]);
CHECK(tbl["d"][""] == tbl[toml::path("d.")]);
}
SECTION("std::variant mismatches")
{
toml::path p0("b[2].c");
p0[1].value = "abc";
CHECK(!at_path(tbl, p0));
toml::path p1("b[2].c");
p1[0].value = std::size_t{ 1 };
CHECK(!at_path(tbl, p1));
}
}
Reference in New Issue View Git Blame Copy Permalink