935 lines
24 KiB
C++
Executable File
935 lines
24 KiB
C++
Executable File
#include "lib/utils/TempFile.h"
|
|
#include "lib/utils/TempDir.h"
|
|
|
|
#include "../config.h"
|
|
#include "../ConfigurationState.h"
|
|
#include "../ConfigurationException.h"
|
|
#include "lib/expression/ParserExceptions.h"
|
|
#include "lib/config/protos/testkeys.pb.h"
|
|
#include "lib/config/invalid/invalid.pb.h"
|
|
|
|
#include "HTTPServer.h"
|
|
#include "catch/catch.hpp"
|
|
#include <iostream>
|
|
#include <memory>
|
|
|
|
using namespace bts::config;
|
|
using namespace bts::config::internal;
|
|
namespace proto = google::protobuf;
|
|
|
|
using bts::config::test::Foo;
|
|
using bts::config::test::FooGroup;
|
|
using bts::config::test::FooList;
|
|
|
|
|
|
namespace bts {
|
|
int config_ref_tests = 0;
|
|
TEST_CASE ("Configuration Reference Tests", "[config]") {
|
|
|
|
SECTION("basic_value")
|
|
{
|
|
initialize_for_test(
|
|
"TestSite {"
|
|
" value {"
|
|
" name: 'ref value'"
|
|
" }"
|
|
"}"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @TestSite.name"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
REQUIRE(foo.name() == "ref value");
|
|
}
|
|
|
|
SECTION("scalar_to_repeat") {
|
|
initialize_for_test(
|
|
"TestSite {"
|
|
" value {"
|
|
" name: 'a@example.com' "
|
|
" }"
|
|
"}"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" email: \"before@example.com\" \n"
|
|
" email: @TestSite.name \n"
|
|
" email: \"after@example.com\" \n"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
|
|
REQUIRE(foo.email_size() == 3);
|
|
REQUIRE(foo.email(0) == "before@example.com");
|
|
REQUIRE(foo.email(1) == "a@example.com");
|
|
REQUIRE(foo.email(2) == "after@example.com");
|
|
}
|
|
|
|
SECTION("repeat_to_repeat ") {
|
|
initialize_for_test(
|
|
"StringTable {"
|
|
" value {"
|
|
" entries: 'a@example.com' "
|
|
" entries: 'b@example.com' "
|
|
" }"
|
|
"}"
|
|
"TestSite {"
|
|
" value {"
|
|
" name: 'c@example.com' "
|
|
" }"
|
|
"}"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" email: \"before@example.com\" \n"
|
|
" email: @StringTable.entries \n"
|
|
" email: @TestSite.name \n"
|
|
" email: \"after@example.com\" \n"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
|
|
REQUIRE(foo.email_size() == 5);
|
|
REQUIRE(foo.email(0) == "before@example.com");
|
|
REQUIRE(foo.email(1) == "a@example.com");
|
|
REQUIRE(foo.email(2) == "b@example.com");
|
|
REQUIRE(foo.email(3) == "c@example.com");
|
|
REQUIRE(foo.email(4) == "after@example.com");
|
|
}
|
|
|
|
SECTION("message_value") {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" rule: 'false'"
|
|
" value {\n"
|
|
" name: \"bad\"\n"
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: \"good\"\n"
|
|
" }\n"
|
|
"}\n"
|
|
"FooGroup {"
|
|
" value { "
|
|
" group: @Foo.name "
|
|
" foo: @Foo "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const FooGroup& g = get<FooGroup>();
|
|
REQUIRE(g.group() == "good");
|
|
REQUIRE(g.foo().name() == "good");
|
|
}
|
|
|
|
SECTION("nested_message_value") {
|
|
initialize_for_test(
|
|
"NamedFoo { \n"
|
|
" value {\n"
|
|
" key: 'good foo' "
|
|
" foo { "
|
|
" name: \"good\"\n"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
"FooGroup {"
|
|
" value { "
|
|
" group: @NamedFoo.key "
|
|
" foo: @NamedFoo.foo "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const FooGroup& g = get<FooGroup>();
|
|
REQUIRE(g.group() == "good foo");
|
|
REQUIRE(g.foo().name() == "good");
|
|
}
|
|
|
|
SECTION("macro_value") {
|
|
initialize_for_test(
|
|
"macro {"
|
|
" name: 'macro1' "
|
|
" expression: \"'m1'\" "
|
|
"}"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: $macro1"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
REQUIRE(foo.name() == "m1");
|
|
}
|
|
|
|
SECTION("enum_value") {
|
|
initialize_for_test(
|
|
"ConsoleColor {"
|
|
" value {"
|
|
" color: Blue "
|
|
" }"
|
|
"}"
|
|
"ConsoleColors {"
|
|
" value {"
|
|
" color: @ConsoleColor.color"
|
|
" colors: Green"
|
|
" colors: @ConsoleColor.color"
|
|
" colors: DarkRed"
|
|
" colors: @ConsoleColor.color"
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const test::ConsoleColor& c1 = get<test::ConsoleColor>();
|
|
const test::ConsoleColors& c2 = get<test::ConsoleColors>();
|
|
REQUIRE(c2.color() == c1.color());
|
|
REQUIRE(c2.colors_size() == 4);
|
|
REQUIRE(c2.colors(0) == test::ConsoleColor::Green);
|
|
REQUIRE(c2.colors(1) == c1.color());
|
|
REQUIRE(c2.colors(2) == test::ConsoleColor::DarkRed);
|
|
REQUIRE(c2.colors(3) == c1.color());
|
|
}
|
|
|
|
SECTION("named_key") {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @FooList.item[foo2].foo.name "
|
|
" }\n"
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" item { "
|
|
" key: 'foo1' "
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo2' "
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo3' "
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" }"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
REQUIRE(get<Foo>().name() == "foo2");
|
|
}
|
|
|
|
SECTION("named_key_rule") {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @FooList.item[foo2].foo.name "
|
|
" }\n"
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" item { "
|
|
" key: 'foo1' "
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo2' "
|
|
" rule: '1=0' "
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo3' "
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" }"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
//NOTE that a false rule will still create a message with defaults, so the list contains the same number of elements
|
|
REQUIRE(get<Foo>().name() == "Blue Foo");
|
|
REQUIRE(get<FooList>().item_size() == 3);
|
|
}
|
|
|
|
SECTION("named_key2") {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" value: @FooList.foo[foo2] "
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" id: 1 "
|
|
" }"
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" id: 2 "
|
|
" }"
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" id: 3 "
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
REQUIRE(get<Foo>().name() == "foo2");
|
|
REQUIRE(get<Foo>().id() == 2);
|
|
}
|
|
|
|
SECTION("named_key_syntax_error") {
|
|
bool error = false;
|
|
try {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" value: @FooList[foo2] " // FooList doesn't have a key or a property named foo2
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" id: 1 "
|
|
" }"
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" id: 2 "
|
|
" }"
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" id: 3 "
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
}
|
|
catch(...) {
|
|
error = true;
|
|
}
|
|
REQUIRE(error);
|
|
}
|
|
|
|
SECTION("named_struture") {
|
|
initialize_for_test(
|
|
"FooGroup { \n"
|
|
" value {\n"
|
|
" foo: @FooList.item[foo3].foo "
|
|
" }\n"
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" item { "
|
|
" key: 'foo1' "
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" id: 1 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo2' "
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" id: 2 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo3' "
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" id: 3 "
|
|
" }"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
REQUIRE(get<FooGroup>().foo().name() == "foo3");
|
|
REQUIRE(get<FooGroup>().foo().id() == 3);
|
|
}
|
|
|
|
SECTION("named_structure_rule") {
|
|
initialize_for_test(
|
|
"FooGroup { \n"
|
|
" value {\n"
|
|
" foo: @FooList.item[foo3].foo "
|
|
" }\n"
|
|
"}\n"
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" item { "
|
|
" key: 'foo1' "
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" id: 1 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo2' "
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" id: 2 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo3' "
|
|
" rule: 'false'"
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" id: 3 "
|
|
" }"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
//NOTE that a false rule will still create a message with defaults, so the list contains the same number of elements
|
|
REQUIRE(get<FooGroup>().foo().name() == "Blue Foo");
|
|
REQUIRE(get<FooGroup>().foo().id() == 1234);
|
|
REQUIRE(get<FooList>().item_size() == 3);
|
|
}
|
|
|
|
SECTION("named_value_rule") {
|
|
initialize_for_test(
|
|
"FooList { \n"
|
|
" value {\n"
|
|
" item { "
|
|
" key: 'foo1' "
|
|
" foo { "
|
|
" name: 'foo1' "
|
|
" id: 1 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo2' "
|
|
" foo { "
|
|
" name: 'foo2' "
|
|
" id: 2 "
|
|
" }"
|
|
" }"
|
|
" item { "
|
|
" key: 'foo3' "
|
|
" foo { "
|
|
" name: 'foo3' "
|
|
" id: 3 "
|
|
" }"
|
|
" }"
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
// Adding [] to BooleanGrammer.h is very difficult because boost::spirit is crap
|
|
// also it risks making list syntax [1,2,3] ambiguous so this is a workaround syntax
|
|
" rule: 'FooList.item.foo1.foo.id = 2' "
|
|
" value {\n"
|
|
" name: 'bad' "
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
" rule: 'FooList.item.foo2.foo.id = 2' "
|
|
" value {\n"
|
|
" name: 'good' "
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
REQUIRE(foo.name() == "good");
|
|
}
|
|
|
|
SECTION("recursive_reference_good") {
|
|
initialize_for_test(
|
|
"TestSite { \n"
|
|
" value {\n"
|
|
" name: \"good\"\n"
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @TestSite.name "
|
|
" }\n"
|
|
"}\n"
|
|
"FooGroup {"
|
|
" value { "
|
|
" group: @Foo.name "
|
|
" foo: @Foo "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
REQUIRE(get<FooGroup>().group() == "good");
|
|
REQUIRE(get<FooGroup>().foo().name() == "good");
|
|
}
|
|
|
|
SECTION("recursive_reference_bad") {
|
|
bool error = false;
|
|
try {
|
|
|
|
initialize_for_test(
|
|
"TestSite { \n"
|
|
" value {\n"
|
|
" name: @Foo.name "
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @TestSite.name "
|
|
" }\n"
|
|
"}\n"
|
|
"FooGroup {"
|
|
" value { "
|
|
" group: @Foo.name "
|
|
" foo: @Foo "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
|
|
} catch(...) {
|
|
error = true;
|
|
}
|
|
REQUIRE(error);
|
|
}
|
|
|
|
SECTION("recursive_order_independent") {
|
|
initialize_for_test(
|
|
"FooGroup {"
|
|
" value { "
|
|
" group: @Foo.name "
|
|
" foo: @Foo "
|
|
" }"
|
|
"}"
|
|
"TestSite { \n"
|
|
" value {\n"
|
|
" name: \"good\"\n"
|
|
" }\n"
|
|
"}\n"
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @TestSite.name "
|
|
" }\n"
|
|
"}\n"
|
|
);
|
|
|
|
// In this test we mighe expect @Foo.name or @Foo to be evaluated first
|
|
// But Foo is incomplete until @TestSite.name is evaluated.
|
|
REQUIRE(get<FooGroup>().group() == "good");
|
|
REQUIRE(get<FooGroup>().foo().name() == "good");
|
|
}
|
|
|
|
SECTION("loop_test") {
|
|
bool error = false;
|
|
try {
|
|
initialize_for_test(
|
|
"Foo { \n"
|
|
" value {\n"
|
|
" name: @Foo.name "
|
|
" }\n"
|
|
"}\n");
|
|
} catch(...) {
|
|
error = true;
|
|
}
|
|
REQUIRE(error);
|
|
}
|
|
|
|
SECTION("merge_test") {
|
|
// Config used to go through a merge step for each file in a directory.
|
|
// This would invalidate the memory held by the deferred value queue and cause
|
|
// crashes and instability. This is to verify that we don't regress the new behavior.
|
|
|
|
HTTPServer server;
|
|
std::string port = boost::lexical_cast<std::string>(server.port());
|
|
std::string config_url = "http://localhost:" + port + "/";
|
|
std::string response =
|
|
"HTTP/1.0 200 OK\r\n"
|
|
"Content-Type: text/plain\r\n\r\n";
|
|
|
|
server.add_response("/spark.conf", response,
|
|
"Foo {\n"
|
|
" value: {\n"
|
|
" name: \"included_value\"\n"
|
|
" id: 4096\n"
|
|
" }}\n"
|
|
"TestSite {"
|
|
" value { "
|
|
" name: @FooGroup.group" // reference to testkeys.conf
|
|
" }"
|
|
"}"
|
|
);
|
|
server.add_response("/testkeys.conf", response,
|
|
"FooGroup {\n"
|
|
" value {\n"
|
|
" group: \"http_group\"\n"
|
|
" foo {\n"
|
|
" name: @Foo.name " // reference to spark.conf
|
|
" id: 80\n"
|
|
"}}}\n"
|
|
);
|
|
|
|
server.start();
|
|
initialize_for_test("include: \"" + config_url + "\"");
|
|
server.stop();
|
|
|
|
const FooGroup& group = get<FooGroup>();
|
|
const test::TestSite& site = get<test::TestSite>();
|
|
|
|
REQUIRE(group.foo().name() == "included_value");
|
|
REQUIRE(site.name() == "http_group");
|
|
}
|
|
|
|
SECTION("test_conversion") {
|
|
initialize_for_test(
|
|
"Foo {\n"
|
|
" value: {\n"
|
|
" name: @RuleRef.a_int \n"
|
|
" id: @RuleRef.a_string "
|
|
" }}\n"
|
|
"Foo {\n"
|
|
" rule: 'false' "
|
|
" value: {\n"
|
|
" name: @RuleRef.a_string \n"
|
|
" id: @RuleRef.a_int "
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" value { "
|
|
" a_string: '42' "
|
|
" a_int: 99 "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
REQUIRE(foo.name() == "99");
|
|
REQUIRE(foo.id() == 42);
|
|
}
|
|
|
|
SECTION("test_int") {
|
|
initialize_for_test(
|
|
"Foo {\n"
|
|
" value: {\n"
|
|
" id: @RuleRef.a_int "
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" value { "
|
|
" a_string: 'good' "
|
|
" a_int: 99 "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const Foo& foo = get<Foo>();
|
|
REQUIRE(foo.id() == 99);
|
|
}
|
|
|
|
SECTION("test_repeated_to_repeated") {
|
|
initialize_for_test(
|
|
"FooList {\n"
|
|
" value: {\n"
|
|
" foo {\n"
|
|
" name: 'good1' \n"
|
|
" }\n"
|
|
" foo {\n"
|
|
" name: 'good2' \n"
|
|
" }\n"
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'original' "
|
|
" }"
|
|
" foox: @FooList.foo "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const test::RuleRef& result = get<test::RuleRef>();
|
|
|
|
REQUIRE(result.foox_size() == 3);
|
|
REQUIRE(result.foox(0).name() == "original");
|
|
REQUIRE(result.foox(1).name() == "good1");
|
|
REQUIRE(result.foox(2).name() == "good2");
|
|
}
|
|
|
|
SECTION("test_repeated_after_key_rule") {
|
|
initialize_for_test(
|
|
"StringTable { \n"
|
|
" value { \n"
|
|
" entries: 'a' \n"
|
|
" entries: 'b' \n"
|
|
" } \n"
|
|
"} \n"
|
|
"FooList {\n"
|
|
" value: {\n"
|
|
" item {\n"
|
|
" key: 'one' \n"
|
|
" rule: \" 'a' in StringTable.entries\" \n"
|
|
" foox { \n"
|
|
" name: 'good1' \n"
|
|
" }\n"
|
|
" foox { \n"
|
|
" name: 'good2' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" item {\n"
|
|
" key: 'two' \n"
|
|
" foox { \n"
|
|
" name: 'bad1' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'original' "
|
|
" }"
|
|
" foox: @FooList.item[one].foox "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const test::RuleRef& result = get<test::RuleRef>();
|
|
REQUIRE(result.foox_size() == 3);
|
|
REQUIRE(result.foox(0).name() == "original");
|
|
REQUIRE(result.foox(1).name() == "good1");
|
|
REQUIRE(result.foox(2).name() == "good2");
|
|
}
|
|
|
|
SECTION("test_repeated_after_key_rule2") {
|
|
//This test fails on purpose to illustrate the frailty of the rule evaluation feature in 'keyed' list keys
|
|
initialize_for_test(
|
|
"TestSite {"
|
|
" value {"
|
|
" name: 'a' "
|
|
" }"
|
|
"}"
|
|
"StringTable {"
|
|
" value {"
|
|
" entries: @TestSite.name "
|
|
" entries: 'b' "
|
|
" }"
|
|
"}"
|
|
"FooList {\n"
|
|
" value: {\n"
|
|
" item {\n"
|
|
" key: 'one' \n"
|
|
" rule: \"'a' in StringTable.entries\" \n"
|
|
" foox { \n"
|
|
" name: 'good1' \n"
|
|
" }\n"
|
|
" foox { \n"
|
|
" name: 'good2' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" item {\n"
|
|
" key: 'two' \n"
|
|
" foox { \n"
|
|
" name: 'bad1' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'original' "
|
|
" }"
|
|
" foox: @FooList.item[one].foox "
|
|
" }"
|
|
"}"
|
|
);
|
|
|
|
const test::RuleRef& result = get<test::RuleRef>();
|
|
REQUIRE(result.foox_size() == 3);
|
|
REQUIRE(result.foox(0).name() == "original");
|
|
REQUIRE(result.foox(1).name() == "good1");
|
|
REQUIRE(result.foox(2).name() == "good2");
|
|
}
|
|
|
|
SECTION("test_repeated_after_key_rule3") {
|
|
//This test fails on purpose to illustrate the frailty of the rule evaluation feature in 'keyed' list keys
|
|
initialize_for_test(
|
|
"RuleRef { "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'original' "
|
|
" }"
|
|
" foox: @FooList.item[one].foox "
|
|
" }"
|
|
"}"
|
|
"TestSite {"
|
|
" value {"
|
|
" name: 'a' "
|
|
" }"
|
|
"}"
|
|
"StringTable {"
|
|
" value {"
|
|
" entries: @TestSite.name "
|
|
" entries: 'b' "
|
|
" }"
|
|
"}"
|
|
"FooList {\n"
|
|
" value: {\n"
|
|
" item {\n"
|
|
" key: 'one' \n"
|
|
" rule: \"'a' in StringTable.entries\" \n"
|
|
" foox { \n"
|
|
" name: 'good1' \n"
|
|
" }\n"
|
|
" foox { \n"
|
|
" name: 'good2' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" item {\n"
|
|
" key: 'two' \n"
|
|
" foox { \n"
|
|
" name: 'bad1' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" }}\n"
|
|
|
|
);
|
|
|
|
const test::RuleRef& result = get<test::RuleRef>();
|
|
//the order matters here, but seems to be deterministic
|
|
REQUIRE(result.foox_size() == 1);
|
|
}
|
|
|
|
// SECTION("test_repeated_after_key_rule_should_fail") {
|
|
// //This test fails on purpose to illustrate the frailty of the rule evaluation feature in 'keyed' list keys
|
|
// initialize_for_test(
|
|
// "RuleRef { "
|
|
// " value { "
|
|
// " foox { "
|
|
// " name: 'original' "
|
|
// " }"
|
|
// " foox: @FooList.item[one].foox "
|
|
// " }"
|
|
// "}"
|
|
// "TestSite {"
|
|
// " value {"
|
|
// " name: 'a' "
|
|
// " }"
|
|
// "}"
|
|
// "StringTable {"
|
|
// " value {"
|
|
// " entries: @TestSite.name "
|
|
// " entries: 'b' "
|
|
// " }"
|
|
// "}"
|
|
// "FooList {\n"
|
|
// " value: {\n"
|
|
// " item {\n"
|
|
// " key: 'one' \n"
|
|
// " rule: \"'a' in StringTable.entries\" \n"
|
|
// " foox { \n"
|
|
// " name: 'good1' \n"
|
|
// " }\n"
|
|
// " foox { \n"
|
|
// " name: 'good2' \n"
|
|
// " }\n"
|
|
// " }\n"
|
|
// " item {\n"
|
|
// " key: 'two' \n"
|
|
// " foox { \n"
|
|
// " name: 'bad1' \n"
|
|
// " }\n"
|
|
// " }\n"
|
|
// " }}\n"
|
|
|
|
// );
|
|
|
|
// const test::RuleRef& result = get<test::RuleRef>();
|
|
// //this should fail
|
|
// REQUIRE(result.foox_size() == 3);
|
|
// }
|
|
|
|
SECTION("test_irrelevant_lookup") {
|
|
// If a key references another key which is not present it should only be an error if the resulting key will ever be used.
|
|
initialize_for_test(
|
|
"FooList {\n"
|
|
" value: {\n"
|
|
" item {\n"
|
|
" key: 'one' \n"
|
|
" foox { \n"
|
|
" name: 'good1' \n"
|
|
" }\n"
|
|
" foox { \n"
|
|
" name: 'good2' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" item {\n"
|
|
" key: 'two' \n"
|
|
" foox { \n"
|
|
" name: 'bad1' \n"
|
|
" }\n"
|
|
" }\n"
|
|
" }}\n"
|
|
"RuleRef { "
|
|
" rule: 'false' "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'never used' "
|
|
" }"
|
|
" foox: @FooList.item[XXXXX].foox " // Invalid lookup
|
|
" }"
|
|
"}"
|
|
"RuleRef { "
|
|
" value { "
|
|
" foox { "
|
|
" name: 'original' "
|
|
" }"
|
|
" foox: @FooList.item[one].foox "
|
|
" }"
|
|
"}"
|
|
);
|
|
const test::RuleRef& result = get<test::RuleRef>();
|
|
REQUIRE(result.foox_size() == 3);
|
|
}
|
|
|
|
SECTION("macro_definition_order_test_hard") {
|
|
// The $is_crusible test hard version
|
|
// $macro1 tests Value2.x with rule about $macro2 before $macro2 is defined
|
|
// Value2.x is an @reference of a 4th location
|
|
initialize_for_test(
|
|
"TestSite {"
|
|
" value { name: 'cme_1u7_cert' }"
|
|
"}"
|
|
"Foo {"
|
|
" rule: '$is_crucible'"
|
|
" value { name: @TestSite.name }"
|
|
"}"
|
|
""
|
|
"Foo {"
|
|
" value { name: '' }"
|
|
"}"
|
|
""
|
|
"macro {"
|
|
" name: 'o2_cme_enabled'"
|
|
" expression: \"Foo.name != ''\" "
|
|
"}"
|
|
""
|
|
"macro {"
|
|
" name: 'is_crucible'"
|
|
" expression: 'true'"
|
|
"}"
|
|
);
|
|
|
|
REQUIRE(get<Foo>().name() == "cme_1u7_cert");
|
|
}
|
|
|
|
reset();
|
|
}
|
|
|
|
}
|