Skip to content

PRIVATE -> private for Fw/Time #3755

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Jun 18, 2025
Merged

PRIVATE -> private for Fw/Time #3755

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
0223eac
PRIVATE -> private in Fw/Time
m-aleem Jun 17, 2025
1b7539a
Merge branch 'nasa:devel' into devel-3446-x
m-aleem Jun 17, 2025
3125ed0
Merge branch 'nasa:devel' into devel-3446-x
m-aleem Jun 17, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 4 additions & 1 deletion Fw/Time/Time.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,9 @@

namespace Fw {
class Time: public Serializable {

friend class TimeTester;

public:

enum {
Expand Down Expand Up @@ -79,7 +82,7 @@ namespace Fw {
#ifdef BUILD_UT // Stream operators to support Googletest
friend std::ostream& operator<<(std::ostream& os, const Time& val);
#endif
PRIVATE:
private:
U32 m_seconds; // !< seconds portion
U32 m_useconds; // !< microseconds portion
TimeBase m_timeBase; // !< basis of time (defined by system)
Expand Down
8 changes: 4 additions & 4 deletions Fw/Time/TimeInterval.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,9 +8,9 @@
//!
//! @class TimeInterval
//! @brief A class to represent a time interval holding two U32 seconds and microseconds values.
//!
//! The TimeInterval class is designed to hold a time interval and provides various methods
//! to manipulate and compare time intervals. It supports serialization and deserialization
//!
//! The TimeInterval class is designed to hold a time interval and provides various methods
//! to manipulate and compare time intervals. It supports serialization and deserialization
//! for easy storage and transmission.
//!
namespace Fw {
Expand Down Expand Up @@ -80,7 +80,7 @@ namespace Fw {
#ifdef BUILD_UT // Stream operators to support Googletest
friend std::ostream& operator<<(std::ostream& os, const TimeInterval& val);
#endif
PRIVATE:
private:
U32 m_seconds; // !< seconds portion of TimeInterval
U32 m_useconds; // !< microseconds portion of TimeInterval
};
Expand Down
226 changes: 135 additions & 91 deletions Fw/Time/test/ut/TimeTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,108 +9,152 @@
#include <iostream>
#include <gtest/gtest.h>

TEST(TimeTestNominal,InstantiateTest) {

Fw::Time time(TB_NONE,1,2);
ASSERT_EQ(time.m_timeBase,TB_NONE);
ASSERT_EQ(time.m_timeContext,0);
ASSERT_EQ(time.m_seconds,1);
ASSERT_EQ(time.m_useconds,2);
std::cout << time << std::endl;
namespace Fw {
class TimeTester{

public:
// ----------------------------------------------------------------------
// Construction and destruction
// ----------------------------------------------------------------------
TimeTester()
{
}

~TimeTester()
{
}

// ----------------------------------------------------------------------
// Tests
// ----------------------------------------------------------------------
void test_MathTest()
{
Fw::Time time1;
Fw::Time time2;

// Comparison
time1.set(1000,1000);
time2.set(1000,1000);
ASSERT_TRUE(time1 == time2);
ASSERT_TRUE(time1 >= time2);
ASSERT_TRUE(time1 <= time2);

time1.set(1000,1000);
time2.set(2000,1000);
ASSERT_TRUE(time1 != time2);
ASSERT_TRUE(time1 < time2);
ASSERT_TRUE(time1 <= time2);

time1.set(2000,1000);
time2.set(1000,1000);
ASSERT_TRUE(time1 > time2);
ASSERT_TRUE(time1 >= time2);

// Addition
time1.set(1000,1000);
time2.set(4000,2000);
Fw::Time time_sum = Fw::Time::add(time1,time2);
ASSERT_EQ(time_sum.m_seconds,5000);
ASSERT_EQ(time_sum.m_useconds,3000);

// Normal subtraction
time1.set(1000,1000);
time2.set(4000,2000);
Fw::Time time3 = Fw::Time::sub(time2,time1);
ASSERT_EQ(time3.m_timeBase,TB_NONE);
ASSERT_EQ(time3.m_timeContext,0);
ASSERT_EQ(time3.m_seconds,3000);
ASSERT_EQ(time3.m_useconds,1000);

// Rollover subtraction
time1.set(1,999999);
time2.set(2,000001);
time3 = Fw::Time::sub(time2,time1);
ASSERT_EQ(time3.m_timeBase,TB_NONE);
ASSERT_EQ(time3.m_timeContext,0);
EXPECT_EQ(time3.m_seconds,0);
EXPECT_EQ(time3.m_useconds,2);
}

void test_InstantiateTest()
{
Fw::Time time(TB_NONE,1,2);
ASSERT_EQ(time.m_timeBase,TB_NONE);
ASSERT_EQ(time.m_timeContext,0);
ASSERT_EQ(time.m_seconds,1);
ASSERT_EQ(time.m_useconds,2);
std::cout << time << std::endl;
}

void test_CopyTest()
{
Fw::Time time0;

// make time that's guaranteed to be different from default
Fw::Time time1(
(time0.getTimeBase() != TB_NONE ? TB_NONE : TB_PROC_TIME),
static_cast<FwTimeContextStoreType>(time0.getContext()+1),
time0.getSeconds()+1,
time0.getUSeconds()+1
);

// copy construction
Fw::Time time2 = time1;
ASSERT_EQ(time1.getSeconds(), time2.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time2.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time2.getTimeBase());
ASSERT_EQ(time1.getContext(), time2.getContext());

// assignment operator
Fw::Time time3;
time3 = time1;
ASSERT_EQ(time1.getSeconds(), time3.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time3.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time3.getTimeBase());
ASSERT_EQ(time1.getContext(), time3.getContext());

// set method
Fw::Time time4;
time4.set(time1.getTimeBase(), time1.getContext(), time1.getSeconds(), time1.getUSeconds());
ASSERT_EQ(time1.getSeconds(), time3.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time3.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time3.getTimeBase());
ASSERT_EQ(time1.getContext(), time3.getContext());

}

void test_ZeroTimeEquality()
{
Fw::Time time(TB_PROC_TIME,1,2);
ASSERT_NE(time, Fw::ZERO_TIME);
Fw::Time time2;
ASSERT_EQ(time2, Fw::ZERO_TIME);
}

};
}

TEST(TimeTestNominal,MathTest) {

Fw::Time time1;
Fw::Time time2;

// Comparison
time1.set(1000,1000);
time2.set(1000,1000);
ASSERT_TRUE(time1 == time2);
ASSERT_TRUE(time1 >= time2);
ASSERT_TRUE(time1 <= time2);

time1.set(1000,1000);
time2.set(2000,1000);
ASSERT_TRUE(time1 != time2);
ASSERT_TRUE(time1 < time2);
ASSERT_TRUE(time1 <= time2);

time1.set(2000,1000);
time2.set(1000,1000);
ASSERT_TRUE(time1 > time2);
ASSERT_TRUE(time1 >= time2);

// Addition
time1.set(1000,1000);
time2.set(4000,2000);
Fw::Time time_sum = Fw::Time::add(time1,time2);
ASSERT_EQ(time_sum.m_seconds,5000);
ASSERT_EQ(time_sum.m_useconds,3000);

// Normal subtraction
time1.set(1000,1000);
time2.set(4000,2000);
Fw::Time time3 = Fw::Time::sub(time2,time1);
ASSERT_EQ(time3.m_timeBase,TB_NONE);
ASSERT_EQ(time3.m_timeContext,0);
ASSERT_EQ(time3.m_seconds,3000);
ASSERT_EQ(time3.m_useconds,1000);

// Rollover subtraction
time1.set(1,999999);
time2.set(2,000001);
time3 = Fw::Time::sub(time2,time1);
ASSERT_EQ(time3.m_timeBase,TB_NONE);
ASSERT_EQ(time3.m_timeContext,0);
EXPECT_EQ(time3.m_seconds,0);
EXPECT_EQ(time3.m_useconds,2);

TEST(TimeTestNominal,InstantiateTest) {
Fw::TimeTester tester;
tester.test_InstantiateTest();
}

TEST(TimeTestNominal,CopyTest) {
TEST(TimeTestNominal,MathTest) {
Fw::TimeTester tester;
tester.test_MathTest();

Fw::Time time0;

// make time that's guaranteed to be different from default
Fw::Time time1(
(time0.getTimeBase() != TB_NONE ? TB_NONE : TB_PROC_TIME),
static_cast<FwTimeContextStoreType>(time0.getContext()+1),
time0.getSeconds()+1,
time0.getUSeconds()+1
);

// copy construction
Fw::Time time2 = time1;
ASSERT_EQ(time1.getSeconds(), time2.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time2.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time2.getTimeBase());
ASSERT_EQ(time1.getContext(), time2.getContext());

// assignment operator
Fw::Time time3;
time3 = time1;
ASSERT_EQ(time1.getSeconds(), time3.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time3.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time3.getTimeBase());
ASSERT_EQ(time1.getContext(), time3.getContext());

// set method
Fw::Time time4;
time4.set(time1.getTimeBase(), time1.getContext(), time1.getSeconds(), time1.getUSeconds());
ASSERT_EQ(time1.getSeconds(), time3.getSeconds());
ASSERT_EQ(time1.getUSeconds(), time3.getUSeconds());
ASSERT_EQ(time1.getTimeBase(), time3.getTimeBase());
ASSERT_EQ(time1.getContext(), time3.getContext());
}

TEST(TimeTestNominal,CopyTest) {
Fw::TimeTester tester;
tester.test_CopyTest();
}

TEST(TimeTestNominal,ZeroTimeEquality) {
Fw::Time time(TB_PROC_TIME,1,2);
ASSERT_NE(time, Fw::ZERO_TIME);
Fw::Time time2;
ASSERT_EQ(time2, Fw::ZERO_TIME);
Fw::TimeTester tester;
tester.test_ZeroTimeEquality();
}

int main(int argc, char* argv[]) {
Expand Down
Loading