and one more minor thing, in google test AdvancedGuide it is recommended to name the death tests to include Death, e.g. TEST(MyDeathTest, Foo). /Thanks HansN |
| On 12/15/2015 10:23 AM, Anders Widell wrote: > 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
