testKeyword.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_fits_test
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Unit tests for json handling.
 */
#include <algorithm>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <nlohmann/json.hpp>
#include <ostream>
#include <random>
 
#include <daq/error/report.hpp>
#include <daq/fits/json.hpp>
 
#include "matchers.hpp"
 
using namespace daq::fits;
using namespace std::string_view_literals;
 
class TestLiteralKeyword : public ::testing::Test {
public:
    void ExpectKeyword(std::string const& record,
                       KeywordType type,
                       std::string_view name,
                       std::string_view logical_name) {
        using namespace ::testing;
        try {
            LiteralKeyword kw(record);
 
            EXPECT_THAT(record, StartsWith(std::string(kw.GetRecord())));
            EXPECT_EQ(type, kw.GetType());
            auto [kw_name, kw_type] = kw.GetName();
            EXPECT_EQ(kw_name, logical_name);
            EXPECT_EQ(type, kw_type);
        } catch (...) {
            daq::error::ReportNestedExceptions(std::cerr);
            throw;
        }
    }
};
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords1) {
    std::string too_long;
    std::fill_n(std::back_inserter(too_long), constants::RECORD_LENGTH + 1, 'N');
    ASSERT_EQ(too_long.size(), constants::RECORD_LENGTH + 1);
    EXPECT_THROW(LiteralKeyword{too_long}, std::invalid_argument);
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords4) {
    LiteralKeyword kw{" "};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, " ");
    EXPECT_EQ(type, KeywordType::Commentary);
    EXPECT_EQ(kw.GetRecord(), " ");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords3) {
    LiteralKeyword kw{"A"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "A");
    EXPECT_EQ(type, KeywordType::Commentary);
    EXPECT_EQ(kw.GetRecord(), "A");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords5) {
    LiteralKeyword kw{"A       = "};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "A");
    EXPECT_EQ(type, KeywordType::Value);
    EXPECT_EQ(kw.GetRecord(), "A       =");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords6) {
    LiteralKeyword kw{"HIERARCH ESO A=T/"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "A");
    EXPECT_EQ(type, KeywordType::Eso);
    EXPECT_EQ(kw.GetRecord(), "HIERARCH ESO A=T/");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords7) {
    LiteralKeyword kw{"HIERARCH ESO A=''/"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "A");
    EXPECT_EQ(type, KeywordType::Eso);
    EXPECT_EQ(kw.GetRecord(), "HIERARCH ESO A=''/");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords8) {
    LiteralKeyword kw{"HIERARCH ESO A=''''''/"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "A");
    EXPECT_EQ(type, KeywordType::Eso);
    EXPECT_EQ(kw.GetRecord(), "HIERARCH ESO A=''''''/");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords9) {
    LiteralKeyword kw{"KEYWORD1= ''/' /"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "KEYWORD1");
    EXPECT_EQ(type, KeywordType::Value);
    EXPECT_EQ(kw.GetComponents().value, "''");
    EXPECT_EQ(kw.GetComponents().comment, "' /");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords10) {
    LiteralKeyword kw{"HIERARCH ESO HAS NO VALUE AFTER INDICATOR="};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "HAS NO VALUE AFTER INDICATOR");
    EXPECT_EQ(type, KeywordType::Eso);
    EXPECT_EQ(kw.GetComponents().value, "");
    EXPECT_EQ(kw.GetComponents().comment, "");
}
 
TEST_F(TestLiteralKeyword, ConstructStrangeKeywords11) {
    LiteralKeyword kw{"HIERARCH ESO HAS NO VALUE AFTER INDICATOR=/with comment"};
    auto [name, type] = kw.GetName();
    EXPECT_EQ(name, "HAS NO VALUE AFTER INDICATOR");
    EXPECT_EQ(type, KeywordType::Eso);
    EXPECT_EQ(kw.GetComponents().value, "");
    EXPECT_EQ(kw.GetComponents().comment, "with comment");
}
 
TEST_F(TestLiteralKeyword, ConstructRegularKeywords) {
    using namespace ::testing;
    std::string_view record = "ORIGIN  = 'ESO-PARANAL'    / European Southern Observatory";
 
    std::array<char, constants::RECORD_LENGTH> array_record = {' '};
    std::copy(std::begin(record), std::end(record), std::begin(array_record));
    LiteralKeyword kw(array_record);
    EXPECT_THAT(std::string(kw.GetRecord()), StartsWith(std::string(record)));
}
 
TEST_F(TestLiteralKeyword, ValueKeywordTypes) {
    try {
        {
            SCOPED_TRACE("");
            ExpectKeyword("SIMPLE  =                T / Standard FITS     ",
                          KeywordType::Value,
                          "SIMPLE  ",
                          "SIMPLE");
        }
        {
            SCOPED_TRACE("");
            ExpectKeyword("DATE    = '2019-12-12T04:30:53.8930' / Date the file was written",
                          KeywordType::Value,
                          "DATE    ",
                          "DATE");
        }
    } catch (...) {
        daq::error::ReportNestedExceptions(std::cout);
    }
}
 
TEST_F(TestLiteralKeyword, StrangeValueKeywordTypes) {
    EXPECT_THROW(LiteralKeyword("KEYWORD1= '"), std::invalid_argument);
    EXPECT_THROW(LiteralKeyword("KEYWORD1= '''"), std::invalid_argument);
}
 
TEST_F(TestLiteralKeyword, InvalidEsoKeywordTypes) {
    EXPECT_THROW(LiteralKeyword("HIERARCH ESO HAS TWO STRINGS ='two' 'strings'/"),
                 std::invalid_argument);
    EXPECT_THROW(LiteralKeyword("HIERARCH ESO HAS TWO VALUES= T 0.1/"), std::invalid_argument);
    EXPECT_THROW(LiteralKeyword("HIERARCH ESO HAS TWO VALUES= T F"), std::invalid_argument);
}
 
TEST_F(TestLiteralKeyword, EsoKeywordTypes) {
    {
        SCOPED_TRACE("");
        ExpectKeyword("HIERARCH ESO ADA ABSROT END = 36.49838 / [deg] Abs rot angle at exp end",
                      KeywordType::Eso,
                      "HIERARCH",
                      "ADA ABSROT END");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword(
            "HIERARCH ESO DEL DLT2 VCM CURV = 0.001512604 / mm-1 actual curv. of VCM beam i",
            KeywordType::Eso,
            "HIERARCH",
            "DEL DLT2 VCM CURV");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword(
            "HIERARCH ESO DEL DLT2 VCM CURV=0.001512604 / mm-1 actual curv. of VCM beam i",
            KeywordType::Eso,
            "HIERARCH",
            "DEL DLT2 VCM CURV");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword("HIERARCH ESO N = 0.001512604 / mm-1 actual curv. of VCM beam i",
                      KeywordType::Eso,
                      "HIERARCH",
                      "N");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword("HIERARCH ESO N =0.001512604 / mm-1 actual curv. of VCM beam i",
                      KeywordType::Eso,
                      "HIERARCH",
                      "N");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword("HIERARCH ESO N= 0.001512604 / mm-1 actual curv. of VCM beam i",
                      KeywordType::Eso,
                      "HIERARCH",
                      "N");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword("HIERARCH ESO N=0.001512604 / mm-1 actual curv. of VCM beam i",
                      KeywordType::Eso,
                      "HIERARCH",
                      "N");
    }
}
 
TEST_F(TestLiteralKeyword, EsoKeywordStringParsing) {
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO KW VAL= '/path/to/somewhere'");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "KW VAL");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'/path/to/somewhere'");
        EXPECT_EQ(c.comment, "");
    }
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO FOO BAR='''escaped'");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "FOO BAR");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'''escaped'");
        EXPECT_EQ(c.comment, "");
    }
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO FOO BAR='/escaped'''");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "FOO BAR");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'/escaped'''");
        EXPECT_EQ(c.comment, "");
    }
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO FOO BAR='escaped''/string'/c");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "FOO BAR");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'escaped''/string'");
        EXPECT_EQ(c.comment, "c");
    }
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO FOO BAR='escaped''string' / with comment");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "FOO BAR");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'escaped''string'");
        EXPECT_EQ(c.comment, "with comment");
    }
    {
        SCOPED_TRACE("");
        LiteralKeyword kw("HIERARCH ESO FOO BAR='escaped''string'/with comment");
        EXPECT_EQ(kw.GetType(), KeywordType::Eso);
        auto [kw_name, kw_type] = kw.GetName();
        EXPECT_EQ(kw_name, "FOO BAR");
        auto c = kw.GetComponents();
        EXPECT_EQ(c.value, "'escaped''string'");
        EXPECT_EQ(c.comment, "with comment");
    }
}
 
TEST_F(TestLiteralKeyword, CommentaryKeywordTypes) {
    {
        SCOPED_TRACE("");
        ExpectKeyword("COMMENT Some comment here", KeywordType::Commentary, "COMMENT ", "COMMENT");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword("HISTORY Some comment here", KeywordType::Commentary, "HISTORY ", "HISTORY");
    }
    {
        SCOPED_TRACE("");
        ExpectKeyword(
            "HIERARCH DET.CAM.ID = 'TestCamera1Id' / System wide unique ID allocated to camer",
            KeywordType::Commentary,
            "HIERARCH ",
            "HIERARCH");
    }
    {
        SCOPED_TRACE("");
        // Invalid ESO HIERARCH keyword
        ExpectKeyword("HIERARCH ESOADA ABSROT END = 36.49838 / [deg] Abs rot angle at exp end",
                      KeywordType::Commentary,
                      "HIERARCH",
                      "HIERARCH");
    }
    {
        SCOPED_TRACE("");
        // Missing = disqualifies keyword to be an HIERARCH ESO keyword.
        ExpectKeyword("HIERARCH ESO ADA ABSROT END  36.49838 / [deg] Abs rot angle at exp end",
                      KeywordType::Commentary,
                      "HIERARCH",
                      "HIERARCH");
    }
}
 
TEST_F(TestLiteralKeyword, EqualityOperator) {
    auto kw1 = LiteralKeyword("HIERARCH ESO UNKN A = T / Comment");
    auto kw2 = LiteralKeyword("HIERARCH ESO UNKN B = T / Comment");
    auto kw2_copy = kw2;
    EXPECT_EQ(kw2, kw2_copy);
    EXPECT_NE(kw1, kw2);
    EXPECT_NE(KeywordVariant(kw1), KeywordVariant(kw2));
    EXPECT_EQ(KeywordVariant(kw2_copy), KeywordVariant(kw2));
}
 
TEST_F(TestLiteralKeyword, OstreamOperator) {
    // Setup
    using namespace ::testing;
    using namespace std::literals::string_view_literals;
 
    // Test
    {
        auto view = "HIERARCH ESO TEL MOON DEC = 22.00047 / [deg] 22:00:01.7 DEC (J2000)"sv;
        LiteralKeyword kw(view);
        std::stringstream ss;
        ss << kw;
        EXPECT_EQ(ss.str(), view);
    }
    {
        auto view = "COMMENT    "sv;
        LiteralKeyword kw(view);
        std::stringstream ss;
        ss << kw;
        EXPECT_EQ(ss.str(), "COMMENT"sv);
    }
}
/**
 * Note that test cases must use `TypeParam` and cannot declare templated aliases.
 */
template <typename Type>
class TestKeyword : public ::testing::Test {};
 
using Types = ::testing::Types<ValueKeyword, EsoKeyword>;
TYPED_TEST_CASE(TestKeyword, Types);
 
TYPED_TEST(TestKeyword, Construction) {
    using Keyword = TypeParam;
 
    Keyword orig("NAME", 1.0, "comment");
    EXPECT_EQ(orig.name, "NAME");
    EXPECT_EQ(orig.value, typename Keyword::ValueType(1.0));
    EXPECT_EQ(orig.comment, "comment");
 
    Keyword copy_assign;
    copy_assign = orig;
    EXPECT_EQ(orig, copy_assign);
 
    Keyword move_assign("TOBE", "replaced");
    move_assign = std::move(copy_assign);
    EXPECT_EQ(orig, move_assign);
 
    Keyword copy_construct(orig);
    EXPECT_EQ(orig, copy_construct);
 
    Keyword move_construct(std::move(copy_construct));
    EXPECT_EQ(orig, move_construct);
}
 
TYPED_TEST(TestKeyword, OptionalComment) {
    using Keyword = TypeParam;
 
    Keyword orig("NAME", 1.0, std::nullopt);
    EXPECT_EQ(orig.comment, std::nullopt);
}
 
/**
 * Test that construction of keyword from a C string is stored as std::string and not a bool,
 * which is the implicitly converted type for the variant construction otherwise.
 */
TYPED_TEST(TestKeyword, ConstructFromString) {
    using Keyword = TypeParam;
 
    Keyword kw("NAME", "str", "comment");
    ASSERT_TRUE(std::holds_alternative<std::string>(kw.value));
    EXPECT_EQ("str", std::get<std::string>(kw.value));
}
 
TYPED_TEST(TestKeyword, Equality) {
    using Keyword = TypeParam;
 
    Keyword lhs("NAME", 1.0, "comment");
    Keyword rhs("NAME", 1.0, "comment");
 
    EXPECT_TRUE(lhs == rhs);
    EXPECT_EQ(KeywordVariant(lhs), KeywordVariant(rhs));
    EXPECT_FALSE(lhs != rhs);
 
    rhs.comment = std::nullopt;
    EXPECT_NE(lhs, rhs);
 
    rhs.comment = "comment ";
    EXPECT_NE(lhs, rhs);
}
 
TYPED_TEST(TestKeyword, Ordering) {
    using Keyword = TypeParam;
 
    Keyword lhs("A", 1.0, "comment");
    Keyword rhs("B", 1.0, "comment");
 
    EXPECT_LT(lhs, rhs);
    EXPECT_FALSE(rhs < lhs);
    EXPECT_FALSE(lhs < lhs);
}
 
TYPED_TEST(TestKeyword, OstreamOperator) {
    using Keyword = TypeParam;
 
    // Setup
    using namespace ::testing;
 
    // Test
    {
        Keyword kw("NAME", std::string("value"), "comment");
        std::stringstream ss;
        ss << kw;
        EXPECT_EQ(ss.str(), "name='NAME', value=(str)'value', comment='comment'");
    }
    {
        Keyword kw("NAME", true, std::nullopt);
        std::stringstream ss;
        ss << kw;
        EXPECT_EQ(ss.str(), "name='NAME', value=(bool)true, comment=n/a");
    }
    {
        Keyword kw("NAME", 1234ul, std::nullopt);
        std::stringstream ss;
        ss << kw;
        EXPECT_THAT(ss.str(), "name='NAME', value=(uint64_t)1234, comment=n/a");
    }
    {
        Keyword kw("NAME", 1234l, std::nullopt);
        std::stringstream ss;
        ss << kw;
        EXPECT_THAT(ss.str(), "name='NAME', value=(int64_t)1234, comment=n/a");
    }
    {
        Keyword kw("NAME", 1.234, std::nullopt);
        std::stringstream ss;
        ss << kw;
        EXPECT_THAT(ss.str(), "name='NAME', value=(double)1.234, comment=n/a");
    }
}
 
TEST(TestKeywordCombinations, OperatorLessComparesKeywordName) {
    EsoKeyword eso_kw("A", "B");
    ValueKeyword value_kw("A", "B");
 
    LiteralKeyword literal_value_kw1("B1      = B");
    LiteralKeyword literal_value_kw2("B2      = B");
    ASSERT_EQ(KeywordType::Value, literal_value_kw1.GetType());
    ASSERT_EQ(KeywordType::Value, literal_value_kw2.GetType());
 
    LiteralKeyword literal_eso_kw1("HIERARCH ESO A1 = B");
    LiteralKeyword literal_eso_kw2("HIERARCH ESO A2 = B");
    ASSERT_EQ(KeywordType::Eso, literal_eso_kw1.GetType());
    ASSERT_EQ(KeywordType::Eso, literal_eso_kw2.GetType());
 
    LiteralKeyword literal_commentary_kw1("COMMENT  A");
    LiteralKeyword literal_commentary_kw2("HIERARCH B");
    ASSERT_EQ(KeywordType::Commentary, literal_commentary_kw1.GetType());
    ASSERT_EQ(KeywordType::Commentary, literal_commentary_kw2.GetType());
 
    EXPECT_FALSE(value_kw < eso_kw);
    EXPECT_LT(KeywordVariant(value_kw), KeywordVariant(eso_kw));
    EXPECT_LT(literal_value_kw1, literal_value_kw2);
    EXPECT_FALSE(literal_value_kw1 < literal_eso_kw1);
    EXPECT_FALSE(literal_value_kw1 < literal_eso_kw2);
    EXPECT_LT(literal_eso_kw1, literal_eso_kw2);
 
    EXPECT_LT(value_kw, literal_commentary_kw1);
    EXPECT_LT(eso_kw, literal_commentary_kw1);
    EXPECT_LT(literal_value_kw1, literal_commentary_kw1);
    EXPECT_LT(literal_eso_kw1, literal_commentary_kw1);
    EXPECT_LT(literal_commentary_kw1, literal_commentary_kw2);
 
    EXPECT_FALSE(literal_eso_kw1 < eso_kw);
    EXPECT_FALSE(value_kw < value_kw);
    EXPECT_FALSE(eso_kw < eso_kw);
    EXPECT_FALSE(eso_kw < value_kw);
    EXPECT_FALSE(literal_eso_kw1 < value_kw);
    EXPECT_FALSE(literal_commentary_kw1 < literal_commentary_kw1);
    EXPECT_FALSE(literal_commentary_kw2 < literal_commentary_kw1);
    EXPECT_FALSE(KeywordVariant(eso_kw) < KeywordVariant(value_kw));
}
 
TEST(TestKeywordCombinations, NameEquals) {
    EsoKeyword eso_kw("A", "B");
    ValueKeyword value_kw("A", "B");
    LiteralKeyword literal_value_kw1("A       = B");
    ASSERT_EQ(literal_value_kw1.GetName().name, "A");
 
    LiteralKeyword literal_eso_kw1("HIERARCH ESO A = B");
    ASSERT_EQ(literal_eso_kw1.GetName().name, "A");
    LiteralKeyword literal_commentary_kw1("COMMENT  A");
    LiteralKeyword literal_commentary_kw2("COMMENT  B");
 
    auto view = GetKeywordName(eso_kw);
    EXPECT_EQ(view, eso_kw.GetName());
 
    EXPECT_FALSE(NameEquals(value_kw, eso_kw));
    EXPECT_FALSE(NameEquals(eso_kw, value_kw));
 
    EXPECT_NE(literal_value_kw1.GetName(), literal_eso_kw1.GetName());
    EXPECT_NE(literal_value_kw1.GetName(), literal_commentary_kw1.GetName());
    EXPECT_EQ(eso_kw.GetName(), literal_eso_kw1.GetName());
    EXPECT_EQ(literal_value_kw1.GetName(), value_kw.GetName());
    EXPECT_EQ(literal_commentary_kw1.GetName(), literal_commentary_kw2.GetName());
 
    EXPECT_TRUE(NameEquals(value_kw, ValueKeyword("A", "NOT B")));
    EXPECT_TRUE(NameEquals(eso_kw, EsoKeyword("A", "NOT B")));
    EXPECT_TRUE(NameEquals(value_kw, literal_value_kw1));
    EXPECT_TRUE(NameEquals(eso_kw, literal_eso_kw1));
    EXPECT_FALSE(NameEquals(eso_kw, literal_value_kw1));
    EXPECT_FALSE(NameEquals(value_kw, eso_kw));
}
 
TEST(KeywordVector, UpdateKeywords) {
    using namespace daq::fits;
    using namespace ::testing;
    // Setup
 
    // Initial values to be updated
    KeywordVector to{
        EsoKeyword("A", "A1-orig"),
        ValueKeyword("A", "A2-orig"),
        ValueKeyword("B", static_cast<uint64_t>(1u)),
        EsoKeyword("B", "B"),
        LiteralKeyword("C       = 'orig'                /"),
        LiteralKeyword("HIERARCH ESO C = 'orig'                /"),
        LiteralKeyword("D       = 'orig'                /"),
        LiteralKeyword("HIERARCH ESO D = 'orig'                /"),
        LiteralKeyword("E       = 'orig'                /"),
        LiteralKeyword("HIERARCH ESO E = 'orig'                /"),
    };
 
    // Overwrite the A, C & D keywords and insert the Z keywords
    KeywordVector from{
        EsoKeyword("A", "A1-updated"),
        ValueKeyword("A", "A2-updated"),
        ValueKeyword("C", "C-updated"),
        EsoKeyword("C", "C-updated"),
        LiteralKeyword("D       = 'updated'                /"),
        LiteralKeyword("HIERARCH ESO D = 'updated'                /"),
        ValueKeyword("Z", "Z"),
        EsoKeyword("Z", true),
    };
 
    KeywordVector result{
        EsoKeyword("A", "A1-updated"),
        ValueKeyword("A", "A2-updated"),
        ValueKeyword("B", static_cast<uint64_t>(1u)),
        EsoKeyword("B", "B"),
        ValueKeyword("C", "C-updated"),
        EsoKeyword("C", "C-updated"),
        LiteralKeyword("D       = 'updated'                /"),
        LiteralKeyword("HIERARCH ESO D = 'updated'                /"),
        LiteralKeyword("E       = 'orig'                /"),
        LiteralKeyword("HIERARCH ESO E = 'orig'                /"),
        ValueKeyword("Z", "Z"),
        EsoKeyword("Z", true),
    };
    // Run
    UpdateKeywords(to, from);
    EXPECT_THAT(to, ContainerEq(result));
}
 
TEST(KeywordVector, InsertKeywordsEnd) {
    using namespace daq::fits;
    using namespace ::testing;
    // Setup
 
    // Initial values to be updated
    KeywordVector to{
        EsoKeyword("A", "A1-orig"),
        ValueKeyword("A", "A2-orig"),
        ValueKeyword("B", static_cast<uint64_t>(1u)),
        EsoKeyword("B", "B")
        // << INSERT POSITION
    };
 
    // Overwrite the A keywords and insert the C keywords
    KeywordVector from{EsoKeyword("A", "A1-updated"),
                       ValueKeyword("A", "A2-updated"),
                       ValueKeyword("C", "C"),
                       EsoKeyword("C", true)};
 
    KeywordVector result{ValueKeyword("B", static_cast<uint64_t>(1u)),
                         EsoKeyword("B", "B"),
                         EsoKeyword("A", "A1-updated"),
                         ValueKeyword("A", "A2-updated"),
                         ValueKeyword("C", "C"),
                         EsoKeyword("C", true)
 
    };
    // Run
    InsertKeywords(to, to.end(), from.begin(), from.end());
    EXPECT_THAT(to, ContainerEq(result));
}
 
TEST(KeywordVector, InsertKeywordsBegin) {
    using namespace daq::fits;
    using namespace ::testing;
    // Setup
 
    // Initial values to be updated
    KeywordVector to{// << INSERT POSITION
                     EsoKeyword("A", "A1-orig"),
                     ValueKeyword("A", "A2-orig"),
                     ValueKeyword("B", static_cast<uint64_t>(1u)),
                     EsoKeyword("B", "B")};
 
    // Overwrite the A keywords and insert the C keywords
    KeywordVector from{EsoKeyword("A", "A1-updated"),
                       ValueKeyword("A", "A2-updated"),
                       ValueKeyword("C", "C"),
                       EsoKeyword("C", true)};
 
    KeywordVector result{EsoKeyword("A", "A1-updated"),
                         ValueKeyword("A", "A2-updated"),
                         ValueKeyword("C", "C"),
                         EsoKeyword("C", true),
                         ValueKeyword("B", static_cast<uint64_t>(1u)),
                         EsoKeyword("B", "B")
 
    };
    // Run
    InsertKeywords(to, to.begin(), from.begin(), from.end());
    EXPECT_THAT(to, ContainerEq(result));
}
 
TEST(KeywordVector, InsertKeywordsMiddle) {
    using namespace daq::fits;
    using namespace ::testing;
    // Setup
 
    // Initial values to be updated
    KeywordVector to{EsoKeyword("A", "A1-orig"),
                     ValueKeyword("A", "A2-orig"),
                     ValueKeyword("B", static_cast<uint64_t>(1u)),
                     // << INSERT POSITION
                     EsoKeyword("B", "B")};
 
    // Overwrite the A keywords and insert the C keywords
    KeywordVector from{EsoKeyword("A", "A1-updated"),
                       ValueKeyword("A", "A2-updated"),
                       ValueKeyword("C", "C"),
                       EsoKeyword("C", true)};
 
    KeywordVector result{ValueKeyword("B", static_cast<uint64_t>(1u)),
                         EsoKeyword("A", "A1-updated"),
                         ValueKeyword("A", "A2-updated"),
                         ValueKeyword("C", "C"),
                         EsoKeyword("C", true),
                         EsoKeyword("B", "B")
 
    };
 
    // Run
    auto pos = to.begin();
    std::advance(pos, 3);
    InsertKeywords(to, pos, from.begin(), from.end());
    EXPECT_THAT(to, ContainerEq(result));
}
 
TEST(TestFormatting, StandardKeywordFormatter) {
    StandardKeywordFormatter fmt;
 
    {
        auto kw = ValueKeyword("DATE-OBS", "2019-12-12T04:25:48.0068", "Observing date");
        EXPECT_EQ(Format(kw), fmt.Format(kw));
    }
    {
        auto kw =
            LiteralKeyword("DATE    = '2019-12-12T04:30:53.8930' / Date the file was written");
        EXPECT_EQ(Format(kw), fmt.Format(kw));
    }
    {
        auto kw = EsoKeyword("ADA ABSROT END", 36.5, "[deg] Abs rot angle at exp end");
        EXPECT_EQ(Format(kw), fmt.Format(kw));
    }
}
 
TEST(TestFormatting, ValueKeyword) {
    EXPECT_EQ(LiteralKeyword("DATE-OBS= '2019-12-12T04:25:48.0068' / Observing date"),
              Format(ValueKeyword("DATE-OBS", "2019-12-12T04:25:48.0068", "Observing date")));
    EXPECT_EQ(
        LiteralKeyword("DATE    = '2019-12-12T04:30:53.8930' / Date the file was written"),
        Format(ValueKeyword("DATE", "2019-12-12T04:30:53.8930", "Date the file was written")));
    EXPECT_EQ(LiteralKeyword("EQUINOX =               2000.0 / Standard FK5"),
              Format(ValueKeyword("EQUINOX ", 2000.0, "Standard FK5")));
    EXPECT_EQ(LiteralKeyword("EXTEND  =                    T / FITS Extension may be present"),
              Format(ValueKeyword("EXTEND", true, "FITS Extension may be present")));
    EXPECT_EQ(LiteralKeyword("ORIGIN  = 'ESO-PARANAL'        / European Southern Observatory"),
              Format(ValueKeyword("ORIGIN", "ESO-PARANAL", "European Southern Observatory")));
    EXPECT_EQ(
        LiteralKeyword("INHERIT =                    F / denotes the INHERIT keyword convention"),
        Format(ValueKeyword("INHERIT", false, "denotes the INHERIT keyword convention")));
 
    EXPECT_EQ(LiteralKeyword("XTENSION= 'IMAGE   '           / Image extension"),
              Format(ValueKeyword("XTENSION", "IMAGE", "Image extension")))
        << "XTENSION has an exception and must be padded to be minimum 8 chars for legacy reasons";
    EXPECT_EQ(LiteralKeyword("XTENSION= 'CUSTOM-EXTENSION-TYPE' / Image extension"),
              Format(ValueKeyword("XTENSION", "CUSTOM-EXTENSION-TYPE", "Image extension")))
        << "XTENSION has an exception and must be padded to be minimum 8 chars for legacy reasons";
}
 
TEST(TestFormatting, EsoKeyword) {
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO ADA ABSROT END = 36.5 / [deg] Abs rot angle at exp end"),
              Format(EsoKeyword("ADA ABSROT END", 36.5, "[deg] Abs rot angle at exp end")));
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO ADA ABSROT PPOS = 'POS' / sign of probe position"),
              Format(EsoKeyword("ADA ABSROT PPOS", "POS", "sign of probe position")));
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO DET ACQ1 REV = 1 / Pre-processor framework revision"),
              Format(EsoKeyword("DET ACQ1 REV", 1lu, "Pre-processor framework revision")));
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO DET ADC1 CLAMP = F / Clamp-and-Sample"),
              Format(EsoKeyword("DET ADC1 CLAMP", false, "Clamp-and-Sample")));
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO DET CLDC1 DCNM16 = 'DC16_RelaySwitchLowActive' / Name of bias volta"),
        Format(
            EsoKeyword("DET CLDC1 DCNM16", "DC16_RelaySwitchLowActive", "Name of bias voltage")));
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO PCR SUMMARY NSCANNED = 1273000 / Total Number of scanned records."),
        Format(EsoKeyword("PCR SUMMARY NSCANNED", 1273000ul, "Total Number of scanned records.")));
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO INS TIM2 START = '2019-07-27T02:46:45.00' / Start UTC time in ISO f"),
        Format(EsoKeyword("INS TIM2 START", "2019-07-27T02:46:45.00", "Start UTC time in ISO f")));
}
 
TEST(TestFormatting, LiteralKeyword) {
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH DET.CAM.ID = 'TestCamera1Id' / System wide unique ID allocated to camer"),
        Format(LiteralKeyword(
            "HIERARCH DET.CAM.ID = 'TestCamera1Id' / System wide unique ID allocated to camer")));
 
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO DET DID= '/home_local/eltdev/BUILDS/ifw-templates/test/temp/micado'"),
        Format(LiteralKeyword(
            "HIERARCH ESO DET DID= '/home_local/eltdev/BUILDS/ifw-templates/test/temp/micado'")));
 
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONX= T"),
        Format(
            EsoKeyword("LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONX", true)));
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG= 'LONG LONG LONG LONG LONG LONX'"),
        Format(EsoKeyword(
            "LONG LONG LONG LONG LONG LONG LONG", "LONG LONG LONG LONG LONG LONX", "comment")));
    EXPECT_EQ(
        LiteralKeyword(
            "HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG = 'LONG LONG LONG LONG LON' / te"),
        Format(EsoKeyword(
            "LONG LONG LONG LONG LONG LONG LONG", "LONG LONG LONG LONG LON", "test")));
}
 
TEST(TestFormatting, TooLongKeywords) {
    // First test the longest possible ESO keyword while still formatting with padded value
    // indicator ' = '.
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG "
                             "LONG LON = T"),
              Format(EsoKeyword("LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LON",
                                true)));
    // And packed `= ` value indicator
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG "
                             "LONG LONG= T"),
              Format(EsoKeyword("LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG",
                                true)));
    EXPECT_THROW(
        LiteralKeyword("HIERARCH ESO LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG "
                       "LONG LONX = T"),
        std::invalid_argument);
    EXPECT_THROW(Format(EsoKeyword(
                     "LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONXX", true)),
                 std::invalid_argument);
    EXPECT_THROW(
        Format(EsoKeyword("LONG LONG LONG LONG LONG LONG LONG", "LONG LONG LONG LONG LONG LONXX")),
        std::invalid_argument);
}
 
TEST(TestFormatting, KeywordVariant) {
    EXPECT_EQ(LiteralKeyword("ORIGIN  = 'ESO-PARANAL'        / European Southern Observatory"),
              Format(KeywordVariant(
                  ValueKeyword("ORIGIN", "ESO-PARANAL", "European Southern Observatory"))));
    EXPECT_EQ(LiteralKeyword("HIERARCH ESO ADA ABSROT END = 36.5 / [deg] Abs rot angle at exp end"),
              Format(KeywordVariant(
                  EsoKeyword("ADA ABSROT END", 36.5, "[deg] Abs rot angle at exp end"))));
 
    auto kw = LiteralKeyword("HIERARCH ESO ADA ABSROT END = 36.5 / [deg] Abs rot angle at exp end");
    EXPECT_EQ(kw, Format(KeywordVariant(kw)));
}
 
TEST(TestStandardSortV1, StableSortsValueKeywords) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("SIMPLE  =                T / Standard FITS");
    kws.emplace_back("BITPIX  =                8 / # of bits per pix value");
    kws.emplace_back("NAXIS   =                0 / # of axes in data array");
 
    // Test
    v1::StandardSort(kws);
    EXPECT_THAT(kws,
                ElementsAre(IsKeyword("SIMPLE", KeywordType::Value),
                            IsKeyword("BITPIX", KeywordType::Value),
                            IsKeyword("NAXIS", KeywordType::Value)));
}
 
TEST(TestStandardSortV1, StableSortsByKeywordType) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("COMMENT First");
    kws.emplace_back("SIMPLE  =                T / Standard FITS");
    kws.emplace_back("HIERARCH ESO KW = T / Comment");
    kws.emplace_back("HIERARCH ESO DET A = T / Comment");
    kws.emplace_back("COMMENT Second");
    kws.emplace_back("BITPIX  =                8 / # of bits per pix value");
 
    // Test
    auto sorted = kws;
    v1::StandardSort(sorted);
    EXPECT_THAT(sorted,
                ElementsAre(IsKeyword("SIMPLE", KeywordType::Value),
                            IsKeyword("BITPIX", KeywordType::Value),
                            IsKeyword("DET A", KeywordType::Eso),
                            IsKeyword("KW", KeywordType::Eso),
                            kws[0],
                            kws[4]));
}
 
TEST(TestStandardSortV1, EsoKeywordsAreSortedByCategory) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("HIERARCH ESO DPR A = T / Comment");
    kws.emplace_back("HIERARCH ESO DPR B = T / Comment");
    kws.emplace_back("HIERARCH ESO DPR1 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DPR2 A = T / Comment");
    kws.emplace_back("HIERARCH ESO OBS A = T / Comment");
    kws.emplace_back("HIERARCH ESO OBS B = T / Comment");
    kws.emplace_back("HIERARCH ESO TPL A = T / Comment");
    kws.emplace_back("HIERARCH ESO TPL B = T / Comment");
    kws.emplace_back("HIERARCH ESO GEN A = T / Comment");
    kws.emplace_back("HIERARCH ESO GEN B = T / Comment");
    kws.emplace_back("HIERARCH ESO TEL A = T / Comment");
    kws.emplace_back("HIERARCH ESO TEL B = T / Comment");
    kws.emplace_back("HIERARCH ESO ADA A = T / Comment");
    kws.emplace_back("HIERARCH ESO ADA B = T / Comment");
    kws.emplace_back("HIERARCH ESO INS A = T / Comment");
    kws.emplace_back("HIERARCH ESO INS B = T / Comment");
    kws.emplace_back("HIERARCH ESO DET A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET B = T / Comment");
    kws.emplace_back("HIERARCH ESO DET1 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET2 B = T / Comment");
    kws.emplace_back("HIERARCH ESO DET3 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET3 B = T / Comment");
    kws.emplace_back("HIERARCH ESO DPRUN A = T / Comment");
    kws.emplace_back("HIERARCH ESO UNK A = T / Comment");
    kws.emplace_back("HIERARCH ESO UNK B = T / Comment");
 
    auto [name, type] = kws[0].GetName();
    ASSERT_EQ(name, "DPR A"sv);
    ASSERT_EQ(type, KeywordType::Eso);
 
    std::random_device rd;
    std::mt19937 g(rd());
    // Test
    for (auto i = 0u; i < 20u; ++i) {
        auto to_sort_kws = kws;
        std::shuffle(std::begin(to_sort_kws), std::end(to_sort_kws), g);
        v1::StandardSort(to_sort_kws);
        ASSERT_THAT(to_sort_kws, ContainerEq(kws));
        // Sorting again shouldn't do anything
        v1::StandardSort(to_sort_kws);
        EXPECT_THAT(to_sort_kws, ContainerEq(kws));
    }
}
 
TEST(TestStandardSortV1, EsoKeywordsAreSortedByNumberedCategory) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("HIERARCH ESO DPR Z = T / Comment");
    kws.emplace_back("HIERARCH ESO DPR1 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DPR2 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET ZZ ZZ = T / Comment");
    kws.emplace_back("HIERARCH ESO DET1 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET2 B = T / Comment");
    kws.emplace_back("HIERARCH ESO DET3 A = T / Comment");
    kws.emplace_back("HIERARCH ESO DET3 B = T / Comment");
 
    std::random_device rd;
    std::mt19937 g(rd());
    // Test
    for (auto i = 0u; i < 20u; ++i) {
        auto to_sort_kws = kws;
        std::shuffle(std::begin(to_sort_kws), std::end(to_sort_kws), g);
        v1::StandardSort(to_sort_kws);
        ASSERT_THAT(to_sort_kws, ContainerEq(kws));
        // Sorting again shouldn't do anything
        v1::StandardSort(to_sort_kws);
        EXPECT_THAT(to_sort_kws, ContainerEq(kws));
    }
}
 
TEST(TestStandardSortV1, EsoKeywordAreSortedEvenIfCloslyMatched) {
    using namespace testing;
    // Setup
    auto dpr = LiteralKeyword("HIERARCH ESO DPR=T");
    auto det1 = LiteralKeyword("HIERARCH ESO DET1 A=T");
    auto deta = LiteralKeyword("HIERARCH ESO DETA=Z/D");
    EXPECT_TRUE(v1::StandardLess()(dpr, det1));
    EXPECT_FALSE(v1::StandardLess()(det1, dpr));
 
    EXPECT_TRUE(v1::StandardLess()(dpr, deta));
    EXPECT_FALSE(v1::StandardLess()(deta, dpr));
 
    EXPECT_TRUE(v1::StandardLess()(det1, deta));
    EXPECT_FALSE(v1::StandardLess()(deta, det1));
}
 
TEST(TestStandardSortV1, EsoKeywordAreSortedEvenIfStrange) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("HIERARCH ESO A=T");
    kws.emplace_back("HIERARCH ESO D=T");
    kws.emplace_back("HIERARCH ESO D C=T/D");
    kws.emplace_back("HIERARCH ESO E1=T");
    kws.emplace_back("HIERARCH ESO E2 C=T/D");
    kws.emplace_back("HIERARCH ESO F1A1=T");
    kws.emplace_back("HIERARCH ESO F1A2 C=T/D");
 
    std::random_device rd;
    std::mt19937 g(rd());
    // Test
    for (auto i = 0u; i < 20u; ++i) {
        auto to_sort_kws = kws;
        std::shuffle(std::begin(to_sort_kws), std::end(to_sort_kws), g);
        v1::StandardSort(to_sort_kws);
        EXPECT_THAT(to_sort_kws, ContainerEq(kws));
    }
}
 
TEST(TestStandardSortV1, CommentsSortedByName) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("COMMENT XXX");
    kws.emplace_back("COMMENT AAA");
    kws.emplace_back("HISTORY XXX");
    kws.emplace_back("HISTORY AAA");
 
    std::vector<LiteralKeyword> unordered;
    unordered.emplace_back("HISTORY XXX");
    unordered.emplace_back("COMMENT XXX");
    unordered.emplace_back("HISTORY AAA");
    unordered.emplace_back("COMMENT AAA");
 
    // Test
    v1::StandardSort(unordered);
    EXPECT_THAT(unordered, ContainerEq(kws));
}
 
TEST(TestStandardSortV1, EsoKeywordsAreSortedAlphabetically) {
    using namespace testing;
    // Setup
    std::vector<LiteralKeyword> kws;
    kws.emplace_back("HIERARCH ESO KWB = T / Comment");
    kws.emplace_back("HIERARCH ESO KWA = T / Comment");
    kws.emplace_back("HIERARCH ESO KWA A = T / Comment");
    kws.emplace_back("HIERARCH ESO KWA1 A = T / Comment");
 
    // Test
    v1::StandardSort(kws);
    EXPECT_THAT(kws,
                ElementsAre(IsKeyword("KWA", KeywordType::Eso),
                            IsKeyword("KWA A", KeywordType::Eso),
                            IsKeyword("KWA1 A", KeywordType::Eso),
                            IsKeyword("KWB", KeywordType::Eso)));
}