testKeywordEx.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#include <daq/dpm/keywordEx.hpp>
 
#include <gtest/gtest.h>
 
namespace daq::dpm {
 
class TestKeywordMatchP : public ::testing::Test,
                          public ::testing::WithParamInterface<fits::KeywordVariant> {};
 
class TestKeywordMatch : public ::testing::Test {};
class TestKeywordTransform : public ::testing::Test {};
 
TEST(TestParseEx, FailsIfOperatorIsInvalid) {
    using namespace detail;
 
    EXPECT_THROW(ParseEx(""), std::invalid_argument);
    EXPECT_THROW(ParseEx("? *"), std::invalid_argument);
    EXPECT_THROW(ParseEx("a *"), std::invalid_argument);
}
 
TEST(TestParseEx, FailsIfScopeIsInValid) {
    using namespace detail;
 
    EXPECT_THROW(ParseEx("+"), std::invalid_argument);
    EXPECT_THROW(ParseEx("+a *"), std::invalid_argument);
    EXPECT_THROW(ParseEx("+ve *"), std::invalid_argument);
    EXPECT_THROW(ParseEx("+cc *"), std::invalid_argument);
}
 
TEST(TestParseEx, FailsIfWhitespaceIsMssing) {
    using namespace detail;
 
    EXPECT_THROW(ParseEx("+pattern"), std::invalid_argument);
    EXPECT_THROW(ParseEx("+vpattern"), std::invalid_argument);
}
 
TEST(TestParseEx, FailsIfPatternIsMissing) {
    using namespace detail;
 
    EXPECT_THROW(ParseEx("+ "), std::invalid_argument);
    EXPECT_THROW(ParseEx("+e"), std::invalid_argument);
}
 
TEST(TestParseEx, IncludeEsoKw) {
    using namespace detail;
 
    Rule r = ParseEx("+e *");
 
    EXPECT_EQ(r.op, Operator::Include);
    EXPECT_EQ(r.scope, Scope::Eso);
    EXPECT_EQ(r.pattern, "*");
}
 
TEST(TestParseEx, ExcludeEsoKw) {
    using namespace detail;
 
    Rule r = ParseEx("-e *");
 
    EXPECT_EQ(r.op, Operator::Exclude);
    EXPECT_EQ(r.scope, Scope::Eso);
    EXPECT_EQ(r.pattern, "*");
}
 
TEST(TestParseEx, IncludeValueKw) {
    using namespace detail;
 
    Rule r = ParseEx("+v *");
 
    EXPECT_EQ(r.op, Operator::Include);
    EXPECT_EQ(r.scope, Scope::Value);
    EXPECT_EQ(r.pattern, "*");
}
 
TEST(TestParseEx, IncludeCommentaryKw) {
    using namespace detail;
 
    Rule r = ParseEx("+c *");
 
    EXPECT_EQ(r.op, Operator::Include);
    EXPECT_EQ(r.scope, Scope::Commentary);
    EXPECT_EQ(r.pattern, "*");
}
 
TEST(TestParseEx, IncludeAnyKw) {
    using namespace detail;
 
    Rule r = ParseEx("+ pat");
 
    EXPECT_EQ(r.op, Operator::Include);
    EXPECT_EQ(r.scope, Scope::Any);
    EXPECT_EQ(r.pattern, "pat");
}
 
TEST(TestKeywordEx, Constructors) {
    EXPECT_NO_THROW(KeywordEx()) << "Default constructor";
    EXPECT_NO_THROW(KeywordEx("+ *")) << "Single rule";
    EXPECT_NO_THROW(KeywordEx({"+ *", "- *"})) << "From initilizer list";
    std::vector<std::string> strings = {"+ *", "- *"};
    EXPECT_NO_THROW(KeywordEx(std::begin(strings), std::end(strings))) << "From iterators";
}
 
TEST_P(TestKeywordMatchP, EmptyPatternDoesntMatch) {
    EXPECT_FALSE(KeywordMatch(GetParam(), KeywordEx()));
}
 
TEST_P(TestKeywordMatchP, MatchAnyWithSingle) {
    EXPECT_TRUE(KeywordMatch(GetParam(), KeywordEx("+ *")));
}
 
TEST_P(TestKeywordMatchP, MatchAnyWithMultiple) {
    EXPECT_TRUE(KeywordMatch(GetParam(), KeywordEx({"+e *", "+v *", "+c *"})));
    EXPECT_TRUE(KeywordMatch(GetParam(), KeywordEx({"+e VALUE", "+v VALUE", "+c VALUE"})));
}
 
INSTANTIATE_TEST_SUITE_P(Test,
                         TestKeywordMatchP,
                         testing::Values(fits::EsoKeyword("VALUE", "value"),
                                         fits::ValueKeyword("VALUE", 0.0),
                                         fits::LiteralKeyword("VALUE   = 'tgt' / comment"),
                                         fits::LiteralKeyword("VALUE     Comment")));
 
TEST_F(TestKeywordMatch, EsoSimpleInclusivePattern) {
    auto kw = fits::EsoKeyword("CAT", "value");
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ CAT")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+e CAT")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+e C?T")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+e *")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ *")));
 
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+e C")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+v CAT")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+c CAT")));
}
 
TEST_F(TestKeywordMatch, ValueSimpleInclusivePattern) {
    auto kw = fits::ValueKeyword("ORIGIN", "value");
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ ORIGIN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v ORIGIN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v OR*IN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v *")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ *")));
 
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+v ORIGI")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+e ORIGIN")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+c ORIGIN")));
}
 
TEST_F(TestKeywordMatch, LiteralSimpleInclusivePattern) {
    auto kw = fits::LiteralKeyword("ORIGIN  = 'value'");
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ ORIGIN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v ORIGIN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v OR*IN")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+v *")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ *")));
 
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+v ORIGI")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+e ORIGIN")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+c ORIGIN")));
}
 
TEST_F(TestKeywordMatch, CommentarySimpleInclusivePattern) {
    auto kw = fits::LiteralKeyword("COMMENT value");
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ COMMENT")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+c COMMENT")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ COMME*")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+c *")));
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+ *")));
 
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+c COMME")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+e COMMENT")));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx("+v COMMENT")));
}
 
TEST_F(TestKeywordMatch, SimpleExclusivePattern) {
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("- CAT")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-e CAT")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-e C?T")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-e *")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("- *")));
 
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-e C")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-v CAT")));
    EXPECT_FALSE(KeywordMatch(fits::EsoKeyword("CAT", "value"), KeywordEx("-c CAT")));
}
 
TEST_F(TestKeywordMatch, EsoInclusiveExclusivePattern) {
    auto kw = fits::EsoKeyword("CAT TEST", "value");
    EXPECT_TRUE(KeywordMatch(kw, KeywordEx("+e CAT*")));
 
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx({"+e CAT", "-e CAT TEST"})));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx({"+e *", "-e *"})));
    EXPECT_FALSE(KeywordMatch(kw, KeywordEx({"+ *", "-e *"})));
}
 
TEST_F(TestKeywordTransform, EsoKeyword) {
    auto kw = fits::EsoKeyword("CAT FOO", "value");
    EXPECT_EQ(KeywordTransform(kw, std::regex("^CAT"), "CAT1"),
              fits::EsoKeyword("CAT1 FOO", "value"));
    EXPECT_EQ(KeywordTransform(fits::KeywordVariant(kw), std::regex("^CAT"), "CAT1"),
              fits::KeywordVariant(fits::EsoKeyword("CAT1 FOO", "value")));
}
 
TEST_F(TestKeywordTransform, InvalidEsoKeyword) {
    std::string long_name(70, 'A');
    auto kw = fits::EsoKeyword("CAT FOO", "value");
    EXPECT_THROW(KeywordTransform(kw, std::regex("^CAT"), long_name.c_str()), std::runtime_error);
}
 
TEST_F(TestKeywordTransform, ValueKeyword) {
    auto kw = fits::ValueKeyword("FOOBAR", "value");
    EXPECT_EQ(KeywordTransform(kw, std::regex("^FOO"), "F00"),
              fits::ValueKeyword("F00BAR", "value"));
    EXPECT_EQ(KeywordTransform(fits::KeywordVariant(kw), std::regex("^FOO"), "F00"),
              fits::KeywordVariant(fits::ValueKeyword("F00BAR", "value")));
}
 
TEST_F(TestKeywordTransform, InvalidValueKeyword) {
    std::string long_name(70, 'A');
    auto kw = fits::ValueKeyword("CAT FOO", "value");
    EXPECT_THROW(KeywordTransform(kw, std::regex("^CAT"), long_name.c_str()), std::runtime_error);
    EXPECT_THROW(KeywordTransform(kw, std::regex("^CAT"), "%!@"), std::runtime_error);
}
 
TEST_F(TestKeywordTransform, LiteralKeyword) {
    using fits::KeywordVariant;
    using fits::LiteralKeyword;
    LiteralKeyword kw1("HIERARCH ESO A1 = B");
    EXPECT_EQ(KeywordTransform(KeywordVariant(kw1), std::regex("^A1"), "$& B1"),
              fits::KeywordVariant(LiteralKeyword("HIERARCH ESO A1 B1 = B /")));
}
 
}  // namespace daq::dpm