Merge pull request #5 from bringauto/fix_incorrect_buffer_sizes

fix buffer sizes

Author: MarioIvancik

.gitignore

@@ -1,3 +1,4 @@
 _*
 cmake-build-debug
-.idea/
+.idea/
+.vscode/

CMakeLists.txt

@@ -4,7 +4,7 @@ PROJECT(fleet-protocol C CXX)
 SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
 SET(CMAKE_CXX_STANDARD 20)
 
-SET(FLEET_PROTOCOL_CXX_HELPERS_VERSION 1.1.0)
+SET(FLEET_PROTOCOL_CXX_HELPERS_VERSION 1.1.1)
 SET(FLEET_PROTOCOL_INTERFACE_VERSION 2.0.0)
 
 FIND_PACKAGE(CMLIB

source/bringauto/fleet_protocol/cxx/DeviceID.cpp

@@ -19,15 +19,15 @@ DeviceID::DeviceID(int module, unsigned int device_type, unsigned int priority,
 }
 
 DeviceID::DeviceID(const device_identification& device_id):
-	device_role_(static_cast<char*>(device_id.device_role.data), device_id.device_role.size_in_bytes - 1),
-	device_name_(static_cast<char*>(device_id.device_name.data), device_id.device_name.size_in_bytes - 1) {
+	device_role_(static_cast<char*>(device_id.device_role.data), device_id.device_role.size_in_bytes),
+	device_name_(static_cast<char*>(device_id.device_name.data), device_id.device_name.size_in_bytes) {
 	id_.device_type = device_id.device_type;
 	id_.module = device_id.module;
 	id_.priority = device_id.priority;
 	id_.device_role.data = const_cast<char*>(device_role_.c_str());
-	id_.device_role.size_in_bytes = device_role_.size() + 1;
+	id_.device_role.size_in_bytes = device_role_.size();
 	id_.device_name.data = const_cast<char*>(device_name_.c_str());
-	id_.device_name.size_in_bytes = device_name_.size() + 1;
+	id_.device_name.size_in_bytes = device_name_.size();
 }
 
 DeviceID::DeviceID(DeviceID&& c) noexcept:
@@ -40,18 +40,18 @@ DeviceID::DeviceID(DeviceID&& c) noexcept:
 
 device_identification DeviceID::createStandaloneDeviceId() const {
 	device_identification device_id{};
-	if(::allocate(&device_id.device_name, device_name_.size() + 1) != ::OK) {
+	if(::allocate(&device_id.device_name, device_name_.size()) != ::OK) {
 		throw std::runtime_error("Cannot allocate space for Device Name");
 	}
-	if(::allocate(&device_id.device_role, device_role_.size() + 1) != ::OK) {
+	if(::allocate(&device_id.device_role, device_role_.size()) != ::OK) {
 		throw std::runtime_error("Cannot allocate space for Device Role");
 	}
 	std::memcpy(device_id.device_name.data,
 	            device_name_.c_str(),
-	            device_name_.size() + 1);
+	            device_name_.size());
 	std::memcpy(device_id.device_role.data,
 	            device_role_.c_str(),
-	            device_role_.size() + 1);
+	            device_role_.size());
 	device_id.device_type = id_.device_type;
 	device_id.module = id_.module;
 	device_id.priority = id_.priority;

source/bringauto/fleet_protocol/cxx/StringAsBuffer.cpp

@@ -10,10 +10,9 @@
 namespace bringauto::fleet_protocol::cxx {
 
 void StringAsBuffer::createBufferAndCopyData(::buffer* buff, const std::string_view& data) {
-	if(::allocate(buff, data.size() + 1) != OK) {
+	if(::allocate(buff, data.size()) != OK) {
 		throw std::runtime_error("Cannot allocate memory for 'std::string' to 'buffer' conversion");
 	}
-	std::cout << "createBufferAndCOpyData Data size: " << data.size() + 1 << std::endl;
 	BufferAsString strbuff{buff};
 	strbuff.copyFromString(data);
 }

test/source/BufferAsStringTest.cpp

@@ -8,14 +8,14 @@ using namespace bringauto::fleet_protocol::cxx;
 
 TEST(BufferAsString_tests, Initialize) {
 	struct buffer buff;
-	::allocate(&buff, 5);
-	std::memcpy(buff.data, "abcd", 5);
+	::allocate(&buff, 4);
+	std::memcpy(buff.data, "abcd", 4);
 	BufferAsString buffAsString(&buff);
 
-	EXPECT_EQ(buff.size_in_bytes, 5);
+	EXPECT_EQ(buff.size_in_bytes, 4);
 	EXPECT_STREQ(std::string(buffAsString.getStringView()).c_str(), "abcd");
 	EXPECT_TRUE(*buffAsString.cbegin() == 'a');
-	EXPECT_STREQ(std::prev(buffAsString.cend()), "");
+	EXPECT_TRUE(*std::prev(buffAsString.cend()) == 'd');
 
 	::deallocate(&buff);
 }
@@ -45,7 +45,7 @@ TEST(BufferAsString_tests, Copy_string) {
 TEST(BufferAsString_tests, Copy_string_buffer_no_data) {
 	struct buffer buff;
 	buff.data = nullptr;
-	buff.size_in_bytes = 5;
+	buff.size_in_bytes = 4;
 	BufferAsString buffAsString(&buff);
 
 	bool failed = false;
@@ -61,8 +61,8 @@ TEST(BufferAsString_tests, Copy_string_buffer_no_data) {
 
 TEST(BufferAsString_tests, Copy_string_too_much_data) {
 	struct buffer buff;
-	::allocate(&buff, 5);
-	std::memcpy(buff.data, "abcd", 5);
+	::allocate(&buff, 4);
+	std::memcpy(buff.data, "abcd", 4);
 	BufferAsString buffAsString(&buff);
 
 	bool failed = false;

test/source/DeviceIDTest.cpp

@@ -27,10 +27,10 @@ TEST(DeviceID_tests, Constructor_from_device_id) {
 	deviceID1.module = 1;
 	deviceID1.device_type = 2;
 	deviceID1.priority = 3;
-	::allocate(&deviceID1.device_role, 6);
-	::allocate(&deviceID1.device_name, 7);
-	std::memcpy(deviceID1.device_role.data, "Slave", 6);
-	std::memcpy(deviceID1.device_name.data, "Device", 7);
+	::allocate(&deviceID1.device_role, 5);
+	::allocate(&deviceID1.device_name, 6);
+	std::memcpy(deviceID1.device_role.data, "Slave", 5);
+	std::memcpy(deviceID1.device_name.data, "Device", 6);
 
 	DeviceID device(deviceID1);
 	device_identification deviceID2 = device.getDeviceId();
@@ -72,10 +72,10 @@ TEST(DeviceID_tests, Standalone_device_id) {
 	EXPECT_EQ(deviceID.module, 1);
 	EXPECT_EQ(deviceID.device_type, 2);
 	EXPECT_EQ(deviceID.priority, 3);
-	std::string role(static_cast<char*>(deviceID.device_role.data));
-	EXPECT_STREQ(role.c_str(), "Slave");
-	std::string name(static_cast<char*>(deviceID.device_name.data));
-	EXPECT_STREQ(name.c_str(), "Device");
+	std::string_view role(static_cast<char*>(deviceID.device_role.data), deviceID.device_role.size_in_bytes);
+	EXPECT_STREQ(std::string(role).c_str(), "Slave");
+	std::string_view name(static_cast<char*>(deviceID.device_name.data), deviceID.device_name.size_in_bytes);
+	EXPECT_STREQ(std::string(name).c_str(), "Device");
 
 	::deallocate(&deviceID.device_role);
 	::deallocate(&deviceID.device_name);

test/source/KeyValueConfigTest.cpp

@@ -11,18 +11,18 @@ TEST(KeyValueConfig_tests, Initialize) {
 	::config configData;
 	configData.size = 3;
 	key_value params[3];
-	::allocate(&params[0].key, 5);
-	std::memcpy(params[0].key.data, "Key1", 5);
-	::allocate(&params[0].value, 7);
-	std::memcpy(params[0].value.data, "Value1", 7);
-	::allocate(&params[1].key, 5);
-	std::memcpy(params[1].key.data, "Key2", 5);
-	::allocate(&params[1].value, 7);
-	std::memcpy(params[1].value.data, "Value2", 7);
-	::allocate(&params[2].key, 5);
-	std::memcpy(params[2].key.data, "Key3", 5);
-	::allocate(&params[2].value, 7);
-	std::memcpy(params[2].value.data, "Value3", 7);
+	::allocate(&params[0].key, 4);
+	std::memcpy(params[0].key.data, "Key1", 4);
+	::allocate(&params[0].value, 6);
+	std::memcpy(params[0].value.data, "Value1", 6);
+	::allocate(&params[1].key, 4);
+	std::memcpy(params[1].key.data, "Key2", 4);
+	::allocate(&params[1].value, 6);
+	std::memcpy(params[1].value.data, "Value2", 6);
+	::allocate(&params[2].key, 4);
+	std::memcpy(params[2].key.data, "Key3", 4);
+	::allocate(&params[2].value, 6);
+	std::memcpy(params[2].value.data, "Value3", 6);
 	configData.parameters = params;
 	KeyValueConfig kvConfig(configData);
 
@@ -44,10 +44,10 @@ TEST(KeyValueConfig_tests, Zero_size) {
 	::config configData;
 	configData.size = 0;
 	key_value params[1];
-	::allocate(&params[0].key, 4);
-	std::memcpy(params[0].key.data, "Key", 4);
-	::allocate(&params[0].value, 6);
-	std::memcpy(params[0].value.data, "Value", 6);
+	::allocate(&params[0].key, 3);
+	std::memcpy(params[0].key.data, "Key", 3);
+	::allocate(&params[0].value, 5);
+	std::memcpy(params[0].value.data, "Value", 5);
 	configData.parameters = params;
 	KeyValueConfig kvConfig(configData);
 

test/source/StringAsBufferTest.cpp

@@ -9,10 +9,11 @@ using namespace bringauto::fleet_protocol::cxx;
 
 TEST(StringAsBuffer_tests, Create_buffer) {
 	struct buffer buff;
-	StringAsBuffer::createBufferAndCopyData(&buff, const_cast<char*>("abcd"));
+	StringAsBuffer::createBufferAndCopyData(&buff, std::string("abcd"));
 
-	EXPECT_EQ(buff.size_in_bytes, 5);
-	EXPECT_STREQ(static_cast<char*>(buff.data), "abcd");
+	EXPECT_EQ(buff.size_in_bytes, 4);
+	std::string_view data(static_cast<char*>(buff.data), buff.size_in_bytes);
+	EXPECT_STREQ(std::string(data).c_str(), "abcd");
 
 	::deallocate(&buff);
 }