testConversion.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_daqifsupport
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief daqif:: conversion helper test
 */
#include <gtest/gtest.h>
 
#include <daq/conversion.hpp>
#include <daq/state.hpp>
#include <daq/status.hpp>
 
using namespace ::testing;
 
TEST(Conversion, MakeOcmIfSubState) {
    using daqif::FullState;
    using daqif::operator==;
    EXPECT_EQ(daq::MakeState(daq::State::NotStarted),
              FullState({daqif::StateAcquiring, daqif::NotStarted}));
    EXPECT_EQ(daq::MakeState(daq::State::Acquiring),
              FullState({daqif::StateAcquiring, daqif::Acquiring}));
    EXPECT_EQ(daq::MakeState(daq::State::Stopping),
              FullState({daqif::StateAcquiring, daqif::Stopping}));
    EXPECT_EQ(daq::MakeState(daq::State::Stopped),
              FullState({daqif::StateAcquiring, daqif::Stopped}));
    EXPECT_EQ(daq::MakeState(daq::State::AbortingAcquiring),
              FullState({daqif::StateAcquiring, daqif::Aborting}));
 
    EXPECT_EQ(daq::MakeState(daq::State::NotScheduled),
              FullState({daqif::StateMerging, daqif::NotScheduled}));
    EXPECT_EQ(daq::MakeState(daq::State::Scheduled),
              FullState({daqif::StateMerging, daqif::Scheduled}));
    EXPECT_EQ(daq::MakeState(daq::State::Collecting),
              FullState({daqif::StateMerging, daqif::Collecting}));
    EXPECT_EQ(daq::MakeState(daq::State::Merging),
              FullState({daqif::StateMerging, daqif::Merging}));
    EXPECT_EQ(daq::MakeState(daq::State::Releasing),
              FullState({daqif::StateMerging, daqif::Releasing}));
    EXPECT_EQ(daq::MakeState(daq::State::AbortingMerging),
              FullState({daqif::StateMerging, daqif::Aborting}));
 
    EXPECT_EQ(daq::MakeState(daq::State::Completed),
              FullState({daqif::StateCompleted, daqif::Completed}));
    EXPECT_EQ(daq::MakeState(daq::State::Aborted),
              FullState({daqif::StateCompleted, daqif::Aborted}));
}
 
TEST(Conversion, MakeDaqState) {
    EXPECT_EQ(daq::MakeState({daqif::StateAcquiring, daqif::NotStarted}), daq::State::NotStarted);
    EXPECT_EQ(daq::MakeState({daqif::StateAcquiring, daqif::Acquiring}), daq::State::Acquiring);
    EXPECT_EQ(daq::MakeState({daqif::StateAcquiring, daqif::Stopping}), daq::State::Stopping);
    EXPECT_EQ(daq::MakeState({daqif::StateAcquiring, daqif::Stopped}), daq::State::Stopped);
    EXPECT_EQ(daq::MakeState({daqif::StateAcquiring, daqif::Aborting}),
              daq::State::AbortingAcquiring);
 
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::NotScheduled}), daq::State::NotScheduled);
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::Scheduled}), daq::State::Scheduled);
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::Collecting}), daq::State::Collecting);
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::Merging}), daq::State::Merging);
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::Releasing}), daq::State::Releasing);
    EXPECT_EQ(daq::MakeState({daqif::StateMerging, daqif::Aborting}), daq::State::AbortingMerging);
 
    EXPECT_EQ(daq::MakeState({daqif::StateCompleted, daqif::Completed}), daq::State::Completed);
    EXPECT_EQ(daq::MakeState({daqif::StateCompleted, daqif::Aborted}), daq::State::Aborted);
}
 
TEST(Conversion, TimestampResolutionIsAtLeastMicrosecond) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    auto now_tp1 = daq::Status::Clock::now();
    double now_d1 = std::chrono::time_point_cast<Seconds>(now_tp1).time_since_epoch().count();
 
    auto now_tp2 = now_tp1 + std::chrono::microseconds(1);
    double now_d2 = std::chrono::time_point_cast<Seconds>(now_tp2).time_since_epoch().count();
 
    EXPECT_GT(now_d2, now_d1);
    EXPECT_GT(now_tp2, now_tp1);
}