From 53113cc9a7631823fdd2be9132eb0003589a1d9b Mon Sep 17 00:00:00 2001 From: francesca Date: Wed, 9 Sep 2020 09:21:50 +0200 Subject: [PATCH 1/3] Added arrays and sequences of primitive types to test. --- .vscode/settings.json | 14 + test/c/src/test_typesupport.cpp | 634 +++++++++++++++++++++++++++++- test/cpp/src/test_typesupport.cpp | 265 +++++++++++++ test/msg/CMakeLists.txt | 1 + test/msg/msg/Array.msg | 14 + test/msg/msg/Primitive.msg | 14 +- test/msg/msg/Sequence.msg | 13 + 7 files changed, 936 insertions(+), 19 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 test/msg/msg/Array.msg diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..3e3997b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,14 @@ +{ + "files.associations": { + "array": "cpp", + "bitset": "cpp", + "string_view": "cpp", + "initializer_list": "cpp", + "utility": "cpp", + "*.tcc": "cpp", + "deque": "cpp", + "vector": "cpp", + "functional": "cpp", + "string": "cpp" + } +} \ No newline at end of file diff --git a/test/c/src/test_typesupport.cpp b/test/c/src/test_typesupport.cpp index 7356905..b85abb2 100644 --- a/test/c/src/test_typesupport.cpp +++ b/test/c/src/test_typesupport.cpp @@ -18,12 +18,13 @@ #include "rosidl_runtime_c/message_type_support_struct.h" // Generic MicroXRCE-DDS typesupport includes -#include +#include F #include // Specific defined types used during testing #include "rosidl_typesupport_microxrcedds_test_msg/msg/primitive.h" #include "rosidl_typesupport_microxrcedds_test_msg/msg/sequence.h" +#include "rosidl_typesupport_microxrcedds_test_msg/msg/array.h" #include "rosidl_runtime_c/string_functions.h" /* @@ -231,8 +232,86 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) const rosidl_typesupport_microxrcedds_test_msg__msg__Sequence & A, const rosidl_typesupport_microxrcedds_test_msg__msg__Sequence & B) -> void { + EXPECT_EQ(A.sequence_bool_test.size(), B.sequence_bool_test.size()); + EXPECT_EQ(A.sequence_byte_test.size(), B.sequence_byte_test.size()); + EXPECT_EQ(A.sequence_char_test.size(), B.sequence_char_test.size()); + EXPECT_EQ(A.sequence_float32_test.size(), B.sequence_float32_test.size()); + EXPECT_EQ(A.sequence_double_test.size(), B.sequence_double_test.size()); + EXPECT_EQ(A.sequence_int8_test.size(), B.sequence_int8_test.size()); + EXPECT_EQ(A.sequence_uint8_test.size(), B.sequence_uint8_test.size()); + EXPECT_EQ(A.sequence_int16_test.size(), B.sequence_int16_test.size()); + EXPECT_EQ(A.sequence_uint16_test.size(), B.sequence_uint16_test.size()); + EXPECT_EQ(A.sequence_int32_test.size(), B.sequence_int32_test.size()); + EXPECT_EQ(A.sequence_uint32_test.size(), B.sequence_uint32_test.size()); + EXPECT_EQ(A.sequence_int64_test.size(), B.sequence_int64_test.size()); + EXPECT_EQ(A.sequence_uint64_test.size(), B.sequence_uint64_test.size()); EXPECT_EQ(A.sequence_string_test.size, B.sequence_string_test.size); + for (size_t i = 0; i < A.sequence_bool_test.size; ++i) + { + EXPECT_EQ(A.sequence_bool_test.data[i].size, B.sequence_bool_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_bool_test.data[i].data, B.sequence_bool_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_byte_test.size; ++i) + { + EXPECT_EQ(A.sequence_byte_test.data[i].size, B.sequence_byte_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_byte_test.data[i].data, B.sequence_byte_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_char_test.size; ++i) + { + EXPECT_EQ(A.sequence_char_test.data[i].size, B.sequence_char_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_char_test.data[i].data, B.sequence_char_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_float32_test.size; ++i) + { + EXPECT_EQ(A.sequence_float32_test.data[i].size, B.sequence_float32_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_float32_test.data[i].data, B.sequence_float32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_double_test.size; ++i) + { + EXPECT_EQ(A.sequence_double_test.data[i].size, B.sequence_double_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_double_test.data[i].data, B.sequence_double_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_int8_test.size; ++i) + { + EXPECT_EQ(A.sequence_int8_test.data[i].size, B.sequence_int8_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_int8_test.data[i].data, B.sequence_int8_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_uint8_test.size; ++i) + { + EXPECT_EQ(A.sequence_uint8_test.data[i].size, B.sequence_uint8_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_uint8_test.data[i].data, B.sequence_uint8_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_int16_test.size; ++i) + { + EXPECT_EQ(A.sequence_int16_test.data[i].size, B.sequence_int16_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_int16_test.data[i].data, B.sequence_int16_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_uint16_test.size; ++i) + { + EXPECT_EQ(A.sequence_uint16_test.data[i].size, B.sequence_uint16_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_uint16_test.data[i].data, B.sequence_uint16_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_int32_test.size; ++i) + { + EXPECT_EQ(A.sequence_int32_test.data[i].size, B.sequence_int32_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_int32_test.data[i].data, B.sequence_int32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_uint32_test.size; ++i) + { + EXPECT_EQ(A.sequence_uint32_test.data[i].size, B.sequence_uint32_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_uint32_test.data[i].data, B.sequence_uint32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_int64_test.size; ++i) + { + EXPECT_EQ(A.sequence_int64_test.data[i].size, B.sequence_int64_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_int64_test.data[i].data, B.sequence_int64_test.data[i].data), 0); + } + for (size_t i = 0; i < A.sequence_uint64_test.size; ++i) + { + EXPECT_EQ(A.sequence_uint64_test.data[i].size, B.sequence_uint64_test.data[i].size); + EXPECT_EQ(strcmp(A.sequence_uint64_test.data[i].data, B.sequence_uint64_test.data[i].data), 0); + } for (size_t i = 0; i < A.sequence_string_test.size; ++i) { EXPECT_EQ(A.sequence_string_test.data[i].size, B.sequence_string_test.data[i].size); @@ -241,10 +320,188 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) }); rosidl_typesupport_microxrcedds_test_msg__msg__Sequence init_sequence; - ASSERT_TRUE(rosidl_runtime_c__String__Sequence__init( - &init_sequence.sequence_string_test, 4)); + + ASSERT_TRUE(rosidl_runtime_c__Bool__Sequence__init(&init_sequence.sequence_bool_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Byte__Sequence__init(&init_sequence.sequence_byte_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Char__Sequence__init(&init_sequence.sequence_char_test, 5)); + ASSERT_TRUE(rosidl_runtime_c__Float32__Sequence__init(&init_sequence.sequence_float32_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Double__Sequence__init(&init_sequence.sequence_double_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Int8__Sequence__init(&init_sequence.sequence_int8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint8__Sequence__init(&init_sequence.sequence_uint8_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Int16__Sequence__init(&init_sequence.sequence_int16_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Uint16__Sequence__init(&init_sequence.sequence_uint16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int32__Sequence__init(&init_sequence.sequence_int32_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Uint32__Sequence__init(&init_sequence.sequence_uint32_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Int64__Sequence__init(&init_sequence.sequence_int64_test, 5)); + ASSERT_TRUE(rosidl_runtime_c__Uint64__Sequence__init(&init_sequence.sequence_uint64_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__String__Sequence__init(&init_sequence.sequence_string_test, 4)); // Initialize data to be serialized and deserialized + + // Bool + + init_sequence.sequence_bool_test.data[0].data = true; + init_sequence.sequence_bool_test.data[0].size = + strlen(init_sequence.sequence_bool_test.data[0].data); + init_sequence.sequence_bool_test.data[1].data = true; + init_sequence.sequence_bool_test.data[1].size = + strlen(init_sequence.sequence_bool_test.data[1].data); + init_sequence.sequence_bool_test.data[2].data = false; + init_sequence.sequence_bool_test.data[2].size = + strlen(init_sequence.sequence_bool_test.data[2].data); + + // Byte + + init_sequence.sequence_byte_test.data[0].data = 0; + init_sequence.sequence_byte_test.data[0].size = + strlen(init_sequence.sequence_byte_test.data[0].data); + init_sequence.sequence_byte_test.data[1].data = 1; + init_sequence.sequence_byte_test.data[1].size = + strlen(init_sequence.sequence_byte_test.data[1].data); + + // Char + + init_sequence.sequence_char_test.data[0].data = 'z'; + init_sequence.sequence_char_test.data[0].size = + strlen(init_sequence.sequence_char_test.data[0].data); + init_sequence.sequence_char_test.data[1].data = 'y'; + init_sequence.sequence_char_test.data[1].size = + strlen(init_sequence.sequence_char_test.data[1].data); + init_sequence.sequence_char_test.data[2].data = 'x'; + init_sequence.sequence_char_test.data[2].size = + strlen(init_sequence.sequence_char_test.data[2].data); + init_sequence.sequence_char_test.data[3].data = 'w'; + init_sequence.sequence_char_test.data[3].size = + strlen(init_sequence.sequence_char_test.data[3].data); + init_sequence.sequence_char_test.data[4].data = 'v'; + init_sequence.sequence_char_test.data[4].size = + strlen(init_sequence.sequence_char_test.data[4].data); + + // Float32 + + init_sequence.sequence_float32_test.data[0].data = 1.23; + init_sequence.sequence_float32_test.data[0].size = + strlen(init_sequence.sequence_float32_test.data[0].data); + init_sequence.sequence_float32_test.data[1].data = 45.6; + init_sequence.sequence_float32_test.data[1].size = + strlen(init_sequence.sequence_float32_test.data[1].data); + init_sequence.sequence_float32_test.data[2].data = - 222.0; + init_sequence.sequence_float32_test.data[2].size = + strlen(init_sequence.sequence_float32_test.data[2].data); + init_sequence.sequence_float32_test.data[3].data = 1287.9; + init_sequence.sequence_float32_test.data[3].size = + strlen(init_sequence.sequence_float32_test.data[3].data); + + // Double + + init_sequence.sequence_double_test.data[0].data = 5287483999.3; + init_sequence.sequence_double_test.data[0].size = + strlen(init_sequence.sequence_double_test.data[0].data); + init_sequence.sequence_double_test.data[1].data = - 46.5; + init_sequence.sequence_double_test.data[1].size = + strlen(init_sequence.sequence_double_test.data[1].data); + + // int8 + + init_sequence.sequence_int8_test.data[0].data = 1; + init_sequence.sequence_int8_test.data[0].size = + strlen(init_sequence.sequence_int8_test.data[0].data); + init_sequence.sequence_int8_test.data[1].data = 2; + init_sequence.sequence_int8_test.data[1].size = + strlen(init_sequence.sequence_int8_test.data[1].data); + init_sequence.sequence_int8_test.data[2].data = - 124; + init_sequence.sequence_int8_test.data[2].size = + strlen(init_sequence.sequence_int8_test.data[2].data); + + // unit8 + + init_sequence.sequence_uint8_test.data[0].data = 11; + init_sequence.sequence_uint8_test.data[0].size = + strlen(init_sequence.sequence_uint8_test.data[0].data); + init_sequence.sequence_uint8_test.data[1].data = 12; + init_sequence.sequence_uint8_test.data[1].size = + strlen(init_sequence.sequence_uint8_test.data[1].data); + init_sequence.sequence_uint8_test.data[2].data = 13; + init_sequence.sequence_uint8_test.data[2].size = + strlen(init_sequence.sequence_uint8_test.data[2].data); + init_sequence.sequence_uint8_test.data[3].data = 250; + init_sequence.sequence_uint8_test.data[3].size = + strlen(init_sequence.sequence_uint8_test.data[3].data); + + // int16 + + init_sequence.sequence_int16_test.data[0].data = - 360; + init_sequence.sequence_int16_test.data[0].size = + strlen(init_sequence.sequence_int16_test.data[0].data); + init_sequence.sequence_int16_test.data[1].data = 1; + init_sequence.sequence_int16_test.data[1].size = + strlen(init_sequence.sequence_int16_test.data[1].data); + + // uint16 + + init_sequence.sequence_uint16_test.data[0].data = 360; + init_sequence.sequence_uint16_test.data[0].size = + strlen(init_sequence.sequence_uint16_test.data[0].data); + init_sequence.sequence_uint16_test.data[1].data = 800; + init_sequence.sequence_uint16_test.data[1].size = + strlen(init_sequence.sequence_uint16_test.data[1].data); + init_sequence.sequence_uint16_test.data[2].data = 13; + init_sequence.sequence_uint16_test.data[2].size = + strlen(init_sequence.sequence_uint16_test.data[2].data); + + // int32 + + init_sequence.sequence_int32_test.data[0].data = 1000; + init_sequence.sequence_int32_test.data[0].size = + strlen(init_sequence.sequence_int32_test.data[0].data); + init_sequence.sequence_int32_test.data[1].data = 16843009; + init_sequence.sequence_int32_test.data[1].size = + strlen(init_sequence.sequence_int32_test.data[1].data); + + // uint32 + + init_sequence.sequence_uint32_test.data[0].data = 1000; + init_sequence.sequence_uint32_test.data[0].size = + strlen(init_sequence.sequence_uint32_test.data[0].data); + init_sequence.sequence_uint32_test.data[1].data = 16843009; + init_sequence.sequence_uint32_test.data[1].size = + strlen(init_sequence.sequence_uint32_test.data[1].data); + init_sequence.sequence_uint32_test.data[2].data = 3000; + init_sequence.sequence_uint32_test.data[2].size = + strlen(init_sequence.sequence_uint32_test.data[2].data); + init_sequence.sequence_uint32_test.data[3].data = 2; + init_sequence.sequence_uint32_test.data[3].size = + strlen(init_sequence.sequence_uint32_test.data[3].data); + + // int64 + + init_sequence.sequence_int64_test.data[0].data = 72340172838076673L; + init_sequence.sequence_int64_test.data[0].size = + strlen(init_sequence.sequence_int64_test.data[0].data); + init_sequence.sequence_int64_test.data[1].data = 16843009; + init_sequence.sequence_int64_test.data[1].size = + strlen(init_sequence.sequence_int64_test.data[1].data); + init_sequence.sequence_int64_test.data[2].data = -3000; + init_sequence.sequence_int64_test.data[2].size = + strlen(init_sequence.sequence_int64_test.data[2].data); + init_sequence.sequence_int64_test.data[3].data = 2; + init_sequence.sequence_int64_test.data[3].size = + strlen(init_sequence.sequence_int64_test.data[3].data); + init_sequence.sequence_int64_test.data[4].data = 16; + init_sequence.sequence_int64_test.data[4].size = + strlen(init_sequence.sequence_int64_test.data[4].data); + + // uint64 + + init_sequence.sequence_uint64_test.data[0].data = 21; + init_sequence.sequence_uint64_test.data[0].size = + strlen(init_sequence.sequence_uint64_test.data[0].data); + init_sequence.sequence_uint64_test.data[1].data = 72340172838076673L; + init_sequence.sequence_uint64_test.data[1].size = + strlen(init_sequence.sequence_uint64_test.data[1].data); + + // String + init_sequence.sequence_string_test.data[0].data = const_cast("This"); init_sequence.sequence_string_test.data[0].size = strlen(init_sequence.sequence_string_test.data[0].data); @@ -259,9 +516,26 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) strlen(init_sequence.sequence_string_test.data[3].data); // Prepare deserialization output instance + rosidl_typesupport_microxrcedds_test_msg__msg__Sequence out_deserialized; - ASSERT_TRUE(rosidl_runtime_c__String__Sequence__init( - &out_deserialized.sequence_string_test, 4)); + + ASSERT_TRUE(rosidl_runtime_c__Bool__Sequence__init(&out_deserialized.sequence_bool_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Byte__Sequence__init(&out_deserialized.sequence_byte_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Char__Sequence__init(&out_deserialized.sequence_char_test, 5)); + ASSERT_TRUE(rosidl_runtime_c__Float32__Sequence__init(&out_deserialized.sequence_float32_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Double__Sequence__init(&out_deserialized.sequence_double_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Int8__Sequence__init(&out_deserialized.sequence_int8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint8__Sequence__init(&out_deserialized.sequence_uint8_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Int16__Sequence__init(&out_deserialized.sequence_int16_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Uint16__Sequence__init(&out_deserialized.sequence_uint16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int32__Sequence__init(&out_deserialized.sequence_int32_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__Uint32__Sequence__init(&out_deserialized.sequence_uint32_test, 4)); + ASSERT_TRUE(rosidl_runtime_c__Int64__Sequence__init(&out_deserialized.sequence_int64_test, 5)); + ASSERT_TRUE(rosidl_runtime_c__Uint64__Sequence__init(&out_deserialized.sequence_uint64_test, 2)); + ASSERT_TRUE(rosidl_runtime_c__String__Sequence__init(&out_deserialized.sequence_string_test, 4)); + + // String + char data_0[10] = {0}; out_deserialized.sequence_string_test.data[0].data = data_0; out_deserialized.sequence_string_test.data[0].capacity = sizeof(data_0); @@ -282,4 +556,352 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) this->setup(sequence_msg_type_support, std::move(init_sequence), compare_sequences); this->check_identifier(); this->test_serialize_deserialize(out_deserialized); -} \ No newline at end of file +} + +/* + * @brief Array ROS 2 types serialization and deserialization tests. + */ +template +class ArraysTestTypeSupport : public TestTypeSupport {}; + +TYPED_TEST_CASE(ArraysTestTypeSupport, + testing::Types); +TYPED_TEST(ArraysTestTypeSupport, serialize_array_types) +{ + std::function compare_arrays ([]( + const rosidl_typesupport_microxrcedds_test_msg__msg__Array & A, + const rosidl_typesupport_microxrcedds_test_msg__msg__Array & B) -> void + { + + EXPECT_EQ(A.array_bool_test.size(), 3); + EXPECT_EQ(A.array_byte_test.size(), 3); + EXPECT_EQ(A.array_char_test.size(), 3); + EXPECT_EQ(A.array_float32_test.size(), 3); + EXPECT_EQ(A.array_double_test.size(), 3); + EXPECT_EQ(A.array_int8_test.size(), 3); + EXPECT_EQ(A.array_uint8_test.size(), 3); + EXPECT_EQ(A.array_int16_test.size(), 3); + EXPECT_EQ(A.array_uint16_test.size(), 3); + EXPECT_EQ(A.array_int32_test.size(), 3); + EXPECT_EQ(A.array_uint32_test.size(), 3); + EXPECT_EQ(A.array_int64_test.size(), 3); + EXPECT_EQ(A.array_uint64_test.size(), 3); + EXPECT_EQ(A.array_string_test.size(), 3); + + EXPECT_EQ(A.array_bool_test.size(), B.array_bool_test.size()); + EXPECT_EQ(A.array_byte_test.size(), B.array_byte_test.size()); + EXPECT_EQ(A.array_char_test.size(), B.array_char_test.size()); + EXPECT_EQ(A.array_float32_test.size(), B.array_float32_test.size()); + EXPECT_EQ(A.array_double_test.size(), B.array_double_test.size()); + EXPECT_EQ(A.array_int8_test.size(), B.array_int8_test.size()); + EXPECT_EQ(A.array_uint8_test.size(), B.array_uint8_test.size()); + EXPECT_EQ(A.array_int16_test.size(), B.array_int16_test.size()); + EXPECT_EQ(A.array_uint16_test.size(), B.array_uint16_test.size()); + EXPECT_EQ(A.array_int32_test.size(), B.array_int32_test.size()); + EXPECT_EQ(A.array_uint32_test.size(), B.array_uint32_test.size()); + EXPECT_EQ(A.array_int64_test.size(), B.array_int64_test.size()); + EXPECT_EQ(A.array_uint64_test.size(), B.array_uint64_test.size()); + EXPECT_EQ(A.array_string_test.size(), B.array_string_test.size()); + + for (size_t i = 0; i < A.array_bool_test.size; ++i) + { + EXPECT_EQ(A.array_bool_test.data[i].size, B.array_bool_test.data[i].size); + EXPECT_EQ(strcmp(A.array_bool_test.data[i].data, B.array_bool_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_byte_test.size; ++i) + { + EXPECT_EQ(A.array_byte_test.data[i].size, B.array_byte_test.data[i].size); + EXPECT_EQ(strcmp(A.array_byte_test.data[i].data, B.array_byte_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_char_test.size; ++i) + { + EXPECT_EQ(A.array_char_test.data[i].size, B.array_char_test.data[i].size); + EXPECT_EQ(strcmp(A.array_char_test.data[i].data, B.array_char_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_float32_test.size; ++i) + { + EXPECT_EQ(A.array_float32_test.data[i].size, B.array_float32_test.data[i].size); + EXPECT_EQ(strcmp(A.array_float32_test.data[i].data, B.array_float32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_double_test.size; ++i) + { + EXPECT_EQ(A.array_double_test.data[i].size, B.array_double_test.data[i].size); + EXPECT_EQ(strcmp(A.array_double_test.data[i].data, B.array_double_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_int8_test.size; ++i) + { + EXPECT_EQ(A.array_int8_test.data[i].size, B.array_int8_test.data[i].size); + EXPECT_EQ(strcmp(A.array_int8_test.data[i].data, B.array_int8_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_uint8_test.size; ++i) + { + EXPECT_EQ(A.array_uint8_test.data[i].size, B.array_uint8_test.data[i].size); + EXPECT_EQ(strcmp(A.array_uint8_test.data[i].data, B.array_uint8_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_int16_test.size; ++i) + { + EXPECT_EQ(A.array_int16_test.data[i].size, B.array_int16_test.data[i].size); + EXPECT_EQ(strcmp(A.array_int16_test.data[i].data, B.array_int16_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_uint16_test.size; ++i) + { + EXPECT_EQ(A.array_uint16_test.data[i].size, B.array_uint16_test.data[i].size); + EXPECT_EQ(strcmp(A.array_uint16_test.data[i].data, B.array_uint16_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_int32_test.size; ++i) + { + EXPECT_EQ(A.array_int32_test.data[i].size, B.array_int32_test.data[i].size); + EXPECT_EQ(strcmp(A.array_int32_test.data[i].data, B.array_int32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_uint32_test.size; ++i) + { + EXPECT_EQ(A.array_uint32_test.data[i].size, B.array_uint32_test.data[i].size); + EXPECT_EQ(strcmp(A.array_uint32_test.data[i].data, B.array_uint32_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_int64_test.size; ++i) + { + EXPECT_EQ(A.array_int64_test.data[i].size, B.array_int64_test.data[i].size); + EXPECT_EQ(strcmp(A.array_int64_test.data[i].data, B.array_int64_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_uint64_test.size; ++i) + { + EXPECT_EQ(A.array_uint64_test.data[i].size, B.array_uint64_test.data[i].size); + EXPECT_EQ(strcmp(A.array_uint64_test.data[i].data, B.array_uint64_test.data[i].data), 0); + } + for (size_t i = 0; i < A.array_string_test.size; ++i) + { + EXPECT_EQ(A.array_string_test.data[i].size, B.array_string_test.data[i].size); + EXPECT_EQ(strcmp(A.array_string_test.data[i].data, B.array_string_test.data[i].data), 0); + } + }); + + rosidl_typesupport_microxrcedds_test_msg__msg__Array init_array; + + // What about this? + + ASSERT_TRUE(rosidl_runtime_c__Bool__Array__init(&init_array.array_bool_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Byte__Array__init(&init_array.array_byte_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Char__Array__init(&init_array.array_char_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Float32__Array__init(&init_array.array_float32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Double__Array__init(&init_array.array_double_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int8__Array__init(&init_array.array_int8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint8__Array__init(&init_array.array_uint8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int16__Array__init(&init_array.array_int16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint16__Array__init(&init_array.array_uint16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int32__Array__init(&init_array.array_int32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint32__Array__init(&init_array.array_uint32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int64__Array__init(&init_array.array_int64_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint64__Array__init(&init_array.array_uint64_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__String__Array__init(&init_array.array_string_test, 3)); + + // Initialize data to be serialized and deserialized + + // Bool + + init_array.array_bool_test.data[0].data = true; + init_array.array_bool_test.data[0].size = + strlen(init_array.array_bool_test.data[0].data); + init_array.array_bool_test.data[1].data = true; + init_array.array_bool_test.data[1].size = + strlen(init_array.array_bool_test.data[1].data); + init_array.array_bool_test.data[2].data = false; + init_array.array_bool_test.data[2].size = + strlen(init_array.array_bool_test.data[2].data); + + // Byte + + init_array.array_byte_test.data[0].data = 0; + init_array.array_byte_test.data[0].size = + strlen(init_array.array_byte_test.data[0].data); + init_array.array_byte_test.data[1].data = 1; + init_array.array_byte_test.data[1].size = + strlen(init_array.array_byte_test.data[1].data); + init_array.array_byte_test.data[2].data = 1; + init_array.array_byte_test.data[2].size = + strlen(init_array.array_byte_test.data[2].data); + + // Char + + init_array.array_char_test.data[0].data = 'y'; + init_array.array_char_test.data[0].size = + strlen(init_array.array_char_test.data[0].data); + init_array.array_char_test.data[1].data = 'x'; + init_array.array_char_test.data[1].size = + strlen(init_array.array_char_test.data[1].data); + init_array.array_char_test.data[2].data = 'w'; + init_array.array_char_test.data[2].size = + strlen(init_array.array_char_test.data[2].data); + + // Float32 + + init_array.array_float32_test.data[0].data = 1.23; + init_array.array_float32_test.data[0].size = + strlen(init_array.array_float32_test.data[0].data); + init_array.array_float32_test.data[1].data = 45.6; + init_array.array_float32_test.data[1].size = + strlen(init_array.array_float32_test.data[1].data); + init_array.array_float32_test.data[2].data = - 222.0; + init_array.array_float32_test.data[2].size = + strlen(init_array.array_float32_test.data[2].data); + + // Double + + init_array.array_double_test.data[0].data = 5287483999.3; + init_array.array_double_test.data[0].size = + strlen(init_array.array_double_test.data[0].data); + init_array.array_double_test.data[1].data = - 46.5; + init_array.array_double_test.data[1].size = + strlen(init_array.array_double_test.data[1].data); + init_array.array_double_test.data[2].data = 2.; + init_array.array_double_test.data[2].size = + strlen(init_array.array_double_test.data[2].data); + + // int8 + + init_array.array_int8_test.data[0].data = 1; + init_array.array_int8_test.data[0].size = + strlen(init_array.array_int8_test.data[0].data); + init_array.array_int8_test.data[1].data = 2; + init_array.array_int8_test.data[1].size = + strlen(init_array.array_int8_test.data[1].data); + init_array.array_int8_test.data[2].data = - 124; + init_array.array_int8_test.data[2].size = + strlen(init_array.array_int8_test.data[2].data); + + // unit8 + + init_array.array_uint8_test.data[0].data = 11; + init_array.array_uint8_test.data[0].size = + strlen(init_array.array_uint8_test.data[0].data); + init_array.array_uint8_test.data[1].data = 12; + init_array.array_uint8_test.data[1].size = + strlen(init_array.array_uint8_test.data[1].data); + init_array.array_uint8_test.data[2].data = 13; + init_array.array_uint8_test.data[2].size = + strlen(init_array.array_uint8_test.data[2].data); + + // int16 + + init_array.array_int16_test.data[0].data = - 360; + init_array.array_int16_test.data[0].size = + strlen(init_array.array_int16_test.data[0].data); + init_array.array_int16_test.data[1].data = 1; + init_array.array_int16_test.data[1].size = + strlen(init_array.array_int16_test.data[1].data); + init_array.array_int16_test.data[2].data = 1; + init_array.array_int16_test.data[2].size = + strlen(init_array.array_int16_test.data[2].data); + + // uint16 + + init_array.array_uint16_test.data[0].data = 360; + init_array.array_uint16_test.data[0].size = + strlen(init_array.array_uint16_test.data[0].data); + init_array.array_uint16_test.data[1].data = 800; + init_array.array_uint16_test.data[1].size = + strlen(init_array.array_uint16_test.data[1].data); + init_array.array_uint16_test.data[2].data = 13; + init_array.array_uint16_test.data[2].size = + strlen(init_array.array_uint16_test.data[2].data); + + // int32 + + init_array.array_int32_test.data[0].data = 1000; + init_array.array_int32_test.data[0].size = + strlen(init_array.array_int32_test.data[0].data); + init_array.array_int32_test.data[1].data = 16843009; + init_array.array_int32_test.data[1].size = + strlen(init_array.array_int32_test.data[1].data); + init_array.array_int32_test.data[2].data = - 244; + init_array.array_int32_test.data[2].size = + strlen(init_array.array_int32_test.data[2].data); + + // uint32 + + init_array.array_uint32_test.data[0].data = 1000; + init_array.array_uint32_test.data[0].size = + strlen(init_array.array_uint32_test.data[0].data); + init_array.array_uint32_test.data[1].data = 3000; + init_array.array_uint32_test.data[1].size = + strlen(init_array.array_uint32_test.data[1].data); + init_array.array_uint32_test.data[2].data = 2; + init_array.array_uint32_test.data[2].size = + strlen(init_array.array_uint32_test.data[2].data); + + // int64 + + init_array.array_int64_test.data[0].data = 72340172838076673L; + init_array.array_int64_test.data[0].size = + strlen(init_array.array_int64_test.data[0].data); + init_array.array_int64_test.data[1].data = -3000; + init_array.array_int64_test.data[1].size = + strlen(init_array.array_int64_test.data[1].data); + init_array.array_int64_test.data[2].data = 16; + init_array.array_int64_test.data[2].size = + strlen(init_array.array_int64_test.data[2].data); + + // uint64 + + init_array.array_uint64_test.data[0].data = 21; + init_array.array_uint64_test.data[0].size = + strlen(init_array.array_uint64_test.data[0].data); + init_array.array_uint64_test.data[1].data = 72340172838076673L; + init_array.array_uint64_test.data[1].size = + strlen(init_array.array_uint64_test.data[1].data); + init_array.array_uint64_test.data[2].data = 14; + init_array.array_uint64_test.data[2].size = + strlen(init_array.array_uint64_test.data[2].data); + + // String + + init_array.array_string_test.data[0].data = const_cast("This"); + init_array.array_string_test.data[0].size = + strlen(init_array.array_string_test.data[0].data); + init_array.array_string_test.data[1].data = const_cast("is"); + init_array.array_string_test.data[1].size = + strlen(init_array.array_string_test.data[1].data); + init_array.array_string_test.data[2].data = const_cast("it"); + init_array.array_string_test.data[2].size = + strlen(init_array.array_string_test.data[2].data); + + // Prepare deserialization output instance + + rosidl_typesupport_microxrcedds_test_msg__msg__Array out_deserialized; + + ASSERT_TRUE(rosidl_runtime_c__Bool__Array__init(&out_deserialized.array_bool_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Byte__Array__init(&out_deserialized.array_byte_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Char__Array__init(&out_deserialized.array_char_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Float32__Array__init(&out_deserialized.array_float32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Double__Array__init(&out_deserialized.array_double_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int8__Array__init(&out_deserialized.array_int8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint8__Array__init(&out_deserialized.array_uint8_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int16__Array__init(&out_deserialized.array_int16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint16__Array__init(&out_deserialized.array_uint16_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int32__Array__init(&out_deserialized.array_int32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint32__Array__init(&out_deserialized.array_uint32_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Int64__Array__init(&out_deserialized.array_int64_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__Uint64__Array__init(&out_deserialized.array_uint64_test, 3)); + ASSERT_TRUE(rosidl_runtime_c__String__Array__init(&out_deserialized.array_string_test, 3)); + + // String + + char data_0[10] = {0}; + out_deserialized.array_string_test.data[0].data = data_0; + out_deserialized.array_string_test.data[0].capacity = sizeof(data_0); + char data_1[10] = {0}; + out_deserialized.array_string_test.data[1].data = data_1; + out_deserialized.array_string_test.data[1].capacity = sizeof(data_1); + char data_2[10] = {0}; + out_deserialized.array_string_test.data[2].data = data_2; + out_deserialized.array_string_test.data[2].capacity = sizeof(data_2); + + const rosidl_message_type_support_t * array_msg_type_support = + ROSIDL_GET_MSG_TYPE_SUPPORT(rosidl_typesupport_microxrcedds_test_msg, msg, Array); + EXPECT_NE(array_msg_type_support, nullptr); + + this->setup(array_msg_type_support, std::move(init_array), compare_arrays); + this->check_identifier(); + this->test_serialize_deserialize(out_deserialized); +} diff --git a/test/cpp/src/test_typesupport.cpp b/test/cpp/src/test_typesupport.cpp index f4b07f9..1d4db4e 100644 --- a/test/cpp/src/test_typesupport.cpp +++ b/test/cpp/src/test_typesupport.cpp @@ -25,6 +25,7 @@ // Specific defined types used during testing #include "rosidl_typesupport_microxrcedds_test_msg/msg/primitive.hpp" #include "rosidl_typesupport_microxrcedds_test_msg/msg/sequence.hpp" +#include "rosidl_typesupport_microxrcedds_test_msg/msg/array.hpp" /* * @brief TestTypeSupport class, used to automate typesupport testing for a specific type. @@ -81,6 +82,17 @@ class TestTypeSupport : public ::testing::Test ROSIDL_TYPESUPPORT_MICROXRCEDDS_CPP__IDENTIFIER_VALUE), 0); } + /* + * @brief Compares sequences and arrays member by member. + */ + void memberwise_comparison(int size, ) + { + for (size_t i = 0; i < A.sequence_bool_test.size(); ++i) + { + EXPECT_EQ(A.sequence_bool_test[i].compare(B.sequence_bool_test[i]), 0); + } + } + /* * @brief Tests serialization and deserialization of a T type message, * and compares the original instance and the deserialized one @@ -159,6 +171,7 @@ TYPED_TEST(PrimitivesTestTypeSupport, serialize_primitive_types) EXPECT_EQ(A.uint32_test, B.uint32_test); EXPECT_EQ(A.int64_test, B.int64_test); EXPECT_EQ(A.uint64_test, B.uint64_test); + EXPECT_EQ(A.string_test, B.string_test); EXPECT_EQ(A.nested_test.unbounded_string1.compare(B.nested_test.unbounded_string1), 0); EXPECT_EQ(A.nested_test.unbounded_string2.compare(B.nested_test.unbounded_string2), 0); @@ -181,6 +194,7 @@ TYPED_TEST(PrimitivesTestTypeSupport, serialize_primitive_types) init_primitive.uint32_test = 0x01010101; init_primitive.int64_test = 0x0101010101010101; init_primitive.uint64_test = 0x0101010101010101; + init_primitive.string_test = "Hello"; init_primitive.nested_test.unbounded_string1 = "ABCDEF"; init_primitive.nested_test.unbounded_string2 = "TGHIJKLMNO"; init_primitive.nested_test.unbounded_string3 = "PQRSTVWX"; @@ -207,15 +221,137 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) const rosidl_typesupport_microxrcedds_test_msg::msg::Sequence & A, const rosidl_typesupport_microxrcedds_test_msg::msg::Sequence & B) -> void { + EXPECT_EQ(A.sequence_bool_test.size(), B.sequence_bool_test.size()); + EXPECT_EQ(A.sequence_byte_test.size(), B.sequence_byte_test.size()); + EXPECT_EQ(A.sequence_char_test.size(), B.sequence_char_test.size()); + EXPECT_EQ(A.sequence_float32_test.size(), B.sequence_float32_test.size()); + EXPECT_EQ(A.sequence_double_test.size(), B.sequence_double_test.size()); + EXPECT_EQ(A.sequence_int8_test.size(), B.sequence_int8_test.size()); + EXPECT_EQ(A.sequence_uint8_test.size(), B.sequence_uint8_test.size()); + EXPECT_EQ(A.sequence_int16_test.size(), B.sequence_int16_test.size()); + EXPECT_EQ(A.sequence_uint16_test.size(), B.sequence_uint16_test.size()); + EXPECT_EQ(A.sequence_int32_test.size(), B.sequence_int32_test.size()); + EXPECT_EQ(A.sequence_uint32_test.size(), B.sequence_uint32_test.size()); + EXPECT_EQ(A.sequence_int64_test.size(), B.sequence_int64_test.size()); + EXPECT_EQ(A.sequence_uint64_test.size(), B.sequence_uint64_test.size()); EXPECT_EQ(A.sequence_string_test.size(), B.sequence_string_test.size()); + for (size_t i = 0; i < A.sequence_bool_test.size(); ++i) + { + EXPECT_EQ(A.sequence_bool_test[i].compare(B.sequence_bool_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_byte_test.size(); ++i) + { + EXPECT_EQ(A.sequence_byte_test[i].compare(B.sequence_byte_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_char_test.size(); ++i) + { + EXPECT_EQ(A.sequence_char_test[i].compare(B.sequence_char_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_float32_test.size(); ++i) + { + EXPECT_EQ(A.sequence_float32_test[i].compare(B.sequence_float32_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_double_test.size(); ++i) + { + EXPECT_EQ(A.sequence_double_test[i].compare(B.sequence_double_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_int8_test.size(); ++i) + { + EXPECT_EQ(A.sequence_int8_test[i].compare(B.sequence_int8_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_uint8_test.size(); ++i) + { + EXPECT_EQ(A.sequence_uint8_test[i].compare(B.sequence_uint8_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_int16_test.size(); ++i) + { + EXPECT_EQ(A.sequence_int16_test[i].compare(B.sequence_int16_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_uint16_test.size(); ++i) + { + EXPECT_EQ(A.sequence_uint16_test[i].compare(B.sequence_uint16_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_int32_test.size(); ++i) + { + EXPECT_EQ(A.sequence_int32_test[i].compare(B.sequence_int32_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_uint32_test.size(); ++i) + { + EXPECT_EQ(A.sequence_uint32_test[i].compare(B.sequence_uint32_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_int64_test.size(); ++i) + { + EXPECT_EQ(A.sequence_int64_test[i].compare(B.sequence_int64_test[i]), 0); + } + for (size_t i = 0; i < A.sequence_uint64_test.size(); ++i) + { + EXPECT_EQ(A.sequence_uint64_test[i].compare(B.sequence_uint64_test[i]), 0); + } for (size_t i = 0; i < A.sequence_string_test.size(); ++i) { EXPECT_EQ(A.sequence_string_test[i].compare(B.sequence_string_test[i]), 0); } }); + // Initialize data to be serialized and deserialized + rosidl_typesupport_microxrcedds_test_msg::msg::Sequence init_sequence; + + init_sequence.sequence_bool_test.emplace_back(true); + init_sequence.sequence_bool_test.emplace_back(true); + init_sequence.sequence_bool_test.emplace_back(false); + + init_sequence.sequence_byte_test.emplace_back(0); + init_sequence.sequence_byte_test.emplace_back(1); + + init_sequence.sequence_char_test.emplace_back('z'); + init_sequence.sequence_char_test.emplace_back('y'); + init_sequence.sequence_char_test.emplace_back('x'); + init_sequence.sequence_char_test.emplace_back('w'); + init_sequence.sequence_char_test.emplace_back('v'); + + init_sequence.sequence_float32_test.emplace_back(1.23); + init_sequence.sequence_float32_test.emplace_back(45.6); + init_sequence.sequence_float32_test.emplace_back(-222.0); + init_sequence.sequence_float32_test.emplace_back(1287.9); + + init_sequence.sequence_double_test.emplace_back(5287483999.3); + init_sequence.sequence_double_test.emplace_back(-46.5); + + init_sequence.sequence_int8_test.emplace_back(1); + init_sequence.sequence_int8_test.emplace_back(2); + init_sequence.sequence_int8_test.emplace_back(-124); + + init_sequence.sequence_uint8_test.emplace_back(11); + init_sequence.sequence_uint8_test.emplace_back(12); + init_sequence.sequence_uint8_test.emplace_back(13); + init_sequence.sequence_uint8_test.emplace_back(250); + + init_sequence.sequence_int16_test.emplace_back(-360); + init_sequence.sequence_int16_test.emplace_back(1); + + init_sequence.sequence_uint16_test.emplace_back(360); + init_sequence.sequence_uint16_test.emplace_back(800); + init_sequence.sequence_uint16_test.emplace_back(13); + + init_sequence.sequence_int32_test.emplace_back(1000); + init_sequence.sequence_int32_test.emplace_back(16843009); + + init_sequence.sequence_uint32_test.emplace_back(1000); + init_sequence.sequence_uint32_test.emplace_back(16843009); + init_sequence.sequence_uint32_test.emplace_back(3000); + init_sequence.sequence_uint32_test.emplace_back(2); + + init_sequence.sequence_int64_test.emplace_back(72340172838076673L); + init_sequence.sequence_int64_test.emplace_back(16843009); + init_sequence.sequence_int64_test.emplace_back(-3000); + init_sequence.sequence_int64_test.emplace_back(2); + init_sequence.sequence_int64_test.emplace_back(16); + + init_sequence.sequence_uint64_test.emplace_back(21); + init_sequence.sequence_uint64_test.emplace_back(72340172838076673L); + init_sequence.sequence_string_test.emplace_back("This"); init_sequence.sequence_string_test.emplace_back("is"); init_sequence.sequence_string_test.emplace_back("a"); @@ -225,3 +361,132 @@ TYPED_TEST(SequencesTestTypeSupport, serialize_sequence_types) this->check_identifier(); this->test_serialize_deserialize(); } + +/* + * @brief Array ROS 2 types serialization and deserialization tests. + */ + +template +class ArraysTestTypeSupport : public TestTypeSupport {}; + +TYPED_TEST_CASE(ArraysTestTypeSupport, + testing::Types); +TYPED_TEST(ArraysTestTypeSupport, serialize_array_types) +{ + std::function compare_arrays ([]( + const rosidl_typesupport_microxrcedds_test_msg::msg::Array & A, + const rosidl_typesupport_microxrcedds_test_msg::msg::Array & B) -> void + { + + EXPECT_EQ(A.array_bool_test.size(), 3); + EXPECT_EQ(A.array_byte_test.size(), 3); + EXPECT_EQ(A.array_char_test.size(), 3); + EXPECT_EQ(A.array_float32_test.size(), 3); + EXPECT_EQ(A.array_double_test.size(), 3); + EXPECT_EQ(A.array_int8_test.size(), 3); + EXPECT_EQ(A.array_uint8_test.size(), 3); + EXPECT_EQ(A.array_int16_test.size(), 3); + EXPECT_EQ(A.array_uint16_test.size(), 3); + EXPECT_EQ(A.array_int32_test.size(), 3); + EXPECT_EQ(A.array_uint32_test.size(), 3); + EXPECT_EQ(A.array_int64_test.size(), 3); + EXPECT_EQ(A.array_uint64_test.size(), 3); + EXPECT_EQ(A.array_string_test.size(), 3); + + EXPECT_EQ(A.array_bool_test.size(), B.array_bool_test.size()); + EXPECT_EQ(A.array_byte_test.size(), B.array_byte_test.size()); + EXPECT_EQ(A.array_char_test.size(), B.array_char_test.size()); + EXPECT_EQ(A.array_float32_test.size(), B.array_float32_test.size()); + EXPECT_EQ(A.array_double_test.size(), B.array_double_test.size()); + EXPECT_EQ(A.array_int8_test.size(), B.array_int8_test.size()); + EXPECT_EQ(A.array_uint8_test.size(), B.array_uint8_test.size()); + EXPECT_EQ(A.array_int16_test.size(), B.array_int16_test.size()); + EXPECT_EQ(A.array_uint16_test.size(), B.array_uint16_test.size()); + EXPECT_EQ(A.array_int32_test.size(), B.array_int32_test.size()); + EXPECT_EQ(A.array_uint32_test.size(), B.array_uint32_test.size()); + EXPECT_EQ(A.array_int64_test.size(), B.array_int64_test.size()); + EXPECT_EQ(A.array_uint64_test.size(), B.array_uint64_test.size()); + EXPECT_EQ(A.array_string_test.size(), B.array_string_test.size()); + + for (size_t i = 0; i < A.array_bool_test.size(); ++i) + { + EXPECT_EQ(A.array_bool_test[i].compare(B.array_bool_test[i]), 0); + } + for (size_t i = 0; i < A.array_byte_test.size(); ++i) + { + EXPECT_EQ(A.array_byte_test[i].compare(B.array_byte_test[i]), 0); + } + for (size_t i = 0; i < A.array_char_test.size(); ++i) + { + EXPECT_EQ(A.array_char_test[i].compare(B.array_char_test[i]), 0); + } + for (size_t i = 0; i < A.array_float32_test.size(); ++i) + { + EXPECT_EQ(A.array_float32_test[i].compare(B.array_float32_test[i]), 0); + } + for (size_t i = 0; i < A.array_double_test.size(); ++i) + { + EXPECT_EQ(A.array_double_test[i].compare(B.array_double_test[i]), 0); + } + for (size_t i = 0; i < A.array_int8_test.size(); ++i) + { + EXPECT_EQ(A.array_int8_test[i].compare(B.array_int8_test[i]), 0); + } + for (size_t i = 0; i < A.array_uint8_test.size(); ++i) + { + EXPECT_EQ(A.array_uint8_test[i].compare(B.array_uint8_test[i]), 0); + } + for (size_t i = 0; i < A.array_int16_test.size(); ++i) + { + EXPECT_EQ(A.array_int16_test[i].compare(B.array_int16_test[i]), 0); + } + for (size_t i = 0; i < A.array_uint16_test.size(); ++i) + { + EXPECT_EQ(A.array_uint16_test[i].compare(B.array_uint16_test[i]), 0); + } + for (size_t i = 0; i < A.array_int32_test.size(); ++i) + { + EXPECT_EQ(A.array_int32_test[i].compare(B.array_int32_test[i]), 0); + } + for (size_t i = 0; i < A.array_uint32_test.size(); ++i) + { + EXPECT_EQ(A.array_uint32_test[i].compare(B.array_uint32_test[i]), 0); + } + for (size_t i = 0; i < A.array_int64_test.size(); ++i) + { + EXPECT_EQ(A.array_int64_test[i].compare(B.array_int64_test[i]), 0); + } + for (size_t i = 0; i < A.array_uint64_test.size(); ++i) + { + EXPECT_EQ(A.array_uint64_test[i].compare(B.array_uint64_test[i]), 0); + } + for (size_t i = 0; i < A.array_string_test.size(); ++i) + { + EXPECT_EQ(A.array_string_test[i].compare(B.array_string_test[i]), 0); + } + }); + + // Initialize data to be serialized and deserialized + + rosidl_typesupport_microxrcedds_test_msg::msg::Array init_array; + init_array.array_bool_test = {true, true, false}; + init_array.array_byte_test = {0, 1, 1}; + init_array.array_char_test = {'y', 'x', 'w'}; + init_array.array_float32_test = {1.23, 45.6, -222.0); + init_array.array_double_test = {5287483999.3, -46.5, 2.}; + init_array.array_int8_test = {1, 2, -124}; + init_array.array_uint8_test = {11, 12, 13}; + init_array.array_int16_test = {-360, 1, 1}; + init_array.array_uint16_test = {360, 800, 13}; + init_array.array_int32_test = {1000, 16843009, - 244}; + init_array.array_uint32_test = {1000, 3000, 2}; + init_array.array_int64_test = {72340172838076673L, -3000, 16}; + init_array.array_uint64_test = {21, 72340172838076673L, 14}; + init_array.array_string_test = {"This", "is", "it"}; + + this->setup(std::move(init_array), compare_arrays); + this->check_identifier(); + this->test_serialize_deserialize(); +} diff --git a/test/msg/CMakeLists.txt b/test/msg/CMakeLists.txt index 125cd88..8dc148b 100644 --- a/test/msg/CMakeLists.txt +++ b/test/msg/CMakeLists.txt @@ -27,6 +27,7 @@ if(BUILD_TESTING) "msg/UnboundedString.msg" "msg/Primitive.msg" "msg/Sequence.msg" + "msg/Array.msg" ) rosidl_generate_interfaces(${PROJECT_NAME} diff --git a/test/msg/msg/Array.msg b/test/msg/msg/Array.msg new file mode 100644 index 0000000..cb772db --- /dev/null +++ b/test/msg/msg/Array.msg @@ -0,0 +1,14 @@ +bool[3] array_bool_test +byte[3] array_byte_test +char[3] array_char_test +float32[3] array_float32_test +float64[3] array_double_test +int8[3] array_int8_test +uint8[3] array_uint8_test +int16[3] array_int16_test +uint16[3] array_uint16_test +int32[3] array_int32_test +uint32[3] array_uint32_test +int64[3] array_int64_test +uint64[3] array_uint64_test +string[3] array_string_test \ No newline at end of file diff --git a/test/msg/msg/Primitive.msg b/test/msg/msg/Primitive.msg index 72d34cf..519c8a8 100644 --- a/test/msg/msg/Primitive.msg +++ b/test/msg/msg/Primitive.msg @@ -1,27 +1,15 @@ bool bool_test -bool[11] bool_array_test byte byte_test -byte[11] byte_array_test char char_test -char[11] char_array_test float32 float32_test -float32[11] float32_array_test float64 double_test -float64[11] float64_array_test int8 int8_test -int8[11] int8_array_test uint8 uint8_test -uint8[11] uint8_array_test int16 int16_test -int16[11] int16_array_test uint16 uint16_test -uint16[11] uint16_array_test int32 int32_test -int32[11] int32_array_test uint32 uint32_test -uint32[11] uint32_array_test int64 int64_test -int64[11] int64_array_test uint64 uint64_test -uint64[11] uint64_array_test +string string_test UnboundedString nested_test diff --git a/test/msg/msg/Sequence.msg b/test/msg/msg/Sequence.msg index c1cd566..9e049de 100644 --- a/test/msg/msg/Sequence.msg +++ b/test/msg/msg/Sequence.msg @@ -1 +1,14 @@ +bool[] sequence_bool_test +byte[] sequence_byte_test +char[] sequence_char_test +float32[] sequence_float32_test +float64[] sequence_double_test +int8[] sequence_int8_test +uint8[] sequence_uint8_test +int16[] sequence_int16_test +uint16[] sequence_uint16_test +int32[] sequence_int32_test +uint32[] sequence_uint32_test +int64[] sequence_int64_test +uint64[] sequence_uint64_test string[] sequence_string_test From 810b4c2f80eb1b42ddf8ab7b76f92df8944dbb73 Mon Sep 17 00:00:00 2001 From: Jose Antonio Moral Date: Wed, 9 Sep 2020 09:32:53 +0200 Subject: [PATCH 2/3] Add .vscode folder to gitignore --- .gitignore | 3 +++ .vscode/settings.json | 14 -------------- 2 files changed, 3 insertions(+), 14 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.gitignore b/.gitignore index 8d386b3..2c81691 100644 --- a/.gitignore +++ b/.gitignore @@ -58,6 +58,9 @@ devel_isolated/ .project .cproject +# VSCode stuff +.vscode + # qcreator stuff CMakeLists.txt.user diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 3e3997b..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "files.associations": { - "array": "cpp", - "bitset": "cpp", - "string_view": "cpp", - "initializer_list": "cpp", - "utility": "cpp", - "*.tcc": "cpp", - "deque": "cpp", - "vector": "cpp", - "functional": "cpp", - "string": "cpp" - } -} \ No newline at end of file From 3206ebaa045ba5a8f8a195f8cebbc1968194e102 Mon Sep 17 00:00:00 2001 From: francesca Date: Wed, 9 Sep 2020 10:26:35 +0200 Subject: [PATCH 3/3] Corrected typo. --- test/c/src/test_typesupport.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/c/src/test_typesupport.cpp b/test/c/src/test_typesupport.cpp index b85abb2..f09d753 100644 --- a/test/c/src/test_typesupport.cpp +++ b/test/c/src/test_typesupport.cpp @@ -18,7 +18,7 @@ #include "rosidl_runtime_c/message_type_support_struct.h" // Generic MicroXRCE-DDS typesupport includes -#include F +#include #include // Specific defined types used during testing