You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2020/03/29 19:28:50 UTC
[celix] branch develop updated: Refactors dfi tests from cpputest
to google test (#168)
This is an automated email from the ASF dual-hosted git repository.
pnoltes pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git
The following commit(s) were added to refs/heads/develop by this push:
new a77b9a2 Refactors dfi tests from cpputest to google test (#168)
a77b9a2 is described below
commit a77b9a2369f70f290218e91616aea4150fc75e27
Author: Pepijn Noltes <pe...@gmail.com>
AuthorDate: Sun Mar 29 21:28:38 2020 +0200
Refactors dfi tests from cpputest to google test (#168)
* Refactors dfi test from cpputest to google test
* Adds undefined behavior sanitizer options to celix project
* Fixed some memory leaks and refactors the avrobin parsing for sequences
---
cmake/celix_project/CelixProject.cmake | 7 +-
libs/dfi/CMakeLists.txt | 27 +-
libs/dfi/gtest/CMakeLists.txt | 42 +++
.../descriptors/example1.descriptor | 0
.../descriptors/example2.descriptor | 0
.../descriptors/example3.descriptor | 0
.../descriptors/example4.descriptor | 0
.../descriptors/invalids/invalid.descriptor | 0
.../invalids/invalidMetaType.descriptor | 0
.../descriptors/invalids/invalidMethod.descriptor | 0
.../invalids/invalidMethodReturnType.descriptor | 0
.../descriptors/invalids/invalidMsgHdr.descriptor | 0
.../invalids/invalidMsgInvalidName.descriptor | 0
.../invalids/invalidMsgInvalidSection.descriptor | 0
.../invalids/invalidMsgInvalidType.descriptor | 0
.../invalids/invalidMsgInvalidVersion.descriptor | 0
.../invalids/invalidMsgMissingVersion.descriptor | 0
.../descriptors/invalids/invalidSection.descriptor | 0
.../descriptors/invalids/invalidType.descriptor | 0
.../descriptors/invalids/invalidVersion.descriptor | 0
.../descriptors/invalids/noVersion.descriptor | 0
.../descriptors/msg_example1.descriptor | 0
.../descriptors/msg_example2.descriptor | 0
.../descriptors/msg_example3.descriptor | 0
.../descriptors/msg_example4.descriptor | 0
libs/dfi/{test => gtest}/schemas/complex.avdl | 0
libs/dfi/{test => gtest}/schemas/complex.avpr | 0
libs/dfi/{test => gtest}/schemas/invalid1.avpr | 0
libs/dfi/{test => gtest}/schemas/invalid2.avpr | 0
libs/dfi/{test => gtest}/schemas/simple.avdl | 0
libs/dfi/{test => gtest}/schemas/simple.avpr | 0
libs/dfi/{test => gtest}/schemas/simple_min.avpr | 0
.../src}/avro_descriptor_translator_tests.cpp | 20 +-
.../src}/avrobin_serialization_tests.cpp | 190 ++++++-----
.../src}/dyn_avpr_function_tests.cpp | 235 +++++++------
.../src}/dyn_avpr_interface_tests.cpp | 44 +--
libs/dfi/{test => gtest/src}/dyn_avpr_tests.cpp | 203 +++++------
libs/dfi/{test => gtest/src}/dyn_closure_tests.cpp | 45 +--
.../src/dyn_example_functions.c} | 39 ++-
.../src/dyn_example_functions.h} | 47 ++-
libs/dfi/gtest/src/dyn_function_tests.cpp | 287 ++++++++++++++++
.../{test => gtest/src}/dyn_interface_tests.cpp | 68 ++--
libs/dfi/{test => gtest/src}/dyn_message_tests.cpp | 111 +++---
libs/dfi/{test => gtest/src}/dyn_type_tests.cpp | 83 ++---
.../{test => gtest/src}/json_rpc_avpr_tests.cpp | 73 ++--
libs/dfi/{test => gtest/src}/json_rpc_tests.cpp | 107 +++---
.../{test => gtest/src}/json_serializer_tests.cpp | 375 +++++++++++----------
libs/dfi/include/avrobin_serializer.h | 11 +
libs/dfi/include/dfi_log_util.h | 22 +-
libs/dfi/include/dyn_common.h | 10 +-
libs/dfi/include/dyn_function.h | 8 +-
libs/dfi/include/dyn_function_common.h | 8 +
libs/dfi/include/dyn_interface.h | 8 +
libs/dfi/include/dyn_interface_common.h | 8 +
libs/dfi/include/dyn_message.h | 8 +
libs/dfi/include/dyn_type.h | 29 ++
libs/dfi/include/dyn_type_common.h | 8 +
libs/dfi/include/json_rpc.h | 8 +
libs/dfi/include/json_serializer.h | 8 +
libs/dfi/src/avrobin_serializer.c | 127 +++----
libs/dfi/src/dyn_function.c | 8 +-
libs/dfi/src/dyn_type.c | 50 ++-
libs/dfi/test/dyn_function_tests.cpp | 309 -----------------
libs/dfi/test/run_tests.cpp | 25 --
64 files changed, 1421 insertions(+), 1237 deletions(-)
diff --git a/cmake/celix_project/CelixProject.cmake b/cmake/celix_project/CelixProject.cmake
index 9d306a7..a0f3484 100644
--- a/cmake/celix_project/CelixProject.cmake
+++ b/cmake/celix_project/CelixProject.cmake
@@ -15,7 +15,8 @@
# specific language governing permissions and limitations
# under the License.
-option(ENABLE_ADDRESS_SANITIZER "Enabled building with address sanitizer. Note for gcc libasan must be installed" OFF)
+option(ENABLE_ADDRESS_SANITIZER "Enabled building with address sanitizer. Note for gcc libasan must be installed," OFF)
+option(ENABLE_UNDEFINED_SANITIZER "Enabled building with undefined behavior sanitizer." OFF)
if (ENABLE_ADDRESS_SANITIZER)
if (APPLE)
@@ -27,6 +28,10 @@ if (ENABLE_ADDRESS_SANITIZER)
endif ()
endif()
+if (ENABLE_UNDEFINED_SANITIZER)
+ set(CMAKE_C_FLAGS "-fsanitize=undefined ${CMAKE_C_FLAGS}")
+ set(CMAKE_CXX_FLAGS "-fsanitize=undefined ${CMAKE_CXX_FLAGS}")
+endif()
MACRO(celix_subproject)
set(ARGS "${ARGN}")
diff --git a/libs/dfi/CMakeLists.txt b/libs/dfi/CMakeLists.txt
index d43af5f..136419f 100644
--- a/libs/dfi/CMakeLists.txt
+++ b/libs/dfi/CMakeLists.txt
@@ -52,31 +52,6 @@ install(DIRECTORY include/ DESTINATION include/celix/dfi COMPONENT dfi)
add_library(Celix::dfi ALIAS dfi)
if (ENABLE_TESTING)
- find_package(CppUTest REQUIRED)
-
- add_executable(test_dfi
- test/dyn_avpr_tests.cpp
- test/dyn_type_tests.cpp
- test/dyn_function_tests.cpp
- test/dyn_closure_tests.cpp
- test/dyn_avpr_function_tests.cpp
- test/dyn_interface_tests.cpp
- test/dyn_avpr_interface_tests.cpp
- test/dyn_message_tests.cpp
- test/json_serializer_tests.cpp
- test/json_rpc_tests.cpp
- test/json_rpc_avpr_tests.cpp
- test/avrobin_serialization_tests.cpp
- test/run_tests.cpp
- )
-
- target_include_directories(test_dfi SYSTEM PRIVATE ${CPPUTEST_INCLUDE_DIR})
- target_link_libraries(test_dfi PRIVATE Celix::dfi Celix::utils FFI::lib Jansson ${CPPUTEST_LIBRARIES})
-
- file(COPY ${CMAKE_CURRENT_LIST_DIR}/test/schemas DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
- file(COPY ${CMAKE_CURRENT_LIST_DIR}/test/descriptors DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
-
- add_test(NAME run_test_dfi COMMAND test_dfi)
- SETUP_TARGET_FOR_COVERAGE(test_dfi_cov test_dfi ${CMAKE_BINARY_DIR}/coverage/test_dfi/test_dfi)
+ add_subdirectory(gtest)
endif(ENABLE_TESTING)
diff --git a/libs/dfi/gtest/CMakeLists.txt b/libs/dfi/gtest/CMakeLists.txt
new file mode 100644
index 0000000..277934e
--- /dev/null
+++ b/libs/dfi/gtest/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+add_executable(test_dfi
+ src/dyn_example_functions.c
+ src/dyn_avpr_tests.cpp
+ src/dyn_type_tests.cpp
+ src/dyn_function_tests.cpp
+ src/dyn_closure_tests.cpp
+ src/dyn_avpr_function_tests.cpp
+ src/dyn_interface_tests.cpp
+ src/dyn_avpr_interface_tests.cpp
+ src/dyn_message_tests.cpp
+ src/json_serializer_tests.cpp
+ src/json_rpc_tests.cpp
+ src/json_rpc_avpr_tests.cpp
+ src/avrobin_serialization_tests.cpp
+)
+
+target_link_libraries(test_dfi PRIVATE Celix::dfi Celix::utils FFI::lib Jansson GTest::GTest GTest::GMain)
+
+file(COPY ${CMAKE_CURRENT_LIST_DIR}/schemas DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+file(COPY ${CMAKE_CURRENT_LIST_DIR}/descriptors DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+add_test(NAME run_test_dfi COMMAND test_dfi)
+SETUP_TARGET_FOR_COVERAGE(test_dfi_cov test_dfi ${CMAKE_BINARY_DIR}/coverage/test_dfi/test_dfi ..)
+
diff --git a/libs/dfi/test/descriptors/example1.descriptor b/libs/dfi/gtest/descriptors/example1.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/example1.descriptor
rename to libs/dfi/gtest/descriptors/example1.descriptor
diff --git a/libs/dfi/test/descriptors/example2.descriptor b/libs/dfi/gtest/descriptors/example2.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/example2.descriptor
rename to libs/dfi/gtest/descriptors/example2.descriptor
diff --git a/libs/dfi/test/descriptors/example3.descriptor b/libs/dfi/gtest/descriptors/example3.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/example3.descriptor
rename to libs/dfi/gtest/descriptors/example3.descriptor
diff --git a/libs/dfi/test/descriptors/example4.descriptor b/libs/dfi/gtest/descriptors/example4.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/example4.descriptor
rename to libs/dfi/gtest/descriptors/example4.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalid.descriptor b/libs/dfi/gtest/descriptors/invalids/invalid.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalid.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalid.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMetaType.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMetaType.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMetaType.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMetaType.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMethod.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMethod.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMethod.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMethod.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMethodReturnType.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMethodReturnType.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMethodReturnType.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMethodReturnType.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgHdr.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgHdr.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgHdr.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgHdr.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgInvalidName.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidName.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgInvalidName.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidName.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgInvalidSection.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidSection.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgInvalidSection.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidSection.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgInvalidType.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidType.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgInvalidType.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidType.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgInvalidVersion.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidVersion.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgInvalidVersion.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgInvalidVersion.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidMsgMissingVersion.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidMsgMissingVersion.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidMsgMissingVersion.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidMsgMissingVersion.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidSection.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidSection.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidSection.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidSection.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidType.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidType.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidType.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidType.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/invalidVersion.descriptor b/libs/dfi/gtest/descriptors/invalids/invalidVersion.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/invalidVersion.descriptor
rename to libs/dfi/gtest/descriptors/invalids/invalidVersion.descriptor
diff --git a/libs/dfi/test/descriptors/invalids/noVersion.descriptor b/libs/dfi/gtest/descriptors/invalids/noVersion.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/invalids/noVersion.descriptor
rename to libs/dfi/gtest/descriptors/invalids/noVersion.descriptor
diff --git a/libs/dfi/test/descriptors/msg_example1.descriptor b/libs/dfi/gtest/descriptors/msg_example1.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/msg_example1.descriptor
rename to libs/dfi/gtest/descriptors/msg_example1.descriptor
diff --git a/libs/dfi/test/descriptors/msg_example2.descriptor b/libs/dfi/gtest/descriptors/msg_example2.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/msg_example2.descriptor
rename to libs/dfi/gtest/descriptors/msg_example2.descriptor
diff --git a/libs/dfi/test/descriptors/msg_example3.descriptor b/libs/dfi/gtest/descriptors/msg_example3.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/msg_example3.descriptor
rename to libs/dfi/gtest/descriptors/msg_example3.descriptor
diff --git a/libs/dfi/test/descriptors/msg_example4.descriptor b/libs/dfi/gtest/descriptors/msg_example4.descriptor
similarity index 100%
rename from libs/dfi/test/descriptors/msg_example4.descriptor
rename to libs/dfi/gtest/descriptors/msg_example4.descriptor
diff --git a/libs/dfi/test/schemas/complex.avdl b/libs/dfi/gtest/schemas/complex.avdl
similarity index 100%
rename from libs/dfi/test/schemas/complex.avdl
rename to libs/dfi/gtest/schemas/complex.avdl
diff --git a/libs/dfi/test/schemas/complex.avpr b/libs/dfi/gtest/schemas/complex.avpr
similarity index 100%
rename from libs/dfi/test/schemas/complex.avpr
rename to libs/dfi/gtest/schemas/complex.avpr
diff --git a/libs/dfi/test/schemas/invalid1.avpr b/libs/dfi/gtest/schemas/invalid1.avpr
similarity index 100%
rename from libs/dfi/test/schemas/invalid1.avpr
rename to libs/dfi/gtest/schemas/invalid1.avpr
diff --git a/libs/dfi/test/schemas/invalid2.avpr b/libs/dfi/gtest/schemas/invalid2.avpr
similarity index 100%
rename from libs/dfi/test/schemas/invalid2.avpr
rename to libs/dfi/gtest/schemas/invalid2.avpr
diff --git a/libs/dfi/test/schemas/simple.avdl b/libs/dfi/gtest/schemas/simple.avdl
similarity index 100%
rename from libs/dfi/test/schemas/simple.avdl
rename to libs/dfi/gtest/schemas/simple.avdl
diff --git a/libs/dfi/test/schemas/simple.avpr b/libs/dfi/gtest/schemas/simple.avpr
similarity index 100%
rename from libs/dfi/test/schemas/simple.avpr
rename to libs/dfi/gtest/schemas/simple.avpr
diff --git a/libs/dfi/test/schemas/simple_min.avpr b/libs/dfi/gtest/schemas/simple_min.avpr
similarity index 100%
rename from libs/dfi/test/schemas/simple_min.avpr
rename to libs/dfi/gtest/schemas/simple_min.avpr
diff --git a/libs/dfi/test/avro_descriptor_translator_tests.cpp b/libs/dfi/gtest/src/avro_descriptor_translator_tests.cpp
similarity index 91%
rename from libs/dfi/test/avro_descriptor_translator_tests.cpp
rename to libs/dfi/gtest/src/avro_descriptor_translator_tests.cpp
index ae4698a..12e6aba 100644
--- a/libs/dfi/test/avro_descriptor_translator_tests.cpp
+++ b/libs/dfi/gtest/src/avro_descriptor_translator_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
@@ -155,28 +154,33 @@ extern "C" {
}
}
-TEST_GROUP(AvroDescTranslatorTest) {
- void setup() {
+class AvroDescTranslatorTest : public ::testing::Test {
+public:
+ AvroDescTranslatorTest() {
descriptorTranslator_logSetup(stdLog, NULL, 3);
dynInterface_logSetup(stdLog, NULL, 3);
dynType_logSetup(stdLog, NULL, 3);
dynCommon_logSetup(stdLog, NULL, 3);
}
+ ~AvroDescTranslatorTest() override {
+ }
+
};
-TEST(AvroDescTranslatorTest, simple) {
+
+TEST_F(AvroDescTranslatorTest, simple) {
simple();
}
-TEST(AvroDescTranslatorTest, complex) {
+TEST_F(AvroDescTranslatorTest, complex) {
complex();
}
-TEST(AvroDescTranslatorTest, invalid1) {
+TEST_F(AvroDescTranslatorTest, invalid1) {
invalid("schemas/invalid1.avpr");
}
-TEST(AvroDescTranslatorTest, invalid2) {
+TEST_F(AvroDescTranslatorTest, invalid2) {
invalid("schemas/invalid2.avpr");
}
diff --git a/libs/dfi/test/avrobin_serialization_tests.cpp b/libs/dfi/gtest/src/avrobin_serialization_tests.cpp
similarity index 79%
rename from libs/dfi/test/avrobin_serialization_tests.cpp
rename to libs/dfi/gtest/src/avrobin_serialization_tests.cpp
index 27bd15a..0a0ebdf 100644
--- a/libs/dfi/test/avrobin_serialization_tests.cpp
+++ b/libs/dfi/gtest/src/avrobin_serialization_tests.cpp
@@ -16,8 +16,11 @@
*specific language governing permissions and limitations
*under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+
extern "C" {
#include "avrobin_serializer.h"
@@ -136,21 +139,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test1_descriptor, "test1", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test1_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(-444,*(int32_t*)inst);
+ ASSERT_EQ(-444,*(int32_t*)inst);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test1.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -172,24 +175,24 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test2_descriptor, "test2", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test2_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(10000,(*(struct test2_type*)inst).a);
- CHECK_EQUAL(20000,(*(struct test2_type*)inst).b);
- CHECK_EQUAL(-30000,(*(struct test2_type*)inst).c);
- CHECK_EQUAL(-40000,(*(struct test2_type*)inst).d);
+ ASSERT_EQ(10000,(*(struct test2_type*)inst).a);
+ ASSERT_EQ(20000,(*(struct test2_type*)inst).b);
+ ASSERT_EQ(-30000,(*(struct test2_type*)inst).c);
+ ASSERT_EQ(-40000,(*(struct test2_type*)inst).d);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test2.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -209,22 +212,22 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test3_descriptor, "test3", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test3_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(101,(*(struct test3_type*)inst).c.a);
- CHECK_EQUAL(99,(*(struct test3_type*)inst).d.b);
+ ASSERT_EQ(101,(*(struct test3_type*)inst).c.a);
+ ASSERT_EQ(99,(*(struct test3_type*)inst).d.b);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test3.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -242,21 +245,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test4_descriptor, "test4", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test4_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(1.234f,*(float*)inst);
+ ASSERT_EQ(1.234f,*(float*)inst);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test4.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -274,21 +277,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test5_descriptor, "test5", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test5_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(2.345678,*(double*)inst);
+ ASSERT_EQ(2.345678,*(double*)inst);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test5.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -306,21 +309,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test6_descriptor, "test6", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test6_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- STRCMP_EQUAL("This is a string.",*(const char**)inst);
+ ASSERT_STREQ("This is a string.",*(const char**)inst);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test6.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -344,27 +347,27 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test7_descriptor, "test7", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test7_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(8, (*(struct test7_type*)inst).cap);
- CHECK_EQUAL(8, (*(struct test7_type*)inst).len);
+ ASSERT_EQ(8, (*(struct test7_type*)inst).cap);
+ ASSERT_EQ(8, (*(struct test7_type*)inst).len);
if ((*(struct test7_type*)inst).cap == 8 && (*(struct test7_type*)inst).len == 8) {
for (int i=0; i<8; i++) {
- CHECK_EQUAL(i, (*(struct test7_type*)inst).buf[i]);
+ ASSERT_EQ(i, (*(struct test7_type*)inst).buf[i]);
}
}
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test7.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -391,28 +394,28 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test8_descriptor, "test8", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test8_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(64, (*(struct test8_type*)inst).cap);
- CHECK_EQUAL(64, (*(struct test8_type*)inst).len);
+ ASSERT_EQ(64, (*(struct test8_type*)inst).cap);
+ ASSERT_EQ(64, (*(struct test8_type*)inst).len);
if ((*(struct test8_type*)inst).cap == 64 && (*(struct test8_type*)inst).len == 64) {
for (int i=0; i<64; i++) {
- CHECK_EQUAL( i * 3.333 , ((*(struct test8_type*)inst).buf[i]).one );
- CHECK_EQUAL( i * 4.444 , ((*(struct test8_type*)inst).buf[i]).two );
+ ASSERT_EQ( i * 3.333 , ((*(struct test8_type*)inst).buf[i]).one );
+ ASSERT_EQ( i * 4.444 , ((*(struct test8_type*)inst).buf[i]).two );
}
}
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test8.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -443,33 +446,33 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test9_descriptor, "test9", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test9_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(64, (*(struct test9_type*)inst).cap);
- CHECK_EQUAL(64, (*(struct test9_type*)inst).len);
+ ASSERT_EQ(64, (*(struct test9_type*)inst).cap);
+ ASSERT_EQ(64, (*(struct test9_type*)inst).len);
if ((*(struct test9_type*)inst).cap == 64 && (*(struct test9_type*)inst).len == 64) {
for (int i=0; i<64; i++) {
- CHECK_EQUAL(8, ((*(struct test9_type*)inst).buf[i]).cap);
- CHECK_EQUAL(8, ((*(struct test9_type*)inst).buf[i]).len);
+ ASSERT_EQ(8, ((*(struct test9_type*)inst).buf[i]).cap);
+ ASSERT_EQ(8, ((*(struct test9_type*)inst).buf[i]).len);
if ( ((*(struct test9_type*)inst).buf[i]).cap == 8 && ((*(struct test9_type*)inst).buf[i]).len == 8 ) {
for (int j=0; j<8; j++) {
- CHECK_EQUAL(j*1.234f, ((*(struct test9_type*)inst).buf[i]).buf[j]);
+ ASSERT_EQ(j*1.234f, ((*(struct test9_type*)inst).buf[i]).buf[j]);
}
}
}
}
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test9.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -493,21 +496,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test10_descriptor, "test10", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test10_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(8765,*(*(int32_t**)inst));
+ ASSERT_EQ(8765,*(*(int32_t**)inst));
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test10.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -530,22 +533,22 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test11_descriptor, "test11", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test11_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(1.234,(*(struct test11_type *)inst).c->a);
- CHECK_EQUAL(2.345,(*(struct test11_type *)inst).c->b);
+ ASSERT_EQ(1.234,(*(struct test11_type *)inst).c->a);
+ ASSERT_EQ(2.345,(*(struct test11_type *)inst).c->b);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test11.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -565,21 +568,21 @@ static void generalTests() {
serdatalen = 0;
schema = NULL;
rc = dynType_parseWithStr(test12_descriptor, "test12", NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_serialize(type, &test12_val, &serdata, &serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
- CHECK_EQUAL(TEST12_ENUM_NOK,*(enum test12_enum*)inst);
+ ASSERT_EQ(TEST12_ENUM_NOK,*(enum test12_enum*)inst);
rc = avrobinSerializer_generateSchema(type, &schema);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
if (rc == 0) {
printf("%s\n", schema);
rc = avrobinSerializer_saveFile("test12.avro", schema, serdata, serdatalen);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
free(schema);
}
dynType_free(type, inst);
@@ -592,13 +595,18 @@ static void generalTests() {
}
-TEST_GROUP(AvrobinSerializerTests) {
- void setup() {
+
+class AvrobinSerializerTests : public ::testing::Test {
+public:
+ AvrobinSerializerTests() {
int lvl = 1;
avrobinSerializer_logSetup(stdLog, NULL, lvl);
}
+ ~AvrobinSerializerTests() override {
+ }
+
};
-TEST(AvrobinSerializerTests, GeneralTests) {
+TEST_F(AvrobinSerializerTests, GeneralTests) {
generalTests();
}
diff --git a/libs/dfi/test/dyn_avpr_function_tests.cpp b/libs/dfi/gtest/src/dyn_avpr_function_tests.cpp
similarity index 81%
rename from libs/dfi/test/dyn_avpr_function_tests.cpp
rename to libs/dfi/gtest/src/dyn_avpr_function_tests.cpp
index 30fbf79..fd507a7 100644
--- a/libs/dfi/test/dyn_avpr_function_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_avpr_function_tests.cpp
@@ -17,9 +17,9 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
+#include "gtest/gtest.h"
+
#include <celix_utils.h>
-#include "CppUTest/CommandLineTestRunner.h"
extern "C" {
#include <stdio.h>
@@ -219,27 +219,32 @@ const char* theAvprFile = "{ \
}\
}";
-TEST_GROUP(DynAvprFunctionTests) {
- void setup() override {
+
+class DynAvprFunctionTests : public ::testing::Test {
+public:
+ DynAvprFunctionTests() {
int lvl = 1;
dynAvprFunction_logSetup(stdLog, nullptr, lvl);
dynAvprType_logSetup(stdLog, nullptr, lvl);
}
+ ~DynAvprFunctionTests() override {
+ }
+
};
// Test 1, simple function with three arguments and a return type
static int avpr_example1(__attribute__((unused)) void* handle, int32_t a, int32_t b, int32_t c, int32_t * out) {
- CHECK_EQUAL(2, a);
- CHECK_EQUAL(4, b);
- CHECK_EQUAL(8, c);
+ EXPECT_EQ(2, a);
+ EXPECT_EQ(4, b);
+ EXPECT_EQ(8, c);
*out = 1;
return 0;
}
-TEST(DynAvprFunctionTests, Example1) {
+TEST_F(DynAvprFunctionTests, Example1) {
auto fp = (void (*)()) avpr_example1;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.simpleFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -257,9 +262,9 @@ TEST(DynAvprFunctionTests, Example1) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(1, out);
- CHECK_EQUAL(0, rVal);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(1, out);
+ ASSERT_EQ(0, rVal);
dynFunction_destroy(dynFunc);
}
@@ -272,19 +277,19 @@ struct avpr_example2_arg2 {
};
static int avpr_example2(__attribute__((unused)) void* handle, int32_t arg1, struct avpr_example2_arg2 arg2, double arg3, double* out) {
- CHECK_EQUAL(2, arg1);
- CHECK_EQUAL(2, arg2.val1);
- CHECK_EQUAL(3, arg2.val2);
- CHECK_EQUAL(4.1, arg2.val3);
- CHECK_EQUAL(8.1, arg3);
+ EXPECT_EQ(2, arg1);
+ EXPECT_EQ(2, arg2.val1);
+ EXPECT_EQ(3, arg2.val2);
+ EXPECT_EQ(4.1, arg2.val3);
+ EXPECT_EQ(8.1, arg3);
*out = 2.2;
return 0;
}
-TEST(DynAvprFunctionTests, Example2) {
+TEST_F(DynAvprFunctionTests, Example2) {
auto fp = (void (*)()) avpr_example2;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "nested.test.dt.structFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -303,29 +308,29 @@ TEST(DynAvprFunctionTests, Example2) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(0, rVal);
- CHECK_EQUAL(2.2, out);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(0, rVal);
+ ASSERT_EQ(2.2, out);
dynFunction_destroy(dynFunc);
}
// Test 3, Test access of functions, see if arguments and result type can be accessed
-TEST(DynAvprFunctionTests, Example3) {
+TEST_F(DynAvprFunctionTests, Example3) {
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.accessFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int nrOfArgs = dynFunction_nrOfArguments(dynFunc);
- CHECK_EQUAL(3+1+1, nrOfArgs);
+ ASSERT_EQ(3+1+1, nrOfArgs);
dyn_type *arg1 = dynFunction_argumentTypeForIndex(dynFunc, 2);
- CHECK(arg1 != nullptr);
- CHECK_EQUAL('{', (char) dynType_descriptorType(arg1));
+ ASSERT_TRUE(arg1 != nullptr);
+ ASSERT_EQ('{', (char) dynType_descriptorType(arg1));
dyn_type *nonExist = dynFunction_argumentTypeForIndex(dynFunc, 10);
- CHECK(nonExist == nullptr);
+ ASSERT_TRUE(nonExist == nullptr);
dyn_type *returnType = dynFunction_returnType(dynFunc);
- CHECK_EQUAL('N', (char) dynType_descriptorType(returnType));
+ ASSERT_EQ('N', (char) dynType_descriptorType(returnType));
dynFunction_destroy(dynFunc);
}
@@ -335,8 +340,8 @@ TEST(DynAvprFunctionTests, Example3) {
/*
static int avpr_example4(__attribute__((unused)) void *handle, void *ptr, double a, double *out, int *out_2) {
auto b = (double *)ptr;
- CHECK_EQUAL(2.0, *b);
- CHECK_EQUAL(2.0, a);
+ ASSERT_EQ(2.0, *b);
+ ASSERT_EQ(2.0, a);
*out = *b * a; // => out parameter
*out_2 = 3;
return 0;
@@ -345,7 +350,7 @@ static int avpr_example4(__attribute__((unused)) void *handle, void *ptr, double
TEST(DynAvprFunctionTests, Example4) {
auto fp = (void(*)()) avpr_example4;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.outFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -364,9 +369,9 @@ TEST(DynAvprFunctionTests, Example4) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(4.0, result);
- CHECK_EQUAL(3, out);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(4.0, result);
+ ASSERT_EQ(3, out);
auto inMemResult = (double *)calloc(1, sizeof(double));
a = 2.0;
@@ -376,8 +381,8 @@ TEST(DynAvprFunctionTests, Example4) {
args[3] = &inMemResult;
rVal = 0;
rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(4.0, result);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(4.0, result);
free(inMemResult);
dynFunction_destroy(dynFunc);
}
@@ -391,18 +396,18 @@ struct tst_seq {
};
static int avpr_example5(__attribute__((unused)) void* handle, struct tst_seq seq, __attribute__((unused)) void* out) {
- CHECK_EQUAL(4, seq.cap);
- CHECK_EQUAL(2, seq.len);
- CHECK_EQUAL(1.1, seq.buf[0]);
- CHECK_EQUAL(2.2, seq.buf[1]);
+ EXPECT_EQ(4, seq.cap);
+ EXPECT_EQ(2, seq.len);
+ EXPECT_EQ(1.1, seq.buf[0]);
+ EXPECT_EQ(2.2, seq.buf[1]);
return 0;
}
-TEST(DynAvprFunctionTests, Example5) {
+TEST_F(DynAvprFunctionTests, Example5) {
auto fp = (void(*)()) avpr_example5;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.seqFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -420,8 +425,8 @@ TEST(DynAvprFunctionTests, Example5) {
int retArg = 1;
int rc = dynFunction_call(dynFunc, fp, &retArg, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(0, retArg);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(0, retArg);
dynFunction_destroy(dynFunc);
}
@@ -434,21 +439,21 @@ struct info {
static int avpr_example6(void *handle, int32_t id_modifier, double* out) {
auto fake_this = (struct info *) handle;
- CHECK(fake_this != nullptr);
- CHECK(fake_this->name != nullptr);
- CHECK_EQUAL(0, strcmp(fake_this->name, "test_name"));
- CHECK_EQUAL(42, fake_this->id);
+ EXPECT_TRUE(fake_this != nullptr);
+ EXPECT_TRUE(fake_this->name != nullptr);
+ EXPECT_EQ(0, strcmp(fake_this->name, "test_name"));
+ EXPECT_EQ(42, fake_this->id);
*out = (double)(fake_this->id + id_modifier);
return 0;
}
-TEST(DynAvprFunctionTests, Example6) {
+TEST_F(DynAvprFunctionTests, Example6) {
auto fp = (void(*)()) avpr_example6;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.infoFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
info handle {strdup("test_name"), 42};
- CHECK(handle.name != nullptr);
+ ASSERT_TRUE(handle.name != nullptr);
struct info * handle_ptr = &handle;
int32_t argument = 58;
@@ -462,9 +467,9 @@ TEST(DynAvprFunctionTests, Example6) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(100.0, out);
- CHECK_EQUAL(0, rVal);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(100.0, out);
+ ASSERT_EQ(0, rVal);
dynFunction_destroy(dynFunc);
free(handle.name);
}
@@ -477,16 +482,16 @@ struct double_seq {
};
static int avpr_example7(__attribute__((unused)) void *handle, struct double_seq seq_in, double* out) {
- CHECK_EQUAL(2, seq_in.cap);
- CHECK_EQUAL(2, seq_in.len);
+ EXPECT_EQ(2, seq_in.cap);
+ EXPECT_EQ(2, seq_in.len);
*out = seq_in.buf[0] + seq_in.buf[1];
return 0;
}
-TEST(DynAvprFunctionTests, Example7) {
+TEST_F(DynAvprFunctionTests, Example7) {
auto fp = (void(*)()) avpr_example7;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.arrayInFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -506,26 +511,26 @@ TEST(DynAvprFunctionTests, Example7) {
int rVal = 0;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- DOUBLES_EQUAL(3.303, out, 0.00001);
+ ASSERT_EQ(0, rc);
+ ASSERT_NEAR(3.303, out, 0.001);
dynFunction_destroy(dynFunc);
}
//Test 8, Test function with array as return value
static int avpr_example8(__attribute__((unused))void *handle, double arg1, struct double_seq** out) {
- DOUBLES_EQUAL(2.0, arg1, 0.0001);
- CHECK_EQUAL(3, (*out)->cap);
+ EXPECT_NEAR(2.0, arg1, 0.001);
+ EXPECT_EQ(3, (*out)->cap);
(*out)->buf[0] = 0.0;
(*out)->buf[1] = 1.1;
(*out)->buf[2] = 2.2;
return 0;
}
-TEST(DynAvprFunctionTests, Example8) {
+TEST_F(DynAvprFunctionTests, Example8) {
auto fp = (void(*)()) avpr_example8;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.arrayOutFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -547,10 +552,10 @@ TEST(DynAvprFunctionTests, Example8) {
int rVal = 0;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- DOUBLES_EQUAL(0.0, buf[0], 0.0001);
- DOUBLES_EQUAL(1.1, buf[1], 0.0001);
- DOUBLES_EQUAL(2.2, buf[2], 0.0001);
+ ASSERT_EQ(0, rc);
+ ASSERT_NEAR(0.0, buf[0], 0.001);
+ ASSERT_NEAR(1.1, buf[1], 0.001);
+ ASSERT_NEAR(2.2, buf[2], 0.001);
dynFunction_destroy(dynFunc);
}
@@ -558,14 +563,14 @@ TEST(DynAvprFunctionTests, Example8) {
// Test 9, Test function with string as return value
static int avpr_example9(__attribute__((unused))void *handle, char** out) {
*out = strdup("result_out");
- CHECK(*out != nullptr);
+ EXPECT_TRUE(*out != nullptr);
return 0;
}
-TEST(DynAvprFunctionTests, Example9) {
+TEST_F(DynAvprFunctionTests, Example9) {
auto fp = (void(*)()) avpr_example9;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.stringOutFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -579,8 +584,8 @@ TEST(DynAvprFunctionTests, Example9) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- STRCMP_EQUAL("result_out", out);
+ ASSERT_EQ(0, rc);
+ ASSERT_STREQ("result_out", out);
free(out);
dynFunction_destroy(dynFunc);
@@ -596,15 +601,15 @@ extern "C" {
static int avpr_example10(__attribute__((unused))void *handle, struct tst_10 ** out) {
(*out)->name = strdup("my_new_char");
- CHECK((*out)->name != nullptr);
+ EXPECT_TRUE((*out)->name != nullptr);
(*out)->id = 132;
return 0;
}
-TEST(DynAvprFunctionTests, Example10) {
+TEST_F(DynAvprFunctionTests, Example10) {
auto fp = (void(*)()) avpr_example10;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.structStringOutFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -619,42 +624,50 @@ TEST(DynAvprFunctionTests, Example10) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(132, out.id);
- STRCMP_EQUAL("my_new_char", out.name);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(132, out.id);
+ ASSERT_STREQ("my_new_char", out.name);
free(out.name);
dynFunction_destroy(dynFunc);
}
-#ifndef __APPLE__
-static int avpr_example11(void *handle __attribute__((unused)), char *arg1) {
- STRCMP_EQUAL("input string test", arg1);
- return 0;
-}
-
-//FIXME does not work in OSX. Also has issues in linux if input is not dynamically allocated.
-TEST(DynAvprFunctionTests, Example11) {
- auto fp = (void(*)()) avpr_example11;
- dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.stringInFunc");
- CHECK(dynFunc != nullptr);
-
- int handle = 0;
- int* handle_ptr = &handle;
-
- char *input = celix_utils_strdup("input string test");
-
- void *args[2];
- args[0] = &handle_ptr;
- args[1]= &input;
- int rVal = 1;
-
- int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(0, rVal);
-
- free(input);
-
- dynFunction_destroy(dynFunc);
-}
-#endif
+//FIXME issue #179
+//extern "C" {
+//static int avpr_example11(void *handle, char *arg1) {
+// if (handle != nullptr && strncmp("input string test", arg1, 1024) == 0) {
+// return 0;
+// }
+// return 1;
+//}
+//
+//static bool test_example11() {
+// auto fp = (void(*)()) avpr_example11;
+// dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.stringInFunc");
+//
+// int handle = 0;
+// void* handle_ptr = &handle;
+//
+// char *input = celix_utils_strdup("input string test");
+//
+// void *args[2];
+// args[0] = &handle_ptr;
+// args[1]= &input;
+// int rVal = 1;
+//
+// int rc = 0;
+// if (dynFunc != nullptr) {
+// rc = dynFunction_call(dynFunc, fp, &rVal, args);
+// dynFunction_destroy(dynFunc);
+// }
+// free(input);
+//
+// return dynFunc != nullptr && rc == 0 && rVal == 0;
+//}
+//}
+//
+//TEST_F(DynAvprFunctionTests, Example11) {
+// //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+// //corrupted memory. Note that libffi is a function for interfacing with C not C++
+// EXPECT_TRUE(test_example11());
+//}
diff --git a/libs/dfi/test/dyn_avpr_interface_tests.cpp b/libs/dfi/gtest/src/dyn_avpr_interface_tests.cpp
similarity index 86%
rename from libs/dfi/test/dyn_avpr_interface_tests.cpp
rename to libs/dfi/gtest/src/dyn_avpr_interface_tests.cpp
index 974368a..3917bd6 100644
--- a/libs/dfi/test/dyn_avpr_interface_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_avpr_interface_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
#include <stdio.h>
@@ -103,13 +102,18 @@ const char* theBigAvprFile = "{ \
} \
}";
-TEST_GROUP(DynAvprInterfaceTests) {
- void setup() override {
+
+class DynAvprInterfaceTests : public ::testing::Test {
+public:
+ DynAvprInterfaceTests() {
int lvl = 1;
dynAvprInterface_logSetup(stdLog, nullptr, lvl);
dynAvprFunction_logSetup(stdLog, nullptr, lvl);
dynAvprType_logSetup(stdLog, nullptr, lvl);
}
+ ~DynAvprInterfaceTests() override {
+ }
+
};
static void checkInterfaceVersion(dyn_interface_type* dynIntf, const char* v) {
@@ -117,22 +121,22 @@ static void checkInterfaceVersion(dyn_interface_type* dynIntf, const char* v) {
char *version = nullptr;
status = dynInterface_getVersionString(dynIntf, &version);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL(v, version);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ(v, version);
version_pt msgVersion = nullptr, localMsgVersion = nullptr;
int cmpVersion = -1;
version_createVersionFromString(version, &localMsgVersion);
status = dynInterface_getVersion(dynIntf, &msgVersion);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
version_compareTo(msgVersion, localMsgVersion, &cmpVersion);
- CHECK_EQUAL(cmpVersion, 0);
+ ASSERT_EQ(cmpVersion, 0);
version_destroy(localMsgVersion);
}
// Test 1, simply see if parsing works and if parsed correctly
-TEST(DynAvprInterfaceTests, Example1) {
+TEST_F(DynAvprInterfaceTests, Example1) {
dyn_interface_type *dynIntf = dynInterface_parseAvprWithStr(theBigAvprFile);
- CHECK(dynIntf != nullptr);
+ ASSERT_TRUE(dynIntf != nullptr);
// Check version
checkInterfaceVersion(dynIntf, "1.1.0");
@@ -140,35 +144,35 @@ TEST(DynAvprInterfaceTests, Example1) {
// Check name
char *name = nullptr;
dynInterface_getName(dynIntf, &name);
- CHECK(name != nullptr);
- STRCMP_EQUAL("the_interface", name);
+ ASSERT_TRUE(name != nullptr);
+ ASSERT_STREQ("the_interface", name);
// Check annotation (namespace)
char *annVal = nullptr;
dynInterface_getAnnotationEntry(dynIntf, "namespace", &annVal);
- CHECK(annVal != nullptr);
- STRCMP_EQUAL("test.dt", annVal);
+ ASSERT_TRUE(annVal != nullptr);
+ ASSERT_STREQ("test.dt", annVal);
// Check nonexisting
char *nonExist = nullptr;
dynInterface_getHeaderEntry(dynIntf, "nonExisting", &nonExist);
- CHECK(nonExist == nullptr);
+ ASSERT_TRUE(nonExist == nullptr);
// Get lists of methods
struct methods_head *list = nullptr;
int status = dynInterface_methods(dynIntf, &list);
- CHECK(status == 0);
- CHECK(list != nullptr);
+ ASSERT_TRUE(status == 0);
+ ASSERT_TRUE(list != nullptr);
int count = dynInterface_nrOfMethods(dynIntf);
- CHECK_EQUAL(2, count);
+ ASSERT_EQ(2, count);
dynInterface_destroy(dynIntf);
}
// Invalid tests
-TEST(DynAvprInterfaceTests, InvalidExample) {
+TEST_F(DynAvprInterfaceTests, InvalidExample) {
dyn_interface_type *dynIntf = dynInterface_parseAvprWithStr(theInvalidAvprFile);
- CHECK(dynIntf == nullptr);
+ ASSERT_TRUE(dynIntf == nullptr);
}
diff --git a/libs/dfi/test/dyn_avpr_tests.cpp b/libs/dfi/gtest/src/dyn_avpr_tests.cpp
similarity index 82%
rename from libs/dfi/test/dyn_avpr_tests.cpp
rename to libs/dfi/gtest/src/dyn_avpr_tests.cpp
index 4dbd3c4..cdb12d7 100644
--- a/libs/dfi/test/dyn_avpr_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_avpr_tests.cpp
@@ -17,35 +17,32 @@
* under the License.
*/
-#include "CppUTest/TestHarness.h"
-#include "CppUTest/CommandLineTestRunner.h"
-
-extern "C" {
- #include <stdarg.h>
-
- #include "dyn_common.h"
- #include "dyn_type.h"
-
- static void stdLogA(void*, int level, const char *file, int line, const char *msg, ...) {
- va_list ap;
- const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
- fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
- va_start(ap, msg);
- vfprintf(stderr, msg, ap);
- fprintf(stderr, "\n");
- va_end(ap);
- }
-
- static void runTestA(const char *descriptorStr, const char *exName, int expectedType) {
- dyn_type *type;
- type = dynType_parseAvprWithStr(descriptorStr, exName);
-
- if (type != nullptr) {
- CHECK_EQUAL(expectedType, dynType_type(type));
- dynType_destroy(type);
- } else {
- CHECK_EQUAL(1, 0);
- }
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+
+#include "dyn_common.h"
+#include "dyn_type.h"
+
+static void stdLogA(void*, int level, const char *file, int line, const char *msg, ...) {
+ va_list ap;
+ const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+ fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+ va_start(ap, msg);
+ vfprintf(stderr, msg, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+}
+
+static void runTestA(const char *descriptorStr, const char *exName, int expectedType) {
+ dyn_type *type;
+ type = dynType_parseAvprWithStr(descriptorStr, exName);
+
+ if (type != nullptr) {
+ ASSERT_EQ(expectedType, dynType_type(type));
+ dynType_destroy(type);
+ } else {
+ ASSERT_EQ(1, 0);
}
}
@@ -286,57 +283,61 @@ const char* arrayIntTestCase = "{\
* Type building tests
*/
-TEST_GROUP(DynAvprTypeTests) {
- void setup() override {
- dynAvprType_logSetup(stdLogA, nullptr, 1);
- }
+class DynAvprTypeTests : public ::testing::Test {
+public:
+ DynAvprTypeTests() {
+ dynAvprType_logSetup(stdLogA, nullptr, 1);
+ }
+ ~DynAvprTypeTests() override {
+ }
+
};
-TEST(DynAvprTypeTests, SimpleTest) {
+TEST_F(DynAvprTypeTests, SimpleTest) {
runTestA(theTestCase, "test.dt.uint", DYN_TYPE_SIMPLE);
}
-TEST(DynAvprTypeTests, SimpleSimpleTest) {
+TEST_F(DynAvprTypeTests, SimpleSimpleTest) {
runTestA(theTestCase, "test.dt.RecordWithSimpleTypes", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, ComplexTest) {
+TEST_F(DynAvprTypeTests, ComplexTest) {
runTestA(theTestCase, "blah.test.dt.A", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, EnumTest2) {
+TEST_F(DynAvprTypeTests, EnumTest2) {
runTestA(theTestCase, "test.dt.EnumWithValue", DYN_TYPE_SIMPLE);
}
-TEST(DynAvprTypeTests, EnumTest) {
+TEST_F(DynAvprTypeTests, EnumTest) {
runTestA(theTestCase, "test.dt.EnumWithoutValue", DYN_TYPE_SIMPLE);
}
-TEST(DynAvprTypeTests, ArrayTest) {
+TEST_F(DynAvprTypeTests, ArrayTest) {
runTestA(theTestCase, "test.dt.V", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, NestedArrayTest) {
+TEST_F(DynAvprTypeTests, NestedArrayTest) {
runTestA(nestedArray, "test.dt.NA", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, ComplexComplexTest) {
+TEST_F(DynAvprTypeTests, ComplexComplexTest) {
runTestA(theTestCase, "test.dt.B", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, ReferenceTest) {
+TEST_F(DynAvprTypeTests, ReferenceTest) {
runTestA(referenceTestCase, "test.dt.R", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, AliasTest) {
+TEST_F(DynAvprTypeTests, AliasTest) {
runTestA(theTestCase, "test.dt.Alias", DYN_TYPE_SIMPLE);
}
-TEST(DynAvprTypeTests, ComplexAliasTest) {
+TEST_F(DynAvprTypeTests, ComplexAliasTest) {
runTestA(aliasTestCase, "common.dt.Polar_2d", DYN_TYPE_COMPLEX);
}
-TEST(DynAvprTypeTests, ArrayWithSimpleTest) { //TODO: fix this testcase
+TEST_F(DynAvprTypeTests, ArrayWithSimpleTest) { //TODO: fix this testcase
runTestA(arrayIntTestCase, "common.dt.SimpleArray", DYN_TYPE_COMPLEX);
}
@@ -347,42 +348,46 @@ TEST(DynAvprTypeTests, ArrayWithSimpleTest) { //TODO: fix this testcase
void test_version(dyn_type* type, const std::string& version_string) {
struct meta_entry *entry = nullptr;
struct meta_properties_head *entries = nullptr;
- CHECK_EQUAL(0, dynType_metaEntries(type, &entries));
- CHECK_FALSE(TAILQ_EMPTY(entries));
+ ASSERT_EQ(0, dynType_metaEntries(type, &entries));
+ ASSERT_FALSE(TAILQ_EMPTY(entries));
const std::string entry_value {"version"};
bool compared = false;
TAILQ_FOREACH(entry, entries, entries) {
if (entry_value == entry->name) {
- STRCMP_EQUAL(version_string.c_str(), entry->value);
+ ASSERT_STREQ(version_string.c_str(), entry->value);
compared = true;
}
}
- CHECK_TRUE_TEXT(compared, "Expect a comparison, otherwise no version meta info is available");
+ ASSERT_TRUE(compared); //"Expect a comparison, otherwise no version meta info is available");
}
-TEST_GROUP(DynAvprAssignTests) {
- void setup() override {
- dynAvprType_logSetup(stdLogA, nullptr, 1);
- }
+class DynAvprAssignTests : public ::testing::Test {
+public:
+ DynAvprAssignTests() {
+ dynAvprType_logSetup(stdLogA, nullptr, 1);
+ }
+ ~DynAvprAssignTests() override {
+ }
+
};
-TEST(DynAvprAssignTests, AssignSimpleTest) {
+TEST_F(DynAvprAssignTests, AssignSimpleTest) {
// Build type
dyn_type* type = dynType_parseAvprWithStr(theTestCase, "test.dt.uint");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// set value
uint32_t simple = 0;
uint32_t nv = 42;
dynType_simple_setValue(type, &simple, &nv);
- CHECK_EQUAL(42, simple);
+ ASSERT_EQ(42, simple);
test_version(type, "2.1.9");
dynType_destroy(type);
}
-TEST(DynAvprAssignTests, AssignComplexTest) {
+TEST_F(DynAvprAssignTests, AssignComplexTest) {
// Build type
struct exA {
struct {
@@ -395,7 +400,7 @@ TEST(DynAvprAssignTests, AssignComplexTest) {
dyn_type *type = dynType_parseAvprWithStr(theTestCase, "blah.test.dt.A");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// set example values
uint32_t a_x_aa = 52;
@@ -406,7 +411,7 @@ TEST(DynAvprAssignTests, AssignComplexTest) {
// Simple element in complex
exA inst {{0, 0, 0.0}, 0};
dynType_complex_setValueAt(type, 1, &inst, &a_y);
- CHECK_EQUAL(1001001, inst.y);
+ ASSERT_EQ(1001001, inst.y);
// Complex element in complex type, first acquire subtype, then check similar to simple type
void *loc = nullptr;
@@ -415,39 +420,39 @@ TEST(DynAvprAssignTests, AssignComplexTest) {
dynType_complex_dynTypeAt(type, 0, &subType);
dynType_complex_setValueAt(subType, 0, &inst.x, &a_x_aa);
- CHECK_EQUAL(52, inst.x.aa);
+ ASSERT_EQ(52, inst.x.aa);
dynType_complex_setValueAt(subType, 1, &inst.x, &a_x_bb);
- CHECK_EQUAL(42, inst.x.bb);
+ ASSERT_EQ(42, inst.x.bb);
dynType_complex_setValueAt(subType, 2, &inst.x, &a_x_cc);
- CHECK_EQUAL(31.13, inst.x.cc);
+ ASSERT_EQ(31.13, inst.x.cc);
test_version(type, "1.1.9");
dynType_destroy(type);
}
-TEST(DynAvprAssignTests, AssignComplexSimpleTest) {
+TEST_F(DynAvprAssignTests, AssignComplexSimpleTest) {
// Build type
struct exB {
int32_t b;
};
dyn_type *type = dynType_parseAvprWithStr(theTestCase, "test.dt.RecordWithSimpleTypes");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// set example values
int32_t b_b = 5301;
exB inst {0};
dynType_complex_setValueAt(type, 0, &inst, &b_b);
- CHECK_EQUAL(5301, inst.b);
+ ASSERT_EQ(5301, inst.b);
test_version(type, "1.1.9");
dynType_destroy(type);
}
-TEST(DynAvprAssignTests, AssignPtrTest) {
+TEST_F(DynAvprAssignTests, AssignPtrTest) {
// Build type
struct exNode {
@@ -457,7 +462,7 @@ TEST(DynAvprAssignTests, AssignPtrTest) {
};
dyn_type* type = dynType_parseAvprWithStr(theTestCase, "N.Node");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// right tree
exNode rightrightright {2.0, nullptr, nullptr};
@@ -475,18 +480,18 @@ TEST(DynAvprAssignTests, AssignPtrTest) {
double nv = 101.101;
dynType_complex_setValueAt(type, 0, &base, &nv);
- CHECK_EQUAL(101.101, base.data);
+ ASSERT_EQ(101.101, base.data);
test_version(type, "1.1.9");
dynType_destroy(type);
}
-TEST(DynAvprAssignTests, AssignEnumTest) {
+TEST_F(DynAvprAssignTests, AssignEnumTest) {
// Build type
dyn_type* type = dynType_parseAvprWithStr(theTestCase, "test.dt.EnumWithValue");
dyn_type* type_2 = dynType_parseAvprWithStr(theTestCase, "test.dt.EnumWithoutValue");
- CHECK(type != nullptr);
- CHECK(type_2 != nullptr);
+ ASSERT_TRUE(type != nullptr);
+ ASSERT_TRUE(type_2 != nullptr);
// Print type
dynType_print(type, stdout);
@@ -499,13 +504,13 @@ TEST(DynAvprAssignTests, AssignEnumTest) {
dynType_simple_setValue(type, &mEnum, &nv);
- CHECK_EQUAL(A, mEnum);
+ ASSERT_EQ(A, mEnum);
test_version(type, "1.1.9");
dynType_destroy(type);
dynType_destroy(type_2);
}
-TEST(DynAvprAssignTests, AssignArrayTest) {
+TEST_F(DynAvprAssignTests, AssignArrayTest) {
// Build type
struct exV_sequence {
uint32_t cap;
@@ -521,7 +526,7 @@ TEST(DynAvprAssignTests, AssignArrayTest) {
exV_sequence *s = &inst.elem;
dyn_type* type = dynType_parseAvprWithStr(theTestCase, "test.dt.V");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// set value
void *loc = nullptr;
@@ -529,23 +534,23 @@ TEST(DynAvprAssignTests, AssignArrayTest) {
dynType_complex_valLocAt(type, 0, static_cast<void*>(&inst), &loc);
dynType_complex_dynTypeAt(type, 0, &subType);
int res = dynType_alloc(subType, reinterpret_cast<void**>(&s));
- CHECK_EQUAL(0, res);
- CHECK(s != nullptr);
+ ASSERT_EQ(0, res);
+ ASSERT_TRUE(s != nullptr);
dynType_free(type, s);
test_version(type, "1.1.9");
dynType_destroy(type);
}
-TEST(DynAvprAssignTests, AnnotationTest) {
+TEST_F(DynAvprAssignTests, AnnotationTest) {
dyn_type* type = dynType_parseAvprWithStr(theTestCase, "test.dt.Anne");
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
// get value for meta entry
struct meta_entry *entry = nullptr;
struct meta_properties_head *entries = nullptr;
- CHECK_EQUAL(0, dynType_metaEntries(type, &entries));
- CHECK_FALSE(TAILQ_EMPTY(entries));
+ ASSERT_EQ(0, dynType_metaEntries(type, &entries));
+ ASSERT_FALSE(TAILQ_EMPTY(entries));
const std::string msg_id_entry {"MsgId"};
bool compared = false;
@@ -553,11 +558,11 @@ TEST(DynAvprAssignTests, AnnotationTest) {
TAILQ_FOREACH(entry, entries, entries) {
printf("Got an entry: %s\n", entry->name);
if (msg_id_entry == entry->name) {
- STRCMP_EQUAL("1000", entry->value);
+ ASSERT_STREQ("1000", entry->value);
compared = true;
}
}
- CHECK_TRUE_TEXT(compared, "Expect a comparison, otherwise no msg id entry available");
+ ASSERT_TRUE(compared); //"Expect a comparison, otherwise no msg id entry available");
dynType_destroy(type);
}
@@ -565,42 +570,46 @@ TEST(DynAvprAssignTests, AnnotationTest) {
/*********************************************************************************
* Invalid tests
*/
-TEST_GROUP(DynAvprInvalidTests) {
- void setup() override {
- dynAvprType_logSetup(stdLogA, nullptr, 1);
- }
+
+class DynAvprInvalidTests : public ::testing::Test {
+public:
+ DynAvprInvalidTests() {
+ dynAvprType_logSetup(stdLogA, nullptr, 1);
+ }
+ ~DynAvprInvalidTests() override {
+ }
+
};
-TEST(DynAvprInvalidTests, InvalidJson) {
+TEST_F(DynAvprInvalidTests, InvalidJson) {
dyn_type* type = dynType_parseAvprWithStr("{", "test.invalid.type"); // Json error
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
}
-TEST(DynAvprInvalidTests, InvalidJsonObject) {
+TEST_F(DynAvprInvalidTests, InvalidJsonObject) {
dyn_type* type = dynType_parseAvprWithStr("[]", "test.invalid.type"); // Root should be object not list
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
type = dynType_parseAvprWithStr("{}", "test.invalid.type"); // Root should have a namespace
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
type = dynType_parseAvprWithStr(R"({"namespace":"nested"})", "test.invalid.type"); // Root should have types array
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
type = dynType_parseAvprWithStr(
R"({"namespace":"nested", "types" : [] })"
, "test.invalid.type"); // types is empty, so not found
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
type = dynType_parseAvprWithStr(
"{\"namespace\":\"nested\", \"types\" : [\
{ \"type\" : \"record\", \"name\" : \"IncompleteStruct\", \"fields\" : [\
{ \"name\" : \"Field1\", \"type\" : \"NonExisting\" } ] } \
] }"
, "nested.IncompleteStruct"); // struct misses definition
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
type = dynType_parseAvprWithStr(
"{\"namespace\":\"nested\", \"types\" : [\
{ \"type\" : \"record\", \"name\" : \"IncompleteStruct\", \"fields\" : [\
{ \"name\" : \"Field1\" } ] } \
] }"
, "nested.IncompleteStruct"); // struct entry misses type
- CHECK(type == nullptr);
+ ASSERT_TRUE(type == nullptr);
// None of the above testcases should crash the parser
-}
-
+}
\ No newline at end of file
diff --git a/libs/dfi/test/dyn_closure_tests.cpp b/libs/dfi/gtest/src/dyn_closure_tests.cpp
similarity index 85%
rename from libs/dfi/test/dyn_closure_tests.cpp
rename to libs/dfi/gtest/src/dyn_closure_tests.cpp
index 91c1265..819a4aa 100644
--- a/libs/dfi/test/dyn_closure_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_closure_tests.cpp
@@ -17,8 +17,10 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+
extern "C" {
@@ -99,12 +101,12 @@ static void tests() {
{
int32_t (*func)(int32_t a, int32_t b, int32_t c) = NULL;
rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, NULL, &dynFunction);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = dynFunction_createClosure(dynFunction, example1_binding, NULL, (void(**)(void))&func);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
int32_t ret = func(2,3,4);
- CHECK_EQUAL(1, g_count);
- CHECK_EQUAL(9, ret);
+ ASSERT_EQ(1, g_count);
+ ASSERT_EQ(9, ret);
dynFunction_destroy(dynFunction);
}
@@ -113,19 +115,19 @@ static void tests() {
double (*func2)(int32_t a, struct example2_arg2 b, int32_t c) = NULL;
dynFunction = NULL;
rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, NULL, &dynFunction);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = dynFunction_createClosure(dynFunction, example2_binding, NULL, (void(**)(void))&func);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = dynFunction_getFnPointer(dynFunction, (void(**)(void))&func2);
- CHECK_EQUAL(0, rc);
- CHECK(func == func2);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(func == func2);
struct example2_arg2 b;
b.val1 = 1.0;
b.val2 = 1.5;
b.val3 = 2.0;
double ret = func(2,b,4);
- CHECK_EQUAL(2, g_count);
- CHECK_EQUAL(10.5, ret);
+ ASSERT_EQ(2, g_count);
+ ASSERT_EQ(10.5, ret);
dynFunction_destroy(dynFunction);
}
@@ -133,12 +135,12 @@ static void tests() {
struct example3_ret * (*func)(int32_t a, int32_t b, int32_t c) = NULL;
dynFunction = NULL;
rc = dynFunction_parseWithStr(EXAMPLE3_DESCRIPTOR, NULL, &dynFunction);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = dynFunction_createClosure(dynFunction, example3_binding, NULL, (void(**)(void))&func);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
struct example3_ret *ret = func(2,8,4);
- CHECK_EQUAL(3, g_count);
- CHECK_EQUAL(14, ret->sum);
+ ASSERT_EQ(3, g_count);
+ ASSERT_EQ(14, ret->sum);
dynFunction_destroy(dynFunction);
free(ret);
}
@@ -146,18 +148,21 @@ static void tests() {
}
-
-TEST_GROUP(DynClosureTests) {
- void setup() {
+class DynClosureTests : public ::testing::Test {
+public:
+ DynClosureTests() {
int lvl = 1;
dynFunction_logSetup(stdLog, NULL, lvl);
dynType_logSetup(stdLog, NULL, lvl);
dynCommon_logSetup(stdLog, NULL, lvl);
g_count = 0;
}
+ ~DynClosureTests() override {
+ }
+
};
-TEST(DynClosureTests, DynClosureTest1) {
+TEST_F(DynClosureTests, DynClosureTest1) {
//TODO split up
tests();
}
diff --git a/libs/dfi/include/avrobin_serializer.h b/libs/dfi/gtest/src/dyn_example_functions.c
similarity index 53%
copy from libs/dfi/include/avrobin_serializer.h
copy to libs/dfi/gtest/src/dyn_example_functions.c
index bb2f63d..091382a 100644
--- a/libs/dfi/include/avrobin_serializer.h
+++ b/libs/dfi/gtest/src/dyn_example_functions.c
@@ -16,20 +16,33 @@
*specific language governing permissions and limitations
*under the License.
*/
-#ifndef __AVROBIN_SERIALIZER_H_
-#define __AVROBIN_SERIALIZER_H_
-#include "dfi_log_util.h"
-#include "dyn_type.h"
-#include "dyn_function.h"
-#include "dyn_interface.h"
+#include <assert.h>
+#include <string.h>
+#include "dyn_example_functions.h"
-//logging
-DFI_SETUP_LOG_HEADER(avrobinSerializer);
+int32_t example1(int32_t a, int32_t b, int32_t c) {
+ return a + b + c;
+}
-int avrobinSerializer_deserialize(dyn_type *type, const uint8_t *input, size_t inlen, void **result);
-int avrobinSerializer_serialize(dyn_type *type, const void *input, uint8_t **output, size_t *outlen);
-int avrobinSerializer_generateSchema(dyn_type *type, char **output);
-int avrobinSerializer_saveFile(const char *filename, const char *schema, const uint8_t *serdata, size_t serdatalen);
+double example2(int32_t arg1, struct example2_arg arg2, double arg3) {
+ return 0.0 + arg1 + arg2.val1 + arg2.val2 + arg2.val3 + arg3;
+}
-#endif
+void example4Func(struct tst_seq seq) {
+ assert(4 == seq.cap);
+ assert(2 == seq.len);
+ assert(1.1 == seq.buf[0]);
+ assert(2.2 == seq.buf[1]);
+}
+
+int testExample3(void *ptr, double a, double *out) {
+ double *b = (double *)ptr;
+ *out = *b * a;
+ return 0;
+}
+
+void example5Func(const char *s1, char *s2) {
+ assert(strncmp("s1", s1, 5) == 0);
+ assert(strncmp("s2", s2, 5) == 0);
+}
diff --git a/libs/dfi/include/avrobin_serializer.h b/libs/dfi/gtest/src/dyn_example_functions.h
similarity index 51%
copy from libs/dfi/include/avrobin_serializer.h
copy to libs/dfi/gtest/src/dyn_example_functions.h
index bb2f63d..4170046 100644
--- a/libs/dfi/include/avrobin_serializer.h
+++ b/libs/dfi/gtest/src/dyn_example_functions.h
@@ -16,20 +16,43 @@
*specific language governing permissions and limitations
*under the License.
*/
-#ifndef __AVROBIN_SERIALIZER_H_
-#define __AVROBIN_SERIALIZER_H_
-#include "dfi_log_util.h"
-#include "dyn_type.h"
-#include "dyn_function.h"
-#include "dyn_interface.h"
+#pragma once
-//logging
-DFI_SETUP_LOG_HEADER(avrobinSerializer);
+#include <stdint.h>
-int avrobinSerializer_deserialize(dyn_type *type, const uint8_t *input, size_t inlen, void **result);
-int avrobinSerializer_serialize(dyn_type *type, const void *input, uint8_t **output, size_t *outlen);
-int avrobinSerializer_generateSchema(dyn_type *type, char **output);
-int avrobinSerializer_saveFile(const char *filename, const char *schema, const uint8_t *serdata, size_t serdatalen);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EXAMPLE1_DESCRIPTOR "example(III)I"
+int32_t example1(int32_t a, int32_t b, int32_t c);
+
+#define EXAMPLE2_DESCRIPTOR "example(I{IID val1 val2 val3}D)D"
+struct example2_arg {
+ int32_t val1;
+ int32_t val2;
+ double val3;
+};
+double example2(int32_t arg1, struct example2_arg arg2, double arg3);
+
+#define EXAMPLE3_DESCRIPTOR "example(PD*D)N"
+int testExample3(void *ptr, double a, double *out);
+
+#define EXAMPLE4_DESCRIPTOR "example([D)V"
+struct tst_seq {
+ uint32_t cap;
+ uint32_t len;
+ double *buf;
+};
+void example4Func(struct tst_seq seq);
+#define EXAMPLE5_DESCRIPTOR "example(#const=true;tt)V"
+void example5Func(const char *s1, char *s2);
+
+
+
+#ifdef __cplusplus
+}
#endif
+
diff --git a/libs/dfi/gtest/src/dyn_function_tests.cpp b/libs/dfi/gtest/src/dyn_function_tests.cpp
new file mode 100644
index 0000000..d3a9a81
--- /dev/null
+++ b/libs/dfi/gtest/src/dyn_function_tests.cpp
@@ -0,0 +1,287 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+#include "dyn_example_functions.h"
+
+#include "dyn_common.h"
+#include "dyn_function.h"
+
+
+static void stdLog(void*, int level, const char *file, int line, const char *msg, ...) {
+ va_list ap;
+ const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+ fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+ va_start(ap, msg);
+ vfprintf(stderr, msg, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+}
+
+
+#define INVALID_FUNC_DESCRIPTOR "example$[D)V"//$ is an invalid symbol, missing (
+#define INVALID_FUNC_TYPE_DESCRIPTOR "example(H)A"//H and A are invalid types
+
+
+class DynFunctionTests : public ::testing::Test {
+public:
+ DynFunctionTests() {
+ int lvl = 1;
+ dynFunction_logSetup(stdLog, nullptr, lvl);
+ dynType_logSetup(stdLog, nullptr, lvl);
+ dynCommon_logSetup(stdLog, nullptr, lvl);
+ }
+ ~DynFunctionTests() override = default;
+
+};
+
+
+extern "C" {
+ static bool func_test1() {
+ dyn_function_type *dynFunc = nullptr;
+ int rc;
+ void (*fp)(void) = (void (*)(void)) example1;
+
+ rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, nullptr, &dynFunc);
+
+ int32_t rVal = 0;
+ int32_t a = 2;
+ int32_t b = 4;
+ int32_t c = 8;
+ void *values[3];
+ values[0] = &a;
+ values[1] = &b;
+ values[2] = &c;
+
+ if (rc == 0) {
+ rc = dynFunction_call(dynFunc, fp, &rVal, values);
+ dynFunction_destroy(dynFunc);
+ }
+
+ return rc == 0 && rVal == 14;
+ }
+}
+
+TEST_F(DynFunctionTests, DynFuncTest1) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_test1());
+}
+
+extern "C" {
+static bool func_test2() {
+ dyn_function_type *dynFunc = nullptr;
+ int rc;
+ void (*fp)(void) = (void (*)(void)) example2;
+
+ rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, nullptr, &dynFunc);
+
+ int32_t arg1 = 2;
+ struct example2_arg arg2;
+ arg2.val1 = 2;
+ arg2.val2 = 3;
+ arg2.val3 = 4.1;
+ double arg3 = 8.1;
+ double returnVal = 0;
+ void *values[3];
+ values[0] = &arg1;
+ values[1] = &arg2;
+ values[2] = &arg3;
+
+ if (rc == 0) {
+ rc = dynFunction_call(dynFunc, fp, &returnVal, values);
+ dynFunction_destroy(dynFunc);
+ }
+
+ return rc == 0 && returnVal == 19.2;
+}
+}
+
+TEST_F(DynFunctionTests, DynFuncTest2) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_test2());
+}
+
+extern "C" {
+static bool func_acc() {
+ dyn_function_type *dynFunc = nullptr;
+ int rc;
+ rc = dynFunction_parseWithStr("add(D{DD a b}*D)V", nullptr, &dynFunc);
+
+ int nrOfArgs = 0;
+ bool isStruct = false;
+ bool isVoid = false;
+ dyn_type *nonExist = nullptr;
+ if (rc == 0) {
+ nrOfArgs = dynFunction_nrOfArguments(dynFunc);
+ dyn_type *arg1 = dynFunction_argumentTypeForIndex(dynFunc, 1);
+ if (arg1 != nullptr) {
+ isStruct = '{' == dynType_descriptorType(arg1);
+ }
+ nonExist = dynFunction_argumentTypeForIndex(dynFunc, 10);
+ dyn_type *returnType = dynFunction_returnType(dynFunc);
+ if (returnType != nullptr) {
+ isVoid = 'V' == dynType_descriptorType(returnType);
+ }
+ dynFunction_destroy(dynFunc);
+ }
+
+ return rc == 0 && nrOfArgs == 3 && isStruct && isVoid && nonExist == nullptr;
+}
+}
+
+TEST_F(DynFunctionTests, DynFuncAccTest) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_acc());
+}
+
+extern "C" {
+static bool func_test3() {
+ dyn_function_type *dynFunc = nullptr;
+ void (*fp)(void) = (void(*)(void)) testExample3;
+ int rc;
+
+ rc = dynFunction_parseWithStr(EXAMPLE3_DESCRIPTOR, nullptr, &dynFunc);
+ double result1 = -1.0;
+ double result2 = -1.0;
+
+ if (rc == 0) {
+ double *input = &result1;
+ double a = 2.0;
+ void *ptr = &a;
+ void *args[3];
+ args[0] = &ptr;
+ args[1] = &a;
+ args[2] = &input;
+ int rVal = 0;
+
+ rc = dynFunction_call(dynFunc, fp, &rVal, args);
+
+ double *inMemResult = (double *)calloc(1, sizeof(double));
+ a = 2.0;
+ ptr = &a;
+ args[0] = &ptr;
+ args[1] = &a;
+ args[2] = &inMemResult;
+ rVal = 0;
+ if (rc == 0) {
+ rc = dynFunction_call(dynFunc, fp, &rVal, args);
+ }
+ result2 = *inMemResult;
+ free(inMemResult);
+
+ dynFunction_destroy(dynFunc);
+ }
+
+ return rc == 0 && result1 == 4.0 && result2 == 4.0;
+}
+}
+
+
+TEST_F(DynFunctionTests, DynFuncTest3) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_test3());
+}
+
+extern "C" {
+static bool func_test4() {
+ dyn_function_type *dynFunc = nullptr;
+ void (*fp)(void) = (void(*)(void)) example4Func;
+ int rc;
+
+ rc = dynFunction_parseWithStr(EXAMPLE4_DESCRIPTOR, nullptr, &dynFunc);
+
+ double buf[4];
+ buf[0] = 1.1;
+ buf[1] = 2.2;
+ struct tst_seq seq;
+ seq.cap = 4;
+ seq.len = 2;
+ seq.buf = buf;
+
+ void *args[1];
+ args[0] = &seq;
+ if (rc == 0) {
+ rc = dynFunction_call(dynFunc, fp, nullptr, args);
+ dynFunction_destroy(dynFunc);
+ }
+
+ return rc == 0;
+}
+}
+
+TEST_F(DynFunctionTests, DynFuncTest4) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_test4());
+}
+
+extern "C" {
+static bool func_test5() {
+ dyn_function_type *dynFunc = nullptr;
+ void (*fp)(void) = (void(*)(void)) example5Func;
+ int rc;
+
+ rc = dynFunction_parseWithStr(EXAMPLE5_DESCRIPTOR, nullptr, &dynFunc);
+
+ const char *a1 = "s1";
+ char *a2 = strdup("s2");
+ void *args[2];
+ args[0] = &a1;
+ args[1] = &a2;
+
+ if (rc == 0) {
+ rc = dynFunction_call(dynFunc, fp, nullptr, args);
+ dynFunction_destroy(dynFunc);
+ }
+
+ free(a2);
+
+ return rc == 0;
+}
+}
+
+TEST_F(DynFunctionTests, DynFuncTest5) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_test5());
+}
+
+extern "C" {
+static bool func_invalid() {
+ dyn_function_type *dynFunc = nullptr;
+ int rc1 = dynFunction_parseWithStr(INVALID_FUNC_DESCRIPTOR, nullptr, &dynFunc);
+
+ dynFunc = nullptr;
+ int rc2 = dynFunction_parseWithStr(INVALID_FUNC_TYPE_DESCRIPTOR, nullptr, &dynFunc);
+ return rc1 != 0 && rc2 != 0;
+}
+}
+
+TEST_F(DynFunctionTests, InvalidDynFuncTest) {
+ //NOTE only using libffi with extern C, because combining libffi with EXPECT_*/ASSERT_* call leads to
+ //corrupted memory. Note that libffi is a function for interfacing with C not C++
+ EXPECT_TRUE(func_invalid());
+}
+
diff --git a/libs/dfi/test/dyn_interface_tests.cpp b/libs/dfi/gtest/src/dyn_interface_tests.cpp
similarity index 78%
rename from libs/dfi/test/dyn_interface_tests.cpp
rename to libs/dfi/gtest/src/dyn_interface_tests.cpp
index bf78ab9..be0635f 100644
--- a/libs/dfi/test/dyn_interface_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_interface_tests.cpp
@@ -17,8 +17,11 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+
+
extern "C" {
#include <stdio.h>
@@ -51,15 +54,15 @@ extern "C" {
char *version = NULL;
status = dynInterface_getVersionString(dynIntf, &version);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL(v, version);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ(v, version);
version_pt msgVersion = NULL, localMsgVersion = NULL;
int cmpVersion = -1;
version_createVersionFromString(version, &localMsgVersion);
status = dynInterface_getVersion(dynIntf, &msgVersion);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
version_compareTo(msgVersion, localMsgVersion, &cmpVersion);
- CHECK_EQUAL(cmpVersion, 0);
+ ASSERT_EQ(cmpVersion, 0);
version_destroy(localMsgVersion);
}
@@ -69,33 +72,33 @@ extern "C" {
FILE *desc = fopen("descriptors/example1.descriptor", "r");
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
fclose(desc);
char *name = NULL;
status = dynInterface_getName(dynIntf, &name);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("calculator", name);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("calculator", name);
checkInterfaceVersion(dynIntf,"1.0.0");
char *annVal = NULL;
status = dynInterface_getAnnotationEntry(dynIntf, "classname", &annVal);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("org.example.Calculator", annVal);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("org.example.Calculator", annVal);
char *nonExist = NULL;
status = dynInterface_getHeaderEntry(dynIntf, "nonExisting", &nonExist);
- CHECK(status != 0);
- CHECK(nonExist == NULL);
+ ASSERT_TRUE(status != 0);
+ ASSERT_TRUE(nonExist == NULL);
struct methods_head *list = NULL;
status = dynInterface_methods(dynIntf, &list);
- CHECK(status == 0);
- CHECK(list != NULL);
+ ASSERT_TRUE(status == 0);
+ ASSERT_TRUE(list != NULL);
int count = dynInterface_nrOfMethods(dynIntf);
- CHECK_EQUAL(4, count);
+ ASSERT_EQ(4, count);
dynInterface_destroy(dynIntf);
}
@@ -106,7 +109,7 @@ extern "C" {
FILE *desc = fopen("descriptors/example3.descriptor", "r");
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
fclose(desc);
dynInterface_destroy(dynIntf);
@@ -121,7 +124,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of a space at the end of the name
+ ASSERT_EQ(1, status); //Test fails because of a space at the end of the name
fclose(desc); desc=NULL;
@@ -130,7 +133,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of missing version field in header section
+ ASSERT_EQ(1, status); //Test fails because of missing version field in header section
fclose(desc); desc=NULL;
/* Invalid section */
@@ -138,7 +141,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of unknown section type
+ ASSERT_EQ(1, status); //Test fails because of unknown section type
fclose(desc); desc=NULL;
/* Invalid return type */
@@ -146,7 +149,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of invalid return type (D instead of N)
+ ASSERT_EQ(1, status); //Test fails because of invalid return type (D instead of N)
fclose(desc); desc=NULL;
/* Invalid method section */
@@ -154,7 +157,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of space at the end of the method
+ ASSERT_EQ(1, status); //Test fails because of space at the end of the method
fclose(desc); desc=NULL;
/* Invalid type */
@@ -162,7 +165,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Test fails because of space at the end of the type
+ ASSERT_EQ(1, status); //Test fails because of space at the end of the type
fclose(desc); desc=NULL;
/* Invalid metatype in method description */
@@ -170,7 +173,7 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
dynInterface_destroy(dynIntf);
- CHECK_EQUAL(0, status); //Invalid meta type doesn't generate errors, just warnings
+ ASSERT_EQ(0, status); //Invalid meta type doesn't generate errors, just warnings
fclose(desc); desc=NULL; dynIntf=NULL;
/* Invalid version section */
@@ -178,32 +181,35 @@ extern "C" {
assert(desc != NULL);
status = dynInterface_parse(desc, &dynIntf);
//dynInterface_destroy(dynIntf);
- CHECK_EQUAL(1, status); //Invalid meta type doesn't generate errors, just warnings
+ ASSERT_EQ(1, status); //Invalid meta type doesn't generate errors, just warnings
fclose(desc); desc=NULL;
}
}
-
-TEST_GROUP(DynInterfaceTests) {
- void setup() {
+class DynInterfaceTests : public ::testing::Test {
+public:
+ DynInterfaceTests() {
int level = 1;
dynCommon_logSetup(stdLog, NULL, level);
dynType_logSetup(stdLog, NULL, level);
dynFunction_logSetup(stdLog, NULL, level);
dynInterface_logSetup(stdLog, NULL, level);
}
+ ~DynInterfaceTests() override {
+ }
+
};
-TEST(DynInterfaceTests, test1) {
+TEST_F(DynInterfaceTests, test1) {
test1();
}
-TEST(DynInterfaceTests, test2) {
+TEST_F(DynInterfaceTests, test2) {
test2();
}
-TEST(DynInterfaceTests, testInvalid) {
+TEST_F(DynInterfaceTests, testInvalid) {
testInvalid();
}
diff --git a/libs/dfi/test/dyn_message_tests.cpp b/libs/dfi/gtest/src/dyn_message_tests.cpp
similarity index 76%
rename from libs/dfi/test/dyn_message_tests.cpp
rename to libs/dfi/gtest/src/dyn_message_tests.cpp
index ca3a1d2..619893d 100644
--- a/libs/dfi/test/dyn_message_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_message_tests.cpp
@@ -17,8 +17,10 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
+
+#include <stdarg.h>
+
extern "C" {
@@ -52,15 +54,15 @@ static void checkMessageVersion(dyn_message_type* dynMsg, const char* v){
char *version = NULL;
status = dynMessage_getVersionString(dynMsg, &version);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL(v, version);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ(v, version);
version_pt msgVersion = NULL, localMsgVersion = NULL;
int cmpVersion = -1;
version_createVersionFromString(version,&localMsgVersion);
status = dynMessage_getVersion(dynMsg,&msgVersion);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
version_compareTo(msgVersion,localMsgVersion,&cmpVersion);
- CHECK_EQUAL(cmpVersion,0);
+ ASSERT_EQ(cmpVersion,0);
version_destroy(localMsgVersion);
}
@@ -72,30 +74,30 @@ static void msg_test1(void) {
FILE *desc = fopen("descriptors/msg_example1.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
fclose(desc);
char *name = NULL;
status = dynMessage_getName(dynMsg, &name);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("poi", name);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("poi", name);
checkMessageVersion(dynMsg,"1.0.0");
char *annVal = NULL;
status = dynMessage_getAnnotationEntry(dynMsg, "classname", &annVal);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("org.example.PointOfInterest", annVal);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("org.example.PointOfInterest", annVal);
char *nonExist = NULL;
status = dynMessage_getHeaderEntry(dynMsg, "nonExisting", &nonExist);
- CHECK(status != 0);
- CHECK(nonExist == NULL);
+ ASSERT_TRUE(status != 0);
+ ASSERT_TRUE(nonExist == NULL);
dyn_type *msgType = NULL;
status = dynMessage_getMessageType(dynMsg, &msgType);
- CHECK_EQUAL(0, status);
- CHECK(msgType != NULL);
+ ASSERT_EQ(0, status);
+ ASSERT_TRUE(msgType != NULL);
dynMessage_destroy(dynMsg);
}
@@ -107,30 +109,30 @@ static void msg_test2(void) {
FILE *desc = fopen("descriptors/msg_example2.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
fclose(desc);
char *name = NULL;
status = dynMessage_getName(dynMsg, &name);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("track", name);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("track", name);
checkMessageVersion(dynMsg,"0.0.1");
char *annVal = NULL;
status = dynMessage_getAnnotationEntry(dynMsg, "classname", &annVal);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("org.example.Track", annVal);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("org.example.Track", annVal);
char *nonExist = NULL;
status = dynMessage_getHeaderEntry(dynMsg, "nonExisting", &nonExist);
- CHECK(status != 0);
- CHECK(nonExist == NULL);
+ ASSERT_TRUE(status != 0);
+ ASSERT_TRUE(nonExist == NULL);
dyn_type *msgType = NULL;
status = dynMessage_getMessageType(dynMsg, &msgType);
- CHECK_EQUAL(0, status);
- CHECK(msgType != NULL);
+ ASSERT_EQ(0, status);
+ ASSERT_TRUE(msgType != NULL);
dynMessage_destroy(dynMsg);
}
@@ -141,30 +143,30 @@ static void msg_test3(void) {
FILE *desc = fopen("descriptors/msg_example3.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
fclose(desc);
char *name = NULL;
status = dynMessage_getName(dynMsg, &name);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("logEntry", name);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("logEntry", name);
checkMessageVersion(dynMsg,"1.0.0");
char *annVal = NULL;
status = dynMessage_getAnnotationEntry(dynMsg, "classname", &annVal);
- CHECK_EQUAL(0, status);
- STRCMP_EQUAL("org.example.LogEntry", annVal);
+ ASSERT_EQ(0, status);
+ ASSERT_STREQ("org.example.LogEntry", annVal);
char *nonExist = NULL;
status = dynMessage_getHeaderEntry(dynMsg, "nonExisting", &nonExist);
- CHECK(status != 0);
- CHECK(nonExist == NULL);
+ ASSERT_TRUE(status != 0);
+ ASSERT_TRUE(nonExist == NULL);
dyn_type *msgType = NULL;
status = dynMessage_getMessageType(dynMsg, &msgType);
- CHECK_EQUAL(0, status);
- CHECK(msgType != NULL);
+ ASSERT_EQ(0, status);
+ ASSERT_TRUE(msgType != NULL);
dynMessage_destroy(dynMsg);
}
@@ -175,7 +177,7 @@ static void msg_test4(void) {
FILE *desc = fopen("descriptors/msg_example4.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK(status != 0);
+ ASSERT_TRUE(status != 0);
fclose(desc);
}
@@ -185,37 +187,37 @@ static void msg_invalid(void) {
FILE *desc = fopen("descriptors/invalids/invalidMsgHdr.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
desc = fopen("descriptors/invalids/invalidMsgMissingVersion.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
desc = fopen("descriptors/invalids/invalidMsgInvalidSection.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
desc = fopen("descriptors/invalids/invalidMsgInvalidName.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
desc = fopen("descriptors/invalids/invalidMsgInvalidType.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
desc = fopen("descriptors/invalids/invalidMsgInvalidVersion.descriptor", "r");
assert(desc != NULL);
status = dynMessage_parse(desc, &dynMsg);
- CHECK_EQUAL(1, status);
+ ASSERT_EQ(1, status);
fclose(desc);
}
@@ -223,33 +225,36 @@ static void msg_invalid(void) {
}
-TEST_GROUP(DynMessageTests) {
- void setup() {
- int level = 1;
- dynCommon_logSetup(stdLog, NULL, level);
- dynType_logSetup(stdLog, NULL, level);
- dynMessage_logSetup(stdLog, NULL, level);
- }
-};
+class DynMessageTests : public ::testing::Test {
+public:
+ DynMessageTests() {
+ int level = 1;
+ dynCommon_logSetup(stdLog, NULL, level);
+ dynType_logSetup(stdLog, NULL, level);
+ dynMessage_logSetup(stdLog, NULL, level);
+ }
+ ~DynMessageTests() override {
+ }
+};
-TEST(DynMessageTests, msg_test1) {
+TEST_F(DynMessageTests, msg_test1) {
msg_test1();
}
-TEST(DynMessageTests, msg_test2) {
+TEST_F(DynMessageTests, msg_test2) {
msg_test2();
}
-TEST(DynMessageTests, msg_test3) {
+TEST_F(DynMessageTests, msg_test3) {
msg_test3();
}
-TEST(DynMessageTests, msg_test4) {
+TEST_F(DynMessageTests, msg_test4) {
msg_test4();
}
-TEST(DynMessageTests, msg_invalid) {
+TEST_F(DynMessageTests, msg_invalid) {
msg_invalid();
}
diff --git a/libs/dfi/test/dyn_type_tests.cpp b/libs/dfi/gtest/src/dyn_type_tests.cpp
similarity index 84%
rename from libs/dfi/test/dyn_type_tests.cpp
rename to libs/dfi/gtest/src/dyn_type_tests.cpp
index e1c2145..2427f1a 100644
--- a/libs/dfi/test/dyn_type_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_type_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
#include <stdarg.h>
@@ -41,7 +40,7 @@ extern "C" {
type = NULL;
//printf("\n-- example %s with descriptor string '%s' --\n", exName, descriptorStr);
int status = dynType_parseWithStr(descriptorStr, exName, NULL, &type);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
//MEM check, to try to ensure no mem leaks/corruptions occur.
int i;
@@ -67,10 +66,14 @@ extern "C" {
}
}
-TEST_GROUP(DynTypeTests) {
- void setup() {
- dynType_logSetup(stdLog, NULL, 1);
- }
+class DynTypeTests : public ::testing::Test {
+public:
+ DynTypeTests() {
+ dynType_logSetup(stdLog, NULL, 1);
+ }
+ ~DynTypeTests() override {
+ }
+
};
#define EX1 "{BbJjIiSsDFNN arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 arg12}"
@@ -92,7 +95,7 @@ TEST_GROUP(DynTypeTests) {
#define EX17 "{#v1=0;#v2=1;E#v1=9;#v2=10;E enum1 enum2}"
#define CREATE_EXAMPLES_TEST(DESC) \
- TEST(DynTypeTests, ParseTestExample ## DESC) { \
+ TEST_F(DynTypeTests, ParseTestExample ## DESC) { \
runTest(DESC, #DESC); \
}
@@ -114,10 +117,10 @@ CREATE_EXAMPLES_TEST(EX15)
CREATE_EXAMPLES_TEST(EX16)
CREATE_EXAMPLES_TEST(EX17)
-TEST(DynTypeTests, ParseRandomGarbageTest) {
+TEST_F(DynTypeTests, ParseRandomGarbageTest) {
/*
unsigned int seed = 4148;
- char *testRandom = getenv("DYN_TYPE_TEST_RANDOM");
+ char *testRandom = getenv("DYN_TYPE_TEST_F_RANDOM");
if (testRandom != NULL && strcmp("true", testRandom) == 0) {
seed = (unsigned int) time(NULL);
}
@@ -153,7 +156,7 @@ TEST(DynTypeTests, ParseRandomGarbageTest) {
*/
}
-TEST(DynTypeTests, AssignTest1) {
+TEST_F(DynTypeTests, AssignTest1) {
struct ex1 {
int32_t a;
int32_t b;
@@ -163,21 +166,21 @@ TEST(DynTypeTests, AssignTest1) {
const char *desc = "{III a b c}";
dyn_type *type = NULL;
int status = dynType_parseWithStr(desc, NULL, NULL, &type);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
int32_t val1 = 2;
int32_t val2 = 4;
int32_t val3 = 8;
dynType_complex_setValueAt(type, 0, &inst, &val1);
- CHECK_EQUAL(2, inst.a);
+ ASSERT_EQ(2, inst.a);
dynType_complex_setValueAt(type, 1, &inst, &val2);
- CHECK_EQUAL(4, inst.b);
+ ASSERT_EQ(4, inst.b);
dynType_complex_setValueAt(type, 2, &inst, &val3);
- CHECK_EQUAL(8, inst.c);
+ ASSERT_EQ(8, inst.c);
dynType_destroy(type);
}
-TEST(DynTypeTests, AssignTest2) {
+TEST_F(DynTypeTests, AssignTest2) {
struct ex {
int32_t a;
struct {
@@ -189,13 +192,13 @@ TEST(DynTypeTests, AssignTest2) {
const char *desc = "{I{DD a b} a b}";
dyn_type *type = NULL;
int status = dynType_parseWithStr(desc, NULL, NULL, &type);
- CHECK_EQUAL(0, status);
+ ASSERT_EQ(0, status);
int32_t a = 2;
double b_a = 1.1;
double b_b = 1.2;
dynType_complex_setValueAt(type, 0, &inst, &a);
- CHECK_EQUAL(2, inst.a);
+ ASSERT_EQ(2, inst.a);
void *loc = NULL;
dyn_type *subType = NULL;
@@ -203,51 +206,51 @@ TEST(DynTypeTests, AssignTest2) {
dynType_complex_dynTypeAt(type, 1, &subType);
dynType_complex_setValueAt(subType, 0, &inst.b, &b_a);
- CHECK_EQUAL(1.1, inst.b.a);
+ ASSERT_EQ(1.1, inst.b.a);
dynType_complex_setValueAt(subType, 1, &inst.b, &b_b);
- CHECK_EQUAL(1.2, inst.b.b);
+ ASSERT_EQ(1.2, inst.b.b);
dynType_destroy(type);
}
-TEST(DynTypeTests, AssignTest3) {
+TEST_F(DynTypeTests, AssignTest3) {
int simple = 1;
dyn_type *type = NULL;
int rc = dynType_parseWithStr("N", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
int newValue = 42;
void *loc = &simple;
void *input = &newValue;
dynType_simple_setValue(type, loc, input);
- CHECK_EQUAL(42, simple);
+ ASSERT_EQ(42, simple);
dynType_destroy(type);
}
-TEST(DynTypeTests, MetaInfoTest) {
+TEST_F(DynTypeTests, MetaInfoTest) {
dyn_type *type = NULL;
int rc = 0;
rc = dynType_parseWithStr("#a=t;{DD#longname=longvalue;D a b c}", NULL, NULL, &type);
//rc = dynType_parseWithStr("{DDD a b c}", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
const char *val = NULL;
val = dynType_getMetaInfo(type, "a");
- CHECK(val != NULL);
- CHECK(strcmp("t", val) == 0);
+ ASSERT_TRUE(val != NULL);
+ ASSERT_TRUE(strcmp("t", val) == 0);
val = dynType_getMetaInfo(type, "longname");
- CHECK(val == NULL);
+ ASSERT_TRUE(val == NULL);
val = dynType_getMetaInfo(type, "nonexisting");
- CHECK(val == NULL);
+ ASSERT_TRUE(val == NULL);
dynType_destroy(type);
}
-TEST(DynTypeTests, SequenceWithPointerTest) {
+TEST_F(DynTypeTests, SequenceWithPointerTest) {
struct val {
double a;
double b;
@@ -271,12 +274,12 @@ TEST(DynTypeTests, SequenceWithPointerTest) {
dyn_type *type = NULL;
int rc = 0;
rc = dynType_parseWithStr("Tval={DD a b};Titem={Jtlval;DDJ a text val c d e};**[Litem;", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
struct item_sequence *seq = NULL;
rc = dynType_alloc(type, (void **)&seq);
- CHECK_EQUAL(0, rc);
- CHECK(seq != NULL);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(seq != NULL);
dynType_free(type, seq);
@@ -298,26 +301,26 @@ TEST(DynTypeTests, SequenceWithPointerTest) {
dynType_destroy(type);
}
-TEST(DynTypeTests, EnumTest) {
+TEST_F(DynTypeTests, EnumTest) {
dyn_type *type = NULL;
int rc = 0;
rc = dynType_parseWithStr("{#v1=0;#v2=1;E#v1=9;#v2=10;E enum1 enum2}", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
dynType_print(type, stdout);
dynType_destroy(type);
}
-TEST(DynTypeTests, NrOfEntriesTest) {
+TEST_F(DynTypeTests, NrOfEntriesTest) {
dyn_type *type = NULL;
int rc = dynType_parseWithStr("{DD}", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(2, dynType_complex_nrOfEntries(type));
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(2, dynType_complex_nrOfEntries(type));
dynType_destroy(type);
type = NULL;
rc = dynType_parseWithStr("{DDJJ}", NULL, NULL, &type);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(4, dynType_complex_nrOfEntries(type));
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(4, dynType_complex_nrOfEntries(type));
dynType_destroy(type);
}
\ No newline at end of file
diff --git a/libs/dfi/test/json_rpc_avpr_tests.cpp b/libs/dfi/gtest/src/json_rpc_avpr_tests.cpp
similarity index 89%
rename from libs/dfi/test/json_rpc_avpr_tests.cpp
rename to libs/dfi/gtest/src/json_rpc_avpr_tests.cpp
index 1971136..b302dee 100644
--- a/libs/dfi/test/json_rpc_avpr_tests.cpp
+++ b/libs/dfi/gtest/src/json_rpc_avpr_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
#include <stdio.h>
@@ -154,8 +153,9 @@ extern "C" {
}";
}
-TEST_GROUP(JsonAvprRpcTests) {
- void setup() override {
+class JsonAvprRpcTests : public ::testing::Test {
+public:
+ JsonAvprRpcTests() {
int lvl = 1;
dynCommon_logSetup(stdLog, nullptr, lvl);
dynType_logSetup(stdLog, nullptr,lvl);
@@ -164,13 +164,16 @@ TEST_GROUP(JsonAvprRpcTests) {
jsonSerializer_logSetup(stdLog, nullptr, lvl);
jsonRpc_logSetup(stdLog, nullptr, lvl);
}
+ ~JsonAvprRpcTests() override {
+ }
+
};
-TEST(JsonAvprRpcTests, prep) {
+TEST_F(JsonAvprRpcTests, prep) {
dyn_function_type * func = dynFunction_parseAvprWithStr(sourceAvprFile, "test.rpc.add");
- CHECK(func != nullptr);
+ ASSERT_TRUE(func != nullptr);
int nof_args = dynFunction_nrOfArguments(func);
- CHECK_EQUAL(4, nof_args);
+ ASSERT_EQ(4, nof_args);
// Msg
char *result = nullptr;
@@ -185,11 +188,11 @@ TEST(JsonAvprRpcTests, prep) {
args[2] = &arg2;
int rc = jsonRpc_prepareInvokeRequest(func, "add", args, &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
- STRCMP_CONTAINS("\"add\"", result);
- STRCMP_CONTAINS("1.0", result);
- STRCMP_CONTAINS("2.0", result);
+ ASSERT_TRUE(strstr(result, "\"add\"") != nullptr);
+ ASSERT_TRUE(strstr(result, "1.0") != nullptr);
+ ASSERT_TRUE(strstr(result, "2.0") != nullptr);
// Reply
const char *reply = "{\"r\": 2.2}";
@@ -199,8 +202,8 @@ TEST(JsonAvprRpcTests, prep) {
args[3] = &out;
rc = jsonRpc_handleReply(func, reply, args);
- CHECK_EQUAL(0, rc);
- DOUBLES_EQUAL(2.2, calc_result, 0.001);
+ ASSERT_EQ(0, rc);
+ ASSERT_NEAR(2.2, calc_result, 0.001);
free(result);
dynFunction_destroy(func);
@@ -222,9 +225,9 @@ extern "C" {
};
}
-TEST(JsonAvprRpcTests, handle_out) {
+TEST_F(JsonAvprRpcTests, handle_out) {
dyn_interface_type * intf = dynInterface_parseAvprWithStr(sourceAvprFile);
- CHECK(intf != nullptr);
+ ASSERT_TRUE(intf != nullptr);
methods_head *head;
dynInterface_methods(intf, &head);
@@ -237,9 +240,9 @@ TEST(JsonAvprRpcTests, handle_out) {
break;
}
}
- CHECK(func != nullptr);
+ ASSERT_TRUE(func != nullptr);
int nof_args = dynFunction_nrOfArguments(func);
- CHECK_EQUAL(3, nof_args);
+ ASSERT_EQ(3, nof_args);
const char *reply = R"({"r":{"input":[1.0,2.0],"max":2.0,"average":1.5,"min":1.0}})";
@@ -253,9 +256,9 @@ TEST(JsonAvprRpcTests, handle_out) {
args[2] = &out;
int rc = jsonRpc_handleReply(func, reply, args);
- CHECK_EQUAL(0, rc);
- CHECK(result != nullptr);
- CHECK_EQUAL(1.5, result->average);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(result != nullptr);
+ ASSERT_EQ(1.5, result->average);
free(result->input.buf);
free(result);
@@ -280,17 +283,17 @@ extern "C" {
}
}
-TEST(JsonAvprRpcTests, preallocated) {
+TEST_F(JsonAvprRpcTests, preallocated) {
dyn_interface_type * intf = dynInterface_parseAvprWithStr(sourceAvprFile);
- CHECK(intf != nullptr);
+ ASSERT_TRUE(intf != nullptr);
char *result = nullptr;
tst_serv serv {nullptr, xadd, nullptr, nullptr, nullptr};
int rc = jsonRpc_call(intf, &serv, R"({"m": "add", "a": [1.0,2.0]})", &result);
- CHECK_EQUAL(0, rc);
- CHECK(result != nullptr);
- STRCMP_CONTAINS("3.0", result);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(result != nullptr);
+ ASSERT_TRUE(strstr(result, "3.0") != nullptr);
free(result);
dynInterface_destroy(intf);
@@ -320,14 +323,14 @@ extern "C" {
}
auto result = static_cast<tst_StatsResult *>(calloc(1, sizeof(tst_StatsResult)));
- CHECK(result != nullptr);
+ EXPECT_TRUE(result != nullptr);
if (count>0) {
result->average = total / count;
}
result->min = min;
result->max = max;
auto buf = static_cast<double *>(calloc(input.len, sizeof(double)));
- CHECK(buf != nullptr);
+ EXPECT_TRUE(buf != nullptr);
memcpy(buf, input.buf, input.len * sizeof(double));
result->input.len = input.len;
result->input.cap = input.len;
@@ -338,16 +341,16 @@ extern "C" {
}
}
-TEST(JsonAvprRpcTests, output) {
+TEST_F(JsonAvprRpcTests, output) {
dyn_interface_type * intf = dynInterface_parseAvprWithStr(sourceAvprFile);
- CHECK(intf != nullptr);
+ ASSERT_TRUE(intf != nullptr);
char *result = nullptr;
tst_serv serv {nullptr, nullptr, nullptr, nullptr, xstats};
int rc = jsonRpc_call(intf, &serv, R"({"m":"stats", "a": [[1.0, 2.0]]})", &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS("1.5", result); //avg
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, "1.5") != nullptr);
free(result);
dynInterface_destroy(intf);
@@ -366,17 +369,17 @@ extern "C" {
}
}
-TEST(JsonAvprRpcTests, output_char) {
+TEST_F(JsonAvprRpcTests, output_char) {
dyn_interface_type * intf = dynInterface_parseAvprWithStr(sourceAvprFile);
- CHECK(intf != nullptr);
+ ASSERT_TRUE(intf != nullptr);
char *result = nullptr;
tst_service_ex_output_char serv {nullptr, getName_ex};
int rc = jsonRpc_call(intf, &serv, R"({"m" : "getName", "a": []})", &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
- STRCMP_CONTAINS("allocatedInFunction", result);
+ ASSERT_TRUE(strstr(result, "allocatedInFunction") != nullptr);
free(result);
dynInterface_destroy(intf);
diff --git a/libs/dfi/test/json_rpc_tests.cpp b/libs/dfi/gtest/src/json_rpc_tests.cpp
similarity index 83%
rename from libs/dfi/test/json_rpc_tests.cpp
rename to libs/dfi/gtest/src/json_rpc_tests.cpp
index 41844a5..8f8d744 100644
--- a/libs/dfi/test/json_rpc_tests.cpp
+++ b/libs/dfi/gtest/src/json_rpc_tests.cpp
@@ -17,10 +17,10 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
+#include "gtest/gtest.h"
+
#include <float.h>
-#include <assert.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include <assert.h>
extern "C" {
#include <stdio.h>
@@ -50,7 +50,7 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void prepareTest(void) {
dyn_function_type *dynFunc = nullptr;
int rc = dynFunction_parseWithStr("add(#am=handle;PDD#am=pre;*D)N", nullptr, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
char *result = nullptr;
@@ -64,13 +64,13 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
args[2] = &arg2;
rc = jsonRpc_prepareInvokeRequest(dynFunc, "add", args, &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
//printf("result is %s\n", result);
- STRCMP_CONTAINS("\"add\"", result);
- STRCMP_CONTAINS("1.0", result);
- STRCMP_CONTAINS("2.0", result);
+ ASSERT_TRUE(strstr(result, "\"add\"") != nullptr);
+ ASSERT_TRUE(strstr(result, "1.0") != nullptr);
+ ASSERT_TRUE(strstr(result, "2.0") != nullptr);
free(result);
dynFunction_destroy(dynFunc);
@@ -79,7 +79,7 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void handleTestPre(void) {
dyn_function_type *dynFunc = nullptr;
int rc = dynFunction_parseWithStr("add(#am=handle;PDD#am=pre;*D)N", nullptr, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
const char *reply = "{\"r\":2.2}";
double result = -1.0;
@@ -87,8 +87,8 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void *args[4];
args[3] = &out;
rc = jsonRpc_handleReply(dynFunc, reply, args);
- CHECK_EQUAL(0, rc);
- //CHECK_EQUAL(2.2, result);
+ ASSERT_EQ(0, rc);
+ //ASSERT_EQ(2.2, result);
dynFunction_destroy(dynFunc);
}
@@ -182,17 +182,17 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void callTestPreAllocated(void) {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example1.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
char *result = nullptr;
tst_serv serv {nullptr, add, nullptr, nullptr, nullptr};
rc = jsonRpc_call(intf, &serv, R"({"m":"add(DD)D", "a": [1.0,2.0]})", &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS("3.0", result);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, "3.0") != nullptr);
free(result);
dynInterface_destroy(intf);
@@ -201,17 +201,17 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void callTestOutput(void) {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example1.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
char *result = nullptr;
tst_serv serv {nullptr, nullptr, nullptr, nullptr, stats};
rc = jsonRpc_call(intf, &serv, R"({"m":"stats([D)LStatsResult;", "a": [[1.0,2.0]]})", &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS("1.5", result); //avg
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, "1.5") != nullptr);
free(result);
dynInterface_destroy(intf);
@@ -220,9 +220,9 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void handleTestOut(void) {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example1.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
struct methods_head *head;
@@ -235,7 +235,7 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
break;
}
}
- CHECK(func != nullptr);
+ ASSERT_TRUE(func != nullptr);
const char *reply = R"({"r":{"input":[1.0,2.0],"max":2.0,"average":1.5,"min":1.0}})";
@@ -249,8 +249,8 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
args[2] = &out;
rc = jsonRpc_handleReply(func, reply, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(1.5, result->average);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(1.5, result->average);
free(result->input.buf);
free(result);
@@ -260,9 +260,9 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
static void handleTestOutputSequence() {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example2.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
struct methods_head *head;
@@ -275,7 +275,7 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
break;
}
}
- CHECK(func != nullptr);
+ ASSERT_TRUE(func != nullptr);
//dyn_type *arg = dynFunction_argumentTypeForIndex(func, 1);
//dynType_print(arg, stdout);
@@ -291,12 +291,12 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
args[1] = &out;
rc = jsonRpc_handleReply(func, reply, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(2, result->len);
- CHECK_EQUAL(1.0, result->buf[0]->a);
- CHECK_EQUAL(1.5, result->buf[0]->b);
- CHECK_EQUAL(2.0, result->buf[1]->a);
- CHECK_EQUAL(2.5, result->buf[1]->b);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(2, result->len);
+ ASSERT_EQ(1.0, result->buf[0]->a);
+ ASSERT_EQ(1.5, result->buf[0]->b);
+ ASSERT_EQ(2.0, result->buf[1]->a);
+ ASSERT_EQ(2.5, result->buf[1]->b);
unsigned int i;
@@ -314,18 +314,18 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void callTestOutChar(void) {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example4.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
char *result = nullptr;
tst_serv_example4 serv {nullptr, getName_example4};
rc = jsonRpc_call(intf, &serv, R"({"m": "getName(V)t", "a": []})", &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
- STRCMP_CONTAINS("allocatedInFunction", result);
+ ASSERT_TRUE(strstr(result, "allocatedInFunction") != nullptr);
free(result);
dynInterface_destroy(intf);
@@ -335,9 +335,9 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
void handleTestOutChar(void) {
dyn_interface_type *intf = nullptr;
FILE *desc = fopen("descriptors/example4.descriptor", "r");
- CHECK(desc != nullptr);
+ ASSERT_TRUE(desc != nullptr);
int rc = dynInterface_parse(desc, &intf);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
fclose(desc);
struct methods_head *head;
@@ -351,7 +351,7 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
}
}
- CHECK(func != nullptr);
+ ASSERT_TRUE(func != nullptr);
const char *reply = R"({"r": "this is a test string"})";
char *result = nullptr;
@@ -365,15 +365,16 @@ static void stdLog(void*, int level, const char *file, int line, const char *msg
jsonRpc_handleReply(func, reply, args);
}
- STRCMP_EQUAL("this is a test string", result);
+ ASSERT_STREQ("this is a test string", result);
free(result);
dynInterface_destroy(intf);
}
}
-TEST_GROUP(JsonRpcTests) {
- void setup() override {
+class JsonRpcTests : public ::testing::Test {
+public:
+ JsonRpcTests() {
int lvl = 1;
dynCommon_logSetup(stdLog, nullptr, lvl);
dynType_logSetup(stdLog, nullptr,lvl);
@@ -382,38 +383,40 @@ TEST_GROUP(JsonRpcTests) {
jsonSerializer_logSetup(stdLog, nullptr, lvl);
jsonRpc_logSetup(stdLog, nullptr, lvl);
}
-};
+ ~JsonRpcTests() override {
+ }
+};
-TEST(JsonRpcTests, prepareTest) {
+TEST_F(JsonRpcTests, prepareTest) {
prepareTest();
}
-TEST(JsonRpcTests, handleTestPre) {
+TEST_F(JsonRpcTests, handleTestPre) {
handleTestPre();
}
-TEST(JsonRpcTests, handleTestOut) {
+TEST_F(JsonRpcTests, handleTestOut) {
handleTestOut();
}
-TEST(JsonRpcTests, callPre) {
+TEST_F(JsonRpcTests, callPre) {
callTestPreAllocated();
}
-TEST(JsonRpcTests, callOut) {
+TEST_F(JsonRpcTests, callOut) {
callTestOutput();
}
-TEST(JsonRpcTests, handleOutSeq) {
+TEST_F(JsonRpcTests, handleOutSeq) {
handleTestOutputSequence();
}
-TEST(JsonRpcTests, callTestOutChar) {
+TEST_F(JsonRpcTests, callTestOutChar) {
callTestOutChar();
}
-TEST(JsonRpcTests, handleOutChar) {
+TEST_F(JsonRpcTests, handleOutChar) {
handleTestOutChar();
}
diff --git a/libs/dfi/test/json_serializer_tests.cpp b/libs/dfi/gtest/src/json_serializer_tests.cpp
similarity index 85%
rename from libs/dfi/test/json_serializer_tests.cpp
rename to libs/dfi/gtest/src/json_serializer_tests.cpp
index c2a6424..0b090e2 100644
--- a/libs/dfi/test/json_serializer_tests.cpp
+++ b/libs/dfi/gtest/src/json_serializer_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
#include <stdio.h>
@@ -120,11 +119,11 @@ struct example1 {
static void check_example1(void *data) {
auto ex = static_cast<example1*>(data);
- CHECK_EQUAL(1.0, ex->a);
- LONGS_EQUAL(22, ex->b);
- LONGS_EQUAL(32, ex->c);
- LONGS_EQUAL(42, ex->d);
- CHECK_EQUAL(4.4f, ex->e);
+ ASSERT_EQ(1.0, ex->a);
+ ASSERT_EQ(22, ex->b);
+ ASSERT_EQ(32, ex->c);
+ ASSERT_EQ(42, ex->d);
+ ASSERT_EQ(4.4f, ex->e);
}
/*********** example 2 ************************/
@@ -202,12 +201,12 @@ struct example2 {
static void check_example2(void *data) {
auto ex = static_cast<example2*>(data);
- CHECK_EQUAL(42, ex->byte);
- LONGS_EQUAL(232, ex->long1);
- LONGS_EQUAL(242, ex->long2);
- CHECK_EQUAL(4.2, ex->double1);
- CHECK_EQUAL(3.2f, ex->float1);
- CHECK_EQUAL(4.4, ex->double2);
+ ASSERT_EQ(42, ex->byte);
+ ASSERT_EQ(232, ex->long1);
+ ASSERT_EQ(242, ex->long2);
+ ASSERT_EQ(4.2, ex->double1);
+ ASSERT_EQ(3.2f, ex->float1);
+ ASSERT_EQ(4.4, ex->double2);
}
@@ -255,10 +254,10 @@ struct example3 {
static void check_example3(void *data) {
auto ex = static_cast<example3*>(data);
- CHECK_EQUAL(3, ex->numbers.len);
- CHECK_EQUAL(22, ex->numbers.buf[0]);
- CHECK_EQUAL(32, ex->numbers.buf[1]);
- CHECK_EQUAL(42, ex->numbers.buf[2]);
+ ASSERT_EQ(3, ex->numbers.len);
+ ASSERT_EQ(22, ex->numbers.buf[0]);
+ ASSERT_EQ(32, ex->numbers.buf[1]);
+ ASSERT_EQ(42, ex->numbers.buf[2]);
}
/*********** example 4 ************************/
@@ -327,12 +326,12 @@ struct example4 {
static void check_example4(void *data) {
auto ex = static_cast<example4*>(data);
- CHECK_EQUAL(1, ex->left.index);
- CHECK_EQUAL(1.0, ex->left.val1);
- CHECK_EQUAL(2.0, ex->left.val2);
- CHECK_EQUAL(2, ex->right.index);
- CHECK_EQUAL(5.0, ex->right.val1);
- CHECK_EQUAL(4.0, ex->right.val2);
+ ASSERT_EQ(1, ex->left.index);
+ ASSERT_EQ(1.0, ex->left.val1);
+ ASSERT_EQ(2.0, ex->left.val2);
+ ASSERT_EQ(2, ex->right.index);
+ ASSERT_EQ(5.0, ex->right.val1);
+ ASSERT_EQ(4.0, ex->right.val2);
}
@@ -434,24 +433,24 @@ struct example5 {
static void check_example5(void *data) {
auto ex = static_cast<example5*>(data);
- CHECK_TRUE(ex->head != nullptr);
-
- CHECK(ex->head->left != nullptr);
- CHECK(ex->head->left->value != nullptr);
- STRCMP_EQUAL("John", ex->head->left->value->name);
- CHECK_EQUAL(44, ex->head->left->value->age);
- CHECK(ex->head->left->right == nullptr);
- CHECK(ex->head->left->left != nullptr);
- CHECK(ex->head->left->left->value != nullptr);
- STRCMP_EQUAL("Victor", ex->head->left->left->value->name);
- CHECK_EQUAL(400, ex->head->left->left->value->age);
-
- CHECK(ex->head->right != nullptr);
- CHECK(ex->head->right->value != nullptr);
- STRCMP_EQUAL("Peter", ex->head->right->value->name);
- CHECK_EQUAL(55, ex->head->right->value->age);
- CHECK(ex->head->right->left == nullptr);
- CHECK(ex->head->right->right == nullptr);
+ ASSERT_TRUE(ex->head != nullptr);
+
+ ASSERT_TRUE(ex->head->left != nullptr);
+ ASSERT_TRUE(ex->head->left->value != nullptr);
+ ASSERT_STREQ("John", ex->head->left->value->name);
+ ASSERT_EQ(44, ex->head->left->value->age);
+ ASSERT_TRUE(ex->head->left->right == nullptr);
+ ASSERT_TRUE(ex->head->left->left != nullptr);
+ ASSERT_TRUE(ex->head->left->left->value != nullptr);
+ ASSERT_STREQ("Victor", ex->head->left->left->value->name);
+ ASSERT_EQ(400, ex->head->left->left->value->age);
+
+ ASSERT_TRUE(ex->head->right != nullptr);
+ ASSERT_TRUE(ex->head->right->value != nullptr);
+ ASSERT_STREQ("Peter", ex->head->right->value->name);
+ ASSERT_EQ(55, ex->head->right->value->age);
+ ASSERT_TRUE(ex->head->right->left == nullptr);
+ ASSERT_TRUE(ex->head->right->right == nullptr);
}
/*********** example 6 ************************/
@@ -512,26 +511,26 @@ struct ex6_avpr_struct {
};
static void check_example6(struct ex6_sequence seq) {
- CHECK_EQUAL(3, seq.cap);
- CHECK_EQUAL(3, seq.len);
- CHECK_EQUAL(0.1, seq.buf[0].v1);
- CHECK_EQUAL(0.2, seq.buf[0].v2);
- CHECK_EQUAL(1.1, seq.buf[1].v1);
- CHECK_EQUAL(1.2, seq.buf[1].v2);
- CHECK_EQUAL(2.1, seq.buf[2].v1);
- CHECK_EQUAL(2.2, seq.buf[2].v2);
+ ASSERT_EQ(3, seq.cap);
+ ASSERT_EQ(3, seq.len);
+ ASSERT_EQ(0.1, seq.buf[0].v1);
+ ASSERT_EQ(0.2, seq.buf[0].v2);
+ ASSERT_EQ(1.1, seq.buf[1].v1);
+ ASSERT_EQ(1.2, seq.buf[1].v2);
+ ASSERT_EQ(2.1, seq.buf[2].v1);
+ ASSERT_EQ(2.2, seq.buf[2].v2);
}
static void check_example6_avpr(void *data) {
auto ex = static_cast<ex6_avpr_struct*>(data);
- CHECK_EQUAL(3, ex->samples.cap);
- CHECK_EQUAL(3, ex->samples.len);
- CHECK_EQUAL(0.1, ex->samples.buf[0].v1);
- CHECK_EQUAL(0.2, ex->samples.buf[0].v2);
- CHECK_EQUAL(1.1, ex->samples.buf[1].v1);
- CHECK_EQUAL(1.2, ex->samples.buf[1].v2);
- CHECK_EQUAL(2.1, ex->samples.buf[2].v1);
- CHECK_EQUAL(2.2, ex->samples.buf[2].v2);
+ ASSERT_EQ(3, ex->samples.cap);
+ ASSERT_EQ(3, ex->samples.len);
+ ASSERT_EQ(0.1, ex->samples.buf[0].v1);
+ ASSERT_EQ(0.2, ex->samples.buf[0].v2);
+ ASSERT_EQ(1.1, ex->samples.buf[1].v1);
+ ASSERT_EQ(1.2, ex->samples.buf[1].v2);
+ ASSERT_EQ(2.1, ex->samples.buf[2].v1);
+ ASSERT_EQ(2.2, ex->samples.buf[2].v2);
}
/*********** example 7 ************************/
@@ -570,7 +569,7 @@ struct example7 {
static void check_example7(void *data) {
auto ex = static_cast<example7*>(data);
- STRCMP_EQUAL("apache celix", ex->a);
+ ASSERT_STREQ("apache celix", ex->a);
}
@@ -657,12 +656,12 @@ struct example8 {
static void check_example8(void *data) {
auto ex = static_cast<example8*>(data);
- CHECK_EQUAL(true,ex->a);
- CHECK_EQUAL(4,ex->b);
- CHECK_EQUAL(8,ex->c);
- //error on mac CHECK_EQUAL(16,ex->d);
- CHECK(16 == ex->d);
- CHECK_EQUAL(32,ex->e);
+ ASSERT_EQ(true,ex->a);
+ ASSERT_EQ(4,ex->b);
+ ASSERT_EQ(8,ex->c);
+ //error on mac ASSERT_EQ(16,ex->d);
+ ASSERT_TRUE(16 == ex->d);
+ ASSERT_EQ(32,ex->e);
}
/*********** example 9 ************************/
@@ -739,23 +738,23 @@ struct example9 {
static void check_example9_1(void *data) {
auto ex = static_cast<example9*>(data);
- CHECK_EQUAL(1000, ex->id);
- STRCMP_EQUAL("my_name", ex->name);
- CHECK_EQUAL(RE_NOK, ex->result);
+ ASSERT_EQ(1000, ex->id);
+ ASSERT_STREQ("my_name", ex->name);
+ ASSERT_EQ(RE_NOK, ex->result);
}
static void check_example9_2(void *data) {
auto ex = static_cast<example9*>(data);
- CHECK_EQUAL(1001, ex->id);
- STRCMP_EQUAL("your_name", ex->name);
- CHECK_EQUAL(RE_MAYBE, ex->result);
+ ASSERT_EQ(1001, ex->id);
+ ASSERT_STREQ("your_name", ex->name);
+ ASSERT_EQ(RE_MAYBE, ex->result);
}
static void check_example9_3(void *data) {
auto ex = static_cast<example9*>(data);
- CHECK_EQUAL(1001, ex->id);
- STRCMP_EQUAL("your_name", ex->name);
- CHECK_EQUAL(RE_OK, ex->result);
+ ASSERT_EQ(1001, ex->id);
+ ASSERT_STREQ("your_name", ex->name);
+ ASSERT_EQ(RE_OK, ex->result);
}
/*********** example A ************************/
const char *exampleA_descriptor = "TPoint={DD x y};{lPoint;lPoint;t point_a point_b name}";
@@ -780,11 +779,11 @@ struct exA_struct {
static void check_exampleA(void *data) {
auto inp = static_cast<exA_struct*>(data);
- CHECK_EQUAL(1.0, inp->point_a.x);
- CHECK_EQUAL(2.0, inp->point_a.y);
- CHECK_EQUAL(3.0, inp->point_b.x);
- CHECK_EQUAL(4.0, inp->point_b.y);
- STRCMP_EQUAL("this_is_my_name", inp->name)
+ ASSERT_EQ(1.0, inp->point_a.x);
+ ASSERT_EQ(2.0, inp->point_a.y);
+ ASSERT_EQ(3.0, inp->point_b.x);
+ ASSERT_EQ(4.0, inp->point_b.y);
+ ASSERT_STREQ("this_is_my_name", inp->name);
}
@@ -795,45 +794,45 @@ static void parseAvprTests() {
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example1_descriptor, avpr_example1_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example1_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example1(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example2_descriptor, avpr_example2_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example2_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example2(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example3_descriptor, avpr_example3_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example3_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example3(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example4_descriptor, avpr_example4_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example4_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example4(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example5_descriptor, avpr_example5_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example5_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example5(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -841,44 +840,44 @@ static void parseAvprTests() {
// Test 6 has custom checker because avdl does not allow an array to be a type on its own
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example6_descriptor, avpr_example6_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, avpr_example6_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example6_avpr(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example7_descriptor, avpr_example7_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example7_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example7(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example8_descriptor, avpr_example8_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example8_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example8(inst);
dynType_free(type, inst);
dynType_destroy(type);
inst = nullptr;
type = dynType_parseAvprWithStr(avpr_example9_descriptor, avpr_example9_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
rc = jsonSerializer_deserialize(type, example9_input_1, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example9_1(inst);
dynType_free(type, inst);
rc = jsonSerializer_deserialize(type, example9_input_2, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example9_2(inst);
dynType_free(type, inst);
rc = jsonSerializer_deserialize(type, example9_input_3, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example9_3(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -892,9 +891,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example1_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example1_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example1(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -902,9 +901,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example2_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example2_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example2(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -912,9 +911,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example3_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example3_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example3(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -922,9 +921,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example4_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example4_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example4(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -932,9 +931,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example5_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example5_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example5(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -942,9 +941,9 @@ static void parseTests() {
type = nullptr;
struct ex6_sequence *seq;
rc = dynType_parseWithStr(example6_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example6_input, (void **)&seq);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example6((*seq));
dynType_free(type, seq);
dynType_destroy(type);
@@ -952,9 +951,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example7_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example7_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example7(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -962,9 +961,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example8_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example8_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example8(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -972,13 +971,13 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(example9_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, example9_input_1, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example9_1(inst);
dynType_free(type, inst);
rc = jsonSerializer_deserialize(type, example9_input_2, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_example9_2(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -986,9 +985,9 @@ static void parseTests() {
type = nullptr;
inst = nullptr;
rc = dynType_parseWithStr(exampleA_descriptor, nullptr, nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_deserialize(type, exampleA_input, &inst);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
check_exampleA(inst);
dynType_free(type, inst);
dynType_destroy(type);
@@ -1125,21 +1124,20 @@ void writeTest1(void) {
dyn_type *type = nullptr;
char *result = nullptr;
int rc = dynType_parseWithStr(write_example1_descriptor, "ex1", nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_serialize(type, &ex1, &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS(R"("a":65)", result);
- STRCMP_CONTAINS(R"("b":2)", result);
- STRCMP_CONTAINS(R"("c":3)", result);
- STRCMP_CONTAINS(R"("d":4)", result);
- STRCMP_CONTAINS(R"("e":5)", result);
- STRCMP_CONTAINS(R"("f":6)", result);
- STRCMP_CONTAINS(R"("g":7)", result);
- STRCMP_CONTAINS(R"("h":8.8)", result);
- STRCMP_CONTAINS(R"("i":9.9)", result);
- STRCMP_CONTAINS(R"("j":10)", result);
- STRCMP_CONTAINS(R"("k":false)", result);
- STRCMP_CONTAINS(R"("l":12)", result);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, R"("b":2)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("c":3)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("d":4)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("e":5)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("f":6)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("g":7)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("h":8.8)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("i":9.9)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("j":10)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("k":false)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("l":12)") != nullptr);
//printf("example 1 result: '%s'\n", result);
dynType_destroy(type);
free(result);
@@ -1150,23 +1148,23 @@ void writeAvprTest1(void) {
char *result = nullptr;
dyn_type *type = dynType_parseAvprWithStr(avpr_write_example1_descriptor, avpr_write_example1_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
int rc = jsonSerializer_serialize(type, &ex1, &result);
- CHECK_EQUAL(0, rc);
-
- STRCMP_CONTAINS(R"("a":1)", result);
- STRCMP_CONTAINS(R"("b":2)", result);
- STRCMP_CONTAINS(R"("c":3)", result);
- STRCMP_CONTAINS(R"("d":4)", result);
- STRCMP_CONTAINS(R"("e":5)", result);
- STRCMP_CONTAINS(R"("f":6)", result);
- STRCMP_CONTAINS(R"("g":7)", result);
- STRCMP_CONTAINS(R"("h":8.8)", result);
- STRCMP_CONTAINS(R"("i":9.9)", result);
- STRCMP_CONTAINS(R"("j":10)", result);
- STRCMP_CONTAINS(R"("k":true)", result);
- STRCMP_CONTAINS(R"("l":12)", result);
+ ASSERT_EQ(0, rc);
+
+ ASSERT_TRUE(strstr(result, R"("a":1)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("b":2)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("c":3)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("d":4)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("e":5)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("f":6)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("g":7)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("h":8.8)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("i":9.9)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("j":10)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("k":true)") != nullptr);
+ ASSERT_TRUE(strstr(result, R"("l":12)") != nullptr);
dynType_destroy(type);
free(result);
@@ -1246,13 +1244,13 @@ void writeTest2(void) {
dyn_type *type = nullptr;
char *result = nullptr;
int rc = dynType_parseWithStr(write_example2_descriptor, "ex2", nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_serialize(type, &ex, &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS("\"a\":1", result);
- STRCMP_CONTAINS("\"b\":2", result);
- STRCMP_CONTAINS("\"c\":3", result);
- STRCMP_CONTAINS("\"d\":4", result);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, "\"a\":1") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"b\":2") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"c\":3") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"d\":4") != nullptr);
//printf("example 2 result: '%s'\n", result);
dynType_destroy(type);
free(result);
@@ -1266,15 +1264,15 @@ void writeAvprTest2(void) {
char *result = nullptr;
dyn_type *type = dynType_parseAvprWithStr(avpr_write_example2_descriptor, avpr_write_example2_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
int rc = jsonSerializer_serialize(type, &ex, &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
- STRCMP_CONTAINS("\"a\":1", result);
- STRCMP_CONTAINS("\"b\":2", result);
- STRCMP_CONTAINS("\"c\":3", result);
- STRCMP_CONTAINS("\"d\":4", result);
+ ASSERT_TRUE(strstr(result, "\"a\":1") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"b\":2") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"c\":3") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"d\":4") != nullptr);
dynType_destroy(type);
free(result);
@@ -1356,13 +1354,13 @@ void writeTest3(void) {
dyn_type *type = nullptr;
char *result = nullptr;
int rc = dynType_parseWithStr(write_example3_descriptor, "ex3", nullptr, &type);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
rc = jsonSerializer_serialize(type, &seq, &result);
- CHECK_EQUAL(0, rc);
- STRCMP_CONTAINS("\"age\":33", result);
- STRCMP_CONTAINS("\"age\":44", result);
- STRCMP_CONTAINS("\"age\":55", result);
- STRCMP_CONTAINS("\"age\":66", result);
+ ASSERT_EQ(0, rc);
+ ASSERT_TRUE(strstr(result, "\"age\":33") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":44") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":55") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":66") != nullptr);
//printf("example 3 result: '%s'\n", result);
free(seq.buf);
dynType_destroy(type);
@@ -1383,15 +1381,15 @@ void writeAvprTest3(void) {
char *result = nullptr;
dyn_type *type = dynType_parseAvprWithStr(avpr_write_example3_descriptor, avpr_write_example3_fqn);
- CHECK(type != nullptr);
+ ASSERT_TRUE(type != nullptr);
int rc = jsonSerializer_serialize(type, &seq, &result);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
- STRCMP_CONTAINS("\"age\":33", result);
- STRCMP_CONTAINS("\"age\":44", result);
- STRCMP_CONTAINS("\"age\":55", result);
- STRCMP_CONTAINS("\"age\":66", result);
+ ASSERT_TRUE(strstr(result, "\"age\":33") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":44") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":55") != nullptr);
+ ASSERT_TRUE(strstr(result, "\"age\":66") != nullptr);
free(seq.buf);
dynType_destroy(type);
@@ -1400,36 +1398,41 @@ void writeAvprTest3(void) {
} // extern "C"
-TEST_GROUP(JsonSerializerTests) {
- void setup() override {
- int lvl = 1;
- dynCommon_logSetup(stdLog, nullptr, lvl);
- dynType_logSetup(stdLog, nullptr,lvl);
- dynAvprType_logSetup(stdLog, nullptr,lvl);
- dynTypeCommon_logSetup(stdLog, nullptr,lvl);
- jsonSerializer_logSetup(stdLog, nullptr, lvl);
- }
+
+class JsonSerializerTests : public ::testing::Test {
+public:
+ JsonSerializerTests() {
+ int lvl = 1;
+ dynCommon_logSetup(stdLog, nullptr, lvl);
+ dynType_logSetup(stdLog, nullptr,lvl);
+ dynAvprType_logSetup(stdLog, nullptr,lvl);
+ dynTypeCommon_logSetup(stdLog, nullptr,lvl);
+ jsonSerializer_logSetup(stdLog, nullptr, lvl);
+ }
+ ~JsonSerializerTests() override {
+ }
+
};
-TEST(JsonSerializerTests, ParseTests) {
+TEST_F(JsonSerializerTests, ParseTests) {
parseTests();
}
-TEST(JsonSerializerTests, ParseAvprTests) {
+TEST_F(JsonSerializerTests, ParseAvprTests) {
parseAvprTests();
}
-TEST(JsonSerializerTests, WriteTest1) {
+TEST_F(JsonSerializerTests, WriteTest1) {
writeTest1();
writeAvprTest1();
}
-TEST(JsonSerializerTests, WriteTest2) {
+TEST_F(JsonSerializerTests, WriteTest2) {
writeTest2();
writeAvprTest2();
}
-TEST(JsonSerializerTests, WriteTest3) {
+TEST_F(JsonSerializerTests, WriteTest3) {
writeTest3();
writeAvprTest3();
}
diff --git a/libs/dfi/include/avrobin_serializer.h b/libs/dfi/include/avrobin_serializer.h
index bb2f63d..5a38e03 100644
--- a/libs/dfi/include/avrobin_serializer.h
+++ b/libs/dfi/include/avrobin_serializer.h
@@ -24,12 +24,23 @@
#include "dyn_function.h"
#include "dyn_interface.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
//logging
DFI_SETUP_LOG_HEADER(avrobinSerializer);
int avrobinSerializer_deserialize(dyn_type *type, const uint8_t *input, size_t inlen, void **result);
+
int avrobinSerializer_serialize(dyn_type *type, const void *input, uint8_t **output, size_t *outlen);
+
int avrobinSerializer_generateSchema(dyn_type *type, char **output);
+
int avrobinSerializer_saveFile(const char *filename, const char *schema, const uint8_t *serdata, size_t serdatalen);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dfi_log_util.h b/libs/dfi/include/dfi_log_util.h
index 4885cbb..2910190 100644
--- a/libs/dfi/include/dfi_log_util.h
+++ b/libs/dfi/include/dfi_log_util.h
@@ -20,7 +20,11 @@
#ifndef _DFI_LOG_UTIL_H_
#define _DFI_LOG_UTIL_H_
-typedef void (*logf_ft)(void *handle, int level, const char *file, int line, const char *format, ...);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*logf_ft)(void *handle, int level, const char *file, int line, const char *format, ...);
#define DFI_SETUP_LOG_HEADER(cmp) \
void cmp ## _logSetup(logf_ft logf, void *handle, int currentLogLevel);
@@ -34,7 +38,7 @@ typedef void (*logf_ft)(void *handle, int level, const char *file, int line, con
g_currentLogLevel = currentLogLevel; \
g_logHandle = handle; \
g_logf = logf; \
- }
+ }
#define LOG_LVL_ERROR 1
#define LOG_LVL_WARNING 2
@@ -44,21 +48,27 @@ typedef void (*logf_ft)(void *handle, int level, const char *file, int line, con
#define LOG_ERROR(msg, ...) \
if (g_logf != NULL && g_currentLogLevel >= LOG_LVL_ERROR) { \
g_logf(g_logHandle, LOG_LVL_ERROR, __FILE__, __LINE__, (msg), ##__VA_ARGS__); \
- }
+ }
#define LOG_WARNING(msg, ...) \
if (g_logf != NULL && g_currentLogLevel >= LOG_LVL_WARNING) { \
g_logf(g_logHandle, LOG_LVL_WARNING, __FILE__, __LINE__, (msg), ##__VA_ARGS__); \
- }
+ }
#define LOG_INFO(msg, ...) \
if (g_logf != NULL && g_currentLogLevel >= LOG_LVL_INFO) { \
g_logf(g_logHandle, LOG_LVL_INFO, __FILE__, __LINE__, (msg), ##__VA_ARGS__); \
- }
+ }
#define LOG_DEBUG(msg, ...) \
if (g_logf != NULL && g_currentLogLevel >= LOG_LVL_DEBUG) { \
g_logf(g_logHandle, LOG_LVL_DEBUG, __FILE__, __LINE__, (msg), ##__VA_ARGS__); \
- }
+ }
+
+
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_common.h b/libs/dfi/include/dyn_common.h
index 744ac71..01adcf3 100644
--- a/libs/dfi/include/dyn_common.h
+++ b/libs/dfi/include/dyn_common.h
@@ -27,8 +27,12 @@
#include "dfi_log_util.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
//logging
-DFI_SETUP_LOG_HEADER(dynCommon);
+DFI_SETUP_LOG_HEADER(dynCommon) ;
TAILQ_HEAD(namvals_head, namval_entry);
@@ -45,4 +49,8 @@ int dynCommon_eatChar(FILE *stream, int c);
void dynCommon_clearNamValHead(struct namvals_head *head);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_function.h b/libs/dfi/include/dyn_function.h
index 4b92456..d9ec07c 100644
--- a/libs/dfi/include/dyn_function.h
+++ b/libs/dfi/include/dyn_function.h
@@ -23,6 +23,10 @@
#include "dyn_type.h"
#include "dfi_log_util.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/**
* Uses the following schema
* (Name)([Type]*)Type
@@ -74,6 +78,8 @@ bool dynFunction_hasReturn(dyn_function_type *dynFunction);
dyn_function_type * dynFunction_parseAvprWithStr(const char * avpr, const char * fqn);
dyn_function_type * dynFunction_parseAvpr(FILE * avprStream, const char * fqn);
-
+#ifdef __cplusplus
+}
+#endif
#endif
diff --git a/libs/dfi/include/dyn_function_common.h b/libs/dfi/include/dyn_function_common.h
index 60688cd..8d96f7c 100644
--- a/libs/dfi/include/dyn_function_common.h
+++ b/libs/dfi/include/dyn_function_common.h
@@ -28,6 +28,10 @@
#include "dyn_common.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
struct _dyn_function_type {
char *name;
struct types_head *refTypes; //NOTE not owned
@@ -52,4 +56,8 @@ struct _dyn_function_argument_type {
TAILQ_ENTRY(_dyn_function_argument_type) entries;
};
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_interface.h b/libs/dfi/include/dyn_interface.h
index a926fcf..74fe126 100644
--- a/libs/dfi/include/dyn_interface.h
+++ b/libs/dfi/include/dyn_interface.h
@@ -27,6 +27,10 @@
#include "version.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
DFI_SETUP_LOG_HEADER(dynInterface);
DFI_SETUP_LOG_HEADER(dynAvprInterface);
@@ -68,4 +72,8 @@ int dynInterface_nrOfMethods(dyn_interface_type *intf);
dyn_interface_type * dynInterface_parseAvprWithStr(const char * avpr);
dyn_interface_type * dynInterface_parseAvpr(FILE * avprStream);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_interface_common.h b/libs/dfi/include/dyn_interface_common.h
index 5574966..9ff377e 100644
--- a/libs/dfi/include/dyn_interface_common.h
+++ b/libs/dfi/include/dyn_interface_common.h
@@ -28,6 +28,10 @@
#include "dyn_common.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
struct _dyn_interface_type {
struct namvals_head header;
struct namvals_head annotations;
@@ -36,4 +40,8 @@ struct _dyn_interface_type {
version_pt version;
};
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_message.h b/libs/dfi/include/dyn_message.h
index 21e9f1b..0d2c111 100644
--- a/libs/dfi/include/dyn_message.h
+++ b/libs/dfi/include/dyn_message.h
@@ -26,6 +26,10 @@
#include "version.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
DFI_SETUP_LOG_HEADER(dynMessage);
/* Description string
@@ -56,4 +60,8 @@ int dynMessage_getMessageType(dyn_message_type *msg, dyn_type **type);
dyn_message_type * dynMessage_parseAvpr(FILE *avprDescriptorStream, const char *fqn);
dyn_message_type * dynMessage_parseAvprWithStr(const char *avprDescriptor, const char *fqn);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/dyn_type.h b/libs/dfi/include/dyn_type.h
index a757c9f..3e63b32 100644
--- a/libs/dfi/include/dyn_type.h
+++ b/libs/dfi/include/dyn_type.h
@@ -28,6 +28,10 @@
#include "dfi_log_util.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#if defined(NO_MEMSTREAM_AVAILABLE)
#include "memstream/open_memstream.h"
#include "memstream/fmemopen.h"
@@ -267,7 +271,27 @@ int dynType_complex_entries(dyn_type *type, struct complex_type_entries_head **e
size_t dynType_complex_nrOfEntries(dyn_type *type);
//sequence
+
+/**
+ * Initialize a sequence struct with a cap & len of 0 and the buf to NULL.
+ */
+void dynType_sequence_init(dyn_type *type, void *inst);
+
+/**
+ * Allocates memory for a sequence with capacity cap.
+ * Will not free if the existing buf.
+ * Sets len to 0
+ */
int dynType_sequence_alloc(dyn_type *type, void *inst, uint32_t cap);
+
+/**
+ * Reserve a sequence capacity of cap
+ * Using realloc of the requested capicity is not enough.
+ * Keeps the len value.
+ * Note will not decrease the allocated memory
+ */
+int dynType_sequence_reserve(dyn_type *type, void *inst, uint32_t cap);
+
int dynType_sequence_locForIndex(dyn_type *type, void *seqLoc, int index, void **valLoc);
int dynType_sequence_increaseLengthAndReturnLastLoc(dyn_type *type, void *seqLoc, void **valLoc);
dyn_type * dynType_sequence_itemType(dyn_type *type);
@@ -286,4 +310,9 @@ void dynType_simple_setValue(dyn_type *type, void *inst, void *in);
dyn_type * dynType_parseAvpr(FILE *avprStream, const char *fqn);
dyn_type * dynType_parseAvprWithStr(const char *avpr, const char *fqn);
+
+#ifdef __cplusplus
+}
+#endif
+
#endif //_DYN_TYPE_H_
diff --git a/libs/dfi/include/dyn_type_common.h b/libs/dfi/include/dyn_type_common.h
index 48b7919..856b9d3 100644
--- a/libs/dfi/include/dyn_type_common.h
+++ b/libs/dfi/include/dyn_type_common.h
@@ -27,6 +27,10 @@
#include "dfi_log_util.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
DFI_SETUP_LOG_HEADER(dynTypeCommon);
struct _dyn_type {
@@ -61,4 +65,8 @@ dyn_type * dynType_findType(dyn_type *type, char *name);
ffi_type * dynType_ffiType(dyn_type * type);
void dynType_prepCif(ffi_type *type);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/json_rpc.h b/libs/dfi/include/json_rpc.h
index b241cfc..f2a7291 100644
--- a/libs/dfi/include/json_rpc.h
+++ b/libs/dfi/include/json_rpc.h
@@ -26,6 +26,10 @@
#include "dyn_function.h"
#include "dyn_interface.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
//logging
DFI_SETUP_LOG_HEADER(jsonRpc);
@@ -35,4 +39,8 @@ int jsonRpc_call(dyn_interface_type *intf, void *service, const char *request, c
int jsonRpc_prepareInvokeRequest(dyn_function_type *func, const char *id, void *args[], char **out);
int jsonRpc_handleReply(dyn_function_type *func, const char *reply, void *args[]);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/include/json_serializer.h b/libs/dfi/include/json_serializer.h
index 759ced7..16e5cfa 100644
--- a/libs/dfi/include/json_serializer.h
+++ b/libs/dfi/include/json_serializer.h
@@ -26,6 +26,10 @@
#include "dyn_function.h"
#include "dyn_interface.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
//logging
DFI_SETUP_LOG_HEADER(jsonSerializer);
@@ -35,4 +39,8 @@ int jsonSerializer_deserializeJson(dyn_type *type, json_t *input, void **result)
int jsonSerializer_serialize(dyn_type *type, const void* input, char **output);
int jsonSerializer_serializeJson(dyn_type *type, const void* input, json_t **out);
+#ifdef __cplusplus
+}
+#endif
+
#endif
diff --git a/libs/dfi/src/avrobin_serializer.c b/libs/dfi/src/avrobin_serializer.c
index d06456f..ef6f6f6 100644
--- a/libs/dfi/src/avrobin_serializer.c
+++ b/libs/dfi/src/avrobin_serializer.c
@@ -438,97 +438,62 @@ static int avrobinSerializer_parseComplex(dyn_type *type, void *loc, FILE *strea
}
static int avrobinSerializer_parseSequence(dyn_type *type, void *loc, FILE *stream) {
- int64_t blockCount;
- int64_t blockSize;
- int64_t totalCount = 0;
-
+ /* Avro 1.8.1 Specification
+ * Arrays
+ * Arrays are encoded as a series of blocks. Each block consists of a long count value, followed by that many array items. A block with count zero indicates the end of the array. Each item is encoded per the array's item schema.
+ * If a block's count is negative, its absolute value is used, and the count is followed immediately by a long block size indicating the number of bytes in the block. This block size permits fast skipping through data, e.g., when projecting a record to a subset of its fields.
+ * For example, the array schema
+ * {"type": "array", "items": "long"}
+ * an array containing the items 3 and 27 could be encoded as the long value 2 (encoded as hex 04) followed by long values 3 and 27 (encoded as hex 06 36) terminated by zero:
+ * 04 06 36 00
+ * The blocked representation permits one to read and write arrays larger than can be buffered in memory, since one can start writing items without knowing the full length of the array.
+ */
+
+ dynType_sequence_init(type, loc);
+ int status = 0;
dyn_type *itemType = dynType_sequence_itemType(type);
+ size_t itemSize = (int64_t)dynType_size(itemType);
+ uint32_t cap = 0;
- void *itemLoc = NULL;
- if (dynType_alloc(itemType, &itemLoc) != OK) {
- return ERROR;
- }
-
- fpos_t streamPos;
- if (fgetpos(stream, &streamPos) != 0) {
- LOG_ERROR("Failed to get position of stream.");
- return ERROR;
- }
-
- if (avrobin_read_long(stream, &blockCount) != OK) {
- LOG_ERROR("Failed to read array block count.");
- dynType_free(itemType, itemLoc);
- return ERROR;
- }
+ int64_t blockCount = 0;
+ int64_t blockSize = 0;
- while (blockCount != 0) {
- if (blockCount < 0) {
- if (avrobin_read_long(stream, &blockSize) != OK) {
- LOG_ERROR("Failed to read array block size.");
- dynType_free(itemType, itemLoc);
- return ERROR;
- }
- blockCount *= -1;
- }
-
- totalCount += blockCount;
-
- for (int64_t i=0; i<blockCount; i++) {
- if (avrobinSerializer_parseAny(itemType, itemLoc, stream) != OK) {
- dynType_free(itemType, itemLoc);
- return ERROR;
- }
- }
-
- if (avrobin_read_long(stream, &blockCount) != OK) {
- LOG_ERROR("Failed to read array block count.");
- dynType_free(itemType, itemLoc);
- return ERROR;
- }
- }
-
- dynType_free(itemType, itemLoc);
-
- if (fsetpos(stream, &streamPos) != 0) {
- LOG_ERROR("Failed to set position of stream.");
- return ERROR;
- }
-
- if (dynType_sequence_alloc(type, loc, (uint32_t)totalCount) != OK) {
- LOG_ERROR("Failed to allocate memory for array.");
- return ERROR;
- }
-
- if (avrobin_read_long(stream, &blockCount) != OK) {
- LOG_ERROR("Failed to read array block count.");
- return ERROR;
- }
-
- while (blockCount != 0) {
- if (blockCount < 0) {
- if (avrobin_read_long(stream, &blockSize) != OK) {
- LOG_ERROR("Failed to read array block size.");
- return ERROR;
+ do {
+ status = avrobin_read_long(stream, &blockCount);
+ if (status != OK) {
+ break;
+ } else if (blockCount < 0) {
+ blockSize = blockCount * -1; //found a block of blockSize bytes
+ blockCount = blockSize / itemSize;
+ int64_t rest = blockSize % itemSize;
+ if (rest != 0) {
+ LOG_ERROR("Found block size (%li) is not a multitude of the item size (%li)", blockSize, itemSize);
+ status = ERROR;
+ break;
}
- blockCount *= -1;
}
-
- for (int64_t i=0; i<blockCount; i++) {
- if (dynType_sequence_increaseLengthAndReturnLastLoc(type, loc, &itemLoc) != OK) {
- return ERROR;
+ if (blockCount > 0) {
+ LOG_DEBUG("Parsing block count of %li", blockCount);
+ cap += blockCount;
+ dynType_sequence_reserve(type, loc, cap);
+ for (int64_t i = 0; i < blockCount; ++i) {
+ void* itemLoc = NULL;
+ status = dynType_sequence_increaseLengthAndReturnLastLoc(type, loc, &itemLoc);
+ if (status != OK) {
+ break;
+ }
+ avrobinSerializer_parseAny(itemType, itemLoc, stream);
}
- if (avrobinSerializer_parseAny(itemType, itemLoc, stream) != OK) {
- return ERROR;
+ if (status != OK) {
+ break;
}
}
+ } while (blockCount != 0);
- if (avrobin_read_long(stream, &blockCount) != OK) {
- LOG_ERROR("Failed to read array block count.");
- return ERROR;
- }
+ if (status != OK) {
+ dynType_free(type, loc);
}
-
- return OK;
+ return status;
}
static int avrobinSerializer_parseEnum(dyn_type *type, void *loc, FILE *stream) {
diff --git a/libs/dfi/src/dyn_function.c b/libs/dfi/src/dyn_function.c
index 56da893..2e7cd98 100644
--- a/libs/dfi/src/dyn_function.c
+++ b/libs/dfi/src/dyn_function.c
@@ -181,13 +181,13 @@ enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(dyn_function_ty
static int dynFunction_initCif(dyn_function_type *dynFunc) {
int status = 0;
- int count = 0;
+ unsigned int nargs = 0;
dyn_function_argument_type *entry = NULL;
TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
- count +=1;
+ nargs +=1;
}
- dynFunc->ffiArguments = calloc(count, sizeof(ffi_type*));
+ dynFunc->ffiArguments = calloc(nargs, sizeof(ffi_type*));
TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
dynFunc->ffiArguments[entry->index] = dynType_ffiType(entry->type);
@@ -196,7 +196,7 @@ static int dynFunction_initCif(dyn_function_type *dynFunc) {
ffi_type **args = dynFunc->ffiArguments;
ffi_type *returnType = dynType_ffiType(dynFunc->funcReturn);
- int ffiResult = ffi_prep_cif(&dynFunc->cif, FFI_DEFAULT_ABI, count, returnType, args);
+ int ffiResult = ffi_prep_cif(&dynFunc->cif, FFI_DEFAULT_ABI, nargs, returnType, args);
if (ffiResult != FFI_OK) {
status = 1;
}
diff --git a/libs/dfi/src/dyn_type.c b/libs/dfi/src/dyn_type.c
index 36ae7dc..0972cb4 100644
--- a/libs/dfi/src/dyn_type.c
+++ b/libs/dfi/src/dyn_type.c
@@ -647,16 +647,25 @@ int dynType_complex_entries(dyn_type *type, struct complex_type_entries_head **e
}
//sequence
+
+void dynType_sequence_init(dyn_type *type, void *inst) {
+ assert(type->type == DYN_TYPE_SEQUENCE);
+ struct generic_sequence *seq = inst;
+ seq->buf = NULL;
+ seq->cap = 0;
+ seq->len = 0;
+}
+
int dynType_sequence_alloc(dyn_type *type, void *inst, uint32_t cap) {
assert(type->type == DYN_TYPE_SEQUENCE);
int status = OK;
struct generic_sequence *seq = inst;
if (seq != NULL) {
size_t size = dynType_size(type->sequence.itemType);
- seq->buf = calloc(cap, size);
+ seq->buf = malloc(cap * size);
if (seq->buf != NULL) {
seq->cap = cap;
- seq->len = 0;;
+ seq->len = 0;
} else {
seq->cap = 0;
status = MEM_ERROR;
@@ -669,6 +678,27 @@ int dynType_sequence_alloc(dyn_type *type, void *inst, uint32_t cap) {
return status;
}
+int dynType_sequence_reserve(dyn_type *type, void *inst, uint32_t cap) {
+ assert(type->type == DYN_TYPE_SEQUENCE);
+ int status = OK;
+ struct generic_sequence *seq = inst;
+ if (seq != NULL && seq->cap < cap) {
+ size_t size = dynType_size(type->sequence.itemType);
+ seq->buf = realloc(seq->buf, (size_t)(cap * size));
+ if (seq->buf != NULL) {
+ seq->cap = cap;
+ } else {
+ seq->cap = 0;
+ status = MEM_ERROR;
+ LOG_ERROR("Error allocating memory for buf")
+ }
+ } else {
+ status = MEM_ERROR;
+ LOG_ERROR("Error allocating memory for seq")
+ }
+ return status;
+}
+
void dynType_free(dyn_type *type, void *loc) {
dynType_deepFree(type, loc, true);
}
@@ -716,7 +746,7 @@ void dynType_freeSequenceType(dyn_type *type, void *seqLoc) {
dyn_type *itemType = dynType_sequence_itemType(type);
void *itemLoc = NULL;
int i;
- for (i = 0; i < seq->len; i += 1) {
+ for (i = 0; i < seq->len; ++i) {
dynType_sequence_locForIndex(type, seqLoc, i, &itemLoc);
dynType_deepFree(itemType, itemLoc, false);
}
@@ -744,7 +774,6 @@ int dynType_sequence_locForIndex(dyn_type *type, void *seqLoc, int index, void *
int status = OK;
struct generic_sequence *seq = seqLoc;
- char *valLoc = seq->buf;
size_t itemSize = dynType_size(type->sequence.itemType);
@@ -757,18 +786,11 @@ int dynType_sequence_locForIndex(dyn_type *type, void *seqLoc, int index, void *
LOG_WARNING("Requesting index (%i) outsize defined length (%u) but within capacity", index, seq->len);
}
- if (status == OK) { }
- int i;
- for (i = 0; i < seq->cap; i += 1) {
- if (index == i) {
- break;
- } else {
- valLoc += itemSize;
- }
+ if (status == OK) {
+ char *valLoc = seq->buf + (index * itemSize);
+ (*out) = valLoc;
}
- (*out) = valLoc;
-
return status;
}
diff --git a/libs/dfi/test/dyn_function_tests.cpp b/libs/dfi/test/dyn_function_tests.cpp
deleted file mode 100644
index 2ac0f58..0000000
--- a/libs/dfi/test/dyn_function_tests.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
-
-extern "C" {
- #include <stdio.h>
- #include <stdint.h>
- #include <stdlib.h>
- #include <string.h>
- #include <ctype.h>
-
-
- #include "dyn_common.h"
- #include "dyn_function.h"
-
- static void stdLog(void*, int level, const char *file, int line, const char *msg, ...) {
- va_list ap;
- const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
- fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
- va_start(ap, msg);
- vfprintf(stderr, msg, ap);
- fprintf(stderr, "\n");
- va_end(ap);
- }
-
- #define EXAMPLE1_DESCRIPTOR "example(III)I"
- int32_t example1(int32_t a, int32_t b, int32_t c) {
- CHECK_EQUAL(2, a);
- CHECK_EQUAL(4, b);
- CHECK_EQUAL(8, c);
- return 1;
- }
-
- void test_example1(void) {
- dyn_function_type *dynFunc = NULL;
- int rc;
- void (*fp)(void) = (void (*)(void)) example1;
-
- rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
-
- int32_t a = 2;
- int32_t b = 4;
- int32_t c = 8;
- void *values[3];
- int32_t rVal = 0;
- values[0] = &a;
- values[1] = &b;
- values[2] = &c;
-
- rc = dynFunction_call(dynFunc, fp, &rVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(1, rVal);
- dynFunction_destroy(dynFunc);
- }
-
- #define EXAMPLE2_DESCRIPTOR "example(I{IID val1 val2 val3}D)D"
- struct example2_arg {
- int32_t val1;
- int32_t val2;
- double val3;
- };
-
- double example2(int32_t arg1, struct example2_arg arg2, double arg3) {
- CHECK_EQUAL(2, arg1);
- CHECK_EQUAL(2, arg2.val1);
- CHECK_EQUAL(3, arg2.val2);
- CHECK_EQUAL(4.1, arg2.val3);
- CHECK_EQUAL(8.1, arg3);
- return 2.2;
- }
-
- void test_example2(void) {
- dyn_function_type *dynFunc = NULL;
- int rc;
- void (*fp)(void) = (void (*)(void)) example2;
-
- rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
-
- int32_t arg1 = 2;
- struct example2_arg arg2;
- arg2.val1 = 2;
- arg2.val2 = 3;
- arg2.val3 = 4.1;
- double arg3 = 8.1;
- double returnVal = 0;
- void *values[3];
- values[0] = &arg1;
- values[1] = &arg2;
- values[2] = &arg3;
-
- rc = dynFunction_call(dynFunc, fp, &returnVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(2.2, returnVal);
- dynFunction_destroy(dynFunc);
- }
-
- static void test_access_functions(void) {
- dyn_function_type *dynFunc = NULL;
- int rc;
- rc = dynFunction_parseWithStr("add(D{DD a b}*D)V", NULL, &dynFunc);
-
- CHECK_EQUAL(0, rc);
-
- int nrOfArgs = dynFunction_nrOfArguments(dynFunc);
- CHECK_EQUAL(3, nrOfArgs);
-
- dyn_type *arg1 = dynFunction_argumentTypeForIndex(dynFunc, 1);
- CHECK(arg1 != NULL);
- CHECK_EQUAL('{', (char) dynType_descriptorType(arg1));
-
- dyn_type *nonExist = dynFunction_argumentTypeForIndex(dynFunc, 10);
- CHECK(nonExist == NULL);
-
- dyn_type *returnType = dynFunction_returnType(dynFunc);
- CHECK_EQUAL('V', (char) dynType_descriptorType(returnType));
-
- dynFunction_destroy(dynFunc);
- }
-
- //example with gen pointer and output
- #define EXAMPLE3_DESCRIPTOR "example(PD*D)N"
-
- static int testExample3(void *ptr, double a, double *out) {
- double *b = (double *)ptr;
- CHECK_EQUAL(2.0, *b);
- CHECK_EQUAL(a, 2.0);
- *out = *b * a;
- return 0;
- }
-
- static void test_example3(void) {
- dyn_function_type *dynFunc = NULL;
- void (*fp)(void) = (void(*)(void)) testExample3;
- int rc;
-
- rc = dynFunction_parseWithStr(EXAMPLE3_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
- double result = -1.0;
- double *input = &result;
- double a = 2.0;
- void *ptr = &a;
- void *args[3];
- args[0] = &ptr;
- args[1] = &a;
- args[2] = &input;
- int rVal = 0;
- rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(4.0, result);
-
-
- double *inMemResult = (double *)calloc(1, sizeof(double));
- a = 2.0;
- ptr = &a;
- args[0] = &ptr;
- args[1] = &a;
- args[2] = &inMemResult;
- rVal = 0;
- rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(4.0, result);
- free(inMemResult);
-
- dynFunction_destroy(dynFunc);
- }
-
- struct tst_seq {
- uint32_t cap;
- uint32_t len;
- double *buf;
- };
-
- #define EXAMPLE4_DESCRIPTOR "example([D)V"
-
- static void example4Func(struct tst_seq seq) {
- CHECK_EQUAL(4, seq.cap);
- CHECK_EQUAL(2, seq.len);
- CHECK_EQUAL(1.1, seq.buf[0]);
- CHECK_EQUAL(2.2, seq.buf[1]);
- }
-
- static void test_example4(void) {
- dyn_function_type *dynFunc = NULL;
- void (*fp)(void) = (void(*)(void)) example4Func;
- int rc;
-
- rc = dynFunction_parseWithStr(EXAMPLE4_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
-
- double buf[4];
- buf[0] = 1.1;
- buf[1] = 2.2;
- struct tst_seq seq;
- seq.cap = 4;
- seq.len = 2;
- seq.buf = buf;
-
- void *args[1];
- args[0] = &seq;
- rc = dynFunction_call(dynFunc, fp, NULL, args);
- CHECK_EQUAL(0, rc);
-
- dynFunction_destroy(dynFunc);
- }
-
- #define EXAMPLE5_DESCRIPTOR "example(#const=true;tt)V"
-
- static void example5Func(const char *s1, char *s2) {
- STRCMP_EQUAL("s1", s1);
- STRCMP_EQUAL("s2", s2);
- }
-
- static void test_example5(void) {
- dyn_function_type *dynFunc = NULL;
- void (*fp)(void) = (void(*)(void)) example5Func;
- int rc;
-
- rc = dynFunction_parseWithStr(EXAMPLE5_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
-
- const char *a1 = "s1";
- char *a2 = strdup("s2");
- void *args[2];
- args[0] = &a1;
- args[1] = &a2;
-
- rc = dynFunction_call(dynFunc, fp, NULL, args);
- CHECK_EQUAL(0, rc);
-
- dynFunction_destroy(dynFunc);
- free(a2);
- }
-
-
- #define INVALID_FUNC_DESCRIPTOR "example$[D)V"//$ is an invalid symbol, missing (
-
- static void test_invalidDynFunc(void) {
- dyn_function_type *dynFunc = NULL;
- int rc = dynFunction_parseWithStr(INVALID_FUNC_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(2, rc); //Mem error
- }
-
- #define INVALID_FUNC_TYPE_DESCRIPTOR "example(H)A"//H and A are invalid types
-
- static void test_invalidDynFuncType(void) {
- dyn_function_type *dynFunc = NULL;
- int rc = dynFunction_parseWithStr(INVALID_FUNC_TYPE_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(3, rc); //Parse Error
- }
-}
-
-TEST_GROUP(DynFunctionTests) {
- void setup() {
- int lvl = 1;
- dynFunction_logSetup(stdLog, NULL, lvl);
- dynType_logSetup(stdLog, NULL, lvl);
- dynCommon_logSetup(stdLog, NULL, lvl);
- }
-};
-
-TEST(DynFunctionTests, DynFuncTest1) {
- test_example1();
-}
-
-TEST(DynFunctionTests, DynFuncTest2) {
- test_example2();
-}
-
-TEST(DynFunctionTests, DynFuncAccTest) {
- test_access_functions();
-}
-
-TEST(DynFunctionTests, DynFuncTest3) {
- test_example3();
-}
-
-TEST(DynFunctionTests, DynFuncTest4) {
- test_example4();
-}
-
-TEST(DynFunctionTests, DynFuncTest5) {
- test_example5();
-}
-
-TEST(DynFunctionTests, InvalidDynFuncTest) {
- test_invalidDynFunc();
- test_invalidDynFuncType();
-}
-
diff --git a/libs/dfi/test/run_tests.cpp b/libs/dfi/test/run_tests.cpp
deleted file mode 100644
index e6d6133..0000000
--- a/libs/dfi/test/run_tests.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
-
-int main(int argc, char** argv) {
- return RUN_ALL_TESTS(argc, argv);
-}