testDictKeywordFormatter.cpp

Go to the documentation of this file.

/**
 * @file
 * @copyright
 * (c) Copyright ESO 2024
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 */
#include <dictKeywordFormatter.hpp>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
using namespace ::testing;
using core::dit::did::DataType;
using core::dit::did::Record;
 
#define EXPECT_THROW_THAT(stmt, etype, matcher)           \
    EXPECT_THROW(                                         \
        try { stmt; } catch (const etype& ex) {           \
            EXPECT_THAT(std::string(ex.what()), matcher); \
            throw;                                        \
        },                                                \
        etype)
 
namespace daq {
using namespace daq::fits;
 
class TestFormatKeyword : public Test {
public:
    void SetUp() {
        m_str_record = Record("NAME",
                              core::dit::did::DataTypeToStr(DataType::STRING),
                              "COMMENT",
                              /*desccription*/ "",
                              /*format*/ "",
                              /*unit*/ "");
        m_float_record = Record("NAME",
                                core::dit::did::DataTypeToStr(DataType::DOUBLE),
                                "COMMENT",
                                /*desccription*/ "",
                                /*format*/ ".3f",
                                /*unit*/ "");
        m_float_no_format_record = Record("NAME",
                                          core::dit::did::DataTypeToStr(DataType::DOUBLE),
                                          "COMMENT",
                                          /*desccription*/ "",
                                          /*format*/ "",
                                          /*unit*/ "");
        m_bool_record = Record("NAME",
                               core::dit::did::DataTypeToStr(DataType::BOOL),
                               "COMMENT",
                               /*desccription*/ "",
                               /*format*/ "",
                               /*unit*/ "");
        m_int_record = Record("NAME",
                              core::dit::did::DataTypeToStr(DataType::INTEGER),
                              "COMMENT",
                              /*desccription*/ "",
                              /*format*/ "",
                              /*unit*/ "");
    }
 
    Record m_str_record;
    Record m_float_record;
    Record m_float_no_format_record;
    Record m_bool_record;
    Record m_int_record;
};
 
class TestFormatLiteralKeyword : public TestFormatKeyword {};
class TestFormatEsoKeyword : public TestFormatKeyword {};
class TestFormatValueKeyword : public TestFormatKeyword {};
 
TEST_F(TestFormatLiteralKeyword, StringIsWrongType) {
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 'string' / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
}
 
TEST_F(TestFormatLiteralKeyword, InvalidStrings) {
    // Note: LiteralKeyword will make minimal validation of the string token so malformed strings
    // cannot be parsed at all.
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = '\x1f' / comment"), m_str_record),
                      InvalidKeyword,
                      HasSubstr("invalid character"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = '\x7f' / comment"), m_str_record),
                      InvalidKeyword,
                      HasSubstr("invalid character"));
}
 
TEST_F(TestFormatLiteralKeyword, InvalidFloat) {
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = /comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 123.456f / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = a1234 / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    =  . / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 1..2 / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 1,34 / comment"), m_float_record),
                      InvalidKeyword,
                      HasSubstr("parsing floating point value"));
}
 
TEST_F(TestFormatLiteralKeyword, InvalidInteger) {
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 123.456 / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"))
        << "floats should not be demoted to integers";
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = /comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = -+0 /comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 123.456f / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = a1234 / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    =  / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 1..2 / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 0x0a / comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("parsing base-10 integer value"));
}
 
TEST_F(TestFormatLiteralKeyword, InvalidBool) {
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = /comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("is not `T` or `F`"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = TRUE /comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("is not `T` or `F`"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = 'T' /comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("is not `T` or `F`"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = TT /comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("is not `T` or `F`"));
    EXPECT_THROW_THAT(Format(LiteralKeyword("NAME    = A /comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("is not `T` or `F`"));
}
 
TEST_F(TestFormatLiteralKeyword, ValidStrings) {
    {
        auto befor = LiteralKeyword("NAME    = 'string' /comment");
        auto after = LiteralKeyword("NAME    = 'string'             / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 'str''ng' /comment");
        auto after = LiteralKeyword("NAME    = 'str''ng'            / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 'str''ng' /");
        auto after = LiteralKeyword("NAME    = 'str''ng'            / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 'string  ' /comment");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 'string  ' / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME    = 'str''ng' /comment");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 'str''ng' / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME    = 'str''ng' /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 'str''ng' / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_str_record), after) << "Expected comment from record to be added";
    }
}
 
TEST_F(TestFormatLiteralKeyword, ValidFloatsAreReformatted) {
    {
        auto befor = LiteralKeyword("NAME    = 12.3456 /comment");
        auto after = LiteralKeyword("NAME    =               12.346 / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 12.1 /");
        auto after = LiteralKeyword("NAME    =               12.100 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 12 /");
        auto after = LiteralKeyword("NAME    =               12.000 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_record), after)
            << "Integers are allowed to be promoted to float";
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12. /comment");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12.000 / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12.1 /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12.100 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12 /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12.000 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_record), after)
            << "Integers are allowed to be promoted to float";
    }
}
 
TEST_F(TestFormatLiteralKeyword, ValidFloatsWithoutFormatKeepsFormatting) {
    {
        auto befor = LiteralKeyword("NAME    = 12.3456 /comment");
        auto after = LiteralKeyword("NAME    =              12.3456 / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 12.1 /");
        auto after = LiteralKeyword("NAME    =                 12.1 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = 12 /");
        auto after = LiteralKeyword("NAME    =                   12 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after)
            << "Integers are allowed to be promoted to float";
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12.3456 /comment");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12.3456 / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12.1 /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12.1 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = 12 /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = 12 / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_float_no_format_record), after)
            << "Integers are allowed to be promoted to float";
    }
}
 
TEST_F(TestFormatLiteralKeyword, ValidBool) {
    {
        auto befor = LiteralKeyword("NAME    = T /");
        auto after = LiteralKeyword("NAME    =                    T / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_bool_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    = F / comment");
        auto after = LiteralKeyword("NAME    =                    F / comment");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_bool_record), after);
    }
    {
        auto befor = LiteralKeyword("NAME    =     T     /");
        auto after = LiteralKeyword("NAME    =                    T / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Value);
        EXPECT_EQ(Format(befor, m_bool_record), after);
    }
    {
        auto befor = LiteralKeyword("HIERARCH ESO NAME = T /");
        auto after = LiteralKeyword("HIERARCH ESO NAME = T / COMMENT");
        ASSERT_EQ(befor.GetType(), KeywordType::Eso);
        EXPECT_EQ(Format(befor, m_bool_record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, ValidStrings) {
    {
        auto befor = ValueKeyword("NAME", "str'in'g", "comment");
        auto after = LiteralKeyword("NAME    = 'str''in''g'         / comment");
        EXPECT_EQ(Format(befor, m_str_record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, ValidBool) {
    {
        auto befor = ValueKeyword("NAME", true, "comment");
        auto after = LiteralKeyword("NAME    =                    T / comment");
        EXPECT_EQ(Format(befor, m_bool_record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, ValidFloat) {
    {
        auto befor = ValueKeyword("NAME", 12.3456);
        auto after = LiteralKeyword("NAME    =               12.346 / COMMENT");
        EXPECT_EQ(Format(befor, m_float_record), after);
    }
    {
        auto befor = ValueKeyword("NAME", 12.34124, "comment");
        auto after = LiteralKeyword("NAME    =                 12.3 / comment");
        EXPECT_EQ(Format(befor, m_float_no_format_record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, ValidFloatNoDecimalDigits) {
    {
        auto record = Record("NAME",
                             core::dit::did::DataTypeToStr(DataType::DOUBLE),
                             "COMMENT",
                             /*desccription*/ "",
                             /*format*/ "#.0f",
                             /*unit*/ "");
        auto befor = ValueKeyword("NAME", -12.3456);
        auto after = LiteralKeyword("NAME    =                 -12. / COMMENT");
        EXPECT_EQ(Format(befor, record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, ValidInteger) {
    {
        auto befor = ValueKeyword("NAME", static_cast<std::uint64_t>(12u), "");
        auto after = LiteralKeyword("NAME    =                   12 / ");
        EXPECT_EQ(Format(befor, m_int_record), after);
    }
    {
        auto befor = ValueKeyword("NAME", -12);
        auto after = LiteralKeyword("NAME    =                  -12 / COMMENT");
        EXPECT_EQ(Format(befor, m_int_record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, NoRecordCommentCoverage) {
    {
        auto record = Record("NAME", core::dit::did::DataTypeToStr(DataType::INTEGER), "", "", "");
        auto befor = ValueKeyword("NAME", -12);
        auto after = LiteralKeyword("NAME    =                  -12 /");
        EXPECT_EQ(Format(befor, record), after);
    }
}
 
TEST_F(TestFormatValueKeyword, StringIsWrongType) {
    EXPECT_THROW_THAT(Format(ValueKeyword("NAME", "str'in'g", "comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("dictionary specifies value to be DidBoolKey"));
}
 
TEST_F(TestFormatValueKeyword, DoubleIsWrongType) {
    EXPECT_THROW_THAT(Format(ValueKeyword("NAME", 0.1, "comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("dictionary specifies value to be DidBoolKey"));
}
 
TEST_F(TestFormatEsoKeyword, DoubleIsWrongType) {
    EXPECT_THROW_THAT(Format(EsoKeyword("NAME", 0.1, "comment"), m_bool_record),
                      InvalidKeyword,
                      HasSubstr("dictionary specifies value to be DidBoolKey"));
}
 
TEST_F(TestFormatEsoKeyword, StringIsWrongType) {
    EXPECT_THROW_THAT(Format(EsoKeyword("NAME", "str'in'g", "comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("dictionary specifies value to be DidIntKey"));
}
 
TEST_F(TestFormatEsoKeyword, IntegersAreTheWrongType) {
    EXPECT_THROW_THAT(
        Format(ValueKeyword("NAME", static_cast<std::uint64_t>(1), "comment"), m_bool_record),
        InvalidKeyword,
        HasSubstr("dictionary specifies value to be DidBoolKey but value is uint64"));
    EXPECT_THROW_THAT(
        Format(ValueKeyword("NAME", static_cast<std::int64_t>(1), "comment"), m_bool_record),
        InvalidKeyword,
        HasSubstr("dictionary specifies value to be DidBoolKey but value is int64"));
}
 
TEST_F(TestFormatEsoKeyword, BoolIsTheWrongType) {
    EXPECT_THROW_THAT(Format(ValueKeyword("NAME", false, "comment"), m_int_record),
                      InvalidKeyword,
                      HasSubstr("dictionary specifies value to be DidIntKey but value is bool"));
}
 
}  // namespace daq