Skip to content

Commit 26db6ce

Browse files
m-aleemm-aleem
authored
PRIVATE -> private for Fw/Buffer.hpp (#3754)
1 parent 58cfd95 commit 26db6ce

File tree

2 files changed

+147
-119
lines changed

2 files changed

+147
-119
lines changed

‎Fw/Buffer/Buffer.hpp‎

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,9 @@
2222
#endif
2323
#endif
2424

25+
// Forward declaration for UTs
26+
namespace Fw { class BufferTester; }
27+
2528
namespace Fw {
2629

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

47+
friend class Fw::BufferTester;
48+
4449
public:
4550

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

108113

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

186-
PRIVATE:
191+
private:
187192
Fw::ExternalSerializeBuffer m_serialize_repr; //<! Representation for serialization and deserialization functions
188193
U8* m_bufferData; //<! data - A pointer to the data
189194
SizeType m_size; //<! size - The data size in bytes

‎Fw/Buffer/test/ut/TestBuffer.cpp‎

Lines changed: 138 additions & 115 deletions
Original file line numberDiff line numberDiff line change
@@ -5,130 +5,153 @@
55
#include <Fw/FPrimeBasicTypes.hpp>
66
#include <gtest/gtest.h>
77

8-
9-
void test_basic() {
10-
U8 data[100];
11-
U8 faux[100];
12-
Fw::Buffer buffer;
13-
// Check basic guarantees
14-
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
15-
buffer.setData(data);
16-
buffer.setSize(sizeof(data));
17-
buffer.setContext(1234);
18-
ASSERT_EQ(buffer.getData(), data);
19-
ASSERT_EQ(buffer.getSize(), sizeof(data));
20-
ASSERT_EQ(buffer.getContext(), 1234);
21-
22-
// Test set method is equivalent
23-
Fw::Buffer buffer_set;
24-
buffer_set.set(data, sizeof(data), 1234);
25-
ASSERT_EQ(buffer_set, buffer);
26-
27-
// Check constructors and assignments
28-
Fw::Buffer buffer_new(buffer);
29-
ASSERT_EQ(buffer_new.getData(), data);
30-
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
31-
ASSERT_EQ(buffer_new.getContext(), 1234);
32-
ASSERT_EQ(buffer, buffer_new);
33-
34-
// Creating empty buffer
35-
Fw::Buffer testBuffer(nullptr,0);
36-
ASSERT_EQ(testBuffer.getData(), nullptr);
37-
ASSERT_EQ(testBuffer.getSize(), 0);
38-
39-
// Assignment operator with transitivity
40-
Fw::Buffer buffer_assignment1, buffer_assignment2;
41-
ASSERT_NE(buffer_assignment1.getData(), data);
42-
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
43-
ASSERT_NE(buffer_assignment1.getContext(), 1234);
44-
ASSERT_NE(buffer_assignment2.getData(), data);
45-
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
46-
ASSERT_NE(buffer_assignment2.getContext(), 1234);
47-
buffer_assignment1 = buffer_assignment2 = buffer;
48-
ASSERT_EQ(buffer_assignment1.getData(), data);
49-
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
50-
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
51-
ASSERT_EQ(buffer_assignment2.getData(), data);
52-
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
53-
ASSERT_EQ(buffer_assignment2.getContext(), 1234);
54-
55-
// Check modifying the copies does not destroy
56-
buffer_new.setSize(0);
57-
buffer_new.setData(faux);
58-
buffer_new.setContext(22222);
59-
buffer_assignment1.setSize(0);
60-
buffer_assignment1.setData(faux);
61-
buffer_assignment1.setContext(22222);
62-
buffer_assignment2.setSize(0);
63-
buffer_assignment2.setData(faux);
64-
buffer_assignment2.setContext(22222);
65-
66-
ASSERT_EQ(buffer.getData(), data);
67-
ASSERT_EQ(buffer.getSize(), sizeof(data));
68-
ASSERT_EQ(buffer.getContext(), 1234);
69-
}
70-
71-
void test_representations() {
72-
U8 data[100];
73-
Fw::Buffer buffer;
74-
buffer.setData(data);
75-
buffer.setSize(sizeof(data));
76-
buffer.setContext(1234);
77-
78-
// Test serialization and that it stops before overflowing
79-
auto serializer = buffer.getSerializer();
80-
for (U32 i = 0; i < sizeof(data)/4; i++) {
81-
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
82-
}
83-
Fw::SerializeStatus stat = serializer.serialize(100);
84-
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);
85-
86-
// And that another call to repr resets it
87-
serializer.resetSer();
88-
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);
89-
90-
// Now deserialize all the things
91-
auto deserializer = buffer.getDeserializer();
92-
U32 out;
93-
for (U32 i = 0; i < sizeof(data)/4; i++) {
94-
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
95-
ASSERT_EQ(i, out);
96-
}
97-
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
98-
deserializer.setBuffLen(buffer.getSize());
99-
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
100-
ASSERT_EQ(0, out);
8+
namespace Fw {
9+
class BufferTester{
10+
11+
12+
public:
13+
// ----------------------------------------------------------------------
14+
// Construction and destruction
15+
// ----------------------------------------------------------------------
16+
BufferTester()
17+
{
18+
}
19+
20+
~BufferTester()
21+
{
22+
}
23+
24+
// ----------------------------------------------------------------------
25+
// Tests
26+
// ----------------------------------------------------------------------
27+
void test_basic() {
28+
U8 data[100];
29+
U8 faux[100];
30+
Fw::Buffer buffer;
31+
// Check basic guarantees
32+
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
33+
buffer.setData(data);
34+
buffer.setSize(sizeof(data));
35+
buffer.setContext(1234);
36+
ASSERT_EQ(buffer.getData(), data);
37+
ASSERT_EQ(buffer.getSize(), sizeof(data));
38+
ASSERT_EQ(buffer.getContext(), 1234);
39+
40+
// Test set method is equivalent
41+
Fw::Buffer buffer_set;
42+
buffer_set.set(data, sizeof(data), 1234);
43+
ASSERT_EQ(buffer_set, buffer);
44+
45+
// Check constructors and assignments
46+
Fw::Buffer buffer_new(buffer);
47+
ASSERT_EQ(buffer_new.getData(), data);
48+
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
49+
ASSERT_EQ(buffer_new.getContext(), 1234);
50+
ASSERT_EQ(buffer, buffer_new);
51+
52+
// Creating empty buffer
53+
Fw::Buffer testBuffer(nullptr,0);
54+
ASSERT_EQ(testBuffer.getData(), nullptr);
55+
ASSERT_EQ(testBuffer.getSize(), 0);
56+
57+
// Assignment operator with transitivity
58+
Fw::Buffer buffer_assignment1, buffer_assignment2;
59+
ASSERT_NE(buffer_assignment1.getData(), data);
60+
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
61+
ASSERT_NE(buffer_assignment1.getContext(), 1234);
62+
ASSERT_NE(buffer_assignment2.getData(), data);
63+
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
64+
ASSERT_NE(buffer_assignment2.getContext(), 1234);
65+
buffer_assignment1 = buffer_assignment2 = buffer;
66+
ASSERT_EQ(buffer_assignment1.getData(), data);
67+
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
68+
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
69+
ASSERT_EQ(buffer_assignment2.getData(), data);
70+
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
71+
ASSERT_EQ(buffer_assignment2.getContext(), 1234);
72+
73+
// Check modifying the copies does not destroy
74+
buffer_new.setSize(0);
75+
buffer_new.setData(faux);
76+
buffer_new.setContext(22222);
77+
buffer_assignment1.setSize(0);
78+
buffer_assignment1.setData(faux);
79+
buffer_assignment1.setContext(22222);
80+
buffer_assignment2.setSize(0);
81+
buffer_assignment2.setData(faux);
82+
buffer_assignment2.setContext(22222);
83+
84+
ASSERT_EQ(buffer.getData(), data);
85+
ASSERT_EQ(buffer.getSize(), sizeof(data));
86+
ASSERT_EQ(buffer.getContext(), 1234);
87+
}
88+
89+
void test_representations() {
90+
U8 data[100];
91+
Fw::Buffer buffer;
92+
buffer.setData(data);
93+
buffer.setSize(sizeof(data));
94+
buffer.setContext(1234);
95+
96+
// Test serialization and that it stops before overflowing
97+
auto serializer = buffer.getSerializer();
98+
for (U32 i = 0; i < sizeof(data)/4; i++) {
99+
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
100+
}
101+
Fw::SerializeStatus stat = serializer.serialize(100);
102+
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);
103+
104+
// And that another call to repr resets it
105+
serializer.resetSer();
106+
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);
107+
108+
// Now deserialize all the things
109+
auto deserializer = buffer.getDeserializer();
110+
U32 out;
111+
for (U32 i = 0; i < sizeof(data)/4; i++) {
112+
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
113+
ASSERT_EQ(i, out);
114+
}
115+
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
116+
deserializer.setBuffLen(buffer.getSize());
117+
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
118+
ASSERT_EQ(0, out);
119+
}
120+
121+
void test_serialization() {
122+
U8 data[100];
123+
U8 wire[100];
124+
125+
Fw::Buffer buffer;
126+
buffer.setData(data);
127+
buffer.setSize(sizeof(data));
128+
buffer.setContext(1234);
129+
130+
Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
131+
externalSerializeBuffer.serialize(buffer);
132+
ASSERT_LT(externalSerializeBuffer.m_serLoc, sizeof(data));
133+
134+
Fw::Buffer buffer_new;
135+
externalSerializeBuffer.deserialize(buffer_new);
136+
ASSERT_EQ(buffer_new, buffer);
137+
}
138+
139+
};
101140
}
102141

103-
void test_serialization() {
104-
U8 data[100];
105-
U8 wire[100];
106-
107-
Fw::Buffer buffer;
108-
buffer.setData(data);
109-
buffer.setSize(sizeof(data));
110-
buffer.setContext(1234);
111-
112-
Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
113-
externalSerializeBuffer.serialize(buffer);
114-
ASSERT_LT(externalSerializeBuffer.m_serLoc, sizeof(data));
115-
116-
Fw::Buffer buffer_new;
117-
externalSerializeBuffer.deserialize(buffer_new);
118-
ASSERT_EQ(buffer_new, buffer);
119-
}
120-
121-
122142
TEST(Nominal, BasicBuffer) {
123-
test_basic();
143+
Fw::BufferTester tester;
144+
tester.test_basic();
124145
}
125146

126147
TEST(Nominal, Representations) {
127-
test_representations();
148+
Fw::BufferTester tester;
149+
tester.test_representations();
128150
}
129151

130152
TEST(Nominal, Serialization) {
131-
test_serialization();
153+
Fw::BufferTester tester;
154+
tester.test_serialization();
132155
}
133156

134157

0 commit comments

Comments
 (0)