Skip to content

PRIVATE -> private for Fw/Buffer #3754

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
LeStarch merged 2 commits into from
Jun 17, 2025
Merged

PRIVATE -> private for Fw/Buffer #3754

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ca5eff7
PRIVATE -> private for Fw/Buffer.hpp
m-aleem Jun 17, 2025
fed9dcb
Merge branch 'nasa:devel' into devel-3446-w
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
13 changes: 9 additions & 4 deletions Fw/Buffer/Buffer.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,9 @@
#endif
#endif

// Forward declaration for UTs
namespace Fw { class BufferTester; }

namespace Fw {

//! Buffer used for wrapping pointer to data for efficient transmission
Expand All @@ -41,6 +44,8 @@ namespace Fw {
//!
class Buffer : public Fw::Serializable {

friend class Fw::BufferTester;

public:

//! The size type for a buffer
Expand Down Expand Up @@ -98,16 +103,16 @@ class Buffer : public Fw::Serializable {
//! Returns a ExternalSerializeBufferWithMemberCopy representation of the wrapped data for serializing
//!
//! \warning The serialization pointer of the returned ExternalSerializeBufferWithMemberCopy object is set to zero
//! \warning so that serialization will start at the beginning of the memory pointed to by the Fw::Buffer. If that
//! \warning behavior is not desired the caller may manipulate the serialization offsets with moveSerToOffset
//! \warning so that serialization will start at the beginning of the memory pointed to by the Fw::Buffer. If that
//! \warning behavior is not desired the caller may manipulate the serialization offsets with moveSerToOffset
//! \warning and serializeSkip methods prior to serialization.
//!
//! \return representation of the wrapped data to aid in serializing to it
ExternalSerializeBufferWithMemberCopy getSerializer();


//! Returns a ExternalSerializeBufferWithMemberCopy representation of the wrapped data for deserializing
//!
//!
//! \warning The entire buffer (up to getSize) is available for deserialization.
//!
//! \return representation of the wrapped data to aid in deserializing to it
Expand Down Expand Up @@ -183,7 +188,7 @@ class Buffer : public Fw::Serializable {
friend std::ostream& operator<<(std::ostream& os, const Buffer& obj);
#endif

PRIVATE:
private:
Fw::ExternalSerializeBuffer m_serialize_repr; //<! Representation for serialization and deserialization functions
U8* m_bufferData; //<! data - A pointer to the data
SizeType m_size; //<! size - The data size in bytes
Expand Down
253 changes: 138 additions & 115 deletions Fw/Buffer/test/ut/TestBuffer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,130 +5,153 @@
#include <Fw/FPrimeBasicTypes.hpp>
#include <gtest/gtest.h>


void test_basic() {
U8 data[100];
U8 faux[100];
Fw::Buffer buffer;
// Check basic guarantees
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);

// Test set method is equivalent
Fw::Buffer buffer_set;
buffer_set.set(data, sizeof(data), 1234);
ASSERT_EQ(buffer_set, buffer);

// Check constructors and assignments
Fw::Buffer buffer_new(buffer);
ASSERT_EQ(buffer_new.getData(), data);
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
ASSERT_EQ(buffer_new.getContext(), 1234);
ASSERT_EQ(buffer, buffer_new);

// Creating empty buffer
Fw::Buffer testBuffer(nullptr,0);
ASSERT_EQ(testBuffer.getData(), nullptr);
ASSERT_EQ(testBuffer.getSize(), 0);

// Assignment operator with transitivity
Fw::Buffer buffer_assignment1, buffer_assignment2;
ASSERT_NE(buffer_assignment1.getData(), data);
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment1.getContext(), 1234);
ASSERT_NE(buffer_assignment2.getData(), data);
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment2.getContext(), 1234);
buffer_assignment1 = buffer_assignment2 = buffer;
ASSERT_EQ(buffer_assignment1.getData(), data);
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
ASSERT_EQ(buffer_assignment2.getData(), data);
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment2.getContext(), 1234);

// Check modifying the copies does not destroy
buffer_new.setSize(0);
buffer_new.setData(faux);
buffer_new.setContext(22222);
buffer_assignment1.setSize(0);
buffer_assignment1.setData(faux);
buffer_assignment1.setContext(22222);
buffer_assignment2.setSize(0);
buffer_assignment2.setData(faux);
buffer_assignment2.setContext(22222);

ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
}

void test_representations() {
U8 data[100];
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);

// Test serialization and that it stops before overflowing
auto serializer = buffer.getSerializer();
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
}
Fw::SerializeStatus stat = serializer.serialize(100);
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);

// And that another call to repr resets it
serializer.resetSer();
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);

// Now deserialize all the things
auto deserializer = buffer.getDeserializer();
U32 out;
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(i, out);
}
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
deserializer.setBuffLen(buffer.getSize());
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(0, out);
namespace Fw {
class BufferTester{


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

~BufferTester()
{
}

// ----------------------------------------------------------------------
// Tests
// ----------------------------------------------------------------------
void test_basic() {
U8 data[100];
U8 faux[100];
Fw::Buffer buffer;
// Check basic guarantees
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);

// Test set method is equivalent
Fw::Buffer buffer_set;
buffer_set.set(data, sizeof(data), 1234);
ASSERT_EQ(buffer_set, buffer);

// Check constructors and assignments
Fw::Buffer buffer_new(buffer);
ASSERT_EQ(buffer_new.getData(), data);
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
ASSERT_EQ(buffer_new.getContext(), 1234);
ASSERT_EQ(buffer, buffer_new);

// Creating empty buffer
Fw::Buffer testBuffer(nullptr,0);
ASSERT_EQ(testBuffer.getData(), nullptr);
ASSERT_EQ(testBuffer.getSize(), 0);

// Assignment operator with transitivity
Fw::Buffer buffer_assignment1, buffer_assignment2;
ASSERT_NE(buffer_assignment1.getData(), data);
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment1.getContext(), 1234);
ASSERT_NE(buffer_assignment2.getData(), data);
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment2.getContext(), 1234);
buffer_assignment1 = buffer_assignment2 = buffer;
ASSERT_EQ(buffer_assignment1.getData(), data);
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
ASSERT_EQ(buffer_assignment2.getData(), data);
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment2.getContext(), 1234);

// Check modifying the copies does not destroy
buffer_new.setSize(0);
buffer_new.setData(faux);
buffer_new.setContext(22222);
buffer_assignment1.setSize(0);
buffer_assignment1.setData(faux);
buffer_assignment1.setContext(22222);
buffer_assignment2.setSize(0);
buffer_assignment2.setData(faux);
buffer_assignment2.setContext(22222);

ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
}

void test_representations() {
U8 data[100];
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);

// Test serialization and that it stops before overflowing
auto serializer = buffer.getSerializer();
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
}
Fw::SerializeStatus stat = serializer.serialize(100);
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);

// And that another call to repr resets it
serializer.resetSer();
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);

// Now deserialize all the things
auto deserializer = buffer.getDeserializer();
U32 out;
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(i, out);
}
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
deserializer.setBuffLen(buffer.getSize());
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(0, out);
}

void test_serialization() {
U8 data[100];
U8 wire[100];

Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);

Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
externalSerializeBuffer.serialize(buffer);
ASSERT_LT(externalSerializeBuffer.m_serLoc, sizeof(data));

Fw::Buffer buffer_new;
externalSerializeBuffer.deserialize(buffer_new);
ASSERT_EQ(buffer_new, buffer);
}

};
}

void test_serialization() {
U8 data[100];
U8 wire[100];

Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);

Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
externalSerializeBuffer.serialize(buffer);
ASSERT_LT(externalSerializeBuffer.m_serLoc, sizeof(data));

Fw::Buffer buffer_new;
externalSerializeBuffer.deserialize(buffer_new);
ASSERT_EQ(buffer_new, buffer);
}


TEST(Nominal, BasicBuffer) {
test_basic();
Fw::BufferTester tester;
tester.test_basic();
}

TEST(Nominal, Representations) {
test_representations();
Fw::BufferTester tester;
tester.test_representations();
}

TEST(Nominal, Serialization) {
test_serialization();
Fw::BufferTester tester;
tester.test_serialization();
}


Expand Down
Loading