4333001432

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/snototter/werkzeugkiste/commit/<a class=hub.com/snototter/werkzeugkiste/commit/bd10cc0abe0466e33074477246921d94e9f57cda">bd10cc0ab<a href="https://github.com/snototter/werkzeugkiste/commit/bd10cc0abe0466e33074477246921d94e9f57cda">">Merge </a><a class="double-link" href="https://github.com/snototter/werkzeugkiste/commit/<a class="double-link" href="https://github.com/snototter/werkzeugkiste/commit/8888ee8d0e4fcb772c9c675ef0f743dad491f82a">8888ee8d0</a>">8888ee8d0</a><a href="https://github.com/snototter/werkzeugkiste/commit/bd10cc0abe0466e33074477246921d94e9f57cda"> into 4defa10e7">4defa10e7</a>

Pull Request Pull Request #38: Add libconfig support

Run Details

765 of 765 new or added lines in 26 files covered. (100.0%)

5972 of 6476 relevant lines covered (92.22%)

168.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.14

/tests/src/config/io_test.cpp

#include <werkzeugkiste/config/configuration.h>
#include <werkzeugkiste/files/filesys.h>
#include <werkzeugkiste/strings/strings.h>

#include <sstream>

#include "../test_utils.h"

namespace wkc = werkzeugkiste::config;
namespace wkf = werkzeugkiste::files;
namespace wks = werkzeugkiste::strings;

// NOLINTBEGIN

using namespace std::string_view_literals;

TEST(ConfigIOTest, NestedTOML) {
  const auto fname_invalid_toml =
      wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.toml"sv);
  std::ostringstream toml_str;
  toml_str << "bool = true\ninteger = 3\nlst = [1, 2]\ndate = 2023-02-21\n"
              "time = 08:30:00\ndatetime = 2023-02-21T11:11:11\n"
              "nested_config = \""sv
           << wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)
           << "\"\n"
              "float = 2.0\n"
              "invalid_nested_config = \""sv
           << fname_invalid_toml
           << "\"\n"
              "lvl1.lvl2.lvl3.nested = \""sv
           << wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)
           << "\"\n"
              "lvl1.arr = [ 1, 2, \""sv
           << wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)
           << "\"]\n"
              "lvl1.another_arr = [1, { name = 'test', nested = \""
           << wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)
           << "\" }]"sv;

  auto config = wkc::LoadTOMLString(toml_str.str());
  EXPECT_THROW(
      config.LoadNestedTOMLConfiguration("no-such-key"sv), wkc::KeyError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("bool"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("integer"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("float"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("lst"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("date"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("time"sv), wkc::TypeError);
  EXPECT_THROW(
      config.LoadNestedTOMLConfiguration("datetime"sv), wkc::TypeError);
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("lvl1"sv), wkc::TypeError);
  EXPECT_THROW(
      config.LoadNestedTOMLConfiguration("lvl1.lvl2"sv), wkc::TypeError);
  config.LoadNestedTOMLConfiguration("nested_config"sv);

  EXPECT_EQ(1, config.GetInteger32("nested_config.value1"sv));
  EXPECT_DOUBLE_EQ(2.3, config.GetDouble("nested_config.value2"sv));
  EXPECT_EQ("this/is/a/relative/path",
      config.GetString("nested_config.section1.rel_path"sv));

  // When trying to load an invalid TOML file, an exception should be thrown,
  // and the parameter should not change.
  EXPECT_THROW(config.LoadNestedTOMLConfiguration("invalid_nested_config"sv),
      wkc::ParseError);
  EXPECT_EQ(fname_invalid_toml, config.GetString("invalid_nested_config"sv));

  // Ensure that loading a nested configuration also works at deeper
  // hierarchy levels.
  EXPECT_NO_THROW(
      config.LoadNestedTOMLConfiguration("lvl1.lvl2.lvl3.nested"sv));
  EXPECT_DOUBLE_EQ(2.3, config.GetDouble("lvl1.lvl2.lvl3.nested.value2"sv));
  EXPECT_EQ("this/is/a/relative/path",
      config.GetString("lvl1.lvl2.lvl3.nested.section1.rel_path"sv));

  // It is not allowed to load a nested configuration directly into an array:
  EXPECT_THROW(
      config.LoadNestedTOMLConfiguration("lvl1.arr[2]"sv), wkc::TypeError);

  // One could abuse it, however, to load a nested configuration into a table
  // that is inside an array... Just because you can doesn't mean you should...
  EXPECT_NO_THROW(
      config.LoadNestedTOMLConfiguration("lvl1.another_arr[1].nested"sv));
  EXPECT_DOUBLE_EQ(
      2.3, config.GetDouble("lvl1.another_arr[1].nested.value2"sv));
  EXPECT_EQ("this/is/a/relative/path",
      config.GetString("lvl1.another_arr[1].nested.section1.rel_path"sv));
}

TEST(ConfigIOTest, ConfigConstruction) {
  const std::string fname =
      wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml");

  // Force copy construction
  auto config = wkc::LoadTOMLFile(fname);
  wkc::Configuration copy{config};

  EXPECT_TRUE(config.Equals(copy));
  EXPECT_FALSE(config.Empty());
  EXPECT_FALSE(copy.Empty());
  EXPECT_EQ(1, config.GetInteger32("value1"sv));
  EXPECT_EQ(1, copy.GetInteger32("value1"sv));

  // Force move construction
  wkc::Configuration moved{std::move(config)};
  EXPECT_FALSE(copy.Empty());
  EXPECT_EQ(1, moved.GetInteger32("value1"sv));

  // Test copy assignment
  wkc::Configuration tmp{};
  EXPECT_TRUE(tmp.Empty());
  copy = tmp;
  EXPECT_TRUE(tmp.Empty());
  EXPECT_TRUE(copy.Empty());

  tmp.SetBoolean("tbl.val"sv, true);
  EXPECT_FALSE(tmp.Empty());
  EXPECT_TRUE(copy.Empty());
  copy = tmp;
  EXPECT_FALSE(tmp.Empty());
  EXPECT_FALSE(copy.Empty());
  EXPECT_TRUE(tmp.Contains("tbl.val"sv));
  EXPECT_TRUE(copy.Contains("tbl.val"sv));
  EXPECT_TRUE(tmp.GetBoolean("tbl.val"sv));
  EXPECT_TRUE(copy.GetBoolean("tbl.val"sv));

  // Test move assignment
  moved = std::move(tmp);
  EXPECT_FALSE(moved.Empty());
  EXPECT_TRUE(moved.Contains("tbl.val"sv));
  EXPECT_TRUE(moved.GetBoolean("tbl.val"sv));
  EXPECT_FALSE(moved.Contains("value1"sv));  // Previously contained
}

TEST(ConfigIOTest, LoadingToml) {
  const std::string fname =
      wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml");

  // Load valid TOML, then reload its string representation
  const auto config1 = wkc::LoadTOMLFile(fname);
  const auto reloaded = wkc::LoadTOMLString(config1.ToTOML());
  EXPECT_TRUE(config1.Equals(reloaded));
  EXPECT_TRUE(reloaded.Equals(config1));
  // Also the string representations should be equal
  EXPECT_EQ(config1.ToTOML(), reloaded.ToTOML());

  // Load a different configuration:
  const auto config2 = wkc::LoadTOMLString(R"toml(
    param1 = "value"
    param2 = "value"

    param3 = true
    )toml");
  EXPECT_FALSE(config1.Equals(config2));
  EXPECT_FALSE(config2.Equals(config1));

  // Identity check
  EXPECT_TRUE(config1.Equals(config1));
  EXPECT_TRUE(config2.Equals(config2));

  // White space mustn't affect the equality check
  auto config3 = wkc::LoadTOMLString(R"toml(

    param1 =     "value"


    param2 =  "value"

    param3         = true

    )toml");

  EXPECT_FALSE(config1.Equals(config3));
  EXPECT_TRUE(config2.Equals(config3));
  EXPECT_TRUE(config3.Equals(config2));

  // Change the first string parameter
  config3 = wkc::LoadTOMLString(R"toml(
    param1 = "value!"
    param2 = "value"

    param3 = true
    )toml");
  EXPECT_FALSE(config1.Equals(config3));
  EXPECT_FALSE(config2.Equals(config3));
  EXPECT_FALSE(config3.Equals(config2));

  // Change the 3rd parameter type
  config3 = wkc::LoadTOMLString(R"toml(
    param1 = "value"
    param2 = "value"

    param3 = [1, 2]
    )toml"sv);
  EXPECT_FALSE(config1.Equals(config3));
  EXPECT_FALSE(config2.Equals(config3));
  EXPECT_FALSE(config3.Equals(config2));

  const auto empty = wkc::LoadTOMLString(""sv);
  EXPECT_FALSE(empty.Equals(config1));
  EXPECT_FALSE(config1.Equals(empty));

  const auto def = wkc::Configuration();
  EXPECT_TRUE(def.Empty());
  EXPECT_TRUE(empty.Equals(def));

  // Edge cases for TOML loading:
  EXPECT_THROW(
      wkc::LoadTOMLFile("this-does-not-exist.toml"sv), wkc::ParseError);
  try {
    wkc::LoadTOMLFile("this-does-not-exist.toml"sv);
  } catch (const wkc::ParseError &e) {
    const std::string exp_err{
        "Cannot open file. Check path: \"this-does-not-exist.toml\"."};
    EXPECT_EQ(exp_err, std::string(e.what()));
  }

  const std::string fname_invalid =
      wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.toml"sv);
  EXPECT_THROW(wkc::LoadTOMLFile(fname_invalid), wkc::ParseError);
  try {
    wkc::LoadTOMLFile(fname_invalid);
    EXPECT_TRUE(false);
  } catch (const wkc::ParseError &e) {
    EXPECT_TRUE(wks::StartsWith(e.what(), "Error while parsing value: "sv))
        << "Error message was: "sv << e.what();
  }
}

TEST(ConfigIOTest, ParsingInvalidDateTimes) {
  // Leap seconds are not supported.
  EXPECT_THROW(
      wkc::LoadTOMLString("dt = 1990-12-31T23:59:60Z"), wkc::ParseError);
  EXPECT_THROW(
      wkc::LoadTOMLString("dt = 1990-12-31T15:59:60-08:00"), wkc::ParseError);

  // Leap seconds are not supported.
  EXPECT_THROW(wkc::date_time({1990, 12, 31}, {23, 59, 60}), wkc::ValueError);
  EXPECT_THROW(wkc::date_time{"1990-12-31T23:59:60Z"sv}, wkc::ParseError);

  // Unknown Local Offset Convention (-00:00) is not supported, i.e. it
  // will be silently converted to UTC+0.
  EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59Z"sv});
  EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59-00:00"sv});
  EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59+00:00"sv});
  EXPECT_EQ(wkc::date_time{"1990-12-31T23:59:59-00:00"sv},
      wkc::date_time{"1990-12-31T23:59:59+00:00"sv});
}

// TODO Can be properly tested once we have LoadJSONString()
TEST(ConfigIOTest, LoadingJson) {
  const auto config = wkc::LoadTOMLString(R"toml(
    param1 = "value"
    )toml"sv);
  EXPECT_TRUE(config.ToJSON().length() > 0);
}

#ifdef WERKZEUGKISTE_WITH_LIBCONFIG
TEST(ConfigIOTest, ParseLibconfigFiles) {
  EXPECT_THROW(wkc::LoadLibconfigFile("no-such-file"sv), wkc::ParseError);

  const auto fname_invalid_cfg =
      wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.cfg"sv);
  EXPECT_THROW(wkc::LoadLibconfigFile(fname_invalid_cfg), wkc::ParseError);

  const auto fname_valid_cfg =
      wkf::FullFile(wkf::DirName(__FILE__), "test-valid.cfg"sv);
  auto config = wkc::LoadLibconfigFile(fname_valid_cfg);

  EXPECT_EQ(4, config.Size());

  // Check the "empty" group
  EXPECT_EQ(0, config.Size("empty_group"sv));
  EXPECT_TRUE(config.GetGroup("empty_group"sv).Empty());

  // Check the "group" group
  EXPECT_EQ(5, config.Size("group"sv));
  EXPECT_EQ(6, config.Size("group.subgroup"sv));

  const auto group = config.GetGroup("group"sv);
  EXPECT_EQ(5, group.Size());
  const auto subgroup = group.GetGroup("subgroup"sv);
  EXPECT_EQ(6, subgroup.Size());

  EXPECT_EQ(subgroup, config.GetGroup("group.subgroup"sv));
  EXPECT_EQ("Value", subgroup.GetString("str"sv));
  EXPECT_EQ(2, subgroup.Size("size"sv));
  EXPECT_EQ(640, subgroup.GetInteger32("size.width"sv));
  EXPECT_EQ(480, subgroup.GetInteger32("size.height"sv));

  EXPECT_EQ(3, subgroup.Size("ints"sv));
  EXPECT_EQ(10, subgroup.GetInteger32("ints[0]"sv));
  EXPECT_EQ(11, subgroup.GetInteger32("ints[1]"sv));
  EXPECT_EQ(-12, subgroup.GetInteger32("ints[2]"sv));

  EXPECT_EQ(3, subgroup.Size("flts"sv));
  EXPECT_DOUBLE_EQ(1e-3, subgroup.GetDouble("flts[0]"sv));
  EXPECT_DOUBLE_EQ(0.0, subgroup.GetDouble("flts[1]"sv));
  EXPECT_DOUBLE_EQ(2.0, subgroup.GetDouble("flts[2]"sv));

  EXPECT_TRUE(subgroup.GetBoolean("flag"sv));
  EXPECT_TRUE(config.GetBoolean("group.subgroup.flag"sv));

  EXPECT_EQ(1, subgroup.Size("another-group"sv));
  auto str = subgroup.GetString("another-group.long-string"sv);
  EXPECT_TRUE(wks::StartsWith(str, "A very long string that spans"sv));
  str = subgroup.GetString("another-group.long-string"sv);
  EXPECT_TRUE(wks::EndsWith(str, "automatically concatenated."sv));

  EXPECT_FALSE(config.GetBoolean("group.flag"sv));
  EXPECT_EQ(-54321, config.GetInteger32("group.int"sv));
  EXPECT_DOUBLE_EQ(1e6, config.GetDouble("group.flt"sv));
  EXPECT_EQ("Another String", config.GetString("group.str"sv));

  // Check the "list" list
  EXPECT_EQ(6, config.Size("list"sv));

  EXPECT_EQ(3, config.Size("list[0]"sv));
  EXPECT_EQ("abc", config.GetString("list[0][0]"sv));
  EXPECT_EQ(123, config.GetInteger32("list[0][1]"sv));
  EXPECT_TRUE(config.GetBoolean("list[0][2]"sv));

  EXPECT_DOUBLE_EQ(1.234, config.GetDouble("list[1]"sv));

  EXPECT_EQ(0, config.Size("list[2]"sv));
  EXPECT_EQ(wkc::ConfigType::List, config.Type("list[2]"sv));

  EXPECT_EQ(3, config.Size("list[3]"sv));
  const auto ints = config.GetInteger32List("list[3]"sv);
  EXPECT_EQ(1, ints[0]);
  EXPECT_EQ(2, ints[1]);
  EXPECT_EQ(3, ints[2]);

  EXPECT_EQ(1, config.Size("list[4]"sv));
  EXPECT_TRUE(config.Contains("list[4].a"sv));
  EXPECT_EQ(3, config.Size("list[4].a"sv));
  EXPECT_EQ(1, config.GetInteger32("list[4].a[0]"sv));
  EXPECT_EQ(2, config.GetInteger32("list[4].a[1]"sv));
  EXPECT_TRUE(config.GetBoolean("list[4].a[2]"sv));

  EXPECT_EQ(0, config.Size("list[5]"sv));
  EXPECT_TRUE(config.GetGroup("list[5]"sv).Empty());

  // Check the "bigints" group
  const auto bigints = config.GetGroup("bigints"sv);
  EXPECT_THROW(bigints.GetInteger32("int"sv), wkc::TypeError);
  EXPECT_EQ(9223372036854775807L, bigints.GetInteger64("int"sv));
  EXPECT_EQ(9223372036854775807L, config.GetInteger64("bigints.int"sv));
  EXPECT_THROW(bigints.GetInteger32("hex"sv), wkc::TypeError);
  EXPECT_EQ(0x1122334455667788L, bigints.GetInteger64("hex"sv));
  EXPECT_EQ(0x1122334455667788L, config.GetInteger64("bigints.hex"sv));
}

TEST(ConfigIOTest, ParseLibconfigStrings) {
  const auto config = wkc::LoadLibconfigString(R"lcfg(
    int_pos = +987654;
    int_neg = -123456;
    int32_max = 2147483647;
    int32_min = -2147483648;
    // Previous libconfig versions require explicit ..L suffix for long ints:
    int32_max_overflow = 2147483648L;
    int32_min_underflow = -2147483649L;
    flt = -1e3;
    flag = false;
    str = "value";

    ints = [1, 2, 3];
    flts = [1.2, 2.0];

    strings = ["foo", "bar"];

    mixed = (1, true, "string");

    nested = (
      "foo",
      { age = 3; name = "bar"; },
      [-1, 23])

    group = {
      flag = true;
      count = 123;

      subgroup = {
        flag = false;
        threshold = 1e-6;
      }
    };
    )lcfg");

  EXPECT_EQ(987654, config.GetInteger32("int_pos"sv));
  EXPECT_EQ(-123456, config.GetInteger32("int_neg"sv));
  EXPECT_EQ(2147483647, config.GetInteger32("int32_max"sv));
  EXPECT_EQ(-2147483648, config.GetInteger32("int32_min"sv));
  EXPECT_THROW(config.GetInteger32("int32_min_underflow"sv), wkc::TypeError);
  EXPECT_THROW(config.GetInteger32("int32_max_overflow"sv), wkc::TypeError);
  EXPECT_EQ(-2147483649, config.GetInteger64("int32_min_underflow"sv));
  EXPECT_EQ(+2147483648, config.GetInteger64("int32_max_overflow"sv));

  EXPECT_DOUBLE_EQ(-1000.0, config.GetDouble("flt"sv));
  EXPECT_FALSE(config.GetBoolean("flag"sv));
  EXPECT_EQ("value", config.GetString("str"sv));

  // List of integers
  auto ints = config.GetInteger32List("ints"sv);
  EXPECT_EQ(3, ints.size());
  EXPECT_EQ(1, ints[0]);
  EXPECT_EQ(2, ints[1]);
  EXPECT_EQ(3, ints[2]);

  // List of floating points
  const auto flts = config.GetDoubleList("flts"sv);
  EXPECT_EQ(2, flts.size());
  EXPECT_DOUBLE_EQ(1.2, flts[0]);
  EXPECT_DOUBLE_EQ(2.0, flts[1]);

  // String list
  const auto strings = config.GetStringList("strings"sv);
  EXPECT_EQ(2, strings.size());
  EXPECT_EQ("foo", strings[0]);
  EXPECT_EQ("bar", strings[1]);

  // Mixed list
  EXPECT_EQ(3, config.Size("mixed"sv));
  EXPECT_EQ(wkc::ConfigType::List, config.Type("mixed"sv));
  EXPECT_EQ(wkc::ConfigType::Integer, config.Type("mixed[0]"sv));
  EXPECT_EQ(1, config.GetInteger32("mixed[0]"sv));
  EXPECT_EQ(wkc::ConfigType::Boolean, config.Type("mixed[1]"sv));
  EXPECT_TRUE(config.GetBoolean("mixed[1]"sv));
  EXPECT_EQ(wkc::ConfigType::String, config.Type("mixed[2]"sv));
  EXPECT_EQ("string", config.GetString("mixed[2]"sv));

  // Mixed & nested list
  EXPECT_EQ(3, config.Size("nested"sv));
  EXPECT_EQ(wkc::ConfigType::List, config.Type("nested"sv));

  EXPECT_EQ(wkc::ConfigType::String, config.Type("nested[0]"sv));
  EXPECT_EQ("foo", config.GetString("nested[0]"sv));

  EXPECT_EQ(wkc::ConfigType::Group, config.Type("nested[1]"sv));
  auto subgroup = config.GetGroup("nested[1]"sv);
  EXPECT_EQ(2, subgroup.Size());
  EXPECT_EQ(3, subgroup.GetInteger32("age"sv));
  EXPECT_EQ(3, config.GetInteger32("nested[1].age"sv));
  EXPECT_EQ("bar", subgroup.GetString("name"sv));
  EXPECT_EQ("bar", config.GetString("nested[1].name"sv));

  EXPECT_EQ(wkc::ConfigType::List, config.Type("nested[2]"sv));
  ints = config.GetInteger32List("nested[2]"sv);
  EXPECT_EQ(2, ints.size());
  EXPECT_EQ(-1, ints[0]);
  EXPECT_EQ(23, ints[1]);

  // Subgroup/Table
  EXPECT_EQ(wkc::ConfigType::Group, config.Type("group"sv));
  EXPECT_EQ(3, config.Size("group"sv));
  EXPECT_TRUE(config.GetBoolean("group.flag"sv));
  EXPECT_EQ(123, config.GetInteger32("group.count"sv));

  EXPECT_EQ(wkc::ConfigType::Group, config.Type("group.subgroup"sv));
  EXPECT_FALSE(config.GetBoolean("group.subgroup.flag"sv));
  EXPECT_DOUBLE_EQ(1e-6, config.GetDouble("group.subgroup.threshold"sv));

  // Try parsing an invalid configuration string.
  const auto invalid_str = R"lcfg(valid = true;
    invalid = [1, 2.5];
    )lcfg"sv;
  EXPECT_THROW(wkc::LoadLibconfigString(invalid_str), wkc::ParseError);
  try {
    wkc::LoadLibconfigString(invalid_str);
  } catch (const wkc::ParseError &e) {
    EXPECT_TRUE(wks::StartsWith(e.what(),
        "Parsing libconfig string failed at line `2`: "
        "mismatched element type in array"))
        << "Actual exception message: " << e.what();
  }
}

#else   // WERKZEUGKISTE_WITH_LIBCONFIG
TEST(ConfigIOTest, MissingLibconfigSupport) {
  EXPECT_THROW(wkc::LoadLibconfigFile("no-such-file"sv), std::logic_error);
  EXPECT_THROW(wkc::LoadLibconfigString("foo = 3"sv), std::logic_error);
}
#endif  // WERKZEUGKISTE_WITH_LIBCONFIG

// NOLINTEND

1	#include <werkzeugkiste/config/configuration.h>
2	#include <werkzeugkiste/files/filesys.h>
3	#include <werkzeugkiste/strings/strings.h>
4
5	#include <sstream>
6
7	#include "../test_utils.h"
8
9	namespace wkc = werkzeugkiste::config;
10	namespace wkf = werkzeugkiste::files;
11	namespace wks = werkzeugkiste::strings;
12
13	// NOLINTBEGIN
14
15	using namespace std::string_view_literals;
16
17	TEST(ConfigIOTest, NestedTOML) {	2✔
18	const auto fname_invalid_toml =	2✔
19	wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.toml"sv);	4✔
20	std::ostringstream toml_str;	2✔
21	toml_str << "bool = true\ninteger = 3\nlst = [1, 2]\ndate = 2023-02-21\n"	2✔
22	"time = 08:30:00\ndatetime = 2023-02-21T11:11:11\n"
23	"nested_config = \""sv
24	<< wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)	4✔
25	<< "\"\n"
26	"float = 2.0\n"
27	"invalid_nested_config = \""sv
28	<< fname_invalid_toml
29	<< "\"\n"
30	"lvl1.lvl2.lvl3.nested = \""sv
31	<< wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)	4✔
32	<< "\"\n"
33	"lvl1.arr = [ 1, 2, \""sv
34	<< wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)	4✔
35	<< "\"]\n"
36	"lvl1.another_arr = [1, { name = 'test', nested = \""
37	<< wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml"sv)	4✔
38	<< "\" }]"sv;	10✔
39
40	auto config = wkc::LoadTOMLString(toml_str.str());	2✔
41	EXPECT_THROW(	2✔
42	config.LoadNestedTOMLConfiguration("no-such-key"sv), wkc::KeyError);	×
43	EXPECT_THROW(config.LoadNestedTOMLConfiguration("bool"sv), wkc::TypeError);	2✔
44	EXPECT_THROW(config.LoadNestedTOMLConfiguration("integer"sv), wkc::TypeError);	2✔
45	EXPECT_THROW(config.LoadNestedTOMLConfiguration("float"sv), wkc::TypeError);	2✔
46	EXPECT_THROW(config.LoadNestedTOMLConfiguration("lst"sv), wkc::TypeError);	2✔
47	EXPECT_THROW(config.LoadNestedTOMLConfiguration("date"sv), wkc::TypeError);	2✔
48	EXPECT_THROW(config.LoadNestedTOMLConfiguration("time"sv), wkc::TypeError);	2✔
49	EXPECT_THROW(	2✔
50	config.LoadNestedTOMLConfiguration("datetime"sv), wkc::TypeError);	×
51	EXPECT_THROW(config.LoadNestedTOMLConfiguration("lvl1"sv), wkc::TypeError);	2✔
52	EXPECT_THROW(	2✔
53	config.LoadNestedTOMLConfiguration("lvl1.lvl2"sv), wkc::TypeError);	×
54	config.LoadNestedTOMLConfiguration("nested_config"sv);	2✔
55
56	EXPECT_EQ(1, config.GetInteger32("nested_config.value1"sv));	2✔
57	EXPECT_DOUBLE_EQ(2.3, config.GetDouble("nested_config.value2"sv));	2✔
58	EXPECT_EQ("this/is/a/relative/path",	4✔
59	config.GetString("nested_config.section1.rel_path"sv));	×
60
61	// When trying to load an invalid TOML file, an exception should be thrown,
62	// and the parameter should not change.
63	EXPECT_THROW(config.LoadNestedTOMLConfiguration("invalid_nested_config"sv),	2✔
64	wkc::ParseError);	×
65	EXPECT_EQ(fname_invalid_toml, config.GetString("invalid_nested_config"sv));	4✔
66
67	// Ensure that loading a nested configuration also works at deeper
68	// hierarchy levels.
69	EXPECT_NO_THROW(	2✔
70	config.LoadNestedTOMLConfiguration("lvl1.lvl2.lvl3.nested"sv));	×
71	EXPECT_DOUBLE_EQ(2.3, config.GetDouble("lvl1.lvl2.lvl3.nested.value2"sv));	2✔
72	EXPECT_EQ("this/is/a/relative/path",	4✔
73	config.GetString("lvl1.lvl2.lvl3.nested.section1.rel_path"sv));	×
74
75	// It is not allowed to load a nested configuration directly into an array:
76	EXPECT_THROW(	2✔
77	config.LoadNestedTOMLConfiguration("lvl1.arr[2]"sv), wkc::TypeError);	×
78
79	// One could abuse it, however, to load a nested configuration into a table
80	// that is inside an array... Just because you can doesn't mean you should...
81	EXPECT_NO_THROW(	2✔
82	config.LoadNestedTOMLConfiguration("lvl1.another_arr[1].nested"sv));	×
83	EXPECT_DOUBLE_EQ(	2✔
84	2.3, config.GetDouble("lvl1.another_arr[1].nested.value2"sv));	×
85	EXPECT_EQ("this/is/a/relative/path",	4✔
86	config.GetString("lvl1.another_arr[1].nested.section1.rel_path"sv));	×
87	}	2✔
88
89	TEST(ConfigIOTest, ConfigConstruction) {	2✔
90	const std::string fname =	2✔
91	wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml");	4✔
92
93	// Force copy construction
94	auto config = wkc::LoadTOMLFile(fname);	2✔
95	wkc::Configuration copy{config};	2✔
96
97	EXPECT_TRUE(config.Equals(copy));	2✔
98	EXPECT_FALSE(config.Empty());	2✔
99	EXPECT_FALSE(copy.Empty());	2✔
100	EXPECT_EQ(1, config.GetInteger32("value1"sv));	2✔
101	EXPECT_EQ(1, copy.GetInteger32("value1"sv));	2✔
102
103	// Force move construction
104	wkc::Configuration moved{std::move(config)};	4✔
105	EXPECT_FALSE(copy.Empty());	2✔
106	EXPECT_EQ(1, moved.GetInteger32("value1"sv));	2✔
107
108	// Test copy assignment
109	wkc::Configuration tmp{};	2✔
110	EXPECT_TRUE(tmp.Empty());	2✔
111	copy = tmp;	2✔
112	EXPECT_TRUE(tmp.Empty());	2✔
113	EXPECT_TRUE(copy.Empty());	2✔
114
115	tmp.SetBoolean("tbl.val"sv, true);	2✔
116	EXPECT_FALSE(tmp.Empty());	2✔
117	EXPECT_TRUE(copy.Empty());	2✔
118	copy = tmp;	2✔
119	EXPECT_FALSE(tmp.Empty());	2✔
120	EXPECT_FALSE(copy.Empty());	2✔
121	EXPECT_TRUE(tmp.Contains("tbl.val"sv));	2✔
122	EXPECT_TRUE(copy.Contains("tbl.val"sv));	2✔
123	EXPECT_TRUE(tmp.GetBoolean("tbl.val"sv));	2✔
124	EXPECT_TRUE(copy.GetBoolean("tbl.val"sv));	2✔
125
126	// Test move assignment
127	moved = std::move(tmp);	2✔
128	EXPECT_FALSE(moved.Empty());	2✔
129	EXPECT_TRUE(moved.Contains("tbl.val"sv));	2✔
130	EXPECT_TRUE(moved.GetBoolean("tbl.val"sv));	2✔
131	EXPECT_FALSE(moved.Contains("value1"sv)); // Previously contained	4✔
132	}	2✔
133
134	TEST(ConfigIOTest, LoadingToml) {	2✔
135	const std::string fname =	2✔
136	wkf::FullFile(wkf::DirName(__FILE__), "test-valid1.toml");	4✔
137
138	// Load valid TOML, then reload its string representation
139	const auto config1 = wkc::LoadTOMLFile(fname);	2✔
140	const auto reloaded = wkc::LoadTOMLString(config1.ToTOML());	2✔
141	EXPECT_TRUE(config1.Equals(reloaded));	2✔
142	EXPECT_TRUE(reloaded.Equals(config1));	2✔
143	// Also the string representations should be equal
144	EXPECT_EQ(config1.ToTOML(), reloaded.ToTOML());	4✔
145
146	// Load a different configuration:
147	const auto config2 = wkc::LoadTOMLString(R"toml(	2✔
148	param1 = "value"
149	param2 = "value"
150
151	param3 = true
152	)toml");	2✔
153	EXPECT_FALSE(config1.Equals(config2));	2✔
154	EXPECT_FALSE(config2.Equals(config1));	2✔
155
156	// Identity check
157	EXPECT_TRUE(config1.Equals(config1));	2✔
158	EXPECT_TRUE(config2.Equals(config2));	2✔
159
160	// White space mustn't affect the equality check
161	auto config3 = wkc::LoadTOMLString(R"toml(	2✔
162
163	param1 = "value"
164
165
166	param2 = "value"
167
168	param3 = true
169
170	)toml");	2✔
171
172	EXPECT_FALSE(config1.Equals(config3));	2✔
173	EXPECT_TRUE(config2.Equals(config3));	2✔
174	EXPECT_TRUE(config3.Equals(config2));	2✔
175
176	// Change the first string parameter
177	config3 = wkc::LoadTOMLString(R"toml(	4✔
178	param1 = "value!"
179	param2 = "value"
180
181	param3 = true
182	)toml");	2✔
183	EXPECT_FALSE(config1.Equals(config3));	2✔
184	EXPECT_FALSE(config2.Equals(config3));	2✔
185	EXPECT_FALSE(config3.Equals(config2));	2✔
186
187	// Change the 3rd parameter type
188	config3 = wkc::LoadTOMLString(R"toml(	4✔
189	param1 = "value"
190	param2 = "value"
191
192	param3 = [1, 2]
193	)toml"sv);	2✔
194	EXPECT_FALSE(config1.Equals(config3));	2✔
195	EXPECT_FALSE(config2.Equals(config3));	2✔
196	EXPECT_FALSE(config3.Equals(config2));	2✔
197
198	const auto empty = wkc::LoadTOMLString(""sv);	2✔
199	EXPECT_FALSE(empty.Equals(config1));	2✔
200	EXPECT_FALSE(config1.Equals(empty));	2✔
201
202	const auto def = wkc::Configuration();	2✔
203	EXPECT_TRUE(def.Empty());	2✔
204	EXPECT_TRUE(empty.Equals(def));	2✔
205
206	// Edge cases for TOML loading:
207	EXPECT_THROW(	2✔
208	wkc::LoadTOMLFile("this-does-not-exist.toml"sv), wkc::ParseError);	×
209	try {	2✔
210	wkc::LoadTOMLFile("this-does-not-exist.toml"sv);	2✔
211	} catch (const wkc::ParseError &e) {	2✔
212	const std::string exp_err{	2✔
213	"Cannot open file. Check path: \"this-does-not-exist.toml\"."};	2✔
214	EXPECT_EQ(exp_err, std::string(e.what()));	6✔
215	}	2✔
216
217	const std::string fname_invalid =	2✔
218	wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.toml"sv);	4✔
219	EXPECT_THROW(wkc::LoadTOMLFile(fname_invalid), wkc::ParseError);	2✔
220	try {	2✔
221	wkc::LoadTOMLFile(fname_invalid);	2✔
222	EXPECT_TRUE(false);	×
223	} catch (const wkc::ParseError &e) {	2✔
224	EXPECT_TRUE(wks::StartsWith(e.what(), "Error while parsing value: "sv))	2✔
225	<< "Error message was: "sv << e.what();	×
226	}	2✔
227	}	2✔
228
229	TEST(ConfigIOTest, ParsingInvalidDateTimes) {	2✔
230	// Leap seconds are not supported.
231	EXPECT_THROW(	2✔
232	wkc::LoadTOMLString("dt = 1990-12-31T23:59:60Z"), wkc::ParseError);	×
233	EXPECT_THROW(	2✔
234	wkc::LoadTOMLString("dt = 1990-12-31T15:59:60-08:00"), wkc::ParseError);	×
235
236	// Leap seconds are not supported.
237	EXPECT_THROW(wkc::date_time({1990, 12, 31}, {23, 59, 60}), wkc::ValueError);	2✔
238	EXPECT_THROW(wkc::date_time{"1990-12-31T23:59:60Z"sv}, wkc::ParseError);	2✔
239
240	// Unknown Local Offset Convention (-00:00) is not supported, i.e. it
241	// will be silently converted to UTC+0.
242	EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59Z"sv});	2✔
243	EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59-00:00"sv});	2✔
244	EXPECT_NO_THROW(wkc::date_time{"1990-12-31T23:59:59+00:00"sv});	2✔
245	EXPECT_EQ(wkc::date_time{"1990-12-31T23:59:59-00:00"sv},	4✔
246	wkc::date_time{"1990-12-31T23:59:59+00:00"sv});	2✔
247	}	2✔
248
249	// TODO Can be properly tested once we have LoadJSONString()
250	TEST(ConfigIOTest, LoadingJson) {	2✔
251	const auto config = wkc::LoadTOMLString(R"toml(	2✔
252	param1 = "value"
253	)toml"sv);	2✔
254	EXPECT_TRUE(config.ToJSON().length() > 0);	2✔
255	}	2✔
256
257	#ifdef WERKZEUGKISTE_WITH_LIBCONFIG
258	TEST(ConfigIOTest, ParseLibconfigFiles) {	2✔
259	EXPECT_THROW(wkc::LoadLibconfigFile("no-such-file"sv), wkc::ParseError);	2✔
260
261	const auto fname_invalid_cfg =	2✔
262	wkf::FullFile(wkf::DirName(__FILE__), "test-invalid.cfg"sv);	4✔
263	EXPECT_THROW(wkc::LoadLibconfigFile(fname_invalid_cfg), wkc::ParseError);	2✔
264
265	const auto fname_valid_cfg =	2✔
266	wkf::FullFile(wkf::DirName(__FILE__), "test-valid.cfg"sv);	4✔
267	auto config = wkc::LoadLibconfigFile(fname_valid_cfg);	2✔
268
269	EXPECT_EQ(4, config.Size());	2✔
270
271	// Check the "empty" group
272	EXPECT_EQ(0, config.Size("empty_group"sv));	2✔
273	EXPECT_TRUE(config.GetGroup("empty_group"sv).Empty());	2✔
274
275	// Check the "group" group
276	EXPECT_EQ(5, config.Size("group"sv));	2✔
277	EXPECT_EQ(6, config.Size("group.subgroup"sv));	2✔
278
279	const auto group = config.GetGroup("group"sv);	2✔
280	EXPECT_EQ(5, group.Size());	2✔
281	const auto subgroup = group.GetGroup("subgroup"sv);	2✔
282	EXPECT_EQ(6, subgroup.Size());	2✔
283
284	EXPECT_EQ(subgroup, config.GetGroup("group.subgroup"sv));	4✔
285	EXPECT_EQ("Value", subgroup.GetString("str"sv));	4✔
286	EXPECT_EQ(2, subgroup.Size("size"sv));	2✔
287	EXPECT_EQ(640, subgroup.GetInteger32("size.width"sv));	2✔
288	EXPECT_EQ(480, subgroup.GetInteger32("size.height"sv));	2✔
289
290	EXPECT_EQ(3, subgroup.Size("ints"sv));	2✔
291	EXPECT_EQ(10, subgroup.GetInteger32("ints[0]"sv));	2✔
292	EXPECT_EQ(11, subgroup.GetInteger32("ints[1]"sv));	2✔
293	EXPECT_EQ(-12, subgroup.GetInteger32("ints[2]"sv));	2✔
294
295	EXPECT_EQ(3, subgroup.Size("flts"sv));	2✔
296	EXPECT_DOUBLE_EQ(1e-3, subgroup.GetDouble("flts[0]"sv));	2✔
297	EXPECT_DOUBLE_EQ(0.0, subgroup.GetDouble("flts[1]"sv));	2✔
298	EXPECT_DOUBLE_EQ(2.0, subgroup.GetDouble("flts[2]"sv));	2✔
299
300	EXPECT_TRUE(subgroup.GetBoolean("flag"sv));	2✔
301	EXPECT_TRUE(config.GetBoolean("group.subgroup.flag"sv));	2✔
302
303	EXPECT_EQ(1, subgroup.Size("another-group"sv));	2✔
304	auto str = subgroup.GetString("another-group.long-string"sv);	2✔
305	EXPECT_TRUE(wks::StartsWith(str, "A very long string that spans"sv));	2✔
306	str = subgroup.GetString("another-group.long-string"sv);	2✔
307	EXPECT_TRUE(wks::EndsWith(str, "automatically concatenated."sv));	2✔
308
309	EXPECT_FALSE(config.GetBoolean("group.flag"sv));	2✔
310	EXPECT_EQ(-54321, config.GetInteger32("group.int"sv));	2✔
311	EXPECT_DOUBLE_EQ(1e6, config.GetDouble("group.flt"sv));	2✔
312	EXPECT_EQ("Another String", config.GetString("group.str"sv));	4✔
313
314	// Check the "list" list
315	EXPECT_EQ(6, config.Size("list"sv));	2✔
316
317	EXPECT_EQ(3, config.Size("list[0]"sv));	2✔
318	EXPECT_EQ("abc", config.GetString("list[0][0]"sv));	4✔
319	EXPECT_EQ(123, config.GetInteger32("list[0][1]"sv));	2✔
320	EXPECT_TRUE(config.GetBoolean("list[0][2]"sv));	2✔
321
322	EXPECT_DOUBLE_EQ(1.234, config.GetDouble("list[1]"sv));	2✔
323
324	EXPECT_EQ(0, config.Size("list[2]"sv));	2✔
325	EXPECT_EQ(wkc::ConfigType::List, config.Type("list[2]"sv));	2✔
326
327	EXPECT_EQ(3, config.Size("list[3]"sv));	2✔
328	const auto ints = config.GetInteger32List("list[3]"sv);	2✔
329	EXPECT_EQ(1, ints[0]);	2✔
330	EXPECT_EQ(2, ints[1]);	2✔
331	EXPECT_EQ(3, ints[2]);	2✔
332
333	EXPECT_EQ(1, config.Size("list[4]"sv));	2✔
334	EXPECT_TRUE(config.Contains("list[4].a"sv));	2✔
335	EXPECT_EQ(3, config.Size("list[4].a"sv));	2✔
336	EXPECT_EQ(1, config.GetInteger32("list[4].a[0]"sv));	2✔
337	EXPECT_EQ(2, config.GetInteger32("list[4].a[1]"sv));	2✔
338	EXPECT_TRUE(config.GetBoolean("list[4].a[2]"sv));	2✔
339
340	EXPECT_EQ(0, config.Size("list[5]"sv));	2✔
341	EXPECT_TRUE(config.GetGroup("list[5]"sv).Empty());	2✔
342
343	// Check the "bigints" group
344	const auto bigints = config.GetGroup("bigints"sv);	2✔
345	EXPECT_THROW(bigints.GetInteger32("int"sv), wkc::TypeError);	2✔
346	EXPECT_EQ(9223372036854775807L, bigints.GetInteger64("int"sv));	2✔
347	EXPECT_EQ(9223372036854775807L, config.GetInteger64("bigints.int"sv));	2✔
348	EXPECT_THROW(bigints.GetInteger32("hex"sv), wkc::TypeError);	2✔
349	EXPECT_EQ(0x1122334455667788L, bigints.GetInteger64("hex"sv));	2✔
350	EXPECT_EQ(0x1122334455667788L, config.GetInteger64("bigints.hex"sv));	2✔
351	}	2✔
352
353	TEST(ConfigIOTest, ParseLibconfigStrings) {	2✔
354	const auto config = wkc::LoadLibconfigString(R"lcfg(	2✔
355	int_pos = +987654;
356	int_neg = -123456;
357	int32_max = 2147483647;
358	int32_min = -2147483648;
359	// Previous libconfig versions require explicit ..L suffix for long ints:
360	int32_max_overflow = 2147483648L;
361	int32_min_underflow = -2147483649L;
362	flt = -1e3;
363	flag = false;
364	str = "value";
365
366	ints = [1, 2, 3];
367	flts = [1.2, 2.0];
368
369	strings = ["foo", "bar"];
370
371	mixed = (1, true, "string");
372
373	nested = (
374	"foo",
375	{ age = 3; name = "bar"; },
376	[-1, 23])
377
378	group = {
379	flag = true;
380	count = 123;
381
382	subgroup = {
383	flag = false;
384	threshold = 1e-6;
385	}
386	};
387	)lcfg");	2✔
388
389	EXPECT_EQ(987654, config.GetInteger32("int_pos"sv));	2✔
390	EXPECT_EQ(-123456, config.GetInteger32("int_neg"sv));	2✔
391	EXPECT_EQ(2147483647, config.GetInteger32("int32_max"sv));	2✔
392	EXPECT_EQ(-2147483648, config.GetInteger32("int32_min"sv));	2✔
393	EXPECT_THROW(config.GetInteger32("int32_min_underflow"sv), wkc::TypeError);	2✔
394	EXPECT_THROW(config.GetInteger32("int32_max_overflow"sv), wkc::TypeError);	2✔
395	EXPECT_EQ(-2147483649, config.GetInteger64("int32_min_underflow"sv));	2✔
396	EXPECT_EQ(+2147483648, config.GetInteger64("int32_max_overflow"sv));	2✔
397
398	EXPECT_DOUBLE_EQ(-1000.0, config.GetDouble("flt"sv));	2✔
399	EXPECT_FALSE(config.GetBoolean("flag"sv));	2✔
400	EXPECT_EQ("value", config.GetString("str"sv));	4✔
401
402	// List of integers
403	auto ints = config.GetInteger32List("ints"sv);	2✔
404	EXPECT_EQ(3, ints.size());	2✔
405	EXPECT_EQ(1, ints[0]);	2✔
406	EXPECT_EQ(2, ints[1]);	2✔
407	EXPECT_EQ(3, ints[2]);	2✔
408
409	// List of floating points
410	const auto flts = config.GetDoubleList("flts"sv);	2✔
411	EXPECT_EQ(2, flts.size());	2✔
412	EXPECT_DOUBLE_EQ(1.2, flts[0]);	2✔
413	EXPECT_DOUBLE_EQ(2.0, flts[1]);	2✔
414
415	// String list
416	const auto strings = config.GetStringList("strings"sv);	2✔
417	EXPECT_EQ(2, strings.size());	2✔
418	EXPECT_EQ("foo", strings[0]);	2✔
419	EXPECT_EQ("bar", strings[1]);	2✔
420
421	// Mixed list
422	EXPECT_EQ(3, config.Size("mixed"sv));	2✔
423	EXPECT_EQ(wkc::ConfigType::List, config.Type("mixed"sv));	2✔
424	EXPECT_EQ(wkc::ConfigType::Integer, config.Type("mixed[0]"sv));	2✔
425	EXPECT_EQ(1, config.GetInteger32("mixed[0]"sv));	2✔
426	EXPECT_EQ(wkc::ConfigType::Boolean, config.Type("mixed[1]"sv));	2✔
427	EXPECT_TRUE(config.GetBoolean("mixed[1]"sv));	2✔
428	EXPECT_EQ(wkc::ConfigType::String, config.Type("mixed[2]"sv));	2✔
429	EXPECT_EQ("string", config.GetString("mixed[2]"sv));	4✔
430
431	// Mixed & nested list
432	EXPECT_EQ(3, config.Size("nested"sv));	2✔
433	EXPECT_EQ(wkc::ConfigType::List, config.Type("nested"sv));	2✔
434
435	EXPECT_EQ(wkc::ConfigType::String, config.Type("nested[0]"sv));	2✔
436	EXPECT_EQ("foo", config.GetString("nested[0]"sv));	4✔
437
438	EXPECT_EQ(wkc::ConfigType::Group, config.Type("nested[1]"sv));	2✔
439	auto subgroup = config.GetGroup("nested[1]"sv);	2✔
440	EXPECT_EQ(2, subgroup.Size());	2✔
441	EXPECT_EQ(3, subgroup.GetInteger32("age"sv));	2✔
442	EXPECT_EQ(3, config.GetInteger32("nested[1].age"sv));	2✔
443	EXPECT_EQ("bar", subgroup.GetString("name"sv));	4✔
444	EXPECT_EQ("bar", config.GetString("nested[1].name"sv));	4✔
445
446	EXPECT_EQ(wkc::ConfigType::List, config.Type("nested[2]"sv));	2✔
447	ints = config.GetInteger32List("nested[2]"sv);	4✔
448	EXPECT_EQ(2, ints.size());	2✔
449	EXPECT_EQ(-1, ints[0]);	2✔
450	EXPECT_EQ(23, ints[1]);	2✔
451
452	// Subgroup/Table
453	EXPECT_EQ(wkc::ConfigType::Group, config.Type("group"sv));	2✔
454	EXPECT_EQ(3, config.Size("group"sv));	2✔
455	EXPECT_TRUE(config.GetBoolean("group.flag"sv));	2✔
456	EXPECT_EQ(123, config.GetInteger32("group.count"sv));	2✔
457
458	EXPECT_EQ(wkc::ConfigType::Group, config.Type("group.subgroup"sv));	2✔
459	EXPECT_FALSE(config.GetBoolean("group.subgroup.flag"sv));	2✔
460	EXPECT_DOUBLE_EQ(1e-6, config.GetDouble("group.subgroup.threshold"sv));	2✔
461
462	// Try parsing an invalid configuration string.
463	const auto invalid_str = R"lcfg(valid = true;	2✔
464	invalid = [1, 2.5];
465	)lcfg"sv;
466	EXPECT_THROW(wkc::LoadLibconfigString(invalid_str), wkc::ParseError);	2✔
467	try {	2✔
468	wkc::LoadLibconfigString(invalid_str);	2✔
469	} catch (const wkc::ParseError &e) {	2✔
470	EXPECT_TRUE(wks::StartsWith(e.what(),	2✔
471	"Parsing libconfig string failed at line `2`: "
472	"mismatched element type in array"))
473	<< "Actual exception message: " << e.what();	×
474	}	2✔
475	}	2✔
476
477	#else // WERKZEUGKISTE_WITH_LIBCONFIG
478	TEST(ConfigIOTest, MissingLibconfigSupport) {
479	EXPECT_THROW(wkc::LoadLibconfigFile("no-such-file"sv), std::logic_error);
480	EXPECT_THROW(wkc::LoadLibconfigString("foo = 3"sv), std::logic_error);
481	}
482	#endif // WERKZEUGKISTE_WITH_LIBCONFIG
483
484	// NOLINTEND

snototter / werkzeugkiste / 4333001432

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous