TestTimestamp.cc

Go to the documentation of this file.

 
#include "utility/TimeStamp.hh"
 
#include <gtest/gtest.h>
 
using namespace crl::multisense::details::utility;
 
TEST(Construction, default_)
{
    const TimeStamp a;
 
    EXPECT_EQ(a.getSeconds(), 0);
    EXPECT_EQ(a.getMicroSeconds(), 0);
}
 
TEST(Construction, second_microsecond)
{
    for (volatile int32_t sec = -1000000; sec <= 1000000; sec += 100000)
    {
        for (volatile int32_t usec = -1000000; usec <= 1100000; usec += 10000)
        {
            const TimeStamp time(sec, usec);
 
            EXPECT_EQ(time.getSeconds() * 1000000 + time.getMicroSeconds(),
                      sec * 1000000 + usec);
 
            if (usec >= 0 && usec < 1000000)
            {
                EXPECT_EQ(time.getSeconds(), sec);
                EXPECT_EQ(time.getMicroSeconds(), usec);
            }
        }
    }
}
 
TEST(Construction, timeval)
{
    for (volatile int32_t sec = -1000000; sec <= 1000000; sec += 100000)
    {
        for (volatile int32_t usec = -1000000; usec <= 1100000; usec += 10000)
        {
            struct timeval tv;
            tv.tv_sec = sec;
            tv.tv_usec = usec;
 
            const TimeStamp time(tv);
 
            EXPECT_EQ(time.getSeconds() * 1000000 + time.getMicroSeconds(),
                      sec * 1000000 + usec);
 
            if (usec >= 0 && usec < 1000000)
            {
                EXPECT_EQ(time.getSeconds(), sec);
                EXPECT_EQ(time.getMicroSeconds(), usec);
            }
        }
    }
}
 
TEST(Construction, nanoseconds)
{
    // numbers are large enough to check for rollover of int32_t when convering seconds to nanoseconds
    for (volatile int64_t sec = -1000000; sec <= 1000000; sec += 100000)
    {
        for (volatile int64_t usec = -1000000; usec <= 1100000; usec += 10000)
        {
            const int64_t nsec = sec * 1000000000 + usec * 1000;
 
            const TimeStamp time(nsec);
 
            EXPECT_EQ(static_cast<int64_t>(time.getSeconds()) * 1000000 + time.getMicroSeconds(),
                      sec * 1000000 + usec);
 
            if (usec >= 0 && usec < 1000000)
            {
                EXPECT_EQ(time.getSeconds(), sec);
                EXPECT_EQ(time.getMicroSeconds(), usec);
            }
        }
    }
}
 
// set() functions have been implicitly tested via constructors
 
TEST(GetNanoSeconds, getNanoSeconds)
{
    // handle values larger than a uint32_t (2,147,483,647) to check rollover
    // increment by 0.1 seconds
    //
    for (volatile int64_t nsec = -100000000000; nsec <= 100000000000; nsec += 100000000)
    {
        const TimeStamp time(nsec);
        EXPECT_EQ(time.getNanoSeconds(), nsec);
    }
}
 
TEST(Operators, add)
{
    // handle nsec values larger than a uint32_t (2,147,483,647) to check rollover
    // increment by 0.1 seconds
    const int64_t max_nsec = 10000000000;
    const int64_t step_nsec = 100000000;
    for (volatile int64_t a_nsec = -max_nsec; a_nsec <= max_nsec; a_nsec += step_nsec)
    {
        for (volatile int64_t b_nsec = -max_nsec; b_nsec <= max_nsec; b_nsec += step_nsec)
        {
            const TimeStamp a(a_nsec);
            const TimeStamp b(b_nsec);
 
            EXPECT_EQ((a + b).getNanoSeconds(), a_nsec + b_nsec);
        }
    }
}
 
TEST(Operators, subtract)
{
    // handle nsec values larger than a uint32_t (2,147,483,647) to check rollover
    // increment by 0.1 seconds
    const int64_t max_nsec = 10000000000;
    const int64_t step_nsec = 100000000;
    for (volatile int64_t a_nsec = -max_nsec; a_nsec <= max_nsec; a_nsec += step_nsec)
    {
        for (volatile int64_t b_nsec = -max_nsec; b_nsec <= max_nsec; b_nsec += step_nsec)
        {
            const TimeStamp a(a_nsec);
            const TimeStamp b(b_nsec);
 
            EXPECT_EQ((a - b).getNanoSeconds(), a_nsec - b_nsec);
        }
    }
}