From 5da14042f70711ea5cf66e034699730335462f66 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 5 May 2024 14:08:03 +0200 Subject: Merging upstream version 1.45.3+dfsg. Signed-off-by: Daniel Baumann --- src/fluent-bit/lib/cfl/tests/CMakeLists.txt | 31 + .../lib/cfl/tests/cfl_tests_internal.h.in | 25 + src/fluent-bit/lib/cfl/tests/hash.c | 57 ++ src/fluent-bit/lib/cfl/tests/kv.c | 82 ++ .../lib/cfl/tests/lib/acutest/.travis.yml | 34 + .../lib/cfl/tests/lib/acutest/CMakeLists.txt | 44 ++ src/fluent-bit/lib/cfl/tests/lib/acutest/GIT | 1 + .../lib/cfl/tests/lib/acutest/LICENSE.md | 22 + src/fluent-bit/lib/cfl/tests/lib/acutest/README.md | 4 + .../lib/cfl/tests/lib/acutest/appveyor.yml | 26 + .../lib/cfl/tests/lib/acutest/include/acutest.h | 864 +++++++++++++++++++++ src/fluent-bit/lib/cfl/tests/list.c | 50 ++ src/fluent-bit/lib/cfl/tests/sds.c | 59 ++ src/fluent-bit/lib/cfl/tests/variant.c | 470 +++++++++++ 14 files changed, 1769 insertions(+) create mode 100644 src/fluent-bit/lib/cfl/tests/CMakeLists.txt create mode 100644 src/fluent-bit/lib/cfl/tests/cfl_tests_internal.h.in create mode 100644 src/fluent-bit/lib/cfl/tests/hash.c create mode 100644 src/fluent-bit/lib/cfl/tests/kv.c create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/.travis.yml create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/CMakeLists.txt create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/GIT create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/LICENSE.md create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/README.md create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/appveyor.yml create mode 100644 src/fluent-bit/lib/cfl/tests/lib/acutest/include/acutest.h create mode 100644 src/fluent-bit/lib/cfl/tests/list.c create mode 100644 src/fluent-bit/lib/cfl/tests/sds.c create mode 100644 src/fluent-bit/lib/cfl/tests/variant.c (limited to 'src/fluent-bit/lib/cfl/tests') diff --git a/src/fluent-bit/lib/cfl/tests/CMakeLists.txt b/src/fluent-bit/lib/cfl/tests/CMakeLists.txt new file mode 100644 index 000000000..0fac328ca --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/CMakeLists.txt @@ -0,0 +1,31 @@ +include_directories(lib/acutest) + +set(UNIT_TESTS_FILES + kv.c + sds.c + hash.c + list.c + variant.c + ) + +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cfl_tests_internal.h.in" + "${CMAKE_CURRENT_SOURCE_DIR}/cfl_tests_internal.h" + ) + +# Prepare list of unit tests +foreach(source_file ${UNIT_TESTS_FILES}) + get_filename_component(source_file_we ${source_file} NAME_WE) + set(source_file_we cfl-test-${source_file_we}) + add_executable( + ${source_file_we} + ${source_file} + ) + target_link_libraries(${source_file_we} cfl-static) + + if (CFL_SANITIZE_ADDRESS) + add_sanitizers(${source_file_we}) + endif() + + add_test(${source_file_we} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${source_file_we}) +endforeach() diff --git a/src/fluent-bit/lib/cfl/tests/cfl_tests_internal.h.in b/src/fluent-bit/lib/cfl/tests/cfl_tests_internal.h.in new file mode 100644 index 000000000..b14ef0121 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/cfl_tests_internal.h.in @@ -0,0 +1,25 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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. + */ + +#ifndef CFL_TEST_INTERNAL_H +#define CFL_TEST_INTERNAL_H + +#include "lib/acutest/include/acutest.h" + +#endif diff --git a/src/fluent-bit/lib/cfl/tests/hash.c b/src/fluent-bit/lib/cfl/tests/hash.c new file mode 100644 index 000000000..afc7311f6 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/hash.c @@ -0,0 +1,57 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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 + +#include "cfl_tests_internal.h" + +static void checks() +{ + int len; + uint64_t cfl_hash; + uint64_t xxh_hash; + XXH3_state_t xxh_state; + cfl_hash_state_t cfl_state; + char *str = "this is a test"; + + len = strlen(str); + + /* a dummy test, we just need to make sure the wrapper is working */ + cfl_hash = cfl_hash_64bits(str, len); + xxh_hash = XXH3_64bits(str, len); + TEST_CHECK(cfl_hash == xxh_hash); + + /* state and updates */ + cfl_hash_64bits_reset(&cfl_state); + cfl_hash_64bits_update(&cfl_state, str, len); + cfl_hash_64bits_update(&cfl_state, str, len); + cfl_hash = cfl_hash_64bits_digest(&cfl_state); + + XXH3_64bits_reset(&xxh_state); + XXH3_64bits_update(&xxh_state, str, len); + XXH3_64bits_update(&xxh_state, str, len); + xxh_hash = XXH3_64bits_digest(&xxh_state); + + TEST_CHECK(cfl_hash == xxh_hash); +} + +TEST_LIST = { + {"checks", checks}, + { 0 } +}; diff --git a/src/fluent-bit/lib/cfl/tests/kv.c b/src/fluent-bit/lib/cfl/tests/kv.c new file mode 100644 index 000000000..f49ade9d6 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/kv.c @@ -0,0 +1,82 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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 + +#include "cfl_tests_internal.h" + + +static void regular_operation() +{ + struct cfl_list *entry_iterator; + size_t entry_index; + struct cfl_list entry_list; + struct cfl_kv *entry; + + cfl_kv_init(&entry_list); + + entry = cfl_kv_item_create(&entry_list, "first entry", "dummy value"); + TEST_CHECK(entry != NULL); + + entry = cfl_kv_item_create(&entry_list, "second entry", NULL); + TEST_CHECK(entry != NULL); + + entry = cfl_kv_item_create(&entry_list, NULL, NULL); + TEST_CHECK(entry == NULL); + + entry = cfl_kv_item_create_len(&entry_list, "third entry", 0, "dummy value", 12); + TEST_CHECK(entry != NULL); + + entry = cfl_kv_item_create_len(&entry_list, "fourth entry", 13, "dummy value", 0); + TEST_CHECK(entry != NULL); + + entry_index = 0; + + cfl_list_foreach(entry_iterator, &entry_list) { + entry = cfl_list_entry(entry_iterator, struct cfl_kv, _head); + + switch (entry_index) { + case 0: + TEST_CHECK(strcmp(entry->key, "first entry") == 0); + TEST_CHECK(strcmp(entry->val, "dummy value") == 0); + break; + case 1: + TEST_CHECK(strcmp(entry->key, "second entry") == 0); + TEST_CHECK(entry->val == NULL); + break; + case 2: + TEST_CHECK(strlen(entry->key) == 0); + TEST_CHECK(strcmp(entry->val, "dummy value") == 0); + break; + case 3: + TEST_CHECK(strcmp(entry->key, "fourth entry") == 0); + TEST_CHECK(entry->val == NULL); + break; + } + + entry_index++; + } + + cfl_kv_release(&entry_list); +} + +TEST_LIST = { + {"regular_operation", regular_operation}, + { 0 } +}; diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/.travis.yml b/src/fluent-bit/lib/cfl/tests/lib/acutest/.travis.yml new file mode 100644 index 000000000..920821985 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/.travis.yml @@ -0,0 +1,34 @@ +# YAML definition for travis-ci.com continuous integration. +# See https://docs.travis-ci.com/user/languages/c + +# Container-based infrastructure (Linux) +# * https://docs.travis-ci.com/user/migrating-from-legacy/#How-can-I-use-container-based-infrastructure%3F +sudo: +- false + +language: c++ + +compiler: + - gcc + - clang + +env: + - CFLAGS="-std=c99 -pedantic" CONFIG=Debug # C99 + - CFLAGS="-std=c99 -pedantic" CONFIG=Release + - CFLAGS="-std=c11 -pedantic" CONFIG=Debug # C11 + - CFLAGS="-std=c11 -pedantic" CONFIG=Release + - CXXFLAGS="-std=c++11 -pedantic" CONFIG=Debug # C++11 + - CXXFLAGS="-std=c++11 -pedantic" CONFIG=Release + # Too old compilers on travis-ci.org for these: + #- CXXFLAGS="-std=c++14 -pedantic" CONFIG=Debug # C++14 + #- CXXFLAGS="-std=c++14 -pedantic" CONFIG=Release + #- CXXFLAGS="-std=c++17 -pedantic" CONFIG=Debug # C++17 + #- CXXFLAGS="-std=c++17 -pedantic" CONFIG=Release + +before_script: + - mkdir build + - cd build + - cmake -DCMAKE_BUILD_TYPE=$CONFIG -G 'Unix Makefiles' .. + +script: + - make VERBOSE=1 diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/CMakeLists.txt b/src/fluent-bit/lib/cfl/tests/lib/acutest/CMakeLists.txt new file mode 100644 index 000000000..4a741a424 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/CMakeLists.txt @@ -0,0 +1,44 @@ + +cmake_minimum_required(VERSION 2.8) +project(Acutest C CXX) + + +set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo MinSizeRel) +if("${CMAKE_BUILD_TYPE}" STREQUAL "") + set(CMAKE_BUILD_TYPE $ENV{CMAKE_BUILD_TYPE}) + + if("${CMAKE_BUILD_TYPE}" STREQUAL "") + set(CMAKE_BUILD_TYPE "Release") + endif() +endif() + + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + + +if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra") +elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra") +elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC") + # Specify proper C runtime library: + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd") + set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE} /MT") + set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_RELEASE} /MT") +endif() + +if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") +elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") +elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + # Specify proper C runtime library: + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} /MT") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_RELEASE} /MT") +endif() + + +add_subdirectory(examples) diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/GIT b/src/fluent-bit/lib/cfl/tests/lib/acutest/GIT new file mode 100644 index 000000000..379ff1483 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/GIT @@ -0,0 +1 @@ +03885e23ea27535251b91abf681257d3d4241eae (git master) \ No newline at end of file diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/LICENSE.md b/src/fluent-bit/lib/cfl/tests/lib/acutest/LICENSE.md new file mode 100644 index 000000000..973092017 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/LICENSE.md @@ -0,0 +1,22 @@ + +# The MIT License (MIT) + +Copyright © 2013-2017 Martin Mitáš + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the “Software”), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/README.md b/src/fluent-bit/lib/cfl/tests/lib/acutest/README.md new file mode 100644 index 000000000..e7f75b652 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/README.md @@ -0,0 +1,4 @@ +Taken from https://github.com/mity/acutest + +MIT License + diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/appveyor.yml b/src/fluent-bit/lib/cfl/tests/lib/acutest/appveyor.yml new file mode 100644 index 000000000..6e85c7a00 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/appveyor.yml @@ -0,0 +1,26 @@ +# YAML definition for Appveyor.com continuous integration. +# See http://www.appveyor.com/docs/appveyor-yml + +version: '{branch}-{build}' + +before_build: + - 'cmake --version' + - 'if "%PLATFORM%"=="x64" cmake -G "Visual Studio 12 Win64"' + - 'if not "%PLATFORM%"=="x64" cmake -G "Visual Studio 12"' + +build: + project: Acutest.sln + verbosity: minimal + +skip_tags: true + +os: + - Windows Server 2012 R2 + +configuration: + - Debug + - Release + +platform: + - x64 # 64-bit build + - win32 # 32-bit build diff --git a/src/fluent-bit/lib/cfl/tests/lib/acutest/include/acutest.h b/src/fluent-bit/lib/cfl/tests/lib/acutest/include/acutest.h new file mode 100644 index 000000000..cd5ffb2c7 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/lib/acutest/include/acutest.h @@ -0,0 +1,864 @@ +/* + * Acutest -- Another C/C++ Unit Test facility + * + * + * Copyright (c) 2013-2017 Martin Mitas + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef ACUTEST_H__ +#define ACUTEST_H__ + + +/************************ + *** Public interface *** + ************************/ + +/* By default, "acutest.h" provides the main program entry point (function + * main()). However, if the test suite is composed of multiple source files + * which include "acutest.h", then this causes a problem of multiple main() + * definitions. To avoid this problem, #define macro TEST_NO_MAIN in all + * compilation units but one. + */ + +/* Macro to specify list of unit tests in the suite. + * The unit test implementation MUST provide list of unit tests it implements + * with this macro: + * + * TEST_LIST = { + * { "test1_name", test1_func_ptr }, + * { "test2_name", test2_func_ptr }, + * ... + * { 0 } + * }; + * + * The list specifies names of each test (must be unique) and pointer to + * a function implementing it. The function does not take any arguments + * and has no return values, i.e. every test function has to be compatible + * with this prototype: + * + * void test_func(void); + */ +#define TEST_LIST const struct test__ test_list__[] + + +/* Macros for testing whether an unit test succeeds or fails. These macros + * can be used arbitrarily in functions implementing the unit tests. + * + * If any condition fails throughout execution of a test, the test fails. + * + * TEST_CHECK takes only one argument (the condition), TEST_CHECK_ allows + * also to specify an error message to print out if the condition fails. + * (It expects printf-like format string and its parameters). The macros + * return non-zero (condition passes) or 0 (condition fails). + * + * That can be useful when more conditions should be checked only if some + * preceding condition passes, as illustrated in this code snippet: + * + * SomeStruct* ptr = allocate_some_struct(); + * if(TEST_CHECK(ptr != NULL)) { + * TEST_CHECK(ptr->member1 < 100); + * TEST_CHECK(ptr->member2 > 200); + * } + */ +#define TEST_CHECK_(cond,...) test_check__((cond), __FILE__, __LINE__, __VA_ARGS__) +#define TEST_CHECK(cond) test_check__((cond), __FILE__, __LINE__, "%s", #cond) + + +/* printf-like macro for outputting an extra information about a failure. + * + * Note it does not output anything if there was not (yet) failed condition + * in the current test. Intended use is to output some computed output + * versus the expected value, e.g. like this: + * + * if(!TEST_CHECK(produced == expected)) { + * TEST_MSG("Expected: %d", expected); + * TEST_MSG("Produced: %d", produced); + * } + * + * The macro can deal with multi-line output fairly well. It also automatically + * adds a final new-line if there is none present. + */ +#define TEST_MSG(...) test_message__(__VA_ARGS__) + +/* Maximal output per TEST_MSG call. Longer messages are cut. + * You may define another limit prior including "acutest.h" + */ +#ifndef TEST_MSG_MAXSIZE + #define TEST_MSG_MAXSIZE 1024 +#endif + + +/********************** + *** Implementation *** + **********************/ + +/* The unit test files should not rely on anything below. */ + +#include +#include +#include +#include + +#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__) + #define ACUTEST_UNIX__ 1 + #include + #include + #include + #include + #include +#endif + +#if defined(__gnu_linux__) + #define ACUTEST_LINUX__ 1 + #include + #include +#endif + +#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__) + #define ACUTEST_WIN__ 1 + #include + #include +#endif + +#ifdef __cplusplus + #include +#endif + + +/* Note our global private identifiers end with '__' to mitigate risk of clash + * with the unit tests implementation. */ + + +#ifdef __cplusplus + extern "C" { +#endif + + +struct test__ { + const char* name; + void (*func)(void); +}; + +extern const struct test__ test_list__[]; + +int test_check__(int cond, const char* file, int line, const char* fmt, ...); +void test_message__(const char* fmt, ...); + + +#ifndef TEST_NO_MAIN + +static char* test_argv0__ = NULL; +static size_t test_list_size__ = 0; +static const struct test__** tests__ = NULL; +static char* test_flags__ = NULL; +static size_t test_count__ = 0; +static int test_no_exec__ = -1; +static int test_no_summary__ = 0; +static int test_skip_mode__ = 0; + +static int test_stat_failed_units__ = 0; +static int test_stat_run_units__ = 0; + +static const struct test__* test_current_unit__ = NULL; +static int test_current_already_logged__ = 0; +static int test_verbose_level__ = 2; +static int test_current_failures__ = 0; +static int test_colorize__ = 0; + +#define TEST_COLOR_DEFAULT__ 0 +#define TEST_COLOR_GREEN__ 1 +#define TEST_COLOR_RED__ 2 +#define TEST_COLOR_DEFAULT_INTENSIVE__ 3 +#define TEST_COLOR_GREEN_INTENSIVE__ 4 +#define TEST_COLOR_RED_INTENSIVE__ 5 + +static int +test_print_in_color__(int color, const char* fmt, ...) +{ + va_list args; + char buffer[256]; + int n; + + va_start(args, fmt); + vsnprintf(buffer, sizeof(buffer), fmt, args); + va_end(args); + buffer[sizeof(buffer)-1] = '\0'; + + if(!test_colorize__) { + return printf("%s", buffer); + } + +#if defined ACUTEST_UNIX__ + { + const char* col_str; + switch(color) { + case TEST_COLOR_GREEN__: col_str = "\033[0;32m"; break; + case TEST_COLOR_RED__: col_str = "\033[0;31m"; break; + case TEST_COLOR_GREEN_INTENSIVE__: col_str = "\033[1;32m"; break; + case TEST_COLOR_RED_INTENSIVE__: col_str = "\033[1;31m"; break; + case TEST_COLOR_DEFAULT_INTENSIVE__: col_str = "\033[1m"; break; + default: col_str = "\033[0m"; break; + } + printf("%s", col_str); + n = printf("%s", buffer); + printf("\033[0m"); + return n; + } +#elif defined ACUTEST_WIN__ + { + HANDLE h; + CONSOLE_SCREEN_BUFFER_INFO info; + WORD attr; + + h = GetStdHandle(STD_OUTPUT_HANDLE); + GetConsoleScreenBufferInfo(h, &info); + + switch(color) { + case TEST_COLOR_GREEN__: attr = FOREGROUND_GREEN; break; + case TEST_COLOR_RED__: attr = FOREGROUND_RED; break; + case TEST_COLOR_GREEN_INTENSIVE__: attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break; + case TEST_COLOR_RED_INTENSIVE__: attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break; + case TEST_COLOR_DEFAULT_INTENSIVE__: attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY; break; + default: attr = 0; break; + } + if(attr != 0) + SetConsoleTextAttribute(h, attr); + n = printf("%s", buffer); + SetConsoleTextAttribute(h, info.wAttributes); + return n; + } +#else + n = printf("%s", buffer); + return n; +#endif +} + +int +test_check__(int cond, const char* file, int line, const char* fmt, ...) +{ + const char *result_str; + int result_color; + int verbose_level; + + if(cond) { + result_str = "ok"; + result_color = TEST_COLOR_GREEN__; + verbose_level = 3; + } else { + if(!test_current_already_logged__ && test_current_unit__ != NULL) { + printf("[ "); + test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED"); + printf(" ]\n"); + } + result_str = "failed"; + result_color = TEST_COLOR_RED__; + verbose_level = 2; + test_current_failures__++; + test_current_already_logged__++; + } + + if(test_verbose_level__ >= verbose_level) { + va_list args; + + printf(" "); + + if(file != NULL) { + if(test_verbose_level__ < 3) { +#ifdef ACUTEST_WIN__ + const char* lastsep1 = strrchr(file, '\\'); + const char* lastsep2 = strrchr(file, '/'); + if(lastsep1 == NULL) + lastsep1 = file-1; + if(lastsep2 == NULL) + lastsep2 = file-1; + file = (lastsep1 > lastsep2 ? lastsep1 : lastsep2) + 1; +#else + const char* lastsep = strrchr(file, '/'); + if(lastsep != NULL) + file = lastsep+1; +#endif + } + printf("%s:%d: Check ", file, line); + } + + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + + printf("... "); + test_print_in_color__(result_color, result_str); + printf("\n"); + test_current_already_logged__++; + } + + return (cond != 0); +} + +void +test_message__(const char* fmt, ...) +{ + char buffer[TEST_MSG_MAXSIZE]; + char* line_beg; + char* line_end; + va_list args; + + if(test_verbose_level__ < 2) + return; + + /* We allow extra message only when something is already wrong in the + * current test. */ + if(!test_current_already_logged__ || test_current_unit__ == NULL) + return; + + va_start(args, fmt); + vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args); + va_end(args); + buffer[TEST_MSG_MAXSIZE-1] = '\0'; + + line_beg = buffer; + while(1) { + line_end = strchr(line_beg, '\n'); + if(line_end == NULL) + break; + printf(" %.*s\n", (int)(line_end - line_beg), line_beg); + line_beg = line_end + 1; + } + if(line_beg[0] != '\0') + printf(" %s\n", line_beg); +} + +static void +test_list_names__(void) +{ + const struct test__* test; + + printf("Unit tests:\n"); + for(test = &test_list__[0]; test->func != NULL; test++) + printf(" %s\n", test->name); +} + +static void +test_remember__(int i) +{ + if(test_flags__[i]) + return; + else + test_flags__[i] = 1; + + tests__[test_count__] = &test_list__[i]; + test_count__++; +} + +static int +test_name_contains_word__(const char* name, const char* pattern) +{ + static const char word_delim[] = " \t-_."; + const char* substr; + size_t pattern_len; + int starts_on_word_boundary; + int ends_on_word_boundary; + + pattern_len = strlen(pattern); + + substr = strstr(name, pattern); + while(substr != NULL) { + starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL); + ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL); + + if(starts_on_word_boundary && ends_on_word_boundary) + return 1; + + substr = strstr(substr+1, pattern); + } + + return 0; +} + +static int +test_lookup__(const char* pattern) +{ + int i; + int n = 0; + + /* Try exact match. */ + for(i = 0; i < (int) test_list_size__; i++) { + if(strcmp(test_list__[i].name, pattern) == 0) { + test_remember__(i); + n++; + break; + } + } + if(n > 0) + return n; + + /* Try word match. */ + for(i = 0; i < (int) test_list_size__; i++) { + if(test_name_contains_word__(test_list__[i].name, pattern)) { + test_remember__(i); + n++; + } + } + if(n > 0) + return n; + + /* Try relaxed match. */ + for(i = 0; i < (int) test_list_size__; i++) { + if(strstr(test_list__[i].name, pattern) != NULL) { + test_remember__(i); + n++; + } + } + + return n; +} + +/* Call directly the given test unit function. */ +static int +test_do_run__(const struct test__* test) +{ + test_current_unit__ = test; + test_current_failures__ = 0; + test_current_already_logged__ = 0; + + if(test_verbose_level__ >= 3) { + test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n", test->name); + test_current_already_logged__++; + } else if(test_verbose_level__ >= 1) { + int n; + char spaces[48]; + + n = test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s... ", test->name); + memset(spaces, ' ', sizeof(spaces)); + if(n < (int) sizeof(spaces)) + printf("%.*s", (int) sizeof(spaces) - n, spaces); + } else { + test_current_already_logged__ = 1; + } + +#ifdef __cplusplus + try { +#endif + + /* This is good to do for case the test unit e.g. crashes. */ + fflush(stdout); + fflush(stderr); + + test->func(); + +#ifdef __cplusplus + } catch(std::exception& e) { + const char* what = e.what(); + if(what != NULL) + test_check__(0, NULL, 0, "Threw std::exception: %s", what); + else + test_check__(0, NULL, 0, "Threw std::exception"); + } catch(...) { + test_check__(0, NULL, 0, "Threw an exception"); + } +#endif + + if(test_verbose_level__ >= 3) { + switch(test_current_failures__) { + case 0: test_print_in_color__(TEST_COLOR_GREEN_INTENSIVE__, " All conditions have passed.\n\n"); break; + case 1: test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, " One condition has FAILED.\n\n"); break; + default: test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, " %d conditions have FAILED.\n\n", test_current_failures__); break; + } + } else if(test_verbose_level__ >= 1 && test_current_failures__ == 0) { + printf("[ "); + test_print_in_color__(TEST_COLOR_GREEN_INTENSIVE__, "OK"); + printf(" ]\n"); + } + + test_current_unit__ = NULL; + return (test_current_failures__ == 0) ? 0 : -1; +} + +#if defined(ACUTEST_UNIX__) || defined(ACUTEST_WIN__) +/* Called if anything goes bad in Acutest, or if the unit test ends in other + * way then by normal returning from its function (e.g. exception or some + * abnormal child process termination). */ +static void +test_error__(const char* fmt, ...) +{ + va_list args; + + if(test_verbose_level__ == 0) + return; + + if(test_verbose_level__ <= 2 && !test_current_already_logged__ && test_current_unit__ != NULL) { + printf("[ "); + test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED"); + printf(" ]\n"); + } + + if(test_verbose_level__ >= 2) { + test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, " Error: "); + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + printf("\n"); + } +} +#endif + +/* Trigger the unit test. If possible (and not suppressed) it starts a child + * process who calls test_do_run__(), otherwise it calls test_do_run__() + * directly. */ +static void +test_run__(const struct test__* test) +{ + int failed = 1; + + test_current_unit__ = test; + test_current_already_logged__ = 0; + + if(!test_no_exec__) { + +#if defined(ACUTEST_UNIX__) + + pid_t pid; + int exit_code; + + pid = fork(); + if(pid == (pid_t)-1) { + test_error__("Cannot fork. %s [%d]", strerror(errno), errno); + failed = 1; + } else if(pid == 0) { + /* Child: Do the test. */ + failed = (test_do_run__(test) != 0); + exit(failed ? 1 : 0); + } else { + /* Parent: Wait until child terminates and analyze its exit code. */ + waitpid(pid, &exit_code, 0); + if(WIFEXITED(exit_code)) { + switch(WEXITSTATUS(exit_code)) { + case 0: failed = 0; break; /* test has passed. */ + case 1: /* noop */ break; /* "normal" failure. */ + default: test_error__("Unexpected exit code [%d]", WEXITSTATUS(exit_code)); + } + } else if(WIFSIGNALED(exit_code)) { + char tmp[32]; + const char* signame; + switch(WTERMSIG(exit_code)) { + case SIGINT: signame = "SIGINT"; break; + case SIGHUP: signame = "SIGHUP"; break; + case SIGQUIT: signame = "SIGQUIT"; break; + case SIGABRT: signame = "SIGABRT"; break; + case SIGKILL: signame = "SIGKILL"; break; + case SIGSEGV: signame = "SIGSEGV"; break; + case SIGILL: signame = "SIGILL"; break; + case SIGTERM: signame = "SIGTERM"; break; + default: sprintf(tmp, "signal %d", WTERMSIG(exit_code)); signame = tmp; break; + } + test_error__("Test interrupted by %s", signame); + } else { + test_error__("Test ended in an unexpected way [%d]", exit_code); + } + } + +#elif defined(ACUTEST_WIN__) + + char buffer[512] = {0}; + STARTUPINFOA startupInfo; + PROCESS_INFORMATION processInfo; + DWORD exitCode; + + /* Windows has no fork(). So we propagate all info into the child + * through a command line arguments. */ + _snprintf(buffer, sizeof(buffer)-1, + "%s --no-exec --no-summary --verbose=%d --color=%s -- \"%s\"", + test_argv0__, test_verbose_level__, + test_colorize__ ? "always" : "never", test->name); + memset(&startupInfo, 0, sizeof(startupInfo)); + startupInfo.cb = sizeof(STARTUPINFO); + if(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo)) { + WaitForSingleObject(processInfo.hProcess, INFINITE); + GetExitCodeProcess(processInfo.hProcess, &exitCode); + CloseHandle(processInfo.hThread); + CloseHandle(processInfo.hProcess); + failed = (exitCode != 0); + } else { + test_error__("Cannot create unit test subprocess [%ld].", GetLastError()); + failed = 1; + } + +#else + + /* A platform where we don't know how to run child process. */ + failed = (test_do_run__(test) != 0); + +#endif + + } else { + /* Child processes suppressed through --no-exec. */ + failed = (test_do_run__(test) != 0); + } + + test_current_unit__ = NULL; + + test_stat_run_units__++; + if(failed) + test_stat_failed_units__++; +} + +#if defined(ACUTEST_WIN__) +/* Callback for SEH events. */ +static LONG CALLBACK +test_exception_filter__(EXCEPTION_POINTERS *ptrs) +{ + test_error__("Unhandled SEH exception %08lx at %p.", + ptrs->ExceptionRecord->ExceptionCode, + ptrs->ExceptionRecord->ExceptionAddress); + fflush(stdout); + fflush(stderr); + return EXCEPTION_EXECUTE_HANDLER; +} +#endif + + +static void +test_help__(void) +{ + printf("Usage: %s [options] [test...]\n", test_argv0__); + printf("Run the specified unit tests; or if the option '--skip' is used, run all\n"); + printf("tests in the suite but those listed. By default, if no tests are specified\n"); + printf("on the command line, all unit tests in the suite are run.\n"); + printf("\n"); + printf("Options:\n"); + printf(" -s, --skip Execute all unit tests but the listed ones\n"); + printf(" --exec=WHEN If supported, execute unit tests as child processes\n"); + printf(" (WHEN is one of 'auto', 'always', 'never')\n"); + printf(" -E, --no-exec Same as --exec=never\n"); + printf(" --no-summary Suppress printing of test results summary\n"); + printf(" -l, --list List unit tests in the suite and exit\n"); + printf(" -v, --verbose Enable more verbose output\n"); + printf(" --verbose=LEVEL Set verbose level to LEVEL:\n"); + printf(" 0 ... Be silent\n"); + printf(" 1 ... Output one line per test (and summary)\n"); + printf(" 2 ... As 1 and failed conditions (this is default)\n"); + printf(" 3 ... As 1 and all conditions (and extended summary)\n"); + printf(" --color=WHEN Enable colorized output\n"); + printf(" (WHEN is one of 'auto', 'always', 'never')\n"); + printf(" -h, --help Display this help and exit\n"); + + if(test_list_size__ < 16) { + printf("\n"); + test_list_names__(); + } +} + +#ifdef ACUTEST_LINUX__ +static int +test_is_tracer_present__(void) +{ + char buf[256+32+1]; + int tracer_present = 0; + int fd; + ssize_t n_read; + + fd = open("/proc/self/status", O_RDONLY); + if(fd == -1) + return 0; + + n_read = read(fd, buf, sizeof(buf)-1); + while(n_read > 0) { + static const char pattern[] = "TracerPid:"; + const char* field; + + buf[n_read] = '\0'; + field = strstr(buf, pattern); + if(field != NULL && field < buf + sizeof(buf) - 32) { + pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1); + tracer_present = (tracer_pid != 0); + break; + } + + if(n_read == sizeof(buf)-1) { + memmove(buf, buf + sizeof(buf)-1 - 32, 32); + n_read = read(fd, buf+32, sizeof(buf)-1-32); + if(n_read > 0) + n_read += 32; + } + } + + close(fd); + return tracer_present; +} +#endif + +int +main(int argc, char** argv) +{ + int i; + int seen_double_dash = 0; + + test_argv0__ = argv[0]; + +#if defined ACUTEST_UNIX__ + test_colorize__ = isatty(STDOUT_FILENO); +#elif defined ACUTEST_WIN__ + #if defined __BORLANDC__ + test_colorize__ = isatty(_fileno(stdout)); + #else + test_colorize__ = _isatty(_fileno(stdout)); + #endif +#else + test_colorize__ = 0; +#endif + + /* Count all test units */ + test_list_size__ = 0; + for(i = 0; test_list__[i].func != NULL; i++) + test_list_size__++; + + tests__ = (const struct test__**) malloc(sizeof(const struct test__*) * test_list_size__); + test_flags__ = (char*) malloc(sizeof(char) * test_list_size__); + if(tests__ == NULL || test_flags__ == NULL) { + fprintf(stderr, "Out of memory.\n"); + exit(2); + } + memset((void*) test_flags__, 0, sizeof(char) * test_list_size__); + + /* Parse options */ + for(i = 1; i < argc; i++) { + if(seen_double_dash || argv[i][0] != '-') { + if(test_lookup__(argv[i]) == 0) { + fprintf(stderr, "%s: Unrecognized unit test '%s'\n", argv[0], argv[i]); + fprintf(stderr, "Try '%s --list' for list of unit tests.\n", argv[0]); + exit(2); + } + } else if(strcmp(argv[i], "--") == 0) { + seen_double_dash = 1; + } else if(strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { + test_help__(); + exit(0); + } else if(strcmp(argv[i], "--verbose") == 0 || strcmp(argv[i], "-v") == 0) { + test_verbose_level__++; + } else if(strncmp(argv[i], "--verbose=", 10) == 0) { + test_verbose_level__ = atoi(argv[i] + 10); + } else if(strcmp(argv[i], "--color=auto") == 0) { + /* noop (set from above) */ + } else if(strcmp(argv[i], "--color=always") == 0 || strcmp(argv[i], "--color") == 0) { + test_colorize__ = 1; + } else if(strcmp(argv[i], "--color=never") == 0 || strcmp(argv[i], "--no-color") == 0) { + test_colorize__ = 0; + } else if(strcmp(argv[i], "--skip") == 0 || strcmp(argv[i], "-s") == 0) { + test_skip_mode__ = 1; + } else if(strcmp(argv[i], "--exec=auto") == 0) { + /* noop (set from above) */ + } else if(strcmp(argv[i], "--exec=always") == 0 || strcmp(argv[i], "--exec") == 0) { + test_no_exec__ = 0; + } else if(strcmp(argv[i], "--exec=never") == 0 || strcmp(argv[i], "--no-exec") == 0 || strcmp(argv[i], "-E") == 0) { + test_no_exec__ = 1; + } else if(strcmp(argv[i], "--no-summary") == 0) { + test_no_summary__ = 1; + } else if(strcmp(argv[i], "--list") == 0 || strcmp(argv[i], "-l") == 0) { + test_list_names__(); + exit(0); + } else { + fprintf(stderr, "%s: Unrecognized option '%s'\n", argv[0], argv[i]); + fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]); + exit(2); + } + } + +#if defined(ACUTEST_WIN__) + SetUnhandledExceptionFilter(test_exception_filter__); +#endif + + /* By default, we want to run all tests. */ + if(test_count__ == 0) { + for(i = 0; test_list__[i].func != NULL; i++) + tests__[i] = &test_list__[i]; + test_count__ = test_list_size__; + } + + /* Guess whether we want to run unit tests as child processes. */ + if(test_no_exec__ < 0) { + test_no_exec__ = 0; + + if(test_count__ <= 1) { + test_no_exec__ = 1; + } else { +#ifdef ACUTEST_WIN__ + if(IsDebuggerPresent()) + test_no_exec__ = 1; +#endif +#ifdef ACUTEST_LINUX__ + if(test_is_tracer_present__()) + test_no_exec__ = 1; +#endif + } + } + + /* Run the tests */ + if(!test_skip_mode__) { + /* Run the listed tests. */ + for(i = 0; i < (int) test_count__; i++) + test_run__(tests__[i]); + } else { + /* Run all tests except those listed. */ + for(i = 0; test_list__[i].func != NULL; i++) { + if(!test_flags__[i]) + test_run__(&test_list__[i]); + } + } + + /* Write a summary */ + if(!test_no_summary__ && test_verbose_level__ >= 1) { + if(test_verbose_level__ >= 3) { + test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Summary:\n"); + + printf(" Count of all unit tests: %4d\n", (int) test_list_size__); + printf(" Count of run unit tests: %4d\n", test_stat_run_units__); + printf(" Count of failed unit tests: %4d\n", test_stat_failed_units__); + printf(" Count of skipped unit tests: %4d\n", (int) test_list_size__ - test_stat_run_units__); + printf(" "); + } + + if(test_stat_failed_units__ == 0) { + test_print_in_color__(TEST_COLOR_GREEN_INTENSIVE__, "SUCCESS:"); + printf(" All unit tests have passed.\n"); + } else { + test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "FAILED:"); + printf(" %d of %d unit tests have failed.\n", + test_stat_failed_units__, test_stat_run_units__); + } + + if(test_verbose_level__ >= 3) + printf("\n"); + } + + free((void*) tests__); + free((void*) test_flags__); + + return (test_stat_failed_units__ == 0) ? 0 : 1; +} + + +#endif /* #ifndef TEST_NO_MAIN */ + +#ifdef __cplusplus + } /* extern "C" */ +#endif + + +#endif /* #ifndef ACUTEST_H__ */ diff --git a/src/fluent-bit/lib/cfl/tests/list.c b/src/fluent-bit/lib/cfl/tests/list.c new file mode 100644 index 000000000..0c12f888f --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/list.c @@ -0,0 +1,50 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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 + +#include "cfl_tests_internal.h" + +struct test { + struct cfl_list _head; +}; + +static void checks() +{ + struct test *t; + struct cfl_list list; + + cfl_list_init(&list); + TEST_CHECK(cfl_list_is_empty(&list)); + + t = malloc(sizeof(struct test)); + cfl_list_add(&t->_head, &list); + TEST_CHECK(!cfl_list_is_empty(&list)); + + cfl_list_del(&t->_head); + TEST_CHECK(cfl_list_is_empty(&list)); + + free(t); +} + +TEST_LIST = { + {"checks", checks}, + { 0 } +}; + diff --git a/src/fluent-bit/lib/cfl/tests/sds.c b/src/fluent-bit/lib/cfl/tests/sds.c new file mode 100644 index 000000000..899725e16 --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/sds.c @@ -0,0 +1,59 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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 +#include "cfl_tests_internal.h" + +static void test_sds_usage() +{ + cfl_sds_t s; + + s = cfl_sds_create("test"); + TEST_CHECK(s != NULL); + TEST_CHECK(cfl_sds_len(s) == 4); + TEST_CHECK(cfl_sds_alloc(s) == 4); + TEST_CHECK(strcmp("test", s) == 0); + + s = cfl_sds_cat(s, ",cat message", 12); + TEST_CHECK(strcmp("test,cat message", s) == 0); + + cfl_sds_destroy(s); +} + +static void test_sds_printf() +{ + int len; + cfl_sds_t s; + cfl_sds_t tmp; + char *str = "0123456789ABCDEFGHIJQLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvewxyz"; + + s = cfl_sds_create_size(10); + tmp = cfl_sds_printf(&s, "%s=%s", str, str); + + len = (strlen(str) * 2) + 1; + TEST_CHECK(tmp == s); + TEST_CHECK(cfl_sds_len(s) == len); + cfl_sds_destroy(s); +} + +TEST_LIST = { + { "sds_usage" , test_sds_usage}, + { "sds_printf", test_sds_printf}, + { 0 } +}; diff --git a/src/fluent-bit/lib/cfl/tests/variant.c b/src/fluent-bit/lib/cfl/tests/variant.c new file mode 100644 index 000000000..83dcb33aa --- /dev/null +++ b/src/fluent-bit/lib/cfl/tests/variant.c @@ -0,0 +1,470 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* CFL + * === + * Copyright (C) 2022 The CFL Authors + * + * Licensed 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 +#include +#include +#include + +#include "cfl_tests_internal.h" + +static int compare(FILE *fp, char *expect, int ignore_len) +{ + int ret; + size_t len = strlen(expect); + size_t ret_fp; + char buf[1024] = {0}; + + ret = fseek(fp, 0, SEEK_SET); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("fseek failed"); + return ret; + } + + ret_fp = fread(&buf[0], 1, sizeof(buf), fp); + if (ret_fp == 0) { + if (!TEST_CHECK(feof(fp) == 0)) { + TEST_MSG("fread error."); + return -1; + } + } + if (ignore_len) { + if (!TEST_CHECK(strstr(&buf[0], expect) != NULL)) { + TEST_MSG("compare error. got=%s expect=%s", &buf[0], expect); + return -1; + } + + } else { + if (!TEST_CHECK(strlen(buf) == len)) { + TEST_MSG("length error. len=%d got=%s expect=%s", strlen(buf), &buf[0], expect); + return -1; + } + if (!TEST_CHECK(strncmp(expect, &buf[0], len) == 0)) { + TEST_MSG("compare error. got=%s expect=%s", &buf[0], expect); + return -1; + } + } + return 0; +} + +static void test_variant_print_bool() +{ + int ret; + int i; + int inputs[] = {CFL_TRUE, CFL_FALSE}; + char *expects[] = {"true", "false"}; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + for (i=0; i 0)) { + TEST_MSG("%d:cfl_variant_print failed", i); + cfl_variant_destroy(val); + fclose(fp); + continue; + } + ret = compare(fp, expects[i], 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("%d:compare failed", i); + } + cfl_variant_destroy(val); + fclose(fp); + } +} + +static void test_variant_print_array() +{ + int ret; + int i; + int64_t inputs[] = {1, 0, -123}; + char *expect = {"[1,0,-123]"}; + + FILE *fp = NULL; + struct cfl_array *array = NULL; + struct cfl_variant *val = NULL; + + fp = tmpfile(); + if (!TEST_CHECK(fp != NULL)) { + TEST_MSG("fp is NULL"); + exit(1); + } + + array = cfl_array_create(sizeof(inputs)/sizeof(int64_t)); + if (!TEST_CHECK(array != NULL)) { + TEST_MSG("cfl_array_create failed"); + fclose(fp); + exit(1); + } + + + for (i=0; i 0)) { + TEST_MSG("cfl_variant_print failed"); + cfl_variant_destroy(val); + fclose(fp); + exit(1); + } + ret = compare(fp, expect, 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("compare failed"); + } + cfl_variant_destroy(val); + fclose(fp); +} + +static void test_variant_print_kvlist() +{ + int ret; + int i; + char *key_inputs[] = {"key", "key2", "aaa"}; + int64_t val_inputs[] = {1, 0, -123}; + char *expect = {"{\"key\":1,\"key2\":0,\"aaa\":-123}"}; + + FILE *fp = NULL; + struct cfl_kvlist *list = NULL; + struct cfl_variant *val = NULL; + + if (!TEST_CHECK(sizeof(key_inputs)/sizeof(char*) == sizeof(val_inputs)/sizeof(int64_t))) { + TEST_MSG("key val array size mismatch. key_len=%d val_len=%d", + sizeof(key_inputs)/sizeof(char*), + sizeof(val_inputs)/sizeof(int64_t)); + exit(1); + } + + fp = tmpfile(); + if (!TEST_CHECK(fp != NULL)) { + TEST_MSG("fp is NULL"); + exit(1); + } + + list = cfl_kvlist_create(); + if (!TEST_CHECK(list != NULL)) { + TEST_MSG("cfl_kvlist_create failed"); + fclose(fp); + exit(1); + } + + for (i=0; i 0)) { + TEST_MSG("cfl_variant_print failed"); + cfl_variant_destroy(val); + fclose(fp); + exit(1); + } + ret = compare(fp, expect, 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("compare failed"); + } + cfl_variant_destroy(val); + fclose(fp); +} + +static void test_variant_print_double() +{ + int ret; + int i; + double inputs[] = {1.0, -12.3}; + char *expects[] = {"1.0", "-12.3"}; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + for (i=0; i 0)) { + TEST_MSG("%d:cfl_variant_print failed", i); + cfl_variant_destroy(val); + fclose(fp); + continue; + } + ret = compare(fp, expects[i], 1); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("%d:compare failed", i); + } + cfl_variant_destroy(val); + fclose(fp); + } +} + +static void test_variant_print_string() +{ + int ret; + int i; + char *inputs[] = {"hoge", "aaa"}; + char *expects[] = {"\"hoge\"", "\"aaa\""}; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + for (i=0; i 0)) { + TEST_MSG("%d:cfl_variant_print failed", i); + cfl_variant_destroy(val); + fclose(fp); + continue; + } + ret = compare(fp, expects[i], 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("%d:compare failed", i); + } + cfl_variant_destroy(val); + fclose(fp); + } +} + +static void test_variant_print_bytes() +{ + int ret; + char input[] = {0x1f, 0xaa, 0x0a, 0xff}; + char *expect = "1faa0aff"; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + fp = tmpfile(); + if (!TEST_CHECK(fp != NULL)) { + TEST_MSG("fp is NULL"); + exit(1); + } + + val = cfl_variant_create_from_bytes(input, 4); + if (!TEST_CHECK(val != NULL)) { + TEST_MSG("cfl_variant_create_from_bytes failed"); + fclose(fp); + exit(1); + } + + ret = cfl_variant_print(fp, val); + if (!TEST_CHECK(ret > 0)) { + TEST_MSG("cfl_variant_print failed"); + cfl_variant_destroy(val); + fclose(fp); + exit(1); + } + ret = compare(fp, expect, 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("compare failed"); + } + cfl_variant_destroy(val); + fclose(fp); +} + + +static void test_variant_print_reference() +{ + int ret; + int *input = (int*)0x12345678; + char expect[] = "0x12345678"; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + fp = tmpfile(); + if (!TEST_CHECK(fp != NULL)) { + TEST_MSG("fp is NULL"); + exit(1); + } + + val = cfl_variant_create_from_reference(input); + if (!TEST_CHECK(val != NULL)) { + TEST_MSG("cfl_variant_create_from_reference failed"); + fclose(fp); + exit(1); + } + + ret = cfl_variant_print(fp, val); + if (!TEST_CHECK(ret > 0)) { + TEST_MSG("cfl_variant_print failed"); + fclose(fp); + cfl_variant_destroy(val); + exit(1); + } + ret = compare(fp, &expect[0], 0); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("compare failed"); + } + cfl_variant_destroy(val); + fclose(fp); +} + +static void test_variant_print_unknown() +{ + int ret; + char expect[] = "Unknown"; + + FILE *fp = NULL; + struct cfl_variant *val = NULL; + + fp = tmpfile(); + if (!TEST_CHECK(fp != NULL)) { + TEST_MSG("fp is NULL"); + exit(1); + } + + val = cfl_variant_create(); + if (!TEST_CHECK(val != NULL)) { + TEST_MSG("cfl_variant_create failed"); + fclose(fp); + exit(1); + } + + ret = cfl_variant_print(fp, val); + if (!TEST_CHECK(ret != EOF)) { + TEST_MSG("cfl_variant_print failed"); + fclose(fp); + cfl_variant_destroy(val); + exit(1); + } + ret = compare(fp, &expect[0], 1); + if (!TEST_CHECK(ret == 0)) { + TEST_MSG("compare failed"); + } + cfl_variant_destroy(val); + fclose(fp); +} + +TEST_LIST = { + {"variant_print_bool", test_variant_print_bool}, + {"variant_print_int64", test_variant_print_int64}, + {"variant_print_double", test_variant_print_double}, + {"variant_print_string", test_variant_print_string}, + {"variant_print_bytes", test_variant_print_bytes}, + {"variant_print_array", test_variant_print_array}, + {"variant_print_kvlist", test_variant_print_kvlist}, + {"variant_print_reference", test_variant_print_reference}, + {"variant_print_unknown", test_variant_print_unknown}, + { 0 } +}; -- cgit v1.2.3