testKeyword.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_fits_test
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Unit tests for json handling.
 */
 
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <nlohmann/json.hpp>
#include <ostream>
 
#include <daq/fits/json.hpp>
 
using namespace daq::fits;
 
/**
 * 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_FALSE(lhs != rhs);
 
    rhs.comment = std::nullopt;
    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, Ordering) {
    EsoKeyword eso_kw("A", "B");
    ValueKeyword value_kw("A", "B");
 
    EXPECT_LT(value_kw, eso_kw);
    EXPECT_LT(KeywordVariant(value_kw), KeywordVariant(eso_kw));
 
    EXPECT_FALSE(eso_kw < value_kw);
    EXPECT_FALSE(KeywordVariant(eso_kw) < KeywordVariant(value_kw));
}
 
TEST(TestKeywordCombinations, NameEquals) {
    EsoKeyword eso_kw("A", "B");
    ValueKeyword value_kw("A", "B");
 
    EXPECT_FALSE(NameEquals(value_kw, eso_kw));
    EXPECT_FALSE(NameEquals(eso_kw, value_kw));
 
    EXPECT_TRUE(NameEquals(value_kw, ValueKeyword("A", "NOT B")));
    EXPECT_TRUE(NameEquals(eso_kw, EsoKeyword("A", "NOT B")));
}
 
 
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")};
 
    // 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("B", static_cast<uint64_t>(1u)),
                         EsoKeyword("B", "B"),
                         ValueKeyword("C", "C"),
                         EsoKeyword("C", true)};
    // Run
    UpdateKeywords(to, from);
    EXPECT_THAT(to, ContainerEq(result));
}