Merged in feature/PROTO-33-improve-sonar-score-and-coverag (pull request #15)

Feature/PROTO-33 improve sonar score and coverag

bitbucket-pipelines.yml

@@ -17,8 +17,6 @@ pipelines:
           - source bitbucket-pipelines-dependencies.sh
 
           - ./build_test.sh
-          - ./build/test/test_EmbeddedProto --gtest_output="xml:build/test/test_details.xml"
-
           - ./code_coverage.sh
 
           - cd build/test

code_coverage.sh

@@ -1,4 +1,4 @@
-#! /bin/sh
+#! /bin/bash
 
 #
 # Copyright (C) 2020 Embedded AMS B.V. - All Rights Reserved
@@ -30,19 +30,32 @@
 #   the Netherlands
 #
 
-./build/test/test_EmbeddedProto
+./build/test/test_EmbeddedProto --gtest_output="xml:build/test/test_details.xml"
 
-# rm -rf ./code_coverage_report/*
-# lcov --directory ./build/test --capture --output-file ./code_coverage_report/total_code_coverage.info -rc lcov_branch_coverage=1
-# lcov --remove ./code_coverage_report/total_code_coverage.info $PWD'/external/googletest/*' '/usr/include/*' -o ./code_coverage_report/filtered_code_coverage.info
-# genhtml ./code_coverage_report/filtered_code_coverage.info --branch-coverage --output-directory ./code_coverage_report
 
-rm -rf ./code_coverage_report/*
-mkdir -p code_coverage_report
-cd code_coverage_report
+if [ $# -eq 0 ]; then
+  # No arguments provided, execte the analyisis for sonar qube.
+  rm -rf ./code_coverage_report/*
+  mkdir -p code_coverage_report
+  cd code_coverage_report
 
-# Run gcov on the static source files.
-gcov ../test/*.cpp --object-directory ../build/test/CMakeFiles/test_EmbeddedProto.dir/test/ 
-gcov ../src/*.cpp --object-directory ../build/test/CMakeFiles/test_EmbeddedProto.dir/src/
+  # Run gcov on the static source files.
+  gcov ../test/*.cpp --object-directory ../build/test/CMakeFiles/test_EmbeddedProto.dir/test/ 
+  gcov ../src/*.cpp --object-directory ../build/test/CMakeFiles/test_EmbeddedProto.dir/src/
 
-cd -
+  cd -
+
+else
+# Pass commands
+case "$1" in
+  -l|--local)
+    # Run the code coverage for local machine analysis
+    rm -rf ./code_coverage_report/*
+    lcov --directory ./build/test --capture --output-file ./code_coverage_report/total_code_coverage.info -rc lcov_branch_coverage=1
+    lcov --remove ./code_coverage_report/total_code_coverage.info $PWD'/external/googletest/*' '/usr/include/*' -o ./code_coverage_report/filtered_code_coverage.info
+    genhtml ./code_coverage_report/filtered_code_coverage.info --branch-coverage --output-directory ./code_coverage_report
+    ;;
+  *)
+    ;;
+esac
+fi

src/MessageSizeCalculator.h

@@ -50,11 +50,7 @@ namespace EmbeddedProto
   class MessageSizeCalculator : public WriteBufferInterface
   {
     public:
-      MessageSizeCalculator()
-        : size_(0)
-      { 
-      };
-
+      MessageSizeCalculator() = default;
       ~MessageSizeCalculator() override = default;
       
       //! Reset the size count of the buffer.
@@ -103,7 +99,7 @@ namespace EmbeddedProto
     private:
 
       //! The calculated size of the buffer.
-      uint32_t size_;
+      uint32_t size_ = 0;
 
   }; // End of class MessageSizeCalculator
 

src/ReadBufferSection.cpp

@@ -30,15 +30,18 @@
 
 #include "ReadBufferSection.h"
 
+#include <algorithm>
+
+
 namespace EmbeddedProto 
 {
 
   ReadBufferSection::ReadBufferSection(ReadBufferInterface& buffer, const uint32_t size)
     : buffer_(buffer),
-      size_(size),
-      max_size_(size)
+      size_(std::min(size, buffer.get_size())),
+      max_size_(std::min(size, buffer.get_size()))
   {
-
+    
   }
 
   uint32_t ReadBufferSection::get_size() const
@@ -66,6 +69,7 @@ namespace EmbeddedProto
     if(0 < size_) 
     {
       buffer_.advance();
+      --size_;
     }
   }
 

test/test_IncludeOtherFiles.cpp

@@ -46,10 +46,10 @@ using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SetArgReferee;
 
+
 namespace test_EmbeddedAMS_IncludeOtherFiles
 {
 
-
 static constexpr uint32_t RF_SIZE = 3;
 
 TEST(IncludeOtherFiles, zero) 
@@ -118,6 +118,7 @@ TEST(IncludeOtherFiles, get)
 
   ::IncludedMessages<RF_SIZE> msg;
   Mocks::ReadBufferMock buffer;
+  ON_CALL(buffer, get_size()).WillByDefault(Return(22));
 
   uint8_t referee[] = { 0x08, 0x01, // state
                        // cmsg

test/test_MessageSizeCalculator.cpp

@@ -0,0 +1,74 @@
+/*
+ *  Copyright (C) 2020 Embedded AMS B.V. - All Rights Reserved
+ *
+ *  This file is part of Embedded Proto.
+ *
+ *  Embedded Proto is open source software: you can redistribute it and/or 
+ *  modify it under the terms of the GNU General Public License as published 
+ *  by the Free Software Foundation, version 3 of the license.
+ *
+ *  Embedded Proto  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. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Embedded Proto. If not, see <https://www.gnu.org/licenses/>.
+ *
+ *  For commercial and closed source application please visit:
+ *  <https://EmbeddedProto.com/license/>.
+ *
+ *  Embedded AMS B.V.
+ *  Info:
+ *    info at EmbeddedProto dot com
+ *
+ *  Postal address:
+ *    Johan Huizingalaan 763a
+ *    1066 VH, Amsterdam
+ *    the Netherlands
+ */
+
+#include "gtest/gtest.h"
+
+#include <MessageSizeCalculator.h>
+
+#include <cstdint>
+#include <limits> 
+
+
+namespace test_EmbeddedAMS_MessageSizeCalculator
+{
+
+TEST(MessageSizeCalculator, push) 
+{
+  ::EmbeddedProto::MessageSizeCalculator msc;
+  uint8_t byte = 0;
+  EXPECT_EQ(0, msc.get_size());
+  EXPECT_TRUE(msc.push(byte));
+  EXPECT_EQ(1, msc.get_size());
+  EXPECT_TRUE(msc.push(byte));
+  EXPECT_EQ(2, msc.get_size());
+
+  // Clear the content
+  msc.clear();
+  EXPECT_EQ(0, msc.get_size());
+}
+
+TEST(MessageSizeCalculator, push_n) 
+{
+  ::EmbeddedProto::MessageSizeCalculator msc;
+
+  static constexpr uint8_t SIZE = 3;
+  uint8_t bytes[SIZE] = {1, 2, 3};
+  EXPECT_TRUE(msc.push(bytes, SIZE));
+  EXPECT_EQ(3, msc.get_size());
+}
+
+TEST(MessageSizeCalculator, unlimited_size) 
+{
+  ::EmbeddedProto::MessageSizeCalculator msc;
+  EXPECT_EQ(std::numeric_limits<uint32_t>::max(), msc.get_max_size());
+  EXPECT_EQ(std::numeric_limits<uint32_t>::max(), msc.get_available_size());
+}
+
+} // End of namespace test_EmbeddedAMS_MessageSizeCalculator

test/test_NestedMessage.cpp

@@ -70,6 +70,8 @@ TEST(NestedMessage, serialize_one)
 
   ::message_b msg;
   Mocks::WriteBufferMock buffer;
+  ON_CALL(buffer, get_size()).WillByDefault(Return(9));
+
 
   // Test if a nested message can be serialized with values set to one.
   msg.set_u(1.0F);
@@ -189,15 +191,20 @@ TEST(NestedMessage, deserialize_one)
   ::message_b msg;
   Mocks::ReadBufferMock buffer;
 
+
+  static constexpr uint32_t SIZE = 22;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
   // Test if a nested message can be deserialized with values set to one.
 
-  uint8_t referee[] = {0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, // u
-                       0x12, 0x09, // tag and size of nested a
-                       0x08, 0x01, // x
-                       0x15, 0x00, 0x00, 0x80, 0x3F, // y
-                       0x18, 0x02, // z
-                       // And back to the parent message with field v.
-                       0x18, 0x01};
+  uint8_t referee[SIZE] = { 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, // u
+                            0x12, 0x09, // tag and size of nested a
+                            0x08, 0x01, // x
+                            0x15, 0x00, 0x00, 0x80, 0x3F, // y
+                            0x18, 0x02, // z
+                            // And back to the parent message with field v.
+                            0x18, 0x01};
 
   for(auto r: referee) {
     EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(r), Return(true)));
@@ -220,16 +227,21 @@ TEST(NestedMessage, deserialize_nested_in_nested_max)
   ::message_c msg;
   Mocks::ReadBufferMock buffer;
 
+
+  static constexpr uint32_t SIZE = 41;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
   // Test if a double nested message can be deserialized with values set to maximum.
 
-  uint8_t referee[] = { 0x0A, 0x27, // tag and size of nested b
-                        0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F, // u
-                        0x12, 0x16, // tag and size of nested a
-                        0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
-                        0x15, 0xFF, 0xFF, 0x7F, 0x7F, // y
-                        0x18, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, // z
-                        // And back to the parent message with field v.
-                        0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0x07};
+  uint8_t referee[SIZE] = { 0x0A, 0x27, // tag and size of nested b
+                            0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F, // u
+                            0x12, 0x16, // tag and size of nested a
+                            0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
+                            0x15, 0xFF, 0xFF, 0x7F, 0x7F, // y
+                            0x18, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, // z
+                            // And back to the parent message with field v.
+                            0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0x07};
 
   for(auto r: referee) {
     EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(r), Return(true)));

test/test_ReadBufferSection.cpp

@@ -0,0 +1,147 @@
+/*
+ *  Copyright (C) 2020 Embedded AMS B.V. - All Rights Reserved
+ *
+ *  This file is part of Embedded Proto.
+ *
+ *  Embedded Proto is open source software: you can redistribute it and/or 
+ *  modify it under the terms of the GNU General Public License as published 
+ *  by the Free Software Foundation, version 3 of the license.
+ *
+ *  Embedded Proto  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. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Embedded Proto. If not, see <https://www.gnu.org/licenses/>.
+ *
+ *  For commercial and closed source application please visit:
+ *  <https://EmbeddedProto.com/license/>.
+ *
+ *  Embedded AMS B.V.
+ *  Info:
+ *    info at EmbeddedProto dot com
+ *
+ *  Postal address:
+ *    Johan Huizingalaan 763a
+ *    1066 VH, Amsterdam
+ *    the Netherlands
+ */
+
+#include <gtest/gtest.h>
+
+#include <ReadBufferSection.h>
+
+#include "mock/ReadBufferMock.h"
+
+using ::testing::_;
+using ::testing::InSequence;
+using ::testing::Return;
+using ::testing::SetArgReferee;
+
+
+namespace test_EmbeddedAMS_ReadBufferSection
+{
+
+TEST(ReadBufferSection, construction) 
+{
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).WillRepeatedly(Return(99));
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 1);
+  EXPECT_EQ(1, read_buffer_section.get_max_size());
+  EXPECT_EQ(1, read_buffer_section.get_size());
+}
+
+TEST(ReadBufferSection, construction_limited) 
+{
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).WillRepeatedly(Return(1));
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 2);
+  EXPECT_EQ(1, read_buffer_section.get_max_size());
+  EXPECT_EQ(1, read_buffer_section.get_size());
+}
+
+TEST(ReadBufferSection, peek) 
+{
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).WillRepeatedly(Return(1));
+  EXPECT_CALL(read_buffer_mock, peak(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 1);
+  
+  uint8_t byte = 0;
+  EXPECT_TRUE(read_buffer_section.peak(byte));
+  EXPECT_EQ(1, byte);
+}
+
+TEST(ReadBufferSection, advance) 
+{
+  InSequence s;
+
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).Times(2).WillRepeatedly(Return(3));
+  EXPECT_CALL(read_buffer_mock, advance());
+  EXPECT_CALL(read_buffer_mock, advance());
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 2);
+  EXPECT_EQ(2, read_buffer_section.get_max_size());
+  EXPECT_EQ(2, read_buffer_section.get_size());
+
+  read_buffer_section.advance();
+  EXPECT_EQ(1, read_buffer_section.get_size());  
+
+  read_buffer_section.advance();
+  EXPECT_EQ(0, read_buffer_section.get_size());  
+
+  // One more advance should still be zero.
+  read_buffer_section.advance();
+  EXPECT_EQ(0, read_buffer_section.get_size());
+
+}
+
+TEST(ReadBufferSection, advance_n) 
+{
+  InSequence s;
+
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).Times(2).WillRepeatedly(Return(3));
+  EXPECT_CALL(read_buffer_mock, advance(2));
+  EXPECT_CALL(read_buffer_mock, advance(1));
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 3);
+  EXPECT_EQ(3, read_buffer_section.get_max_size());
+  EXPECT_EQ(3, read_buffer_section.get_size());
+
+  read_buffer_section.advance(2);
+  EXPECT_EQ(1, read_buffer_section.get_size());  
+
+  // We should not advance beond the max size.
+  read_buffer_section.advance(2);
+  EXPECT_EQ(0, read_buffer_section.get_size()); 
+}
+
+TEST(ReadBufferSection, pop) 
+{
+  Mocks::ReadBufferMock read_buffer_mock;
+  EXPECT_CALL(read_buffer_mock, get_size()).WillRepeatedly(Return(1));
+  EXPECT_CALL(read_buffer_mock, pop(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
+
+  EmbeddedProto::ReadBufferSection read_buffer_section(read_buffer_mock, 1);
+  
+  uint8_t byte = 0;
+  EXPECT_TRUE(read_buffer_section.pop(byte));
+  EXPECT_EQ(1, byte);
+  EXPECT_EQ(0, read_buffer_section.get_size());
+
+  // When attempting to read or peak at more we should not change byte and get a false.
+  byte = 0;
+  EXPECT_FALSE(read_buffer_section.pop(byte));
+  EXPECT_EQ(0, byte);
+  EXPECT_EQ(0, read_buffer_section.get_size());
+  EXPECT_FALSE(read_buffer_section.peak(byte));
+  EXPECT_EQ(0, byte);
+}
+
+} // End of namespace ReadBufferSection

test/test_RepeatedFieldMessage.cpp

@@ -353,9 +353,13 @@ TEST(RepeatedFieldMessage, deserialize_one)
   repeated_fields<Y_SIZE> msg;
   Mocks::ReadBufferMock buffer;
 
-  uint8_t referee[] = {0x08, 0x01, // x
-                       0x12, 0x03, 0x01, 0x01, 0x01, // y
-                       0x18, 0x01}; // z 
+  static constexpr uint32_t SIZE = 9;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
+  uint8_t referee[SIZE] = { 0x08, 0x01, // x
+                            0x12, 0x03, 0x01, 0x01, 0x01, // y
+                            0x18, 0x01}; // z 
 
   for(auto r: referee) 
   {
@@ -381,9 +385,13 @@ TEST(RepeatedFieldMessage, deserialize_one_message_array)
   repeated_message<Y_SIZE> msg;
   Mocks::ReadBufferMock buffer;
 
-  uint8_t referee[] = {0x08, 0x01, // x
-                       0x12, 0x00, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01, 0x12, 0x00, // y
-                       0x18, 0x01}; // z 
+  static constexpr uint32_t SIZE = 15;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
+  uint8_t referee[SIZE] = { 0x08, 0x01, // x
+                            0x12, 0x00, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01, 0x12, 0x00, // y
+                            0x18, 0x01}; // z 
 
   for(auto r: referee) 
   {
@@ -414,11 +422,15 @@ TEST(RepeatedFieldMessage, deserialize_mixed_message_array)
   repeated_message<Y_SIZE> msg;
   Mocks::ReadBufferMock buffer;
 
-  uint8_t referee[] = {0x12, 0x00, // y[0]
-                       0x08, 0x01, // x
-                       0x12, 0x04, 0x08, 0x01, 0x10, 0x01, // y[1]
-                       0x18, 0x01, // z
-                       0x12, 0x00, }; // y[2] 
+  static constexpr uint32_t SIZE = 14;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
+  uint8_t referee[SIZE] = { 0x12, 0x00, // y[0]
+                            0x08, 0x01, // x
+                            0x12, 0x04, 0x08, 0x01, 0x10, 0x01, // y[1]
+                            0x18, 0x01, // z
+                            0x12, 0x00, }; // y[2] 
 
   for(auto r: referee) 
   {
@@ -446,9 +458,13 @@ TEST(RepeatedFieldMessage, deserialize_max)
   repeated_fields<Y_SIZE> msg;
   Mocks::ReadBufferMock buffer;
 
-  uint8_t referee[] = {0x08, 0xff, 0xff, 0xff, 0xff, 0x0f,  // x
-                       0x12, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, // y
-                       0x18, 0xff, 0xff, 0xff, 0xff, 0x0f}; // z
+  static constexpr uint32_t SIZE = 29;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
+  uint8_t referee[SIZE] = { 0x08, 0xff, 0xff, 0xff, 0xff, 0x0f,  // x
+                            0x12, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, // y
+                            0x18, 0xff, 0xff, 0xff, 0xff, 0x0f}; // z
 
   for(auto r: referee) 
   {

test/test_oneof_fields.cpp

@@ -300,7 +300,11 @@ TEST(OneofField, deserialize_oneof_msg)
   message_oneof msg;
   Mocks::ReadBufferMock buffer;
 
-  uint8_t referee[] = {0xaa, 0x01, 0x07, 0x08, 0x01, 0x10, 0x16, 0x18, 0xcd, 0x02};
+  static constexpr uint32_t SIZE = 10;
+
+  ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
+
+  uint8_t referee[SIZE] = {0xaa, 0x01, 0x07, 0x08, 0x01, 0x10, 0x16, 0x18, 0xcd, 0x02};
     for(auto r: referee) {
     EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(r), Return(true)));
   }