Increase cmake minimum required (#72)

* Refs #16427. Increase cmake minimum required

Signed-off-by: Ricardo González Moreno <ricardo@richiware.dev>

* Refs #16427. Fix googletest warning

Signed-off-by: Ricardo González Moreno <ricardo@richiware.dev>

* Fix tests

Signed-off-by: Pablo Garrido <pablogs9@gmail.com>

Signed-off-by: Ricardo González Moreno <ricardo@richiware.dev>
Signed-off-by: Pablo Garrido <pablogs9@gmail.com>
Co-authored-by: Pablo Garrido <pablogs9@gmail.com>

Author: richiware

CMakeLists.txt

@@ -15,7 +15,7 @@
 ###############################################################################
 # CMake build rules for Micro CDR
 ###############################################################################
-cmake_minimum_required(VERSION 3.5.0 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.15)
 
 ###############################################################################
 # Build options

cmake/SuperBuild.cmake

@@ -31,7 +31,7 @@ if(UCDR_BUILD_TESTS)
             GIT_REPOSITORY
                 https://github.com/google/googletest.git
             GIT_TAG
-                v1.10.x
+                release-1.11.0
             PREFIX
                 ${PROJECT_BINARY_DIR}/googletest
             INSTALL_DIR

test/Alignment.cpp

@@ -40,7 +40,13 @@ class Alignment : public BasicSerialization, public ::testing::WithParamInterfac
 
 };
 
-INSTANTIATE_TEST_SUITE_P(Offset, Alignment, ::testing::Range(0, 17), ::testing::PrintToStringParamName());
+#ifdef INSTANTIATE_TEST_SUITE_P
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z, w) INSTANTIATE_TEST_SUITE_P(x, y, z, w)
+#else
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z, w) INSTANTIATE_TEST_CASE_P(x, y, z, w)
+#endif // ifdef INSTANTIATE_TEST_SUITE_P
+
+GTEST_INSTANTIATE_TEST_MACRO(Offset, Alignment, ::testing::Range(0, 17), ::testing::PrintToStringParamName());
 
 TEST_P(Alignment, Block_8)
 {

test/CommonFunctions.cpp

@@ -16,7 +16,7 @@
 #include <ucdr/microcdr.h>
 #include <cstring>
 
-#define BUFFER_LENGTH 1024
+#define BUFFER_LENGTH 1024UL
 
 bool operator ==(
         const ucdrBuffer& rhs,
@@ -56,7 +56,7 @@ TEST_F(CommonFunctions, ucdr_init_buffer)
     EXPECT_EQ(ub.init, buffer);
     EXPECT_EQ(ub.final, ub.init + BUFFER_LENGTH);
     EXPECT_EQ(ub.iterator, ub.init);
-    EXPECT_EQ(ub.origin, 0);
+    EXPECT_EQ(ub.origin, 0UL);
     EXPECT_EQ(ub.offset, ub.origin);
     EXPECT_EQ(ub.endianness, UCDR_MACHINE_ENDIANNESS);
     EXPECT_EQ(ub.last_data_size, 0);
@@ -145,29 +145,29 @@ TEST_F(CommonFunctions, ucdr_align)
     size_t offset = 1;
 
     ucdr_init_buffer_origin_offset(&ub, buffer, BUFFER_LENGTH, origin, offset);
-    EXPECT_EQ(ucdr_alignment(offset, 1), 0);
-    EXPECT_EQ(ucdr_buffer_alignment(&ub, 1), 0);
+    EXPECT_EQ(ucdr_alignment(offset, 1), 0UL);
+    EXPECT_EQ(ucdr_buffer_alignment(&ub, 1), 0UL);
     ucdr_align_to(&ub, 1);
     EXPECT_EQ(ub.iterator, ub.init + 1);
     EXPECT_EQ(ub.offset, ub.origin + 1);
 
     ucdr_reset_buffer_offset(&ub, offset);
-    EXPECT_EQ(ucdr_alignment(offset, 2), 1);
-    EXPECT_EQ(ucdr_buffer_alignment(&ub, 2), 0);
+    EXPECT_EQ(ucdr_alignment(offset, 2), 1UL);
+    EXPECT_EQ(ucdr_buffer_alignment(&ub, 2), 0UL);
     ucdr_align_to(&ub, 2);
     EXPECT_EQ(ub.iterator, ub.init + 1);
     EXPECT_EQ(ub.offset, ub.origin + 1);
 
     ucdr_reset_buffer_offset(&ub, offset);
-    EXPECT_EQ(ucdr_alignment(offset, 4), 3);
-    EXPECT_EQ(ucdr_buffer_alignment(&ub, 4), 2);
+    EXPECT_EQ(ucdr_alignment(offset, 4), 3UL);
+    EXPECT_EQ(ucdr_buffer_alignment(&ub, 4), 2UL);
     ucdr_align_to(&ub, 4);
     EXPECT_EQ(ub.iterator, ub.init + 3);
     EXPECT_EQ(ub.offset, ub.origin + 3);
 
     ucdr_reset_buffer_offset(&ub, offset);
-    EXPECT_EQ(ucdr_alignment(offset, 8), 7);
-    EXPECT_EQ(ucdr_buffer_alignment(&ub, 8), 6);
+    EXPECT_EQ(ucdr_alignment(offset, 8), 7UL);
+    EXPECT_EQ(ucdr_buffer_alignment(&ub, 8), 6UL);
     ucdr_align_to(&ub, 8);
     EXPECT_EQ(ub.iterator, ub.init + 7);
     EXPECT_EQ(ub.offset, ub.origin + 7);

test/SequenceOverflow.cpp

@@ -39,7 +39,7 @@ class SequenceOverflow : public SequenceSerialization
 
 TEST_F(SequenceOverflow, Block1)
 {
-    uint8_t input[SEQUENCE_SIZE_OVERFLOW];
+    uint8_t input[SEQUENCE_SIZE_OVERFLOW] = {0};
     uint8_t output[ARRAY_CAPACITY] = {0};
 
     EXPECT_TRUE(ucdr_serialize_sequence_uint8_t(&writer, input, SEQUENCE_SIZE_OVERFLOW));
@@ -48,7 +48,7 @@ TEST_F(SequenceOverflow, Block1)
 
 TEST_F(SequenceOverflow, Block2)
 {
-    uint16_t input[SEQUENCE_SIZE_OVERFLOW];
+    uint16_t input[SEQUENCE_SIZE_OVERFLOW] = {0};
     uint16_t output[ARRAY_CAPACITY] = {0};
 
     EXPECT_TRUE(ucdr_serialize_sequence_uint16_t(&writer, input, SEQUENCE_SIZE_OVERFLOW));
@@ -57,7 +57,7 @@ TEST_F(SequenceOverflow, Block2)
 
 TEST_F(SequenceOverflow, Block4)
 {
-    uint32_t input[SEQUENCE_SIZE_OVERFLOW];
+    uint32_t input[SEQUENCE_SIZE_OVERFLOW] = {0};
     uint32_t output[ARRAY_CAPACITY] = {0};
 
     EXPECT_TRUE(ucdr_serialize_sequence_uint32_t(&writer, input, SEQUENCE_SIZE_OVERFLOW));
@@ -66,7 +66,7 @@ TEST_F(SequenceOverflow, Block4)
 
 TEST_F(SequenceOverflow, Block8)
 {
-    uint64_t input[SEQUENCE_SIZE_OVERFLOW];
+    uint64_t input[SEQUENCE_SIZE_OVERFLOW] = {0};
     uint64_t output[ARRAY_CAPACITY] = {0};
 
     EXPECT_TRUE(ucdr_serialize_sequence_uint64_t(&writer, input, SEQUENCE_SIZE_OVERFLOW));

test/endianness/ArrayEndianness.cpp

@@ -128,5 +128,11 @@ TEST_P(ArrayEndianness, Double)
     EXPECT_TRUE(0 == std::memcmp(input, output, ARRAY_SIZE * sizeof(input[0])));
 }
 
-INSTANTIATE_TEST_SUITE_P(ucdrEndianness, ArrayEndianness,
+#ifdef INSTANTIATE_TEST_SUITE_P
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_SUITE_P(x, y, z)
+#else
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_CASE_P(x, y, z)
+#endif // ifdef INSTANTIATE_TEST_SUITE_P
+
+GTEST_INSTANTIATE_TEST_MACRO(ucdrEndianness, ArrayEndianness,
         ::testing::Values(UCDR_LITTLE_ENDIANNESS, UCDR_BIG_ENDIANNESS));

test/endianness/BasicEndianness.cpp

@@ -120,5 +120,11 @@ TEST_P(BasicEndianness, Double)
     EXPECT_EQ(input, output);
 }
 
-INSTANTIATE_TEST_SUITE_P(ucdrEndianness, BasicEndianness,
+#ifdef INSTANTIATE_TEST_SUITE_P
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_SUITE_P(x, y, z)
+#else
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_CASE_P(x, y, z)
+#endif // ifdef INSTANTIATE_TEST_SUITE_P
+       //
+GTEST_INSTANTIATE_TEST_MACRO(ucdrEndianness, BasicEndianness,
         ::testing::Values(UCDR_LITTLE_ENDIANNESS, UCDR_BIG_ENDIANNESS));

test/endianness/SequenceEndianness.cpp

@@ -176,5 +176,11 @@ TEST_P(SequenceEndianness, Double)
     EXPECT_TRUE(0 == std::memcmp(input, output, SEQUENCE_SIZE * sizeof(input[0])));
 }
 
-INSTANTIATE_TEST_SUITE_P(ucdrEndianness, SequenceEndianness,
+#ifdef INSTANTIATE_TEST_SUITE_P
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_SUITE_P(x, y, z)
+#else
+#define GTEST_INSTANTIATE_TEST_MACRO(x, y, z) INSTANTIATE_TEST_CASE_P(x, y, z)
+#endif // ifdef INSTANTIATE_TEST_SUITE_P
+       //
+GTEST_INSTANTIATE_TEST_MACRO(ucdrEndianness, SequenceEndianness,
         ::testing::Values(UCDR_LITTLE_ENDIANNESS, UCDR_BIG_ENDIANNESS));