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/09 19:28:18 UTC
[celix] branch feature/dfi_to_gtest created (now c167d31)
This is an automated email from the ASF dual-hosted git repository.
pnoltes pushed a change to branch feature/dfi_to_gtest
in repository https://gitbox.apache.org/repos/asf/celix.git.
at c167d31 Refactors dfi test from cpputest to google test
This branch includes the following new commits:
new c167d31 Refactors dfi test from cpputest to google test
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[celix] 01/01: Refactors dfi test from cpputest to google test
Posted by pn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
pnoltes pushed a commit to branch feature/dfi_to_gtest
in repository https://gitbox.apache.org/repos/asf/celix.git
commit c167d3194d1136b2512eb0141b44bf83f23bb9c4
Author: Pepijn Noltes <pe...@gmail.com>
AuthorDate: Mon Mar 9 20:26:52 2020 +0100
Refactors dfi test from cpputest to google test
---
libs/dfi/CMakeLists.txt | 27 +-
libs/dfi/gtest/CMakeLists.txt | 41 +++
.../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 | 187 +++++-----
.../src}/dyn_avpr_function_tests.cpp | 171 +++++-----
.../src}/dyn_avpr_interface_tests.cpp | 44 +--
libs/dfi/{test => gtest/src}/dyn_avpr_tests.cpp | 152 +++++----
libs/dfi/{test => gtest/src}/dyn_closure_tests.cpp | 43 +--
.../dfi/{test => gtest/src}/dyn_function_tests.cpp | 103 +++---
.../{test => gtest/src}/dyn_interface_tests.cpp | 65 ++--
libs/dfi/{test => gtest/src}/dyn_message_tests.cpp | 108 +++---
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/test/run_tests.cpp | 25 --
45 files changed, 834 insertions(+), 790 deletions(-)
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..f84fab4
--- /dev/null
+++ b/libs/dfi/gtest/CMakeLists.txt
@@ -0,0 +1,41 @@
+# 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_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..f3dc578 100644
--- a/libs/dfi/test/avrobin_serialization_tests.cpp
+++ b/libs/dfi/gtest/src/avrobin_serialization_tests.cpp
@@ -16,8 +16,8 @@
*specific language governing permissions and limitations
*under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+
+#include "gtest/gtest.h"
extern "C" {
#include "avrobin_serializer.h"
@@ -136,21 +136,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 +172,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 +209,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 +242,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 +274,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 +306,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 +344,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 +391,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 +443,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 +493,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 +530,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 +565,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 +592,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 86%
rename from libs/dfi/test/dyn_avpr_function_tests.cpp
rename to libs/dfi/gtest/src/dyn_avpr_function_tests.cpp
index 30fbf79..735c953 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,9 +624,9 @@ 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);
@@ -637,7 +642,7 @@ static int avpr_example11(void *handle __attribute__((unused)), char *arg1) {
TEST(DynAvprFunctionTests, Example11) {
auto fp = (void(*)()) avpr_example11;
dyn_function_type * dynFunc = dynFunction_parseAvprWithStr(theAvprFile, "test.dt.stringInFunc");
- CHECK(dynFunc != nullptr);
+ ASSERT_TRUE(dynFunc != nullptr);
int handle = 0;
int* handle_ptr = &handle;
@@ -650,8 +655,8 @@ TEST(DynAvprFunctionTests, Example11) {
int rVal = 1;
int rc = dynFunction_call(dynFunc, fp, &rVal, args);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(0, rVal);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(0, rVal);
free(input);
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 85%
rename from libs/dfi/test/dyn_avpr_tests.cpp
rename to libs/dfi/gtest/src/dyn_avpr_tests.cpp
index 4dbd3c4..7f0e9b9 100644
--- a/libs/dfi/test/dyn_avpr_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_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 <stdarg.h>
@@ -41,10 +40,10 @@ extern "C" {
type = dynType_parseAvprWithStr(descriptorStr, exName);
if (type != nullptr) {
- CHECK_EQUAL(expectedType, dynType_type(type));
+ ASSERT_EQ(expectedType, dynType_type(type));
dynType_destroy(type);
} else {
- CHECK_EQUAL(1, 0);
+ ASSERT_EQ(1, 0);
}
}
}
@@ -286,57 +285,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 +350,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 +402,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 +413,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 +422,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 +464,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 +482,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 +506,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 +528,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 +536,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 +560,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 +572,47 @@ 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
}
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..ee51a15 100644
--- a/libs/dfi/test/dyn_closure_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_closure_tests.cpp
@@ -17,8 +17,8 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
+
extern "C" {
@@ -99,12 +99,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 +113,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 +133,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 +146,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/test/dyn_function_tests.cpp b/libs/dfi/gtest/src/dyn_function_tests.cpp
similarity index 78%
rename from libs/dfi/test/dyn_function_tests.cpp
rename to libs/dfi/gtest/src/dyn_function_tests.cpp
index 3073a98..3250487 100644
--- a/libs/dfi/test/dyn_function_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_function_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>
@@ -43,9 +42,9 @@ extern "C" {
#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);
+ EXPECT_EQ(2, a);
+ EXPECT_EQ(4, b);
+ EXPECT_EQ(8, c);
return 1;
}
@@ -55,7 +54,7 @@ extern "C" {
void (*fp)(void) = (void (*)(void)) example1;
rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
int32_t a = 2;
int32_t b = 4;
@@ -67,8 +66,8 @@ extern "C" {
values[2] = &c;
rc = dynFunction_call(dynFunc, fp, &rVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(1, rVal);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(1, rVal);
dynFunction_destroy(dynFunc);
}
@@ -80,11 +79,11 @@ extern "C" {
};
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);
+ 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);
return 2.2;
}
@@ -94,7 +93,7 @@ extern "C" {
void (*fp)(void) = (void (*)(void)) example2;
rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
int32_t arg1 = 2;
struct example2_arg arg2;
@@ -109,8 +108,8 @@ extern "C" {
values[2] = &arg3;
rc = dynFunction_call(dynFunc, fp, &returnVal, values);
- CHECK_EQUAL(0, rc);
- CHECK_EQUAL(2.2, returnVal);
+ ASSERT_EQ(0, rc);
+ ASSERT_EQ(2.2, returnVal);
dynFunction_destroy(dynFunc);
}
@@ -119,20 +118,20 @@ extern "C" {
int rc;
rc = dynFunction_parseWithStr("add(D{DD a b}*D)V", NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
int nrOfArgs = dynFunction_nrOfArguments(dynFunc);
- CHECK_EQUAL(3, nrOfArgs);
+ ASSERT_EQ(3, nrOfArgs);
dyn_type *arg1 = dynFunction_argumentTypeForIndex(dynFunc, 1);
- CHECK(arg1 != NULL);
- CHECK_EQUAL('{', (char) dynType_descriptorType(arg1));
+ ASSERT_TRUE(arg1 != NULL);
+ ASSERT_EQ('{', (char) dynType_descriptorType(arg1));
dyn_type *nonExist = dynFunction_argumentTypeForIndex(dynFunc, 10);
- CHECK(nonExist == NULL);
+ ASSERT_TRUE(nonExist == NULL);
dyn_type *returnType = dynFunction_returnType(dynFunc);
- CHECK_EQUAL('V', (char) dynType_descriptorType(returnType));
+ ASSERT_EQ('V', (char) dynType_descriptorType(returnType));
dynFunction_destroy(dynFunc);
}
@@ -142,8 +141,8 @@ extern "C" {
static int testExample3(void *ptr, double a, double *out) {
double *b = (double *)ptr;
- CHECK_EQUAL(2.0, *b);
- CHECK_EQUAL(a, 2.0);
+ EXPECT_EQ(2.0, *b);
+ EXPECT_EQ(a, 2.0);
*out = *b * a;
return 0;
}
@@ -154,7 +153,7 @@ extern "C" {
int rc;
rc = dynFunction_parseWithStr(EXAMPLE3_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
double result = -1.0;
double *input = &result;
double a = 2.0;
@@ -165,8 +164,8 @@ extern "C" {
args[2] = &input;
int 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);
double *inMemResult = (double *)calloc(1, sizeof(double));
@@ -177,8 +176,8 @@ extern "C" {
args[2] = &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);
@@ -193,10 +192,10 @@ extern "C" {
#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]);
+ ASSERT_EQ(4, seq.cap);
+ ASSERT_EQ(2, seq.len);
+ ASSERT_EQ(1.1, seq.buf[0]);
+ ASSERT_EQ(2.2, seq.buf[1]);
}
static void test_example4(void) {
@@ -205,7 +204,7 @@ extern "C" {
int rc;
rc = dynFunction_parseWithStr(EXAMPLE4_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
double buf[4];
buf[0] = 1.1;
@@ -218,7 +217,7 @@ extern "C" {
void *args[1];
args[0] = &seq;
rc = dynFunction_call(dynFunc, fp, NULL, args);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
dynFunction_destroy(dynFunc);
}
@@ -226,8 +225,8 @@ extern "C" {
#define EXAMPLE5_DESCRIPTOR "example(#const=true;tt)V"
static void example5Func(const char *s1, char *s2) {
- STRCMP_EQUAL("s1", s1);
- STRCMP_EQUAL("s2", s2);
+ ASSERT_STREQ("s1", s1);
+ ASSERT_STREQ("s2", s2);
}
static void test_example5(void) {
@@ -236,7 +235,7 @@ extern "C" {
int rc;
rc = dynFunction_parseWithStr(EXAMPLE5_DESCRIPTOR, NULL, &dynFunc);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
const char *a1 = "s1";
char *a2 = strdup("s2");
@@ -245,7 +244,7 @@ extern "C" {
args[1] = &a2;
rc = dynFunction_call(dynFunc, fp, NULL, args);
- CHECK_EQUAL(0, rc);
+ ASSERT_EQ(0, rc);
dynFunction_destroy(dynFunc);
}
@@ -256,7 +255,7 @@ extern "C" {
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
+ ASSERT_EQ(2, rc); //Mem error
}
#define INVALID_FUNC_TYPE_DESCRIPTOR "example(H)A"//H and A are invalid types
@@ -264,44 +263,48 @@ extern "C" {
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
+ ASSERT_EQ(3, rc); //Parse Error
}
}
-TEST_GROUP(DynFunctionTests) {
- void setup() {
+class DynFunctionTests : public ::testing::Test {
+public:
+ DynFunctionTests() {
int lvl = 1;
dynFunction_logSetup(stdLog, NULL, lvl);
dynType_logSetup(stdLog, NULL, lvl);
dynCommon_logSetup(stdLog, NULL, lvl);
}
+ ~DynFunctionTests() override {
+ }
+
};
-TEST(DynFunctionTests, DynFuncTest1) {
+TEST_F(DynFunctionTests, DynFuncTest1) {
test_example1();
}
-TEST(DynFunctionTests, DynFuncTest2) {
+TEST_F(DynFunctionTests, DynFuncTest2) {
test_example2();
}
-TEST(DynFunctionTests, DynFuncAccTest) {
+TEST_F(DynFunctionTests, DynFuncAccTest) {
test_access_functions();
}
-TEST(DynFunctionTests, DynFuncTest3) {
+TEST_F(DynFunctionTests, DynFuncTest3) {
test_example3();
}
-TEST(DynFunctionTests, DynFuncTest4) {
+TEST_F(DynFunctionTests, DynFuncTest4) {
test_example4();
}
-TEST(DynFunctionTests, DynFuncTest5) {
+TEST_F(DynFunctionTests, DynFuncTest5) {
test_example5();
}
-TEST(DynFunctionTests, InvalidDynFuncTest) {
+TEST_F(DynFunctionTests, InvalidDynFuncTest) {
test_invalidDynFunc();
test_invalidDynFuncType();
}
diff --git a/libs/dfi/test/dyn_interface_tests.cpp b/libs/dfi/gtest/src/dyn_interface_tests.cpp
similarity index 79%
rename from libs/dfi/test/dyn_interface_tests.cpp
rename to libs/dfi/gtest/src/dyn_interface_tests.cpp
index bf78ab9..5aba748 100644
--- a/libs/dfi/test/dyn_interface_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_interface_tests.cpp
@@ -17,8 +17,8 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
+
extern "C" {
#include <stdio.h>
@@ -51,15 +51,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 +69,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 +106,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 +121,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 +130,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 +138,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 +146,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 +154,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 +162,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 +170,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 +178,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..4833fae 100644
--- a/libs/dfi/test/dyn_message_tests.cpp
+++ b/libs/dfi/gtest/src/dyn_message_tests.cpp
@@ -17,8 +17,7 @@
* under the License.
*/
-#include <CppUTest/TestHarness.h>
-#include "CppUTest/CommandLineTestRunner.h"
+#include "gtest/gtest.h"
extern "C" {
@@ -52,15 +51,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 +71,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 +106,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 +140,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 +174,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 +184,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 +222,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/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);
-}