parse_document_test.cc File Reference

#include "boost/test/unit_test.hpp"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/intermediate_table.h"
#include "fhiclcpp/parse.h"
#include <ostream>
#include <regex>
#include <string>

Go to the source code of this file.

Namespaces
	fhicl

Macros
#define	BOOST_TEST_MODULE   (document test)
#define	PV_EXCEPTION
#define	PARSE_ERROR(line, charpos)

Functions
std::ostream &	fhicl::boost_test_print_type (std::ostream &os, Protection const protection)
	BOOST_AUTO_TEST_CASE (empty_document)
	BOOST_AUTO_TEST_CASE (nonempty_document)
	BOOST_AUTO_TEST_CASE (nested_document)
	BOOST_AUTO_TEST_CASE (badly_nested_document)
	BOOST_AUTO_TEST_CASE (overridden_prolog_document)
	BOOST_AUTO_TEST_CASE (contiguous_prolog)
	BOOST_AUTO_TEST_CASE (noncontiguous_prolog)
	BOOST_AUTO_TEST_CASE (overridden_toplevel_document)
	BOOST_AUTO_TEST_CASE (overridden_nested_document)
	BOOST_AUTO_TEST_CASE (nil_value)
	BOOST_AUTO_TEST_CASE (erase_value)
	BOOST_AUTO_TEST_CASE (expand_nested_tables)
	BOOST_AUTO_TEST_CASE (expand_table)
	BOOST_AUTO_TEST_CASE (expand_sequence)
	BOOST_AUTO_TEST_CASE (string_escaping)
	BOOST_AUTO_TEST_CASE (bad_lookup)
	BOOST_AUTO_TEST_CASE (bad_expand_table)
	BOOST_AUTO_TEST_CASE (bad_expand_sequence)
	BOOST_AUTO_TEST_CASE (colon_spacing)
	BOOST_AUTO_TEST_CASE (protect_ignore_01)
	BOOST_AUTO_TEST_CASE (protect_ignore_02)
	BOOST_AUTO_TEST_CASE (protect_ignore_03)
	BOOST_AUTO_TEST_CASE (protect_ignore_04)
	BOOST_AUTO_TEST_CASE (protect_ignore_05)
	BOOST_AUTO_TEST_CASE (protect_ignore_06)
	BOOST_AUTO_TEST_CASE (protect_ignore_07)
	BOOST_AUTO_TEST_CASE (protect_ignore_08)
	BOOST_AUTO_TEST_CASE (protect_ignore_09)
	BOOST_AUTO_TEST_CASE (protect_ignore_10)
	BOOST_AUTO_TEST_CASE (protect_ignore_11)
	BOOST_AUTO_TEST_CASE (protect_ignore_12)
	BOOST_AUTO_TEST_CASE (protect_ignore_13)
	BOOST_AUTO_TEST_CASE (protect_ignore_14)
	BOOST_AUTO_TEST_CASE (protect_ignore_15)
	BOOST_AUTO_TEST_CASE (protect_ignore_16)
	BOOST_AUTO_TEST_CASE (protect_ignore_17)
	BOOST_AUTO_TEST_CASE (protect_ignore_18)
	BOOST_AUTO_TEST_CASE (protect_ignore_19)
	BOOST_AUTO_TEST_CASE (protect_ignore_20)
	BOOST_AUTO_TEST_CASE (protect_ignore_21)
	BOOST_AUTO_TEST_CASE (protect_ignore_22)
	BOOST_AUTO_TEST_CASE (protect_ignore_23)
	BOOST_AUTO_TEST_CASE (protect_error_01)
	BOOST_AUTO_TEST_CASE (protect_error_02)
	BOOST_AUTO_TEST_CASE (protect_error_03)
	BOOST_AUTO_TEST_CASE (protect_error_04)
	BOOST_AUTO_TEST_CASE (protect_error_05)
	BOOST_AUTO_TEST_CASE (protect_error_06)
	BOOST_AUTO_TEST_CASE (protect_error_07)
	BOOST_AUTO_TEST_CASE (protect_error_08)
	BOOST_AUTO_TEST_CASE (protect_error_09)
	BOOST_AUTO_TEST_CASE (protect_error_10)
	BOOST_AUTO_TEST_CASE (protect_error_11)
	BOOST_AUTO_TEST_CASE (erase_01)
	BOOST_AUTO_TEST_CASE (erase_02)
	BOOST_AUTO_TEST_CASE (erase_03)
	BOOST_AUTO_TEST_CASE (erase_04)
	BOOST_AUTO_TEST_CASE (erase_05)
	BOOST_AUTO_TEST_CASE (erase_06)
	BOOST_AUTO_TEST_CASE (erase_07)
	BOOST_AUTO_TEST_CASE (erase_08)
	BOOST_AUTO_TEST_CASE (erase_09)
	BOOST_AUTO_TEST_CASE (erase_10)
	BOOST_AUTO_TEST_CASE (erase_11)
	BOOST_AUTO_TEST_CASE (protect_local_01)
	BOOST_AUTO_TEST_CASE (protect_local_02)
	BOOST_AUTO_TEST_CASE (protect_local_03)
	BOOST_AUTO_TEST_CASE (protect_local_04)
	BOOST_AUTO_TEST_CASE (protect_local_05)
	BOOST_AUTO_TEST_CASE (protect_local_06)
	BOOST_AUTO_TEST_CASE (protect_local_07)
	BOOST_AUTO_TEST_CASE (bad_par_01)
	BOOST_AUTO_TEST_CASE (bad_par_02)
	BOOST_AUTO_TEST_CASE (bad_prolog)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (document test)

Definition at line 7 of file parse_document_test.cc.

#define PARSE_ERROR	(		line,
			charpos
	)

Value:

BOOST_CHECK_EXCEPTION(                                                       \
    parse_document(doc),                                                       \
    fhicl::exception,                                                          \
    std::bind(&is_parse_error_at, std::placeholders::_1, line, charpos));

Definition at line 848 of file parse_document_test.cc.

#define PV_EXCEPTION

Value:

BOOST_CHECK_EXCEPTION(parse_document(doc),                                   \
                        fhicl::exception,                                      \
                        [](fhicl::exception const& e) -> bool {                \
                          return e.categoryCode() ==                           \
                                   fhicl::error::parse_error &&                \
                                 e.root_cause() == "Protection violation";     \
                        })

Definition at line 368 of file parse_document_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

empty_document

)

Definition at line 31 of file parse_document_test.cc.

{
  std::string document;
  auto const pset = ParameterSet::make(document);
  BOOST_TEST(pset.is_empty());
}

BOOST_AUTO_TEST_CASE

(

nonempty_document

)

Definition at line 38 of file parse_document_test.cc.

{
  std::string document = "a: 1\n"
                         "b: 2\n";
  auto const pset = ParameterSet::make(document);
  BOOST_TEST(!pset.is_empty());
  BOOST_TEST(pset.get<int>("a") == 1);
  BOOST_TEST(pset.get<int>("b") == 2);
  BOOST_TEST(pset.get<unsigned>("a") == 1u);
  BOOST_TEST(pset.get<unsigned>("b") == 2u);
  BOOST_TEST(pset.get<string>("a") == "1");
  BOOST_TEST(pset.get<string>("b") == "2");
}

BOOST_AUTO_TEST_CASE

(

nested_document

)

Definition at line 52 of file parse_document_test.cc.

{
  std::string document = "x.a: 1\n"
                         "x.b: 2\n";
  auto const tbl = parse_document(document);
  auto const pset = ParameterSet::make(tbl);
  BOOST_TEST(!pset.is_empty());
  BOOST_REQUIRE_NO_THROW(pset.get<ParameterSet>("x"));
  BOOST_TEST_REQUIRE(!pset.get<ParameterSet>("x").is_empty());
  BOOST_TEST(pset.get<int>("x.a") == 1);
  BOOST_TEST(pset.get<int>("x.b") == 2);
  BOOST_TEST(pset.get<unsigned>("x.a") == 1u);
  BOOST_TEST(pset.get<unsigned>("x.b") == 2u);
  BOOST_TEST(pset.get<string>("x.a") == "1");
  BOOST_TEST(pset.get<string>("x.b") == "2");
}

BOOST_AUTO_TEST_CASE

(

badly_nested_document

)

Definition at line 69 of file parse_document_test.cc.

{
  std::string document = "{ x.a: 1\n"
                         "  x.b: 2\n"
                         "}\n";
  BOOST_CHECK_THROW(parse_document(document), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

overridden_prolog_document

)

Definition at line 77 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "  a: 1\n"
                         "  t: { a: 11\n"
                         "       b: 12\n"
                         "     }\n"
                         "END_PROLOG\n"
                         "a: 2\n"
                         "t.a: @local::t.b\n";
  auto const pset = ParameterSet::make(document);
  BOOST_TEST(pset.get<int>("a") == 2);
  BOOST_REQUIRE_NO_THROW(pset.get<ParameterSet>("t"));
  BOOST_TEST_REQUIRE(!pset.get<ParameterSet>("t").is_empty());
  BOOST_TEST(pset.get<int>("t.a") == 12);
  BOOST_CHECK_THROW(pset.get<int>("t.b"), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

contiguous_prolog

)

Definition at line 95 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "  a: 1\n"
                         "  t: { a: 11\n"
                         "       b: 12\n"
                         "     }\n"
                         "END_PROLOG\n"
                         "BEGIN_PROLOG\n"
                         "  c: 47\n"
                         "END_PROLOG\n";
  auto const tbl = parse_document(document);
  BOOST_TEST(tbl.exists("c"));
}

BOOST_AUTO_TEST_CASE

(

noncontiguous_prolog

)

Definition at line 110 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "  a: 1\n"
                         "  t: { a: 11\n"
                         "       b: 12\n"
                         "     }\n"
                         "END_PROLOG\n"
                         "d: 27\n"
                         "BEGIN_PROLOG\n"
                         "  c: 47\n"
                         "END_PROLOG\n";
  BOOST_REQUIRE_THROW(parse_document(document), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

overridden_toplevel_document

)

Definition at line 125 of file parse_document_test.cc.

{
  std::string document = "a: 1\n"
                         "b: 2\n"
                         "a: 3\n"
                         "c: 4\n"
                         "b: 5\n"
                         "a: 6\n";
  auto const pset = ParameterSet::make(document);
  BOOST_TEST(pset.get<int>("a") == 6);
  BOOST_TEST(pset.get<int>("b") == 5);
  BOOST_TEST(pset.get<int>("c") == 4);
}

BOOST_AUTO_TEST_CASE

(

overridden_nested_document

)

Definition at line 139 of file parse_document_test.cc.

{
  std::string document = "t: { a: 1\n"
                         "     b: 2\n"
                         "     a: 3\n"
                         "     c: 4\n"
                         "     b: 5\n"
                         "     a: 6\n"
                         "   }\n";
  auto const pset = ParameterSet::make(document);
  BOOST_TEST(pset.get<int>("t.a") == 6);
  BOOST_TEST(pset.get<int>("t.b") == 5);
  BOOST_TEST(pset.get<int>("t.c") == 4);
}

BOOST_AUTO_TEST_CASE

(

nil_value

)

Definition at line 154 of file parse_document_test.cc.

{
  std::string document = "a: @nil\n"
                         "b: nil\n"
                         "c: \"@nil\"\n"
                         "d: \"nil\"\n"
                         "t: { a: @nil\n"
                         "     b: nil\n"
                         "     c: \"@nil\"\n"
                         "     d: \"nil\"\n"
                         "   }\n";
  auto const pset = ParameterSet::make(document);

  using nil_t = std::nullptr_t;
  BOOST_TEST(pset.get<nil_t>("a") == nil_t{});
  BOOST_TEST(pset.get<nil_t>("t.a") == nil_t{});
  BOOST_CHECK_THROW(pset.get<string>("a"), fhicl::exception);
  BOOST_CHECK_THROW(pset.get<double>("a", 14.), fhicl::exception);
  BOOST_CHECK_THROW(pset.get<string>("t.a"), fhicl::exception);
  BOOST_CHECK_THROW(pset.get_if_present<string>("a"), fhicl::exception);
  BOOST_TEST(pset.get<string>("b") == "nil");
  BOOST_TEST(pset.get<string>("t.b") == "nil");
  BOOST_TEST(pset.get<string>("c") == "@nil");
  BOOST_TEST(pset.get<string>("t.c") == "@nil");
  BOOST_TEST(pset.get<string>("d") == "nil");
  BOOST_TEST(pset.get<string>("t.d") == "nil");
}

BOOST_AUTO_TEST_CASE

(

erase_value

)

Definition at line 182 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "x: 27\n"
                         "z: 43\n"
                         "z: @erase\n"
                         "END_PROLOG\n"
                         "a: 27\n"
                         "b: { x: 7 y: 12 }\n"
                         "c: { x: 7 y: 12 x: @erase }\n"
                         "a: @erase\n"
                         "b.x: @erase\n";
  auto const tbl = parse_document(document);
  BOOST_TEST(tbl.exists("x"));
  BOOST_TEST(!tbl.exists("z"));
  BOOST_TEST(!tbl.exists("a"));
  BOOST_TEST(tbl.exists("b"));
  BOOST_TEST(!tbl.exists("b.x"));
  BOOST_TEST(tbl.exists("b.y"));
  BOOST_TEST(tbl.exists("c"));
  BOOST_TEST(!tbl.exists("c.x"));
  BOOST_TEST(tbl.exists("c.y"));
}

BOOST_AUTO_TEST_CASE

(

expand_nested_tables

)

Definition at line 206 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "A: { B: { x: foo } }\n"
                         "END_PROLOG\n"
                         "modules: {\n"
                         "   A: {\n"
                         "      @table::A\n"
                         "      B:{ @table::A.B x:bar }\n"
                         "   }\n"
                         "}\n";
  auto tbl = parse_document(document);
  BOOST_TEST(tbl.get<std::string>("modules.A.B.x") == std::string("bar"));
}

BOOST_AUTO_TEST_CASE

(

expand_table

)

Definition at line 221 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "fred: { bill: twelve charlie: 27 }\n"
                         "y: { @table::fred bill: \"one dozen\" }\n"
                         "END_PROLOG\n"
                         "x: { ethel: 14 bill: 12 @table::fred }\n"
                         "@table::fred\n"
                         "y: @local::y\n";
  auto tbl = parse_document(document);
  BOOST_TEST(tbl.exists("x.ethel"));
  BOOST_TEST(tbl.exists("x.charlie"));
  BOOST_TEST(tbl.exists("bill"));
  BOOST_TEST(tbl.exists("charlie"));
  BOOST_TEST(tbl.exists("y.bill"));
  BOOST_TEST(tbl.exists("y.charlie"));
  BOOST_TEST(tbl.get<std::string>("x.bill") == std::string("twelve"));
  BOOST_TEST(tbl.get<std::string>("bill") == std::string("twelve"));
  BOOST_TEST(tbl.get<std::string>("y.bill") == std::string("one dozen"));
}

BOOST_AUTO_TEST_CASE

(

expand_sequence

)

Definition at line 242 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "fred: [ three, four, five ]\n"
                         "END_PROLOG\n"
                         "bill: [ one, two, @sequence::fred, six ]\n"
                         "charlie: @local::fred\n"
                         "ethel: [ @sequence::fred, six ]\n";
  auto const tbl = parse_document(document);
  BOOST_TEST(tbl.exists("fred"));
  BOOST_TEST(tbl.exists("bill"));
  BOOST_TEST(tbl.exists("charlie"));
  BOOST_TEST(tbl.exists("ethel"));

  auto const pset = ParameterSet::make(tbl);

  BOOST_TEST(pset.get<std::vector<std::string>>("charlie").size() == 3ul);

  std::vector<std::string> const billref{
    "one", "two", "three", "four", "five", "six"};
  std::vector<std::string> const ethelref{"three", "four", "five", "six"};

  auto cmp = [](std::vector<std::string> const& seq,
                std::vector<std::string> const& ref) {
    BOOST_TEST(seq.size() == ref.size());
    for (auto i = seq.cbegin(), e = seq.cend(), iref = ref.cbegin(); i != e;
         ++i, ++iref) {
      BOOST_TEST(*i == *iref);
    }
  };

  cmp(pset.get<std::vector<std::string>>("bill"), billref);
  cmp(pset.get<std::vector<std::string>>("ethel"), ethelref);
}

BOOST_AUTO_TEST_CASE

(

string_escaping

)

Definition at line 277 of file parse_document_test.cc.

{
  BOOST_CHECK_THROW(parse_document(R"(x: "$\d+^")"), cet::exception);
  BOOST_CHECK_NO_THROW(parse_document(R"(x: "$\\d+^")"));
  BOOST_CHECK_NO_THROW(parse_document(R"(x: '$\d+^')"));
}

BOOST_AUTO_TEST_CASE

(

bad_lookup

)

Definition at line 284 of file parse_document_test.cc.

{
  std::string document = "x: @local::dead\n";
  BOOST_CHECK_THROW(parse_document(document), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

bad_expand_table

)

Definition at line 290 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "bad: John\n"
                         "END_PROLOG\n"
                         "@table::bad\n";
  BOOST_CHECK_THROW(parse_document(document), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

bad_expand_sequence

)

Definition at line 299 of file parse_document_test.cc.

{
  std::string document = "BEGIN_PROLOG\n"
                         "bad: John\n"
                         "END_PROLOG\n"
                         "f: [ @sequence::bad ]\n";
  BOOST_CHECK_THROW(parse_document(document), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

colon_spacing

)

Definition at line 308 of file parse_document_test.cc.

{
  std::string const prolog = "BEGIN_PROLOG\n"
                             "t: { a: 7 b: 6}\n"
                             "s: [ 7, 6, 7 ]\n"
                             "END_PROLOG\n";
  std::vector<std::string> refs{
    "t1: @local::t\n",
    "@table::t\n",
    "s2: [ 1, 2, @sequence::s ]\n",
    "a: @id::0001020304050607080910111213141516171819\n",
    "t1: { t2: @local::t }\n",
    "t1: { @table::t }\n",
    "t1: { s1: [ 1, 2, 3, @sequence::s ] }\n",
    "t1: { a: @id::0001020304050607080910111213141516171819 }\n",
  };
  for (auto const& ref : refs) {
    BOOST_CHECK_NO_THROW(parse_document(prolog + ref));
    auto const cpos = ref.find("::");
    BOOST_TEST_REQUIRE(cpos != std::string::npos);
    std::string bad1{ref};
    std::string bad2{ref};
    bad1.insert(cpos, " ");
    BOOST_CHECK_THROW(parse_document(prolog + bad1), cet::exception);
    bad2.insert(cpos + 2, " ");
    BOOST_CHECK_THROW(parse_document(prolog + bad2), cet::exception);
  }
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_01

)

Definition at line 337 of file parse_document_test.cc.

{
  std::string const doc = "x @protect_ignore: 29\n"
                          "x: 33\n"
                          "x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_02

)

Definition at line 346 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 29\n"
                          "x: 33\n"
                          "END_PROLOG\n"
                          "x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 37ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_03

)

Definition at line 357 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 29\n"
                          "END_PROLOG\n"
                          "x @protect_ignore: 33\n"
                          "x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_04

)

Definition at line 377 of file parse_document_test.cc.

{
  std::string const doc = "x @protect_ignore: 29\n"
                          "x @protect_ignore: 33\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_05

)

Definition at line 385 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 29\n"
                          "x @protect_ignore: 33\n"
                          "END_PROLOG\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_06

)

Definition at line 395 of file parse_document_test.cc.

{
  std::string const doc = "a: { x @protect_ignore: 29 }\n"
                          "a.x: 33\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_07

)

Definition at line 404 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x @protect_ignore: 29 }\n"
                          "a.x: 33\n"
                          "END_PROLOG\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 37ul);
  BOOST_TEST(tbl.find("a.x").protection == fhicl::Protection::NONE);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_08

)

Definition at line 416 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x @protect_ignore: 29 } \n"
                          "END_PROLOG\n"
                          "a.x @protect_ignore: 33\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_09

)

Definition at line 427 of file parse_document_test.cc.

{
  std::string const doc = "a: { x @protect_ignore: 29 }\n"
                          "a.x @protect_ignore: 33\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_10

)

Definition at line 435 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x @protect_ignore: 29 }\n"
                          "a.x @protect_ignore: 33\n"
                          "END_PROLOG\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_11

)

Definition at line 445 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_ignore: { x: 29 }\n"
                          "a.x: 33\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_12

)

Definition at line 454 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a @protect_ignore: { x: 29 }\n"
                          "a.x: 33\n"
                          "END_PROLOG\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 37ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_13

)

Definition at line 465 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a @protect_ignore: { x: 29 }\n"
                          "END_PROLOG\n"
                          "a @protect_ignore: { x: 33 }\n"
                          "a.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_14

)

Definition at line 476 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_ignore: { x: 29 }\n"
                          "a @protect_ignore: { x: 33 }\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_15

)

Definition at line 484 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a @protect_ignore: { x: 29 }\n"
                          "a @protect_ignore: { x: 33 }\n"
                          "END_PROLOG\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_16

)

Definition at line 494 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { x: 29 } }\n"
                          "a.b.x: 33\n"
                          "a.b.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_17

)

Definition at line 503 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { b @protect_ignore: { x: 29 } }\n"
                          "a.b.x: 33\n"
                          "END_PROLOG\n"
                          "a: { b @protect_ignore: { x: 37 } }\n"
                          "a.b.x: 41\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 37ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_18

)

Definition at line 515 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { b @protect_ignore: { x: 29 } }\n"
                          "END_PROLOG\n"
                          "a: { b @protect_ignore: { x: 33 } }\n"
                          "a.b.x: 37\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_19

)

Definition at line 526 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { x: 29 } }\n"
                          "a: { b @protect_ignore: { x: 33 } }\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_20

)

Definition at line 534 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { b @protect_ignore: { x: 29 } }\n"
                          "a: { b @protect_ignore: { x: 33 } }\n"
                          "END_PROLOG\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_21

)

Definition at line 544 of file parse_document_test.cc.

{
  std::string const doc = "a: { x: 29 }\n"
                          "a.x @protect_ignore: 33\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_22

)

Definition at line 551 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x: 29 }\n"
                          "a.x @protect_ignore: 33\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_ignore_23

)

Definition at line 560 of file parse_document_test.cc.

{
  // Even though 'x' is nested inside of 'a', which has a protection
  // of PROTECT_IGNORE, the protection of 'x' is still NONE.
  std::string const doc = "a @protect_ignore: { x: 29 }\n"
                          "a.x: 33";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 29ul);
  BOOST_TEST(tbl.find("a").protection == Protection::PROTECT_IGNORE);
  BOOST_TEST(tbl.find("a.x").protection == Protection::NONE);
}

BOOST_AUTO_TEST_CASE

(

protect_error_01

)

Definition at line 572 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_error: 29\n"
                          "x: 37\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_02

)

Definition at line 581 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_error: 29\n"
                          "END_PROLOG\n"
                          "x: 33\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_error_03

)

Definition at line 591 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_error: 29\n"
                          "END_PROLOG\n"
                          "x @protect_error: 33\n"
                          "x: 37\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_04

)

Definition at line 601 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 29\n"
                          "x @protect_error: 33\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_05

)

Definition at line 610 of file parse_document_test.cc.

{
  std::string const doc = "x @protect_ignore: 29\n"
                          "x @protect_error: 33\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_06

)

Definition at line 617 of file parse_document_test.cc.

{
  std::string const doc = "a: { x @protect_error: 29 }\n"
                          "a: { x @protect_error: 33 }\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_error_07

)

Definition at line 625 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x @protect_error: 29 }\n"
                          "a: { x @protect_error: 33 }\n"
                          "END_PROLOG\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.x") == 33ul);
}

BOOST_AUTO_TEST_CASE

(

protect_error_08

)

Definition at line 635 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { x @protect_error: 29 }\n"
                          "a.x: 33\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_09

)

Definition at line 644 of file parse_document_test.cc.

{
  std::string const doc = "a: { x @protect_error: 29 }\n"
                          "a.x: 33\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_10

)

Definition at line 651 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { b: { x @protect_error: 29 } } \n"
                          "a.b.x: 33\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_error_11

)

Definition at line 660 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "a: { b @protect_error: { x: 29 } }\n"
                          "a.b: { x: 33 }\n"
                          "END_PROLOG\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

erase_01

)

Definition at line 669 of file parse_document_test.cc.

{
  std::string const doc = "x: 29\n"
                          "x: @erase";
  auto const tbl = parse_document(doc);
  BOOST_TEST(tbl.empty());
}

BOOST_AUTO_TEST_CASE

(

erase_02

)

Definition at line 677 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x: 29\n"
                          "x: @erase"
                          "END_PROLOG\n";
  auto const tbl = parse_document(doc);
  BOOST_TEST(tbl.empty());
}

BOOST_AUTO_TEST_CASE

(

erase_03

)

Definition at line 687 of file parse_document_test.cc.

{
  std::string const doc = "x @protect_ignore: 29\n"
                          "x: @erase";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

erase_04

)

Definition at line 695 of file parse_document_test.cc.

{
  std::string const doc = "x @protect_error: 29\n"
                          "x: @erase";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

erase_05

)

Definition at line 702 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { x: 29 } }\n"
                          "a: @erase\n";
  auto const tbl = parse_document(doc);
  BOOST_TEST(tbl.empty());
}

BOOST_AUTO_TEST_CASE

(

erase_06

)

Definition at line 710 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { x: 29 } }\n"
                          "a.b: @erase\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

erase_07

)

Definition at line 718 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { x: 29 } }\n"
                          "a.b.x: @erase\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

erase_08

)

Definition at line 726 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_ignore: { c: { x: 29 } } }\n"
                          "a.b.c: @erase\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.c.x") == 29ul);
}

BOOST_AUTO_TEST_CASE

(

erase_09

)

Definition at line 734 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_error: { c: { x: 29 } } }\n"
                          "a.b.c: @erase\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

erase_10

)

Definition at line 741 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_error: { c: { x: 29 } } }\n"
                          "a.b: @erase\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

erase_11

)

Definition at line 748 of file parse_document_test.cc.

{
  std::string const doc = "a: { b @protect_error: { x: 29 } }\n"
                          "a: @erase\n";
  auto const tbl = parse_document(doc);
  BOOST_TEST(tbl.empty());
}

BOOST_AUTO_TEST_CASE

(

protect_local_01

)

Definition at line 756 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_ignore: 42\n"
                          "b: @local::a\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.find("b").protection == Protection::NONE);
}

BOOST_AUTO_TEST_CASE

(

protect_local_02

)

Definition at line 764 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_error: 42\n"
                          "b: 43\n"
                          "b: @local::a\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("b") == 42ul);
}

BOOST_AUTO_TEST_CASE

(

protect_local_03

)

Definition at line 773 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_ignore: 42\n"
                          "b: @local::a\n"
                          "b: @erase\n"
                          "b: 43\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("b") == 43ul);
}

BOOST_AUTO_TEST_CASE

(

protect_local_04

)

Definition at line 783 of file parse_document_test.cc.

{
  std::string const doc = "a @protect_error: 42\n"
                          "b: @local::a\n"
                          "b: 43\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("b") == 43ul);
}

BOOST_AUTO_TEST_CASE

(

protect_local_05

)

Definition at line 792 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 27\n"
                          "a: { b: { x: @local::x } }\n"
                          "END_PROLOG\n"
                          "a: @local::a\n"
                          "a.b.x: 29\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 29ul);
  BOOST_TEST(tbl.find("a.b.x").protection == Protection::NONE);
}

BOOST_AUTO_TEST_CASE

(

protect_local_06

)

Definition at line 805 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 27\n"
                          "a: { b: { x: @local::x } }\n"
                          "END_PROLOG\n"
                          "a @protect_error: @local::a\n"
                          "a.b.x: 29\n";
  PV_EXCEPTION;
}

BOOST_AUTO_TEST_CASE

(

protect_local_07

)

Definition at line 816 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x @protect_ignore: 27\n"
                          "a: { b: { x: @local::x } }\n"
                          "END_PROLOG\n"
                          "a @protect_ignore: @local::a\n"
                          "a.b.x: 29\n";
  auto tbl = parse_document(doc);
  BOOST_TEST(tbl.get<std::size_t>("a.b.x") == 27ul);
  BOOST_TEST(tbl.find("a.b.x").protection == Protection::NONE);
  BOOST_TEST(tbl.find("a").protection == Protection::PROTECT_IGNORE);
}

BOOST_AUTO_TEST_CASE

(

bad_par_01

)

Definition at line 854 of file parse_document_test.cc.

{
  std::string const doc = "x: 26\n"
                          "a 36\n";
  PARSE_ERROR(2, 1);
}

BOOST_AUTO_TEST_CASE

(

bad_par_02

)

Definition at line 861 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x: 26\n"
                          "a: 36\n"
                          "END_PROLOG\n"
                          "y: 26\n"
                          "b 36\n";
  PARSE_ERROR(6, 1);
}

BOOST_AUTO_TEST_CASE

(

bad_prolog

)

Definition at line 872 of file parse_document_test.cc.

{
  std::string const doc = "BEGIN_PROLOG\n"
                          "x: 26\n"
                          "a 36\n"
                          "END_PROLOG\n";
  PARSE_ERROR(3, 1);
}