Yes, I forgot to remove this file from the patch after splitting up the contents into several smaller files. Will remove it before pushing.
/ Anders Widell On 12/15/2015 10:16 AM, Hans Nordebäck wrote: > ack, one minor comment, it seems the file osaf_time_test.cc is not > needed./Thanks HansN. > > > On 12/10/2015 11:38 AM, Anders Widell wrote: >> configure.ac | 1 + >> osaf/libs/core/common/Makefile.am | 2 +- >> osaf/libs/core/common/tests/Makefile.am | 51 + >> osaf/libs/core/common/tests/mock_clock_gettime.cc | 45 + >> osaf/libs/core/common/tests/mock_clock_gettime.h | 33 + >> osaf/libs/core/common/tests/mock_clock_nanosleep.cc | 66 ++ >> osaf/libs/core/common/tests/mock_clock_nanosleep.h | 33 + >> osaf/libs/core/common/tests/mock_syslog.cc | 23 + >> osaf/libs/core/common/tests/mock_syslog.h | 23 + >> osaf/libs/core/common/tests/osaf_clock_gettime_test.cc | 73 ++ >> osaf/libs/core/common/tests/osaf_nanosleep_test.cc | 81 ++ >> osaf/libs/core/common/tests/osaf_normalize_timespec_test.cc | 81 ++ >> osaf/libs/core/common/tests/osaf_time_test.cc | 390 >> ++++++++++++ >> osaf/libs/core/common/tests/osaf_timespec_add_test.cc | 62 + >> osaf/libs/core/common/tests/osaf_timespec_compare_test.cc | 75 ++ >> osaf/libs/core/common/tests/osaf_timespec_convert_test.cc | 100 +++ >> osaf/libs/core/common/tests/osaf_timespec_subtract_test.cc | 62 + >> 17 files changed, 1200 insertions(+), 1 deletions(-) >> >> >> diff --git a/configure.ac b/configure.ac >> --- a/configure.ac >> +++ b/configure.ac >> @@ -705,6 +705,7 @@ AC_CONFIG_FILES([ >> osaf/libs/core/include/Makefile >> osaf/libs/core/common/Makefile >> osaf/libs/core/common/include/Makefile >> + osaf/libs/core/common/tests/Makefile >> osaf/libs/core/leap/Makefile >> osaf/libs/core/leap/include/Makefile >> osaf/libs/core/mbcsv/Makefile >> diff --git a/osaf/libs/core/common/Makefile.am >> b/osaf/libs/core/common/Makefile.am >> --- a/osaf/libs/core/common/Makefile.am >> +++ b/osaf/libs/core/common/Makefile.am >> @@ -18,7 +18,7 @@ include $(top_srcdir)/Makefile.common >> MAINTAINERCLEANFILES = Makefile.in >> -SUBDIRS = include >> +SUBDIRS = include tests >> noinst_LTLIBRARIES = libopensaf_common.la >> diff --git a/osaf/libs/core/common/tests/Makefile.am >> b/osaf/libs/core/common/tests/Makefile.am >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/Makefile.am >> @@ -0,0 +1,51 @@ >> +# -*- OpenSAF -*- >> +# >> +# (C) Copyright 2015 The OpenSAF Foundation >> +# >> +# This program is distributed in the hope that it will be useful, but >> +# WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> +# or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> +# under the GNU Lesser General Public License Version 2.1, February >> 1999. >> +# The complete license can be accessed from the following location: >> +# http://opensource.org/licenses/lgpl-license.php >> +# See the Copying file included with the OpenSAF distribution for full >> +# licensing terms. >> +# >> +# Author(s): Ericsson AB >> +# >> + >> +include $(top_srcdir)/Makefile.common >> + >> +MAINTAINERCLEANFILES = Makefile.in >> + >> +TESTS = core_common_test >> + >> +check_PROGRAMS = $(TESTS) >> + >> +core_common_test_CXXFLAGS =$(AM_CXXFLAGS) >> + >> +core_common_test_CPPFLAGS = \ >> + $(AM_CPPFLAGS) \ >> + -I$(top_srcdir)/osaf/libs/core/common/include \ >> + -I$(GTEST_DIR)/include >> + >> +core_common_test_LDFLAGS = \ >> + -pthread -lrt \ >> + >> $(top_builddir)/osaf/libs/core/common/libopensaf_common_la-osaf_time.o \ >> + >> $(top_builddir)/osaf/libs/core/common/libopensaf_common_la-osaf_utility.o >> + >> +core_common_test_SOURCES = \ >> + osaf_clock_gettime_test.cc \ >> + osaf_nanosleep_test.cc \ >> + osaf_normalize_timespec_test.cc \ >> + osaf_timespec_add_test.cc \ >> + osaf_timespec_compare_test.cc \ >> + osaf_timespec_convert_test.cc \ >> + osaf_timespec_subtract_test.cc \ >> + mock_clock_gettime.cc \ >> + mock_clock_nanosleep.cc \ >> + mock_syslog.cc >> + >> +core_common_test_LDADD = \ >> + $(GTEST_DIR)/lib/libgtest.la \ >> + $(GTEST_DIR)/lib/libgtest_main.la >> diff --git a/osaf/libs/core/common/tests/mock_clock_gettime.cc >> b/osaf/libs/core/common/tests/mock_clock_gettime.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_clock_gettime.cc >> @@ -0,0 +1,45 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "mock_clock_gettime.h" >> +#include <cerrno> >> +#include "osaf_time.h" >> + >> +timespec realtime_clock; >> +timespec monotonic_clock; >> +MockClockGettime mock_clock_gettime; >> + >> +int clock_gettime(clockid_t clock_id, struct timespec* tp) { >> + struct timespec* clock_source = nullptr; >> + if (clock_id == CLOCK_REALTIME) { >> + clock_source = &realtime_clock; >> + } else if (clock_id == CLOCK_MONOTONIC) { >> + clock_source = &monotonic_clock; >> + } else { >> + errno = EINVAL; >> + return -1; >> + } >> + if (tp == nullptr) { >> + errno = EFAULT; >> + return -1; >> + } >> + if (tp != nullptr && clock_source != nullptr) *tp = *clock_source; >> + osaf_timespec_add(&realtime_clock, >> &mock_clock_gettime.execution_time, &realtime_clock); >> + osaf_timespec_add(&monotonic_clock, >> &mock_clock_gettime.execution_time, &monotonic_clock); >> + if (mock_clock_gettime.return_value < 0) errno = >> mock_clock_gettime.errno_value; >> + return mock_clock_gettime.return_value; >> +} >> diff --git a/osaf/libs/core/common/tests/mock_clock_gettime.h >> b/osaf/libs/core/common/tests/mock_clock_gettime.h >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_clock_gettime.h >> @@ -0,0 +1,33 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#ifndef OPENSAF_BASE_TESTS_MOCK_CLOCK_GETTIME_H_ >> +#define OPENSAF_BASE_TESTS_MOCK_CLOCK_GETTIME_H_ >> + >> +#include <time.h> >> + >> +struct MockClockGettime { >> + struct timespec execution_time; >> + int return_value; >> + int errno_value; >> +}; >> + >> +extern timespec realtime_clock; >> +extern timespec monotonic_clock; >> +extern MockClockGettime mock_clock_gettime; >> + >> +#endif >> diff --git a/osaf/libs/core/common/tests/mock_clock_nanosleep.cc >> b/osaf/libs/core/common/tests/mock_clock_nanosleep.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_clock_nanosleep.cc >> @@ -0,0 +1,66 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "mock_clock_nanosleep.h" >> +#include <cerrno> >> +#include "osaf_time.h" >> +#include "mock_clock_gettime.h" >> + >> +int current_nanosleep_index = 0; >> +int number_of_nanosleep_instances = 1; >> +MockClockNanosleep mock_clock_nanosleep[kMockClockNanosleepInstances]; >> + >> +int clock_nanosleep(clockid_t clock_id, int flags, >> + const struct timespec *request, >> + struct timespec *remain) { >> + MockClockNanosleep& mock_instance = >> mock_clock_nanosleep[current_nanosleep_index++]; >> + if (current_nanosleep_index >= number_of_nanosleep_instances) >> current_nanosleep_index = 0; >> + struct timespec* clock_source = nullptr; >> + if (clock_id == CLOCK_REALTIME) { >> + clock_source = &realtime_clock; >> + } else if (clock_id == CLOCK_MONOTONIC) { >> + clock_source = &monotonic_clock; >> + } else { >> + errno = EINVAL; >> + return -1; >> + } >> + if (request->tv_sec < 0 || request->tv_nsec < 0 || >> request->tv_nsec >= kNanosPerSec) { >> + errno = EINVAL; >> + return -1; >> + } >> + struct timespec sleep_duration = kZeroSeconds; >> + if (flags == 0) { >> + sleep_duration = *request; >> + } else if (flags == TIMER_ABSTIME) { >> + if (osaf_timespec_compare(request, clock_source) >= 0) { >> + osaf_timespec_subtract(request, clock_source, &sleep_duration); >> + } >> + } else { >> + errno = EINVAL; >> + return -1; >> + } >> + if (mock_instance.return_value < 0 && mock_instance.errno_value == >> EINTR) { >> + osaf_nanos_to_timespec(osaf_timespec_to_nanos(&sleep_duration) / 2, >> &sleep_duration); >> + } >> + if (flags == 0 && remain != nullptr) { >> + osaf_timespec_subtract(request, &sleep_duration, remain); >> + } >> + osaf_timespec_add(&realtime_clock, &sleep_duration, &realtime_clock); >> + osaf_timespec_add(&monotonic_clock, &sleep_duration, >> &monotonic_clock); >> + if (mock_instance.return_value < 0) errno = >> mock_instance.errno_value; >> + return mock_instance.return_value; >> +} >> diff --git a/osaf/libs/core/common/tests/mock_clock_nanosleep.h >> b/osaf/libs/core/common/tests/mock_clock_nanosleep.h >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_clock_nanosleep.h >> @@ -0,0 +1,33 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#ifndef OPENSAF_BASE_TESTS_MOCK_CLOCK_NANOSLEEP_H_ >> +#define OPENSAF_BASE_TESTS_MOCK_CLOCK_NANOSLEEP_H_ >> + >> +#include <time.h> >> + >> +struct MockClockNanosleep { >> + int return_value; >> + int errno_value; >> +}; >> + >> +static const int kMockClockNanosleepInstances = 3; >> +extern int current_nanosleep_index; >> +extern int number_of_nanosleep_instances; >> +extern MockClockNanosleep >> mock_clock_nanosleep[kMockClockNanosleepInstances]; >> + >> +#endif >> diff --git a/osaf/libs/core/common/tests/mock_syslog.cc >> b/osaf/libs/core/common/tests/mock_syslog.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_syslog.cc >> @@ -0,0 +1,23 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "mock_syslog.h" >> + >> +void syslog(int priority, const char *format, ...) { >> + (void) priority; >> + (void) format; >> +} >> diff --git a/osaf/libs/core/common/tests/mock_syslog.h >> b/osaf/libs/core/common/tests/mock_syslog.h >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/mock_syslog.h >> @@ -0,0 +1,23 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#ifndef OPENSAF_BASE_TESTS_MOCK_SYSLOG_H_ >> +#define OPENSAF_BASE_TESTS_MOCK_SYSLOG_H_ >> + >> +#include <syslog.h> >> + >> +#endif >> diff --git a/osaf/libs/core/common/tests/osaf_clock_gettime_test.cc >> b/osaf/libs/core/common/tests/osaf_clock_gettime_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_clock_gettime_test.cc >> @@ -0,0 +1,73 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include <cerrno> >> +#include "osaf_time.h" >> +#include "osaf_utility.h" >> +#include "mock_clock_gettime.h" >> +#include "gtest/gtest.h" >> + >> +TEST(OsafClockGettime, ReadRealtimeClock) { >> + time_t sec = 123456789; >> + long nsec = 987654321; >> + realtime_clock = { sec, nsec }; >> + monotonic_clock = { 0, 0 }; >> + mock_clock_gettime.return_value = 0; >> + >> + struct timespec ts = { 0, 0 }; >> + osaf_clock_gettime(CLOCK_REALTIME, &ts); >> + >> + EXPECT_EQ(ts.tv_sec, sec); >> + EXPECT_EQ(ts.tv_nsec, nsec); >> +} >> + >> +TEST(OsafClockGettime, ReadMonotonicClock) { >> + time_t sec = 212121212; >> + long nsec = 565656565; >> + realtime_clock = { 0, 0 }; >> + monotonic_clock = { sec, nsec }; >> + mock_clock_gettime.return_value = 0; >> + >> + struct timespec ts = { 0, 0 }; >> + osaf_clock_gettime(CLOCK_MONOTONIC, &ts); >> + >> + EXPECT_EQ(ts.tv_sec, sec); >> + EXPECT_EQ(ts.tv_nsec, nsec); >> +} >> + >> +TEST(OsafClockGettime, FailWithEFAULT) { >> + mock_clock_gettime.return_value = -1; >> + mock_clock_gettime.errno_value = EFAULT; >> + >> + ASSERT_EXIT(osaf_clock_gettime(CLOCK_REALTIME, NULL), >> ::testing::KilledBySignal(SIGABRT), ""); >> +} >> + >> +TEST(OsafClockGettime, FailWithEINVAL) { >> + mock_clock_gettime.return_value = -1; >> + mock_clock_gettime.errno_value = EINVAL; >> + >> + struct timespec ts; >> + ASSERT_EXIT(osaf_clock_gettime(CLOCK_REALTIME, &ts), >> ::testing::KilledBySignal(SIGABRT), ""); >> +} >> + >> +TEST(OsafClockGettime, FailWithEPERM) { >> + mock_clock_gettime.return_value = -1; >> + mock_clock_gettime.errno_value = EPERM; >> + >> + struct timespec ts; >> + ASSERT_EXIT(osaf_clock_gettime(CLOCK_REALTIME, &ts), >> ::testing::KilledBySignal(SIGABRT), ""); >> +} >> diff --git a/osaf/libs/core/common/tests/osaf_nanosleep_test.cc >> b/osaf/libs/core/common/tests/osaf_nanosleep_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_nanosleep_test.cc >> @@ -0,0 +1,81 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include <cerrno> >> +#include "osaf_time.h" >> +#include "osaf_utility.h" >> +#include "mock_clock_gettime.h" >> +#include "mock_clock_nanosleep.h" >> +#include "gtest/gtest.h" >> + >> +TEST(OsafNanosleep, SleepTenMilliseconds) { >> + time_t start_sec = 1234; >> + long start_nsec = 5678; >> + monotonic_clock = { start_sec, start_nsec }; >> + mock_clock_gettime.execution_time = kZeroSeconds; >> + mock_clock_gettime.return_value = 0; >> + current_nanosleep_index = 0; >> + number_of_nanosleep_instances = 2; >> + mock_clock_nanosleep[0].return_value = 0; >> + >> + timespec sleep_duration = kTenMilliseconds; >> + osaf_nanosleep(&sleep_duration); >> + >> + EXPECT_EQ(monotonic_clock.tv_sec, start_sec); >> + EXPECT_EQ(monotonic_clock.tv_nsec, start_nsec + 10000000); >> + EXPECT_EQ(current_nanosleep_index, 1); >> +} >> + >> +TEST(OsafNanosleep, SleepOneHourWithInterrupt) { >> + monotonic_clock = kZeroSeconds; >> + mock_clock_gettime.execution_time = kZeroSeconds; >> + mock_clock_gettime.return_value = 0; >> + current_nanosleep_index = 0; >> + number_of_nanosleep_instances = 3; >> + mock_clock_nanosleep[0].return_value = -1; >> + mock_clock_nanosleep[0].errno_value = EINTR; >> + mock_clock_nanosleep[1].return_value = 0; >> + >> + timespec sleep_duration = kOneHour; >> + osaf_nanosleep(&sleep_duration); >> + >> + EXPECT_EQ(monotonic_clock.tv_sec, 60 * 60); >> + EXPECT_EQ(monotonic_clock.tv_nsec, 0); >> + EXPECT_EQ(current_nanosleep_index, 2); >> +} >> + >> +TEST(OsafNanosleep, FailWithEFAULT) { >> + mock_clock_gettime.return_value = 0; >> + current_nanosleep_index = 0; >> + number_of_nanosleep_instances = 1; >> + mock_clock_nanosleep[0].return_value = -1; >> + mock_clock_nanosleep[0].errno_value = EFAULT; >> + >> + timespec sleep_duration = kOneSecond; >> + ASSERT_EXIT(osaf_nanosleep(&sleep_duration), >> ::testing::KilledBySignal(SIGABRT), ""); >> +} >> + >> +TEST(OsafNanosleep, FailWithEINVAL) { >> + mock_clock_gettime.return_value = 0; >> + current_nanosleep_index = 0; >> + number_of_nanosleep_instances = 1; >> + mock_clock_nanosleep[0].return_value = -1; >> + mock_clock_nanosleep[0].errno_value = EINVAL; >> + >> + timespec sleep_duration = kOneSecond; >> + ASSERT_EXIT(osaf_nanosleep(&sleep_duration), >> ::testing::KilledBySignal(SIGABRT), ""); >> +} >> diff --git >> a/osaf/libs/core/common/tests/osaf_normalize_timespec_test.cc >> b/osaf/libs/core/common/tests/osaf_normalize_timespec_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_normalize_timespec_test.cc >> @@ -0,0 +1,81 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "osaf_time.h" >> +#include "gtest/gtest.h" >> + >> +TEST(OsafNormalizeTimespec, Zero) { >> + const timespec zero_seconds = kZeroSeconds; >> + timespec result; >> + osaf_normalize_timespec(&zero_seconds, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kZeroSeconds), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, AlreadyNormalized) { >> + const timespec already_normalized = { 123456789, 987654321 }; >> + timespec result; >> + osaf_normalize_timespec(&already_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &already_normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, NanoseconsdGreaterThanOneBillion) { >> + const timespec not_normalized = { 123456789, 1987654321 }; >> + const timespec normalized = { 123456790, 987654321 }; >> + timespec result; >> + osaf_normalize_timespec(¬_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, NanoseconsdLessThanZero) { >> + const timespec not_normalized = { 123456789, -100 }; >> + const timespec normalized = { 123456788, 1000000000 - 100 }; >> + timespec result; >> + osaf_normalize_timespec(¬_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, NanoseconsGreaterThan2Billions) { >> + const timespec not_normalized = { 123456789, 2101234567 }; >> + const timespec normalized = { 123456789 + 2, 101234567 }; >> + timespec result; >> + osaf_normalize_timespec(¬_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, NanoseconsLessThanMinus2Billions) { >> + const timespec not_normalized = { 123456789, -2000000567 }; >> + const timespec normalized = { 123456789 - 2 - 1, 1000000000 - 567 }; >> + timespec result; >> + osaf_normalize_timespec(¬_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, BothParametersAtSameAddress) { >> + const timespec not_normalized = { 123456789, -2000000567 }; >> + const timespec normalized = { 123456789 - 2 - 1, 1000000000 - 567 }; >> + timespec result = not_normalized; >> + osaf_normalize_timespec(&result, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> + >> +TEST(OsafNormalizeTimespec, NegativeSecondsAndNanoseconds) { >> + const timespec not_normalized = { -123, -1 }; >> + const timespec normalized = { -124, 999999999 }; >> + timespec result; >> + osaf_normalize_timespec(¬_normalized, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &normalized), 0); >> +} >> diff --git a/osaf/libs/core/common/tests/osaf_time_test.cc >> b/osaf/libs/core/common/tests/osaf_time_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_time_test.cc >> @@ -0,0 +1,390 @@ >> +// Copyright 2005, Google Inc. >> +// All rights reserved. >> +// >> +// Redistribution and use in source and binary forms, with or without >> +// modification, are permitted provided that the following >> conditions are >> +// met: >> +// >> +// * Redistributions of source code must retain the above copyright >> +// notice, this list of conditions and the following disclaimer. >> +// * Redistributions in binary form must reproduce the above >> +// copyright notice, this list of conditions and the following >> disclaimer >> +// in the documentation and/or other materials provided with the >> +// distribution. >> +// * Neither the name of Google Inc. nor the names of its >> +// contributors may be used to endorse or promote products derived from >> +// this software without specific prior written permission. >> +// >> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS >> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT >> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS >> FOR >> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT >> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, >> INCIDENTAL, >> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT >> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF >> USE, >> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON >> ANY >> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT >> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE >> USE >> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. >> + >> +// A sample program demonstrating using Google C++ testing framework. >> +// >> +// Author: [email protected] (Zhanyong Wan) >> + >> + >> +// This sample shows how to write a simple unit test for a function, >> +// using Google C++ testing framework. >> +// >> +// Writing a unit test using Google C++ testing framework is easy as >> 1-2-3: >> + >> + >> +// Step 1. Include necessary header files such that the stuff your >> +// test logic needs is declared. >> +// >> +// Don't forget gtest.h, which declares the testing framework. >> + >> +#include <limits.h> >> +#include "osaf_time.h" >> +#include "osaf_utility.h" >> +#include "gtest/gtest.h" >> +#include <stdio.h> >> +#include <stdlib.h> >> +#include <unistd.h> >> +#include <signal.h> >> +#include <sys/time.h> >> + >> +static long counter; >> + >> +void osaf_abort(long i_cause) { >> + fprintf(stderr, "osaf_abort(%ld) called\n", i_cause); >> + abort(); >> +} >> + >> +void alarm_handler(int sig) { >> + ++counter; >> +} >> + >> +// Step 2. Use the TEST macro to define your tests. >> +// >> +// TEST has two parameters: the test case name and the test name. >> +// After using the macro, you should define your test logic between a >> +// pair of braces. You can use a bunch of macros to indicate the >> +// success or failure of a test. EXPECT_TRUE and EXPECT_EQ are >> +// examples of such macros. For a complete list, see gtest.h. >> +// >> +// <TechnicalDetails> >> +// >> +// In Google Test, tests are grouped into test cases. This is how we >> +// keep test code organized. You should put logically related tests >> +// into the same test case. >> +// >> +// The test case name and the test name should both be valid C++ >> +// identifiers. And you should not use underscore (_) in the names. >> +// >> +// Google Test guarantees that each test you define is run exactly >> +// once, but it makes no guarantee on the order the tests are >> +// executed. Therefore, you should write your tests in such a way >> +// that their results don't depend on their order. >> +// >> +// </TechnicalDetails> >> + >> + >> +// Tests Factorial(). >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_clock_gettime) { >> + struct timespec ts1 = { 10, 10 }; >> + struct timespec ts2 = { 9, 9 }; >> + struct timespec ts3 = { 11, 11 }; >> + const struct timespec ts_9ms = { 0, 9000000 }; >> + const struct timespec ts_10ms = { 0, 10000000 }; >> + const struct timespec ts_900ms = { 0, 900000000 }; >> + >> + osaf_clock_gettime(CLOCK_MONOTONIC, &ts1); >> + usleep(10000); >> + osaf_clock_gettime(CLOCK_MONOTONIC, &ts2); >> + >> + osaf_timespec_subtract(&ts2, &ts1, &ts3); >> + >> + EXPECT_GE(osaf_timespec_compare(&ts2, &ts1), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts3, &ts_9ms), 1); >> + EXPECT_GE(osaf_timespec_compare(&ts3, &ts_10ms), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts3, &ts_900ms), -1); >> +} >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_nanosleep) { >> + struct timespec ts1 = { 10, 10 }; >> + struct timespec ts2 = { 9, 9 }; >> + struct timespec ts3 = { 11, 11 }; >> + const struct timespec ts_1_233ms = { 1, 233000000 }; >> + const struct timespec ts_1_234ms = { 1, 234000000 }; >> + const struct timespec ts_1_567ms = { 1, 567000000 }; >> + >> + counter = 0; >> + signal(SIGALRM, alarm_handler); >> + struct itimerval itv = { >> + {0, 379}, >> + {0, 379} >> + }; >> + setitimer(ITIMER_REAL, &itv, NULL); >> + >> + osaf_clock_gettime(CLOCK_MONOTONIC, &ts1); >> + osaf_nanosleep(&ts_1_234ms); >> + osaf_clock_gettime(CLOCK_MONOTONIC, &ts2); >> + >> + osaf_timespec_subtract(&ts2, &ts1, &ts3); >> + >> + printf("counter: %ld\n", counter); >> + >> + EXPECT_EQ(osaf_timespec_compare(&ts3, &ts_1_233ms), 1); >> + EXPECT_GE(osaf_timespec_compare(&ts3, &ts_1_234ms), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts3, &ts_1_567ms), -1); >> + // EXPECT_LE(counter, 1234000 / 379); >> + // EXPECT_GT(counter, 1000); >> + >> + signal(SIGALRM, SIG_IGN); >> + struct itimerval itv2 = { >> + {0, 0}, >> + {0, 0} >> + }; >> + setitimer(ITIMER_REAL, &itv2, NULL); >> +} >> + >> +TEST(osaf_time_test, osaf_normalize_timespec) { >> + struct timespec ts = { 1, 1 }; >> + >> + const struct timespec ts0 = { 0, 0 }; // should be same after >> normalization >> + osaf_normalize_timespec(&ts0, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts0), 0); >> + >> + const struct timespec ts1 = { 123456789, 987654321 }; // should be >> same after normalization >> + osaf_normalize_timespec(&ts1, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts1), 0); >> + >> + // Positive tv_nsec. tv_sec needs to stepped exactly than one second >> + const struct timespec ts2 = { 123456789, 1987654321 }; >> + const struct timespec ts2_nrm = { 123456790, 987654321 }; // ts2 >> normalized >> + osaf_normalize_timespec(&ts2, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts2_nrm), 0); >> + >> + // Negative tv_nsec. tv_sec needs to stepped exactly than one second >> + const struct timespec ts3 = { 123456789, -100 }; >> + const struct timespec ts3_nrm = { 123456788, 1000000000 - 100 }; >> // ts3 normalized >> + osaf_normalize_timespec(&ts3, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts3_nrm), 0); >> + >> + // Positive tv_nsec. tv_sec needs to stepped with more than one >> second >> + const struct timespec ts4 = { 123456789, 123987654321 }; >> + const struct timespec ts4_nrm = { 123456789 + 123, 987654321 }; // >> ts4 normalized >> + osaf_normalize_timespec(&ts4, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts4_nrm), 0); >> + >> + // Negative tv_nsec. tv_sec needs to stepped with more than one >> second >> + const struct timespec ts5 = { 123456789, -456000000567 }; >> + const struct timespec ts5_nrm = { 123456789 - 456 - 1, 1000000000 >> - 567 }; // ts5 normalized >> + osaf_normalize_timespec(&ts5, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts5_nrm), 0); >> + >> + // Check that normalization works if both both parameters refer to >> the same memory location >> + ts = ts5; >> + osaf_normalize_timespec(&ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts5_nrm), 0); >> + >> + // Negative tv_sec and tv_nsec. >> + const struct timespec ts6 = { -123, -1 }; >> + const struct timespec ts6_nrm = { -124, 999999999 }; // ts6 >> normalized >> + osaf_normalize_timespec(&ts6, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts6_nrm), 0); >> +} >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_timespec_add) { >> + struct timespec ts; >> + const struct timespec ts_0_0s = { 0, 0 }; >> + const struct timespec ts_0_1s = { 0, 100000000 }; >> + const struct timespec ts_2_4s = { 2, 400000000 }; >> + const struct timespec ts_4_8s = { 4, 800000000 }; >> + const struct timespec ts_9_6s = { 9, 600000000 }; >> + const struct timespec ts_9_7s = { 9, 700000000 }; >> + const struct timespec ts_19_3s = { 19, 300000000 }; >> + const struct timespec ts1 = { 3715800020576315623, 358743382 }; >> + const struct timespec ts2 = { 3637143377279394477, 719128783 }; >> + const struct timespec ts3 = { 7352943397855710101, 77872165 }; // >> sum of ts1 + ts2 >> + >> + ts = ts_0_0s; >> + >> + osaf_timespec_add(&ts, &ts_0_0s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_0_0s), 0); >> + >> + osaf_timespec_add(&ts, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_0_0s), 0); >> + >> + osaf_timespec_add(&ts, &ts_2_4s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_2_4s), 0); >> + >> + osaf_timespec_add(&ts, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_4_8s), 0); >> + >> + osaf_timespec_add(&ts, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_9_6s), 0); >> + >> + osaf_timespec_add(&ts_0_0s, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_9_6s), 0); >> + >> + osaf_timespec_add(&ts_0_1s, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_9_7s), 0); >> + >> + osaf_timespec_add(&ts, &ts_9_6s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_19_3s), 0); >> + >> + osaf_timespec_add(&ts1, &ts2, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts3), 0); >> + >> +} >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_timespec_subtract) { >> + struct timespec ts; >> + const struct timespec ts_0_0s = { 0, 0 }; >> + const struct timespec ts_0_9s = { 0, 900000000 }; >> + const struct timespec ts_1_0s = { 1, 0 }; >> + const struct timespec ts_0_1s = { 0, 100000000 }; >> + const struct timespec ts_0_2s = { 0, 200000000 }; >> + const struct timespec ts_1_1s = { 1, 100000000 }; >> + const struct timespec ts1 = { 3715800020576315623, 358743382 }; >> + const struct timespec ts2 = { 3637143377279394477, 639614599 }; >> + const struct timespec ts3 = { 78656643296921145, 719128783 }; // >> difference of ts1 - ts2 >> + >> + ts = ts1; >> + >> + osaf_timespec_subtract(&ts, &ts, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_0_0s), 0); >> + >> + osaf_timespec_subtract(&ts_1_1s, &ts_0_1s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_1_0s), 0); >> + >> + osaf_timespec_subtract(&ts_1_1s, &ts_1_0s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_0_1s), 0); >> + >> + osaf_timespec_subtract(&ts_1_1s, &ts_0_2s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_0_9s), 0); >> + >> + osaf_timespec_subtract(&ts1, &ts2, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts3), 0); >> + >> + osaf_timespec_subtract(&ts, &ts_0_0s, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts3), 0); >> +} >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_timespec_compare) { >> + const struct timespec ts_0_0s = { 0, 0 }; >> + const struct timespec ts_0_1s = { 0, 100000000 }; >> + const struct timespec ts_0_9s = { 0, 900000000 }; >> + const struct timespec ts_1_0s = { 1, 0 }; >> + const struct timespec ts_1_1s = { 1, 100000000 }; >> + >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_0s, &ts_0_0s), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_0s, &ts_0_1s), -1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_1s, &ts_0_0s), 1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_0s, &ts_1_0s), -1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_1_0s, &ts_0_0s), 1); >> + >> + EXPECT_EQ(osaf_timespec_compare(&ts_1_0s, &ts_1_0s), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts_1_0s, &ts_1_1s), -1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_1_1s, &ts_1_0s), 1); >> + >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_9s, &ts_0_9s), 0); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_9s, &ts_1_1s), -1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_9s, &ts_0_1s), 1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_1_1s, &ts_0_9s), 1); >> + EXPECT_EQ(osaf_timespec_compare(&ts_0_1s, &ts_0_9s), -1); >> +} >> + >> +// Tests factorial of negative numbers. >> +TEST(osaf_time_test, osaf_timespec_to_timeval) { >> + const struct timespec ts = { 3715800020576315623, 358743382 }; >> + const struct timeval tv_expected = { 3715800020576315623, 358743 }; >> + struct timeval tv = { 0, 0 }; >> + >> + osaf_timespec_to_timeval(&ts, &tv); >> + EXPECT_EQ(tv.tv_sec, tv_expected.tv_sec); >> + EXPECT_EQ(tv.tv_usec, tv_expected.tv_usec); >> +} >> + >> +TEST(osaf_time_test, osaf_timeval_to_timespec) { >> + const struct timeval tv = { 3715800020576315623, 358743 }; >> + const struct timespec ts_expected = { 3715800020576315623, >> 358743000 }; >> + struct timespec ts = { 0, 0}; >> + >> + osaf_timeval_to_timespec(&tv, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected), 0); >> +} >> + >> +TEST(osaf_time_test, osaf_millis_to_timespec) { >> + const struct timespec ts_expected = { 13725125428499100, 961000000 }; >> + struct timespec ts = { 0, 0}; >> + >> + osaf_millis_to_timespec(13725125428499100961ull, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected), 0); >> +} >> + >> +TEST(osaf_time_test, osaf_micros_to_timespec) { >> + const struct timespec ts_expected = { 13725125428499, 100961000 }; >> + struct timespec ts = { 0, 0}; >> + >> + osaf_micros_to_timespec(13725125428499100961ull, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected), 0); >> +} >> + >> +TEST(osaf_time_test, osaf_nanos_to_timespec) { >> + const struct timespec ts_expected = { 13725125428, 499100961 }; >> + struct timespec ts = { 0, 0}; >> + >> + osaf_nanos_to_timespec(13725125428499100961ull, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected), 0); >> +} >> + >> +TEST(osaf_time_test, osaf_double_to_timespec) { >> + const struct timespec ts_expected = { 15714713, 125433700 }; >> + const struct timespec ts_expected2 = { -15714714, 874566300 }; >> + struct timespec ts = { 0, 0}; >> + >> + osaf_double_to_timespec(15714713.1254337, &ts); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected), 0); >> + osaf_double_to_timespec(-15714713.1254337, &ts); >> + // printf("%lld %lld\n", (long long) ts.tv_sec, (long long) >> ts.tv_nsec); >> + EXPECT_EQ(osaf_timespec_compare(&ts, &ts_expected2), 0); >> +} >> + >> +TEST(osaf_time_test, osaf_timespec_to_millis) { >> + const struct timespec ts = { 13725125428499100, 961923266 }; >> + >> + uint64_t result = osaf_timespec_to_millis(&ts); >> + EXPECT_EQ(result, 13725125428499100961ull); >> +} >> + >> +TEST(osaf_time_test, osaf_timespec_to_micros) { >> + const struct timespec ts = { 13725125428499, 100961923 }; >> + >> + uint64_t result = osaf_timespec_to_micros(&ts); >> + EXPECT_EQ(result, 13725125428499100961ull); >> +} >> + >> +TEST(osaf_time_test, osaf_timespec_to_nanos) { >> + const struct timespec ts = { 13725125428, 499100961 }; >> + >> + uint64_t result = osaf_timespec_to_nanos(&ts); >> + EXPECT_EQ(result, 13725125428499100961ull); >> +} >> + >> +TEST(osaf_time_test, osaf_timespec_to_double) { >> + const struct timespec ts = { 15714713, 125433700 }; >> + const struct timespec ts2 = { -15714714, 874566300 }; >> + >> + double result1 = osaf_timespec_to_double(&ts); >> + double result2 = osaf_timespec_to_double(&ts2); >> + EXPECT_EQ(result1, 15714713.1254337); >> + EXPECT_EQ(result2, -15714713.1254337); >> +} >> diff --git a/osaf/libs/core/common/tests/osaf_timespec_add_test.cc >> b/osaf/libs/core/common/tests/osaf_timespec_add_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_timespec_add_test.cc >> @@ -0,0 +1,62 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "osaf_time.h" >> +#include "gtest/gtest.h" >> + >> +static const timespec kTwoDotFourSeconds = { 2, 400000000 }; >> +static const timespec kFourDotEightSeconds = { 4, 800000000 }; >> +static const timespec kNineDotSixSeconds = { 9, 600000000 }; >> +static const timespec number1 = { 576315623, 358743382 }; >> +static const timespec number2 = { 1279394477, 719128783 }; >> +static const timespec sum = { 1855710101, 77872165 }; >> + >> +TEST(OsafTimespecAdd, ZeroPlusZero) { >> + timespec result; >> + osaf_timespec_add(&kZeroSeconds, &kZeroSeconds, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kZeroSeconds), 0); >> +} >> + >> +TEST(OsafTimespecAdd, TwoDotFourAddedWithItself) { >> + timespec result = kTwoDotFourSeconds; >> + osaf_timespec_add(&result, &result, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kFourDotEightSeconds), 0); >> +} >> + >> +TEST(OsafTimespecAdd, FourDotEightAddedWithItself) { >> + timespec result = kFourDotEightSeconds; >> + osaf_timespec_add(&result, &result, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kNineDotSixSeconds), 0); >> +} >> + >> +TEST(OsafTimespecAdd, AddRandomNumbers) { >> + timespec result; >> + osaf_timespec_add(&number1, &number2, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &sum), 0); >> +} >> + >> +TEST(OsafTimespecAdd, FirstParameterAndResultAtSameAddress) { >> + timespec result = number1; >> + osaf_timespec_add(&result, &number2, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &sum), 0); >> +} >> + >> +TEST(OsafTimespecAdd, SecondParameterAndResultAtSameAddress) { >> + timespec result = number2; >> + osaf_timespec_add(&number1, &result, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &sum), 0); >> +} >> diff --git >> a/osaf/libs/core/common/tests/osaf_timespec_compare_test.cc >> b/osaf/libs/core/common/tests/osaf_timespec_compare_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_timespec_compare_test.cc >> @@ -0,0 +1,75 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "osaf_time.h" >> +#include "gtest/gtest.h" >> + >> +static const timespec kZeroDotOneSeconds = { 0, 100000000 }; >> +static const timespec kZeroDotNineSeconds = { 0, 900000000 }; >> +static const timespec kOneDotOneSeconds = { 1, 100000000 }; >> + >> +TEST(OsafTimespecCompare, ZeroWithZero) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroSeconds, &kZeroSeconds), 0); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroWithZeroDotOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroSeconds, >> &kZeroDotOneSeconds), -1); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroDotOneWithZero) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroDotOneSeconds, >> &kZeroSeconds), 1); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroWithOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroSeconds, &kOneSecond), -1); >> +} >> + >> +TEST(OsafTimespecCompare, OneWithZero) { >> + EXPECT_EQ(osaf_timespec_compare(&kOneSecond, &kZeroSeconds), 1); >> +} >> + >> +TEST(OsafTimespecCompare, OneWithOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kOneSecond, &kOneSecond), 0); >> +} >> + >> +TEST(OsafTimespecCompare, OneWithOneDotOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kOneSecond, &kOneDotOneSeconds), >> -1); >> +} >> + >> +TEST(OsafTimespecCompare, OneDotOneWithOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kOneDotOneSeconds, &kOneSecond), 1); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroDotNineWithZeroDotNine) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroDotNineSeconds, >> &kZeroDotNineSeconds), 0); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroDotNineWithOneDotOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroDotNineSeconds, >> &kOneDotOneSeconds), -1); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroDotNineWithZeroDotOne) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroDotNineSeconds, >> &kZeroDotOneSeconds), 1); >> +} >> + >> +TEST(OsafTimespecCompare, OneDotOneWithZeroDotNine) { >> + EXPECT_EQ(osaf_timespec_compare(&kOneDotOneSeconds, >> &kZeroDotNineSeconds), 1); >> +} >> + >> +TEST(OsafTimespecCompare, ZeroDotOneWithZeroDotNine) { >> + EXPECT_EQ(osaf_timespec_compare(&kZeroDotOneSeconds, >> &kZeroDotNineSeconds), -1); >> +} >> diff --git >> a/osaf/libs/core/common/tests/osaf_timespec_convert_test.cc >> b/osaf/libs/core/common/tests/osaf_timespec_convert_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_timespec_convert_test.cc >> @@ -0,0 +1,100 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "osaf_time.h" >> +#include "gtest/gtest.h" >> + >> +static const timespec kTimespec = { 1576315623, 358743382 }; >> +static const timeval kTimeval = { 1576315623, 358743 }; >> +static const timespec kTruncatedTimespec = { 1576315623, 358743000 }; >> + >> +TEST(OsafTimespecConvert, TimespecToTimeval) { >> + timeval result = { 0, 0 }; >> + osaf_timespec_to_timeval(&kTimespec, &result); >> + EXPECT_EQ(result.tv_sec, kTimeval.tv_sec); >> + EXPECT_EQ(result.tv_usec, kTimeval.tv_usec); >> +} >> + >> +TEST(OsafTimespecConvert, TimevalToTimespec) { >> + timespec result = { 0, 0 }; >> + osaf_timeval_to_timespec(&kTimeval, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kTruncatedTimespec), 0); >> +} >> + >> +TEST(OsafTimespecConvert, MillisToTimespec) { >> + const timespec expected_result = { 1428499100, 961000000 }; >> + timespec result = { 0, 0 }; >> + osaf_millis_to_timespec(1428499100961ull, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &expected_result), 0); >> +} >> + >> +TEST(OsafTimespecConvert, MicrosToTimespec) { >> + const timespec expected_result = { 2125428499, 100961000 }; >> + timespec result = { 0, 0 }; >> + osaf_micros_to_timespec(2125428499100961ull, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &expected_result), 0); >> +} >> + >> +TEST(OsafTimespecConvert, NanosToTimespec) { >> + const struct timespec expected_result = { 1725125428, 499100961 }; >> + timespec result = { 0, 0 }; >> + >> + osaf_nanos_to_timespec(1725125428499100961ull, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &expected_result), 0); >> +} >> + >> +TEST(OsafTimespecConvert, DoubleToTimespec) { >> + const struct timespec expected_result = { 15714713, 125433700 }; >> + const struct timespec expected_result2 = { -15714714, 874566300 }; >> + timespec result = { 0, 0 }; >> + >> + osaf_double_to_timespec(15714713.1254337, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &expected_result), 0); >> + osaf_double_to_timespec(-15714713.1254337, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &expected_result2), 0); >> +} >> + >> +TEST(OsafTimespecConvert, TimespecToMillis) { >> + const struct timespec ts = { 1428499100, 961923266 }; >> + >> + uint64_t result = osaf_timespec_to_millis(&ts); >> + EXPECT_EQ(result, 1428499100961ull); >> +} >> + >> +TEST(OsafTimespecConvert, TimespecToMicros) { >> + const struct timespec ts = { 1125428499, 100961923 }; >> + >> + uint64_t result = osaf_timespec_to_micros(&ts); >> + EXPECT_EQ(result, 1125428499100961ull); >> +} >> + >> +TEST(OsafTimespecConvert, TimespecToNanos) { >> + const struct timespec ts = { 1725125428, 499100961 }; >> + >> + uint64_t result = osaf_timespec_to_nanos(&ts); >> + EXPECT_EQ(result, 1725125428499100961ull); >> +} >> + >> +TEST(OsafTimespecConvert, TimespecToDouble) { >> + const struct timespec ts = { 15714713, 125433700 }; >> + const struct timespec ts2 = { -15714714, 874566300 }; >> + >> + double result1 = osaf_timespec_to_double(&ts); >> + double result2 = osaf_timespec_to_double(&ts2); >> + EXPECT_EQ(result1, 15714713.1254337); >> + EXPECT_EQ(result2, -15714713.1254337); >> +} >> diff --git >> a/osaf/libs/core/common/tests/osaf_timespec_subtract_test.cc >> b/osaf/libs/core/common/tests/osaf_timespec_subtract_test.cc >> new file mode 100644 >> --- /dev/null >> +++ b/osaf/libs/core/common/tests/osaf_timespec_subtract_test.cc >> @@ -0,0 +1,62 @@ >> +/* -*- OpenSAF -*- >> + * >> + * (C) Copyright 2015 The OpenSAF Foundation >> + * >> + * This program is distributed in the hope that it will be useful, but >> + * WITHOUT ANY WARRANTY; without even the implied warranty of >> MERCHANTABILITY >> + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are >> licensed >> + * under the GNU Lesser General Public License Version 2.1, February >> 1999. >> + * The complete license can be accessed from the following location: >> + * http://opensource.org/licenses/lgpl-license.php >> + * See the Copying file included with the OpenSAF distribution for full >> + * licensing terms. >> + * >> + * Author(s): Ericsson AB >> + * >> + */ >> + >> +#include "osaf_time.h" >> +#include "gtest/gtest.h" >> + >> +static const timespec kOneDotOneSeconds = { 1, 100000000 }; >> +static const timespec kZeroDotTwoSeconds = { 0, 200000000 }; >> +static const timespec kZeroDotNineSeconds = { 0, 900000000 }; >> +static const timespec number1 = { 1576315623, 358743382 }; >> +static const timespec number2 = { 279394477, 639614599 }; >> +static const timespec difference = { 1296921145, 719128783 }; >> + >> +TEST(OsafTimespecSubtract, ZeroMinusZero) { >> + timespec result; >> + osaf_timespec_subtract(&kZeroSeconds, &kZeroSeconds, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kZeroSeconds), 0); >> +} >> + >> +TEST(OsafTimespecSubtract, FifteenMinusFive) { >> + timespec result = kFifteenSeconds; >> + osaf_timespec_subtract(&result, &kFiveSeconds, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kTenSeconds), 0); >> +} >> + >> +TEST(OsafTimespecSubtract, OneDotOneMinusZeroDotTwo) { >> + timespec result; >> + osaf_timespec_subtract(&kOneDotOneSeconds, &kZeroDotTwoSeconds, >> &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &kZeroDotNineSeconds), 0); >> +} >> + >> +TEST(OsafTimespecSubtract, SubtractRandomNumbers) { >> + timespec result; >> + osaf_timespec_subtract(&number1, &number2, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &difference), 0); >> +} >> + >> +TEST(OsafTimespecSubtract, FirstParameterAndResultAtSameAddress) { >> + timespec result = number1; >> + osaf_timespec_subtract(&result, &number2, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &difference), 0); >> +} >> + >> +TEST(OsafTimespecSubtract, SecondParameterAndResultAtSameAddress) { >> + timespec result = number2; >> + osaf_timespec_subtract(&number1, &result, &result); >> + EXPECT_EQ(osaf_timespec_compare(&result, &difference), 0); >> +} > ------------------------------------------------------------------------------ _______________________________________________ Opensaf-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/opensaf-devel
