Introduced own scripted test framework to replace fct.h and reduce
compile time
The new test framework generates a data file parsing engine plus the
templated function code. In order to 'understand' defines, during
the generation phase, a mapping is made to check for dependencies and
result code mappings.
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 17d31e9..2bd41c0 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -20,9 +20,9 @@
add_custom_command(
OUTPUT test_suite_${data_name}.c
COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate_code.pl ${CMAKE_CURRENT_SOURCE_DIR}/suites test_suite_${suite_name} test_suite_${data_name}
- DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate_code.pl polarssl fct.h suites/helpers.function suites/test_suite_${suite_name}.function suites/test_suite_${data_name}.data
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate_code.pl polarssl suites/helpers.function suites/main_test.function suites/test_suite_${suite_name}.function suites/test_suite_${data_name}.data
)
-
+
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
add_executable(test_suite_${data_name} test_suite_${data_name}.c)
target_link_libraries(test_suite_${data_name} ${libs})
diff --git a/tests/Makefile b/tests/Makefile
index b78062c..b2a5fe6 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -54,71 +54,71 @@
all: $(APPS)
-test_suite_aes.ecb.c : suites/test_suite_aes.function suites/test_suite_aes.ecb.data scripts/generate_code.pl suites/helpers.function
+test_suite_aes.ecb.c : suites/test_suite_aes.function suites/test_suite_aes.ecb.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_aes test_suite_aes.ecb
-test_suite_aes.cbc.c : suites/test_suite_aes.function suites/test_suite_aes.cbc.data scripts/generate_code.pl suites/helpers.function
+test_suite_aes.cbc.c : suites/test_suite_aes.function suites/test_suite_aes.cbc.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_aes test_suite_aes.cbc
-test_suite_aes.cfb.c : suites/test_suite_aes.function suites/test_suite_aes.cfb.data scripts/generate_code.pl suites/helpers.function
+test_suite_aes.cfb.c : suites/test_suite_aes.function suites/test_suite_aes.cfb.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_aes test_suite_aes.cfb
-test_suite_aes.rest.c : suites/test_suite_aes.function suites/test_suite_aes.rest.data scripts/generate_code.pl suites/helpers.function
+test_suite_aes.rest.c : suites/test_suite_aes.function suites/test_suite_aes.rest.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_aes test_suite_aes.rest
-test_suite_cipher.aes.c : suites/test_suite_cipher.function suites/test_suite_cipher.aes.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.aes.c : suites/test_suite_cipher.function suites/test_suite_cipher.aes.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.aes
-test_suite_cipher.blowfish.c : suites/test_suite_cipher.function suites/test_suite_cipher.blowfish.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.blowfish.c : suites/test_suite_cipher.function suites/test_suite_cipher.blowfish.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.blowfish
-test_suite_cipher.camellia.c : suites/test_suite_cipher.function suites/test_suite_cipher.camellia.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.camellia.c : suites/test_suite_cipher.function suites/test_suite_cipher.camellia.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.camellia
-test_suite_cipher.des.c : suites/test_suite_cipher.function suites/test_suite_cipher.des.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.des.c : suites/test_suite_cipher.function suites/test_suite_cipher.des.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.des
-test_suite_cipher.null.c : suites/test_suite_cipher.function suites/test_suite_cipher.null.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.null.c : suites/test_suite_cipher.function suites/test_suite_cipher.null.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.null
-test_suite_cipher.padding.c : suites/test_suite_cipher.function suites/test_suite_cipher.padding.data scripts/generate_code.pl suites/helpers.function
+test_suite_cipher.padding.c : suites/test_suite_cipher.function suites/test_suite_cipher.padding.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_cipher test_suite_cipher.padding
-test_suite_gcm.decrypt_128.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_128.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.decrypt_128.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_128.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.decrypt_128
-test_suite_gcm.decrypt_192.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_192.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.decrypt_192.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_192.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.decrypt_192
-test_suite_gcm.decrypt_256.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_256.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.decrypt_256.c : suites/test_suite_gcm.function suites/test_suite_gcm.decrypt_256.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.decrypt_256
-test_suite_gcm.encrypt_128.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_128.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.encrypt_128.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_128.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.encrypt_128
-test_suite_gcm.encrypt_192.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_192.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.encrypt_192.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_192.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.encrypt_192
-test_suite_gcm.encrypt_256.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_256.data scripts/generate_code.pl suites/helpers.function
+test_suite_gcm.encrypt_256.c : suites/test_suite_gcm.function suites/test_suite_gcm.encrypt_256.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites test_suite_gcm test_suite_gcm.encrypt_256
-%.c : suites/%.function suites/%.data scripts/generate_code.pl suites/helpers.function
+%.c : suites/%.function suites/%.data scripts/generate_code.pl suites/helpers.function suites/main_test.function
echo " Generate $@"
scripts/generate_code.pl suites $* $*
diff --git a/tests/fct.h b/tests/fct.h
deleted file mode 100644
index 78bc27b..0000000
--- a/tests/fct.h
+++ /dev/null
@@ -1,3959 +0,0 @@
-/*
-====================================================================
-Copyright (c) 2008 Ian Blumel. All rights reserved.
-
-FCTX (Fast C Test) Unit Testing Framework
-
-Copyright (c) 2008, Ian Blumel (ian.blumel@gmail.com)
-All rights reserved.
-
-This license is based on the BSD License.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
-
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the
- distribution.
-
- * Neither the name of, Ian Blumel, nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-====================================================================
-
-File: fct.h
-*/
-
-#if !defined(FCT_INCLUDED__IMB)
-#define FCT_INCLUDED__IMB
-
-/* Configuration Values. You can over-ride these values in your own
-header, then include this header. For example, in your file, myfct.h,
-
- #define FCT_DEFAULT_LOGGER "standard"
- #include "fct.h"
-
-then if your unit tests included, myfct.h, you would default to work
-with a standard logger. */
-
-#if !defined(FCT_DEFAULT_LOGGER)
-# define FCT_DEFAULT_LOGGER "standard"
-#endif /* !FCT_DEFAULT_LOGGER */
-
-#define FCT_VERSION_MAJOR 1
-#define FCT_VERSION_MINOR 6
-#define FCT_VERSION_MICRO 1
-
-#define _FCT_QUOTEME(x) #x
-#define FCT_QUOTEME(x) _FCT_QUOTEME(x)
-
-#define FCT_VERSION_STR (FCT_QUOTEME(FCT_VERSION_MAJOR) "."\
- FCT_QUOTEME(FCT_VERSION_MINOR) "."\
- FCT_QUOTEME(FCT_VERSION_MICRO))
-
-#include <string.h>
-#include <assert.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-#include <float.h>
-#include <math.h>
-#include <ctype.h>
-
-#define FCT_MAX_NAME 256
-#define FCT_MAX_LOG_LINE 256
-
-#define nbool_t int
-#define FCT_TRUE 1
-#define FCT_FALSE 0
-
-#define FCTMIN(x, y) ( x < y) ? (x) : (y)
-
-#ifndef __INTEL_COMPILER
-/* Use regular assertions for non-Intel compilers */
-#define FCT_ASSERT(expr) assert(expr)
-#else
-/* Silence Intel warnings on assert(expr && "str") or assert("str") */
-#define FCT_ASSERT(expr) do { \
- _Pragma("warning(push,disable:279)"); \
- assert(expr); \
- _Pragma("warning(pop)"); \
- } while (0)
-#endif
-
-#if defined(__cplusplus)
-#define FCT_EXTERN_C extern "C"
-#else
-#define FCT_EXTERN_C
-#endif
-
-/* Forward declarations. The following forward declarations are required
-because there is a inter-relationship between certain objects that
-just can not be untwined. */
-typedef struct _fct_logger_evt_t fct_logger_evt_t;
-typedef struct _fct_logger_i fct_logger_i;
-typedef struct _fct_logger_types_t fct_logger_types_t;
-typedef struct _fct_standard_logger_t fct_standard_logger_t;
-typedef struct _fct_junit_logger_t fct_junit_logger_t;
-typedef struct _fct_minimal_logger_t fct_minimal_logger_t;
-typedef struct _fctchk_t fctchk_t;
-typedef struct _fct_test_t fct_test_t;
-typedef struct _fct_ts_t fct_ts_t;
-typedef struct _fctkern_t fctkern_t;
-
-/* Forward declare some functions used throughout. */
-static fct_logger_i*
-fct_standard_logger_new(void);
-
-static fct_logger_i*
-fct_minimal_logger_new(void);
-
-static fct_junit_logger_t *
-fct_junit_logger_new(void);
-
-static void
-fct_logger__del(fct_logger_i *logger);
-
-static void
-fct_logger__on_chk(fct_logger_i *self, fctchk_t const *chk);
-
-static void
-fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test);
-
-static void
-fct_logger__on_test_end(fct_logger_i *logger, fct_test_t *test);
-
-static void
-fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts);
-
-static void
-fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts);
-
-static void
-fct_logger__on_test_suite_skip(
- fct_logger_i *logger,
- char const *condition,
- char const *name
-);
-
-static void
-fct_logger__on_test_skip(
- fct_logger_i *logger,
- char const *condition,
- char const *name
-);
-
-
-static void
-fct_logger__on_warn(fct_logger_i *logger, char const *warn);
-
-
-
-/* Explicitly indicate a no-op */
-#define fct_pass()
-
-#define fct_unused(x) (void)(x)
-
-/* This is just a little trick to let me put comments inside of macros. I
-really only want to bother with this when we are "unwinding" the macros
-for debugging purposes. */
-#if defined(FCT_CONF_UNWIND)
-# define _fct_cmt(string) {char*_=string;}
-#else
-# define _fct_cmt(string)
-#endif
-
-/*
---------------------------------------------------------
-UTILITIES
---------------------------------------------------------
-*/
-
-
-/* STDIO and STDERR redirect support */
-#define FCT_PIPE_RESERVE_BYTES_DEFAULT 512
-static int fct_stdout_pipe[2];
-static int fct_stderr_pipe[2];
-static int fct_saved_stdout;
-static int fct_saved_stderr;
-
-/* Platform indepedent pipe functions. TODO: Look to figure this out in a way
-that follows the ISO C++ conformant naming convention. */
-#if defined(WIN32)
-# include <io.h>
-# include <fcntl.h>
-# define _fct_pipe(_PFDS_) \
- _pipe((_PFDS_), FCT_PIPE_RESERVE_BYTES_DEFAULT, _O_TEXT)
-# define _fct_dup _dup
-# define _fct_dup2 _dup2
-# define _fct_close _close
-# define _fct_read _read
-/* Until I can figure a better way to do this, rely on magic numbers. */
-# define STDOUT_FILENO 1
-# define STDERR_FILENO 2
-#else
-# include <unistd.h>
-# define _fct_pipe pipe
-# define _fct_dup dup
-# define _fct_dup2 dup2
-# define _fct_close close
-# define _fct_read read
-#endif /* WIN32 */
-
-
-
-
-static void
-fct_switch_std_to_buffer(int std_pipe[2], FILE *out, int fileno_, int *save_handle)
-{
- fflush(out);
- *save_handle = _fct_dup(fileno_);
- if ( _fct_pipe(std_pipe) != 0 )
- {
- exit(1);
- }
- _fct_dup2(std_pipe[1], fileno_);
- _fct_close(std_pipe[1]);
-}
-
-
-static void
-fct_switch_std_to_std(FILE *out, int fileno_, int save_handle)
-{
- fflush(out);
- _fct_dup2(save_handle, fileno_);
-}
-
-
-#define FCT_SWITCH_STDOUT_TO_BUFFER() \
- fct_switch_std_to_buffer(fct_stdout_pipe, stdout, STDOUT_FILENO, &fct_saved_stdout)
-#define FCT_SWITCH_STDOUT_TO_STDOUT() \
- fct_switch_std_to_std(stdout, STDOUT_FILENO, fct_saved_stdout)
-#define FCT_SWITCH_STDERR_TO_BUFFER() \
- fct_switch_std_to_buffer(fct_stderr_pipe, stderr, STDERR_FILENO, &fct_saved_stderr)
-#define FCT_SWITCH_STDERR_TO_STDERR() \
- fct_switch_std_to_std(stderr, STDERR_FILENO, fct_saved_stderr)
-
-
-/* Utility for truncated, safe string copies. The NUM
-should be the length of DST plus the null-termintor. */
-static void
-fctstr_safe_cpy(char *dst, char const *src, size_t num)
-{
- FCT_ASSERT( dst != NULL );
- FCT_ASSERT( src != NULL );
- FCT_ASSERT( num > 0 );
-#if defined(WIN32) && _MSC_VER >= 1400
- strncpy_s(dst, num, src, _TRUNCATE);
-#else
- strncpy(dst, src, num);
-#endif
- dst[num-1] = '\0';
-}
-
-/* Isolate the vsnprintf implementation */
-static int
-fct_vsnprintf(char *buffer,
- size_t buffer_len,
- char const *format,
- va_list args)
-{
- int count =0;
- /* Older microsoft compilers where not ANSI compliant with this
- function and you had to use _vsnprintf. I will assume that newer
- Microsoft Compilers start implementing vsnprintf. */
-#if defined(_MSC_VER) && (_MSC_VER < 1400)
- count = _vsnprintf(buffer, buffer_len, format, args);
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
- count = vsnprintf_s(buffer, buffer_len, _TRUNCATE, format, args);
-#else
- count = vsnprintf(buffer, buffer_len, format, args);
-#endif
- return count;
-}
-
-
-/* Isolate the snprintf implemenation. */
-static int
-fct_snprintf(char *buffer, size_t buffer_len, char const *format, ...)
-{
- int count =0;
- va_list args;
- va_start(args, format);
- count =fct_vsnprintf(buffer, buffer_len, format, args);
- va_end(args);
- return count;
-}
-
-
-/* Helper to for cloning strings on the heap. Returns NULL for
-an out of memory condition. */
-static char*
-fctstr_clone(char const *s)
-{
- char *k =NULL;
- size_t klen =0;
- FCT_ASSERT( s != NULL && "invalid arg");
- klen = strlen(s)+1;
- k = (char*)malloc(sizeof(char)*klen+1);
- fctstr_safe_cpy(k, s, klen);
- return k;
-}
-
-
-/* Clones and returns a lower case version of the original string. */
-static char*
-fctstr_clone_lower(char const *s)
-{
- char *k =NULL;
- size_t klen =0;
- size_t i;
- if ( s == NULL )
- {
- return NULL;
- }
- klen = strlen(s)+1;
- k = (char*)malloc(sizeof(char)*klen+1);
- for ( i=0; i != klen; ++i )
- {
- k[i] = (char)tolower((int)s[i]);
- }
- return k;
-}
-
-
-/* A very, very simple "filter". This just compares the supplied prefix
-against the test_str, to see if they both have the same starting
-characters. If they do we return true, otherwise we return false. If the
-prefix is a blank string or NULL, then it will return FCT_TRUE.*/
-static nbool_t
-fct_filter_pass(char const *prefix, char const *test_str)
-{
- nbool_t is_match = FCT_FALSE;
- char const *prefix_p;
- char const *test_str_p;
-
- /* If you got nothing to test against, why test? */
- FCT_ASSERT( test_str != NULL );
-
- /* When the prefix is NULL or blank, we always return FCT_TRUE. */
- if ( prefix == NULL || prefix[0] == '\0' )
- {
- return FCT_TRUE;
- }
-
- /* Iterate through both character arrays at the same time. We are
- going to play a game and see if we can beat the house. */
- for ( prefix_p = prefix, test_str_p = test_str;
- *prefix_p != '\0' && *test_str_p != '\0';
- ++prefix_p, ++test_str_p )
- {
- is_match = *prefix_p == *test_str_p;
- if ( !is_match )
- {
- break; /* Quit the first time we don't match. */
- }
- }
-
- /* If the iterator for the test_str is pointing at the null char, and
- the iterator for the prefix string is not, then the prefix string is
- larger than the actual test string, and therefore we failed to pass the
- filter. */
- if ( *test_str_p == '\0' && *prefix_p != '\0' )
- {
- return FCT_FALSE;
- }
-
- /* is_match will be set to the either FCT_TRUE if we kicked of the loop
- early because our filter ran out of characters or FCT_FALSE if we
- encountered a mismatch before our filter ran out of characters. */
- return is_match;
-}
-
-
-/* Routine checks if two strings are equal. Taken from
-http://publications.gbdirect.co.uk/c_book/chapter5/character_handling.html
-*/
-static int
-fctstr_eq(char const *s1, char const *s2)
-{
- if ( s1 == s2 )
- {
- return 1;
- }
- if ( (s1 == NULL && s2 != NULL)
- || (s1 != NULL && s2 == NULL) )
- {
- return 0;
- }
- while (*s1 == *s2)
- {
- if (*s1 == '\0')
- return 1;
- s1++;
- s2++;
- }
- /* Difference detected! */
- return 0;
-}
-
-
-static int
-fctstr_ieq(char const *s1, char const *s2)
-{
- if ( s1 == s2 )
- {
- return 1;
- }
- if ( (s1 == NULL && s2 != NULL)
- || (s1 != NULL && s2 == NULL) )
- {
- return 0;
- }
- while (tolower((int)*s1) == tolower((int)*s2))
- {
- if (*s1 == '\0')
- return 1;
- s1++;
- s2++;
- }
- /* Difference detected! */
- return 0;
-}
-
-
-/* Returns 1 if the STR contains the CHECK_INCL substring. NULL's
-are handled, and NULL always INCLUDES NULL. This check is case
-sensitive. If two strings point to the same place they are
-included. */
-static int
-fctstr_incl(char const *str, char const *check_incl)
-{
- static char const *blank_s = "";
- char const *found = NULL;
- if ( str == NULL )
- {
- str = blank_s;
- }
- if ( check_incl == NULL )
- {
- check_incl = blank_s;
- }
- if ( str == check_incl )
- {
- return 1;
- }
- found = strstr(str, check_incl);
- return found != NULL;
-}
-
-
-/* Does a case insensitive include check. */
-static int
-fctstr_iincl(char const *str, char const *check_incl)
-{
- /* Going to do this with a memory allocation to save coding
- time. In the future this can be rewritten. Both clone_lower
- and _incl are NULL tolerant. */
- char *lstr = fctstr_clone_lower(str);
- char *lcheck_incl = fctstr_clone_lower(check_incl);
- int found = fctstr_incl(lstr, lcheck_incl);
- free(lstr);
- free(lcheck_incl);
- return found;
-}
-
-
-/* Returns true if STR starts with CHECK. NULL and NULL is consider
-true. */
-static int
-fctstr_startswith(char const *str, char const *check)
-{
- char const *sp;
- if ( str == NULL && check == NULL )
- {
- return 1;
- }
- else if ( ((str == NULL) && (check != NULL))
- || ((str != NULL) && (check == NULL)) )
- {
- return 0;
- }
- sp = strstr(str, check);
- return sp == str;
-}
-
-
-/* Case insenstive variant of fctstr_startswith. */
-static int
-fctstr_istartswith(char const *str, char const *check)
-{
- /* Taking the lazy approach for now. */
- char *istr = fctstr_clone_lower(str);
- char *icheck = fctstr_clone_lower(check);
- /* TODO: check for memory. */
- int startswith = fctstr_startswith(istr, icheck);
- free(istr);
- free(icheck);
- return startswith;
-}
-
-
-/* Returns true if the given string ends with the given
-check. Treats NULL as a blank string, and as such, will
-pass the ends with (a blank string endswith a blank string). */
-static int
-fctstr_endswith(char const *str, char const *check)
-{
- size_t check_i;
- size_t str_i;
- if ( str == NULL && check == NULL )
- {
- return 1;
- }
- else if ( ((str == NULL) && (check != NULL))
- || ((str != NULL) && (check == NULL)) )
- {
- return 0;
- }
- check_i = strlen(check);
- str_i = strlen(str);
- if ( str_i < check_i )
- {
- return 0; /* Can't do it string is too small. */
- }
- for ( ; check_i != 0; --check_i, --str_i)
- {
- if ( str[str_i] != check[check_i] )
- {
- return 0; /* Found a case where they are not equal. */
- }
- }
- /* Exahausted check against string, can only be true. */
- return 1;
-}
-
-
-static int
-fctstr_iendswith(char const *str, char const *check)
-{
- size_t check_i;
- size_t str_i;
- if ( str == NULL && check == NULL )
- {
- return 1;
- }
- else if ( ((str == NULL) && (check != NULL))
- || ((str != NULL) && (check == NULL)) )
- {
- return 0;
- }
- check_i = strlen(check);
- str_i = strlen(str);
- if ( str_i < check_i )
- {
- return 0; /* Can't do it string is too small. */
- }
- for ( ; check_i != 0; --check_i, --str_i)
- {
- if ( tolower((int)str[str_i]) != tolower((int)check[check_i]) )
- {
- return 0; /* Found a case where they are not equal. */
- }
- }
- /* Exahausted check against string, can only be true. */
- return 1;
-}
-
-
-/* Use this with the _end variant to get the
-
-STARTSWITH ........................................ END
-
-effect. Assumes that the line will be maxwidth in characters. The
-maxwidth can't be greater than FCT_DOTTED_MAX_LEN. */
-#define FCT_DOTTED_MAX_LEN 256
-static void
-fct_dotted_line_start(size_t maxwidth, char const *startwith)
-{
- char line[FCT_DOTTED_MAX_LEN];
- size_t len =0;
- size_t line_len =0;
-
- memset(line, '.', sizeof(char)*maxwidth);
- len = strlen(startwith);
- line_len = FCTMIN(maxwidth-1, len);
- memcpy(line, startwith, sizeof(char)*line_len);
- if ( len < maxwidth-1)
- {
- line[len] = ' ';
- }
- line[maxwidth-1] = '\0';
- fputs(line, stdout);
-}
-
-
-static void
-fct_dotted_line_end(char const *endswith)
-{
- printf(" %s\n", endswith);
-}
-
-
-/*
---------------------------------------------------------
-TIMER
---------------------------------------------------------
-This is a low-res implementation at the moment.
-
-We will improve this in the future, and isolate the
-implementation from the rest of the code.
-*/
-
-typedef struct _fct_timer_t fct_timer_t;
-struct _fct_timer_t
-{
- clock_t start;
- clock_t stop;
- double duration;
-};
-
-
-static void
-fct_timer__init(fct_timer_t *timer)
-{
- FCT_ASSERT(timer != NULL);
- memset(timer, 0, sizeof(fct_timer_t));
-}
-
-
-static void
-fct_timer__start(fct_timer_t *timer)
-{
- FCT_ASSERT(timer != NULL);
- timer->start = clock();
-}
-
-
-static void
-fct_timer__stop(fct_timer_t *timer)
-{
- FCT_ASSERT(timer != NULL);
- timer->stop = clock();
- timer->duration = (double) (timer->stop - timer->start) / CLOCKS_PER_SEC;
-}
-
-
-/* Returns the time in seconds. */
-static double
-fct_timer__duration(fct_timer_t const *timer)
-{
- FCT_ASSERT( timer != NULL );
- return timer->duration;
-}
-
-
-/*
---------------------------------------------------------
-GENERIC LIST
---------------------------------------------------------
-*/
-
-/* For now we will just keep it at a linear growth rate. */
-#define FCT_LIST_GROWTH_FACTOR 2
-
-/* Starting size for the list, to keep it simple we will start
-at a reasonable size. */
-#define FCT_LIST_DEFAULT_START_SZ 8
-
-/* Helper macros for quickly iterating through a list. You should be able
-to do something like,
-
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, my_list)
- {
- fct_logger__on_blah(logger);
- }
- FCT_NLIST_FOREACH_END();
-
-*/
-#define FCT_NLIST_FOREACH_BGN(Type, Var, List)\
-{\
- if ( List != NULL ) {\
- size_t item_i##Var;\
- size_t num_items##Var = fct_nlist__size(List);\
- for( item_i##Var =0; item_i##Var != num_items##Var; ++item_i##Var )\
- {\
- Type Var = (Type) fct_nlist__at((List), item_i##Var);
-
-#define FCT_NLIST_FOREACH_END() }}}
-
-/* Used to manage a list of loggers. This works mostly like
-the STL vector, where the array grows as more items are
-appended. */
-typedef struct _fct_nlist_t fct_nlist_t;
-struct _fct_nlist_t
-{
- /* Item's are stored as pointers to void. */
- void **itm_list;
-
- /* Indicates the number of element's in the array. */
- size_t avail_itm_num;
-
- /* Indicates the number of actually elements in the array. */
- size_t used_itm_num;
-};
-typedef void (*fct_nlist_on_del_t)(void*);
-
-
-/* Clears the contents of the list, and sets the list count to 0. The
-actual count remains unchanged. If on_del is supplied it is executed
-against each list element. */
-static void
-fct_nlist__clear(fct_nlist_t *list, fct_nlist_on_del_t on_del)
-{
- size_t itm_i__ =0;
- FCT_ASSERT( list != NULL );
- if ( on_del != NULL )
- {
- for ( itm_i__=0; itm_i__ != list->used_itm_num; ++itm_i__ )
- {
- on_del(list->itm_list[itm_i__]);
- }
- }
- list->used_itm_num =0;
-}
-
-
-/* If you used init, then close with final. This is useful for
-working with structures that live on the stack. */
-static void
-fct_nlist__final(fct_nlist_t *list, fct_nlist_on_del_t on_del)
-{
- FCT_ASSERT( list != NULL );
- fct_nlist__clear(list, on_del);
- free(list->itm_list);
-}
-
-
-static int
-fct_nlist__init2(fct_nlist_t *list, size_t start_sz)
-{
- FCT_ASSERT( list != NULL );
- if ( start_sz == 0 )
- {
- list->itm_list = NULL;
- }
- else
- {
- list->itm_list = (void**)malloc(sizeof(void*)*start_sz);
- if ( list->itm_list == NULL )
- {
- return 0;
- }
- }
- /* If these are both 0, then they are equal and that means
- that the first append operation will allocate memory. The beauty
- here is that if the list remains empty, then we save a malloc.
- Empty lists are relatively common in FCT (consider an error list). */
- list->avail_itm_num = start_sz;
- list->used_itm_num =0;
- return 1;
-}
-
-
-/* Initializes a list. Useful for populating existing structures.
-Returns 0 if there was an error allocating memory. Returns 1 otherwise. */
-#define fct_nlist__init(_LIST_PTR_) \
- (fct_nlist__init2((_LIST_PTR_), FCT_LIST_DEFAULT_START_SZ))
-
-
-/* Returns the number of elements within the list. */
-static size_t
-fct_nlist__size(fct_nlist_t const *list)
-{
- FCT_ASSERT( list != NULL );
- return list->used_itm_num;
-}
-
-
-/* Returns the item at idx, asserts otherwise. */
-static void*
-fct_nlist__at(fct_nlist_t const *list, size_t idx)
-{
- FCT_ASSERT( list != NULL );
- FCT_ASSERT( idx < list->used_itm_num );
- return list->itm_list[idx];
-}
-
-
-static void
-fct_nlist__append(fct_nlist_t *list, void *itm)
-{
- FCT_ASSERT( list != NULL );
- /* If we ran out of room, then the last increment should be equal to the
- available space, in this case we need to grow a little more. If this
- list started as size 0, then we should encounter the same effect as
- "running out of room." */
- if ( list->used_itm_num == list->avail_itm_num )
- {
- /* Use multiple and add, since the avail_itm_num could be 0. */
- list->avail_itm_num = list->avail_itm_num*FCT_LIST_GROWTH_FACTOR+\
- FCT_LIST_GROWTH_FACTOR;
- list->itm_list = (void**)realloc(
- list->itm_list, sizeof(void*)*list->avail_itm_num
- );
- FCT_ASSERT( list->itm_list != NULL && "memory check");
- }
-
- list->itm_list[list->used_itm_num] = itm;
- ++(list->used_itm_num);
-}
-
-
-
-/*
------------------------------------------------------------
-A SINGLE CHECK
------------------------------------------------------------
-This defines a single check. It indicates what the check was,
-and where it occurred. A "Test" object will have-a bunch
-of "checks".
-*/
-
-struct _fctchk_t
-{
- /* This string that represents the condition. */
- char cndtn[FCT_MAX_LOG_LINE];
-
- /* These indicate where the condition occurred. */
- char file[FCT_MAX_LOG_LINE];
-
- int lineno;
-
- nbool_t is_pass;
-
- /* This is a message that we can "format into", if
- no format string is specified this should be
- equivalent to the cntdn. */
- char msg[FCT_MAX_LOG_LINE];
-};
-
-#define fctchk__is_pass(_CHK_) ((_CHK_)->is_pass)
-#define fctchk__file(_CHK_) ((_CHK_)->file)
-#define fctchk__lineno(_CHK_) ((_CHK_)->lineno)
-#define fctchk__cndtn(_CHK_) ((_CHK_)->cndtn)
-#define fctchk__msg(_CHK_) ((_CHK_)->msg)
-
-static fctchk_t*
-fctchk_new(int is_pass,
- char const *cndtn,
- char const *file,
- int lineno,
- char const *format,
- va_list args)
-{
- fctchk_t *chk = NULL;
-
- FCT_ASSERT( cndtn != NULL );
- FCT_ASSERT( file != NULL );
- FCT_ASSERT( lineno > 0 );
-
- chk = (fctchk_t*)calloc(1, sizeof(fctchk_t));
- if ( chk == NULL )
- {
- return NULL;
- }
-
- fctstr_safe_cpy(chk->cndtn, cndtn, FCT_MAX_LOG_LINE);
- fctstr_safe_cpy(chk->file, file, FCT_MAX_LOG_LINE);
- chk->lineno = lineno;
-
- chk->is_pass =is_pass;
-
- if ( format != NULL )
- {
- fct_vsnprintf(chk->msg, FCT_MAX_LOG_LINE, format, args);
- }
- else
- {
- /* Default to make the condition be the message, if there was no format
- specified. */
- fctstr_safe_cpy(chk->msg, cndtn, FCT_MAX_LOG_LINE);
- }
-
- return chk;
-}
-
-
-/* Cleans up a "check" object. If the `chk` is NULL, this function does
-nothing. */
-static void
-fctchk__del(fctchk_t *chk)
-{
- if ( chk == NULL )
- {
- return;
- }
- free( chk );
-}
-
-
-/*
------------------------------------------------------------
-A TEST
------------------------------------------------------------
-A suite will have-a list of tests. Where each test will have-a
-list of failed and passed checks.
-*/
-
-struct _fct_test_t
-{
- /* List of failed and passed "checks" (fctchk_t). Two seperate
- lists make it faster to determine how many checks passed and how
- many checks failed. */
- fct_nlist_t failed_chks;
- fct_nlist_t passed_chks;
-
- /* To store the test run time */
- fct_timer_t timer;
-
- /* The name of the test case. */
- char name[FCT_MAX_NAME];
-};
-
-#define fct_test__name(_TEST_) ((_TEST_)->name)
-
-/* Clears the failed tests ... partly for internal testing. */
-#define fct_test__clear_failed(test) \
- fct_nlist__clear(test->failed_chks, (fct_nlist_on_del_t)fctchk__del);\
-
-
-static void
-fct_test__del(fct_test_t *test)
-{
- if (test == NULL )
- {
- return;
- }
- fct_nlist__final(&(test->passed_chks), (fct_nlist_on_del_t)fctchk__del);
- fct_nlist__final(&(test->failed_chks), (fct_nlist_on_del_t)fctchk__del);
- free(test);
-}
-
-
-static fct_test_t*
-fct_test_new(char const *name)
-{
- nbool_t ok =FCT_FALSE;
- fct_test_t *test =NULL;
-
- test = (fct_test_t*)malloc(sizeof(fct_test_t));
- if ( test == NULL )
- {
- return NULL;
- }
-
- fctstr_safe_cpy(test->name, name, FCT_MAX_NAME);
-
- /* Failures are an exception, so lets not allocate up
- the list until we need to. */
- fct_nlist__init2(&(test->failed_chks), 0);
- if (!fct_nlist__init(&(test->passed_chks)))
- {
- ok =FCT_FALSE;
- goto finally;
- }
-
- fct_timer__init(&(test->timer));
-
- ok =FCT_TRUE;
-finally:
- if ( !ok )
- {
- fct_test__del(test);
- test =NULL;
- }
- return test;
-}
-
-
-static void
-fct_test__start_timer(fct_test_t *test)
-{
- FCT_ASSERT( test != NULL );
- fct_timer__start(&(test->timer));
-}
-
-
-static void
-fct_test__stop_timer(fct_test_t *test)
-{
- FCT_ASSERT( test != NULL );
- fct_timer__stop(&(test->timer));
-}
-
-
-static double
-fct_test__duration(fct_test_t const *test)
-{
- FCT_ASSERT( test != NULL );
- return fct_timer__duration(&(test->timer));
-}
-
-
-static nbool_t
-fct_test__is_pass(fct_test_t const *test)
-{
- FCT_ASSERT( test != NULL );
- return fct_nlist__size(&(test->failed_chks)) == 0;
-}
-
-
-static void
-fct_test__add(fct_test_t *test, fctchk_t *chk)
-{
-
- FCT_ASSERT( test != NULL );
- FCT_ASSERT( chk != NULL );
-
- if ( fctchk__is_pass(chk) )
- {
- fct_nlist__append(&(test->passed_chks), (void*)chk);
- }
- else
- {
- fct_nlist__append(&(test->failed_chks), (void*)chk);
- }
-}
-
-/* Returns the number of checks made throughout the test. */
-static size_t
-fct_test__chk_cnt(fct_test_t const *test)
-{
- FCT_ASSERT( test != NULL );
- return fct_nlist__size(&(test->failed_chks)) \
- + fct_nlist__size(&(test->passed_chks));
-}
-
-
-/*
------------------------------------------------------------
-TEST SUITE (TS)
------------------------------------------------------------
-*/
-
-
-/* The different types of 'modes' that a test suite can be in.
-
-While the test suite is iterating through all the tests, its "State"
-can change from "setup mode", to "test mode" to "tear down" mode.
-These help to indicate what mode are currently in. Think of it as a
-basic FSM.
-
- if the count was 0 end
- +--------->---------------------> ending_mode-----+-+
- | ^ |
- ^ | ^
-start | [if no more tests] |
- | | | |
- +-count_mode -> setup_mode -> test_mode -> teardown_mode->-+
- | ^ | |
- | +-----------<---------------+ |
- +----------->---[if fct_req fails]--------+
-
-*/
-enum ts_mode
-{
- ts_mode_cnt, /* To setup when done counting. */
- ts_mode_setup, /* To test when done setup. */
- ts_mode_teardown, /* To ending mode, when no more tests. */
- ts_mode_test, /* To tear down mode. */
- ts_mode_ending, /* To ... */
- ts_mode_end, /* .. The End. */
- ts_mode_abort /* Abort */
-};
-
-/* Types of states the test could be in. */
-typedef enum
-{
- fct_test_status_SUCCESS,
- fct_test_status_FAILURE
-} fct_test_status;
-
-
-struct _fct_ts_t
-{
- /* For counting our 'current' test number, and the total number of
- tests. */
- int curr_test_num;
- int total_test_num;
-
- /* Keeps track of the current state of the object while it is walking
- through its "FSM" */
- enum ts_mode mode;
-
- /* The name of the test suite. */
- char name[FCT_MAX_NAME];
-
- /* List of tests that where executed within the test suite. */
- fct_nlist_t test_list;
-};
-
-
-#define fct_ts__is_setup_mode(ts) ((ts)->mode == ts_mode_setup)
-#define fct_ts__is_teardown_mode(ts) ((ts)->mode == ts_mode_teardown)
-#define fct_ts__is_test_mode(ts) ((ts)->mode == ts_mode_test)
-#define fct_ts__is_ending_mode(ts) ((ts)->mode == ts_mode_ending)
-#define fct_ts__is_end(ts) ((ts)->mode == ts_mode_end)
-#define fct_ts__is_cnt_mode(ts) ((ts)->mode == ts_mode_cnt)
-#define fct_ts__is_abort_mode(ts) ((ts)->mode == ts_mode_abort)
-
-/* This cndtn is set when we have iterated through all the tests, and
-there was nothing more to do. */
-#define fct_ts__ending(ts) ((ts)->mode = ts_mode_ending)
-
-/* Flag a test suite as complete. It will no longer accept any more tests. */
-#define fct_ts__end(ts) ((ts)->mode = ts_mode_end)
-
-#define fct_ts__name(ts) ((ts)->name)
-
-
-static void
-fct_ts__del(fct_ts_t *ts)
-{
- if ( ts == NULL )
- {
- return;
- }
- fct_nlist__final(&(ts->test_list), (fct_nlist_on_del_t)fct_test__del);
- free(ts);
-}
-
-static fct_ts_t *
-fct_ts_new(char const *name)
-{
- fct_ts_t *ts =NULL;
- ts = (fct_ts_t*)calloc(1, sizeof(fct_ts_t));
- FCT_ASSERT( ts != NULL );
-
- fctstr_safe_cpy(ts->name, name, FCT_MAX_NAME);
- ts->mode = ts_mode_cnt;
- fct_nlist__init(&(ts->test_list));
- return ts;
-}
-
-
-
-static nbool_t
-fct_ts__is_more_tests(fct_ts_t const *ts)
-{
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT( !fct_ts__is_end(ts) );
- return ts->curr_test_num < ts->total_test_num;
-}
-
-
-/* Indicates that we have started a test case. */
-static void
-fct_ts__test_begin(fct_ts_t *ts)
-{
- FCT_ASSERT( !fct_ts__is_end(ts) );
- ++(ts->curr_test_num);
-}
-
-
-/* Takes OWNERSHIP of a test object, and warehouses it for later stat
-generation. */
-static void
-fct_ts__add_test(fct_ts_t *ts, fct_test_t *test)
-{
- FCT_ASSERT( ts != NULL && "invalid arg");
- FCT_ASSERT( test != NULL && "invalid arg");
- FCT_ASSERT( !fct_ts__is_end(ts) );
- fct_nlist__append(&(ts->test_list), test);
-}
-
-
-static void
-fct_ts__test_end(fct_ts_t *ts)
-{
- FCT_ASSERT( ts != NULL );
- /* After a test has completed, move to teardown mode. */
- ts->mode = ts_mode_teardown;
-}
-
-
-/* Increments the internal count by 1. */
-static void
-fct_ts__inc_total_test_num(fct_ts_t *ts)
-{
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT( fct_ts__is_cnt_mode(ts) );
- FCT_ASSERT( !fct_ts__is_end(ts) );
- ++(ts->total_test_num);
-}
-
-
-/* Flags the end of the setup, which implies we are going to move into
-setup mode. You must be already in setup mode for this to work! */
-static void
-fct_ts__setup_end(fct_ts_t *ts)
-{
- if ( ts->mode != ts_mode_abort )
- {
- ts->mode = ts_mode_test;
- }
-}
-
-
-static fct_test_t *
-fct_ts__make_abort_test(fct_ts_t *ts)
-{
- char setup_testname[FCT_MAX_LOG_LINE+1] = {'\0'};
- char const *suitename = fct_ts__name(ts);
- fct_snprintf(setup_testname, FCT_MAX_LOG_LINE, "setup_%s", suitename);
- return fct_test_new(setup_testname);
-}
-
-/* Flags a pre-mature abort of a setup (like a failed fct_req). */
-static void
-fct_ts__setup_abort(fct_ts_t *ts)
-{
- FCT_ASSERT( ts != NULL );
- ts->mode = ts_mode_abort;
-}
-
-/* Flags the end of the teardown, which implies we are going to move
-into setup mode (for the next 'iteration'). */
-static void
-fct_ts__teardown_end(fct_ts_t *ts)
-{
- if ( ts->mode == ts_mode_abort )
- {
- return; /* Because we are aborting . */
- }
- /* We have to decide if we should keep on testing by moving into tear down
- mode or if we have reached the real end and should be moving into the
- ending mode. */
- if ( fct_ts__is_more_tests(ts) )
- {
- ts->mode = ts_mode_setup;
- }
- else
- {
- ts->mode = ts_mode_ending;
- }
-}
-
-
-/* Flags the end of the counting, and proceeding to the first setup.
-Consider the special case when a test suite has NO tests in it, in
-that case we will have a current count that is zero, in which case
-we can skip right to 'ending'. */
-static void
-fct_ts__cnt_end(fct_ts_t *ts)
-{
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT( fct_ts__is_cnt_mode(ts) );
- FCT_ASSERT( !fct_ts__is_end(ts) );
- if (ts->total_test_num == 0 )
- {
- ts->mode = ts_mode_ending;
- }
- else
- {
- ts->mode = ts_mode_setup;
- }
-}
-
-
-static nbool_t
-fct_ts__is_test_cnt(fct_ts_t const *ts, int test_num)
-{
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT( 0 <= test_num );
- FCT_ASSERT( test_num < ts->total_test_num );
- FCT_ASSERT( !fct_ts__is_end(ts) );
-
- /* As we roll through the tests we increment the count. With this
- count we can decide if we need to execute a test or not. */
- return test_num == ts->curr_test_num;
-}
-
-
-/* Returns the # of tests on the FCT TS object. This is the actual
-# of tests executed. */
-static size_t
-fct_ts__tst_cnt(fct_ts_t const *ts)
-{
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT(
- fct_ts__is_end(ts)
- && "can't count number of tests executed until the test suite ends"
- );
- return fct_nlist__size(&(ts->test_list));
-}
-
-
-/* Returns the # of tests in the TS object that passed. */
-static size_t
-fct_ts__tst_cnt_passed(fct_ts_t const *ts)
-{
- size_t tally =0;
-
- FCT_ASSERT( ts != NULL );
- FCT_ASSERT( fct_ts__is_end(ts) );
-
- FCT_NLIST_FOREACH_BGN(fct_test_t*, test, &(ts->test_list))
- {
- if ( fct_test__is_pass(test) )
- {
- tally += 1;
- }
- }
- FCT_NLIST_FOREACH_END();
- return tally;
-}
-
-
-/* Returns the # of checks made throughout a test suite. */
-static size_t
-fct_ts__chk_cnt(fct_ts_t const *ts)
-{
- size_t tally =0;
-
- FCT_ASSERT( ts != NULL );
-
- FCT_NLIST_FOREACH_BGN(fct_test_t *, test, &(ts->test_list))
- {
- tally += fct_test__chk_cnt(test);
- }
- FCT_NLIST_FOREACH_END();
- return tally;
-}
-
-/* Currently the duration is simply a sum of all the tests. */
-static double
-fct_ts__duration(fct_ts_t const *ts)
-{
- double tally =0.0;
- FCT_ASSERT( ts != NULL );
- FCT_NLIST_FOREACH_BGN(fct_test_t *, test, &(ts->test_list))
- {
- tally += fct_test__duration(test);
- }
- FCT_NLIST_FOREACH_END();
- return tally;
-}
-
-
-/*
---------------------------------------------------------
-FCT COMMAND LINE OPTION INITIALIZATION (fctcl_init)
---------------------------------------------------------
-
-Structure used for command line initialization. To keep it clear that we do
-not delete the char*'s present on this structure.
-*/
-
-
-typedef enum
-{
- FCTCL_STORE_UNDEFINED,
- FCTCL_STORE_TRUE,
- FCTCL_STORE_VALUE
-} fctcl_store_t;
-
-
-typedef struct _fctcl_init_t
-{
- /* What to parse for this option. --long versus -s. */
- char const *long_opt; /* i.e. --help */
- char const *short_opt; /* i.e. -h */
-
- /* What action to take when the option is activated. */
- fctcl_store_t action;
-
- /* The help string for the action. */
- char const *help;
-} fctcl_init_t;
-
-
-/* Use when defining the option list. */
-#define FCTCL_INIT_NULL \
- {NULL, NULL, FCTCL_STORE_UNDEFINED, NULL}
-
-
-/*
---------------------------------------------------------
-FCT COMMAND LINE OPTION (fctcl)
---------------------------------------------------------
-
-Specifies the command line configuration options. Use this
-to help initialize the fct_clp (command line parser).
-*/
-
-
-/* Handy strings for storing "true" and "false". We can reference
-these strings throughout the parse operation and not have to
-worry about dealing with memory. */
-#define FCTCL_TRUE_STR "1"
-
-
-typedef struct _fctcl_t
-{
- /* What to parse for this option. --long versus -s. */
- char *long_opt; /* i.e. --help */
- char *short_opt; /* i.e. -h */
-
- /* What action to take when the option is activated. */
- fctcl_store_t action;
-
- /* The help string for the action. */
- char *help;
-
- /* The result. */
- char *value;
-} fctcl_t;
-
-
-#define fctcl_new() ((fctcl_t*)calloc(1, sizeof(fctcl_t)))
-
-
-static void
-fctcl__del(fctcl_t *clo)
-{
- if ( clo == NULL )
- {
- return;
- }
- if ( clo->long_opt )
- {
- free(clo->long_opt);
- }
- if ( clo->short_opt)
- {
- free(clo->short_opt);
- }
- if ( clo->value )
- {
- free(clo->value);
- }
- if ( clo->help )
- {
- free(clo->help);
- }
- free(clo);
-}
-
-
-static fctcl_t*
-fctcl_new2(fctcl_init_t const *clo_init)
-{
- fctcl_t *clone = NULL;
- int ok =0;
- clone = fctcl_new();
- if ( clone == NULL )
- {
- return NULL;
- }
- clone->action = clo_init->action;
- if ( clo_init->help == NULL )
- {
- clone->help = NULL;
- }
- else
- {
- clone->help = fctstr_clone(clo_init->help);
- if ( clone->help == NULL )
- {
- ok =0;
- goto finally;
- }
- }
- if ( clo_init->long_opt == NULL )
- {
- clone->long_opt = NULL;
- }
- else
- {
- clone->long_opt = fctstr_clone(clo_init->long_opt);
- if ( clone->long_opt == NULL )
- {
- ok = 0;
- goto finally;
- }
- }
- if ( clo_init->short_opt == NULL )
- {
- clone->short_opt = NULL;
- }
- else
- {
- clone->short_opt = fctstr_clone(clo_init->short_opt);
- if ( clone->short_opt == NULL )
- {
- ok =0;
- goto finally;
- }
- }
- ok = 1;
-finally:
- if ( !ok )
- {
- fctcl__del(clone);
- clone = NULL;
- }
- return clone;
-}
-
-
-static int
-fctcl__is_option(fctcl_t const *clo, char const *option)
-{
- FCT_ASSERT( clo != NULL );
- if ( option == NULL )
- {
- return 0;
- }
- return ((clo->long_opt != NULL
- && fctstr_eq(clo->long_opt, option))
- ||
- (clo->short_opt != NULL
- && fctstr_eq(clo->short_opt, option))
- );
-}
-
-
-#define fctcl__set_value(_CLO_, _VAL_) \
- (_CLO_)->value = fctstr_clone((_VAL_));
-
-/*
---------------------------------------------------------
-FCT COMMAND PARSER (fct_clp)
---------------------------------------------------------
-*/
-
-#define FCT_CLP_MAX_ERR_MSG_LEN 256
-
-typedef struct _fct_clp_t
-{
- /* List of command line options. */
- fct_nlist_t clo_list;
-
- /* List of parameters (not options). */
- fct_nlist_t param_list;
-
- char error_msg[FCT_CLP_MAX_ERR_MSG_LEN];
- int is_error;
-} fct_clp_t;
-
-
-static void
-fct_clp__final(fct_clp_t *clp)
-{
- fct_nlist__final(&(clp->clo_list), (fct_nlist_on_del_t)fctcl__del);
- fct_nlist__final(&(clp->param_list), (fct_nlist_on_del_t)free);
-}
-
-
-/* Add an configuration options. */
-static int
-fct_clp__add_options(fct_clp_t *clp, fctcl_init_t const *options)
-{
- fctcl_init_t const *pclo =NULL;
- int ok;
- for ( pclo = options; pclo->action != FCTCL_STORE_UNDEFINED; ++pclo )
- {
- fctcl_t *cpy = fctcl_new2(pclo);
- if ( cpy == NULL )
- {
- ok = 0;
- goto finally;
- }
- fct_nlist__append(&(clp->clo_list), (void*)cpy);
- }
- ok =1;
-finally:
- return ok;
-}
-
-/* Returns false if we ran out of memory. */
-static int
-fct_clp__init(fct_clp_t *clp, fctcl_init_t const *options)
-{
- int ok =0;
- FCT_ASSERT( clp != NULL );
- /* It is just much saner to manage a clone of the options. Then we know
- who is in charge of the memory. */
- ok = fct_nlist__init(&(clp->clo_list));
- if ( !ok )
- {
- goto finally;
- }
- if ( options != NULL )
- {
- ok = fct_clp__add_options(clp, options);
- if ( !ok )
- {
- goto finally;
- }
- }
- ok = fct_nlist__init(&(clp->param_list));
- if ( !ok )
- {
- goto finally;
- }
- ok =1;
-finally:
- if ( !ok )
- {
- fct_clp__final(clp);
- }
- return ok;
-}
-
-
-/* Parses the command line arguments. Use fct_clp__is_error and
-fct_clp__get_error to figure out if something went awry. */
-static void
-fct_clp__parse(fct_clp_t *clp, int argc, char const *argv[])
-{
- int argi =1;
- int is_option =0;
- char *arg =NULL;
- char *token =NULL;
- char *next_token =NULL;
-
- clp->error_msg[0] = '\0';
- clp->is_error =0;
-
- while ( argi < argc )
- {
- is_option =0;
- token =NULL;
- next_token = NULL;
- arg = fctstr_clone(argv[argi]);
-
-#if defined(_MSC_VER) && _MSC_VER > 1300
- token = strtok_s(arg, "=", &next_token);
-#else
- token = strtok(arg, "=");
- next_token = strtok(NULL, "=");
-#endif
-
- FCT_NLIST_FOREACH_BGN(fctcl_t*, pclo, &(clp->clo_list))
- {
- /* Need to reset for each search. strtok below is destructive. */
- if ( fctcl__is_option(pclo, token) )
- {
- is_option =1;
- if ( pclo->action == FCTCL_STORE_VALUE )
- {
- /* If this is --xxxx=value then the next strtok should succeed.
- Otherwise, we need to chew up the next argument. */
- if ( next_token != NULL && strlen(next_token) > 0 )
- {
- fctcl__set_value(pclo, next_token);
- }
- else
- {
- ++argi; /* Chew up the next value */
- if ( argi >= argc )
- {
- /* error */
- fct_snprintf(
- clp->error_msg,
- FCT_CLP_MAX_ERR_MSG_LEN,
- "missing argument for %s",
- token
- );
- clp->is_error =1;
- break;
- }
- fctcl__set_value(pclo, argv[argi]);
- }
- }
- else if (pclo->action == FCTCL_STORE_TRUE)
- {
- fctcl__set_value(pclo, FCTCL_TRUE_STR);
- }
- else
- {
- FCT_ASSERT("undefined action requested");
- }
- break; /* No need to parse this argument further. */
- }
- }
- FCT_NLIST_FOREACH_END();
- /* If we have an error, exit. */
- if ( clp->is_error )
- {
- break;
- }
- /* If we walked through all the options, and didn't find
- anything, then we must have a parameter. Forget the fact that
- an unknown option will be treated like a parameter... */
- if ( !is_option )
- {
- fct_nlist__append(&(clp->param_list), arg);
- arg =NULL; /* Owned by the nlist */
- }
- ++argi;
- if ( arg != NULL )
- {
- free(arg);
- arg =NULL;
- }
- }
-}
-
-
-static fctcl_t const*
-fct_clp__get_clo(fct_clp_t const *clp, char const *option)
-{
- fctcl_t const *found =NULL;
-
- FCT_NLIST_FOREACH_BGN(fctcl_t const*, pclo, &(clp->clo_list))
- {
- if ( fctcl__is_option(pclo, option) )
- {
- found = pclo;
- break;
- }
- }
- FCT_NLIST_FOREACH_END();
- return found;
-}
-
-
-#define fct_clp__optval(_CLP_, _OPTION_) \
- fct_clp__optval2((_CLP_), (_OPTION_), NULL)
-
-
-/* Returns the value parsed at the command line, and equal to OPTION.
-If the value wasn't parsed, the DEFAULT_VAL is returned instead. */
-static char const*
-fct_clp__optval2(fct_clp_t *clp, char const *option, char const *default_val)
-{
- fctcl_t const *clo =NULL;
- FCT_ASSERT( clp != NULL );
- FCT_ASSERT( option != NULL );
- clo = fct_clp__get_clo(clp, option);
- if ( clo == NULL || clo->value == NULL)
- {
- return default_val;
- }
- return clo->value;
-}
-
-
-
-/* Mainly used for unit tests. */
-static int
-fct_clp__is_param(fct_clp_t *clp, char const *param)
-{
- if ( clp == NULL || param == NULL )
- {
- return 0;
- }
- FCT_NLIST_FOREACH_BGN(char *, aparam, &(clp->param_list))
- {
- if ( fctstr_eq(aparam, param) )
- {
- return 1;
- }
- }
- FCT_NLIST_FOREACH_END();
- return 0;
-}
-
-
-#define fct_clp__is_error(_CLP_) ((_CLP_)->is_error)
-#define fct_clp__get_error(_CLP_) ((_CLP_)->error_msg);
-
-#define fct_clp__num_clo(_CLP_) \
- (fct_nlist__size(&((_CLP_)->clo_list)))
-
-#define fct_clp__param_cnt(_CLP_) \
- (fct_nlist__size(&((_CLP_)->param_list)))
-
-/* Returns a *reference* to the parameter at _IDX_. Do not modify
-its contents. */
-#define fct_clp__param_at(_CLP_, _IDX_) \
- ((char const*)fct_nlist__at(&((_CLP_)->param_list), (_IDX_)))
-
-
-/* Returns true if the given option was on the command line.
-Use either the long or short option name to check against. */
-#define fct_clp__is(_CLP_, _OPTION_) \
- (fct_clp__optval((_CLP_), (_OPTION_)) != NULL)
-
-
-
-/*
---------------------------------------------------------
-FCT NAMESPACE
---------------------------------------------------------
-
-The macros below start to pollute the watch window with
-lots of "system" variables. This NAMESPACE is an
-attempt to hide all the "system" variables in one place.
-*/
-typedef struct _fct_namespace_t
-{
- /* The currently active test suite. */
- fct_ts_t *ts_curr;
- int ts_is_skip_suite;
- char const *ts_skip_cndtn;
-
- /* Current test name. */
- char const* curr_test_name;
- fct_test_t *curr_test;
- const char *test_skip_cndtn;
- int test_is_skip;
-
- /* Counts the number of tests in a test suite. */
- int test_num;
-
- /* Set at the end of the test suites. */
- size_t num_total_failed;
-} fct_namespace_t;
-
-
-static void
-fct_namespace_init(fct_namespace_t *ns)
-{
- FCT_ASSERT( ns != NULL && "invalid argument!");
- memset(ns, 0, sizeof(fct_namespace_t));
-}
-
-
-/*
---------------------------------------------------------
-FCT KERNAL
---------------------------------------------------------
-
-The "fctkern" is a singleton that is defined throughout the
-system.
-*/
-
-struct _fctkern_t
-{
- /* Holds variables used throughout MACRO MAGIC. In order to reduce
- the "noise" in the watch window during a debug trace. */
- fct_namespace_t ns;
-
- /* Command line parsing. */
- fct_clp_t cl_parser;
-
- /* Hold onto the command line arguments. */
- int cl_argc;
- char const **cl_argv;
- /* Track user options. */
- fctcl_init_t const *cl_user_opts;
-
- /* Tracks the delay parsing. */
- int cl_is_parsed;
-
- /* This is an list of loggers that can be used in the fct system. */
- fct_nlist_t logger_list;
-
- /* Array of custom types, you have built-in system ones and you
- have optionally supplied user ones.. */
- fct_logger_types_t *lt_usr;
- fct_logger_types_t *lt_sys;
-
- /* This is a list of prefix's that can be used to determine if a
- test is should be run or not. */
- fct_nlist_t prefix_list;
-
- /* This is a list of test suites that where generated throughout the
- testing process. */
- fct_nlist_t ts_list;
-
- /* Records what we expect to fail. */
- size_t num_expected_failures;
-};
-
-
-#define FCT_OPT_VERSION "--version"
-#define FCT_OPT_VERSION_SHORT "-v"
-#define FCT_OPT_HELP "--help"
-#define FCT_OPT_HELP_SHORT "-h"
-#define FCT_OPT_LOGGER "--logger"
-#define FCT_OPT_LOGGER_SHORT "-l"
-static fctcl_init_t FCT_CLP_OPTIONS[] =
-{
- /* Totally unsafe, since we are assuming we can clean out this data,
- what I need to do is have an "initialization" object, full of
- const objects. But for now, this should work. */
- {
- FCT_OPT_VERSION,
- FCT_OPT_VERSION_SHORT,
- FCTCL_STORE_TRUE,
- "Displays the FCTX version number and exits."
- },
- {
- FCT_OPT_HELP,
- FCT_OPT_HELP_SHORT,
- FCTCL_STORE_TRUE,
- "Shows this help."
- },
- {
- FCT_OPT_LOGGER,
- FCT_OPT_LOGGER_SHORT,
- FCTCL_STORE_VALUE,
- NULL
- },
- FCTCL_INIT_NULL /* Sentinel */
-};
-
-typedef fct_logger_i* (*fct_logger_new_fn)(void);
-struct _fct_logger_types_t
-{
- char const *name;
- fct_logger_new_fn logger_new_fn;
- char const *desc;
-};
-
-static fct_logger_types_t FCT_LOGGER_TYPES[] =
-{
- {
- "standard",
- (fct_logger_new_fn)fct_standard_logger_new,
- "the basic fctx logger"
- },
- {
- "minimal",
- (fct_logger_new_fn)fct_minimal_logger_new,
- "the least amount of logging information."
- },
- {
- "junit",
- (fct_logger_new_fn)fct_junit_logger_new,
- "junit compatable xml"
- },
- {NULL, (fct_logger_new_fn)NULL, NULL} /* Sentinel */
-};
-
-
-/* Returns the number of filters defined for the fct kernal. */
-#define fctkern__filter_cnt(_NK_) (fct_nlist__size(&((_NK_)->prefix_list)))
-
-
-static void
-fctkern__add_logger(fctkern_t *nk, fct_logger_i *logger_owns)
-{
- FCT_ASSERT(nk != NULL && "invalid arg");
- FCT_ASSERT(logger_owns != NULL && "invalid arg");
- fct_nlist__append(&(nk->logger_list), logger_owns);
-}
-
-
-static void
-fctkern__write_help(fctkern_t *nk, FILE *out)
-{
- fct_clp_t *clp = &(nk->cl_parser);
- fprintf(out, "test.exe [options] prefix_filter ...\n\n");
- FCT_NLIST_FOREACH_BGN(fctcl_t*, clo, &(clp->clo_list))
- {
- if ( clo->short_opt != NULL )
- {
- fprintf(out, "%s, %s\n", clo->short_opt, clo->long_opt);
- }
- else
- {
- fprintf(out, "%s\n", clo->long_opt);
- }
- if ( !fctstr_ieq(clo->long_opt, FCT_OPT_LOGGER) )
- {
- /* For now lets not get to fancy with the text wrapping. */
- fprintf(out, " %s\n", clo->help);
- }
- else
- {
- fct_logger_types_t *types[2];
- int type_i;
- fct_logger_types_t *itr;
- types[0] = nk->lt_sys;
- types[1] = nk->lt_usr;
- fputs(" Sets the logger. The types of loggers currently "
- "available are,\n", out);
- for (type_i =0; type_i != 2; ++type_i )
- {
- for ( itr=types[type_i]; itr && itr->name != NULL; ++itr )
- {
- fprintf(out, " =%s : %s\n", itr->name, itr->desc);
- }
- }
- fprintf(out, " default is '%s'.\n", FCT_DEFAULT_LOGGER);
- }
- }
- FCT_NLIST_FOREACH_END();
- fputs("\n", out);
-}
-
-
-/* Appends a prefix filter that is used to determine if a test can
-be executed or not. If the test starts with the same characters as
-the prefix, then it should be "runnable". The prefix filter must be
-a non-NULL, non-Blank string. */
-static void
-fctkern__add_prefix_filter(fctkern_t *nk, char const *prefix_filter)
-{
- char *filter =NULL;
- size_t filter_len =0;
- FCT_ASSERT( nk != NULL && "invalid arg" );
- FCT_ASSERT( prefix_filter != NULL && "invalid arg" );
- FCT_ASSERT( strlen(prefix_filter) > 0 && "invalid arg" );
- /* First we make a copy of the prefix, then we store it away
- in our little list. */
- filter_len = strlen(prefix_filter);
- filter = (char*)malloc(sizeof(char)*(filter_len+1));
- fctstr_safe_cpy(filter, prefix_filter, filter_len+1);
- fct_nlist__append(&(nk->prefix_list), (void*)filter);
-}
-
-
-/* Cleans up the contents of a fctkern. NULL does nothing. */
-static void
-fctkern__final(fctkern_t *nk)
-{
- if ( nk == NULL )
- {
- return;
- }
- fct_clp__final(&(nk->cl_parser));
- fct_nlist__final(&(nk->logger_list), (fct_nlist_on_del_t)fct_logger__del);
- /* The prefix list is a list of malloc'd strings. */
- fct_nlist__final(&(nk->prefix_list), (fct_nlist_on_del_t)free);
- fct_nlist__final(&(nk->ts_list), (fct_nlist_on_del_t)fct_ts__del);
-}
-
-
-#define fctkern__cl_is_parsed(_NK_) ((_NK_)->cl_is_parsed)
-
-
-static int
-fctkern__cl_is(fctkern_t *nk, char const *opt_str)
-{
- FCT_ASSERT( opt_str != NULL );
- return opt_str[0] != '\0'
- && fct_clp__is(&(nk->cl_parser), opt_str);
-}
-
-
-/* Returns the command line value given by OPT_STR. If OPT_STR was not defined
-at the command line, DEF_STR is returned (you can use NULL for the DEF_STR).
-The result returned should not be mofidied, and MAY even be the same pointer
-to DEF_STR. */
-static char const *
-fctkern__cl_val2(fctkern_t *nk, char const *opt_str, char const *def_str)
-{
- FCT_ASSERT( opt_str != NULL );
- if ( nk == NULL )
- {
- return NULL;
- }
- return fct_clp__optval2(&(nk->cl_parser), opt_str, def_str);
-}
-
-
-/* Selects a logger from the list based on the selection name.
-May return NULL if the name doesn't exist in the list. */
-static fct_logger_i*
-fckern_sel_log(fct_logger_types_t *search, char const *sel_logger)
-{
- fct_logger_types_t *iter;
- FCT_ASSERT(search != NULL);
- FCT_ASSERT(sel_logger != NULL);
- FCT_ASSERT(strlen(sel_logger) > 0);
- for ( iter = search; iter->name != NULL; ++iter)
- {
- if ( fctstr_ieq(iter->name, sel_logger) )
- {
- return iter->logger_new_fn();
- }
- }
- return NULL;
-}
-
-static int
-fctkern__cl_parse_config_logger(fctkern_t *nk)
-{
- fct_logger_i *logger =NULL;
- char const *sel_logger =NULL;
- char const *def_logger =FCT_DEFAULT_LOGGER;
- sel_logger = fctkern__cl_val2(nk, FCT_OPT_LOGGER, def_logger);
- FCT_ASSERT(sel_logger != NULL && "should never be NULL");
- /* First search the user selected types, then search the
- built-in types. */
- if ( nk->lt_usr != NULL )
- {
- logger = fckern_sel_log(nk->lt_usr, sel_logger);
- }
- if ( nk->lt_sys != NULL && logger == NULL )
- {
- logger = fckern_sel_log(nk->lt_sys, sel_logger);
- }
- if ( logger == NULL )
- {
- /* No logger configured, you must have supplied an invalid selection. */
- fprintf(stderr, "error: unknown logger selected - '%s'", sel_logger);
- return 0;
- }
- fctkern__add_logger(nk, logger);
- logger = NULL; /* owned by nk. */
- return 1;
-}
-
-
-
-/* Call this if you want to (re)parse the command line options with a new
-set of options. Returns -1 if you are to abort with EXIT_SUCCESS, returns
-0 if you are to abort with EXIT_FAILURE and returns 1 if you are to continue. */
-static int
-fctkern__cl_parse(fctkern_t *nk)
-{
- int status =0;
- size_t num_params =0;
- size_t param_i =0;
- if ( nk == NULL )
- {
- return 0;
- }
- if ( nk->cl_user_opts != NULL )
- {
- if ( !fct_clp__add_options(&(nk->cl_parser), nk->cl_user_opts) )
- {
- status =0;
- goto finally;
- }
- }
- /* You want to add the "house options" after the user defined ones. The
- options are stored as a list so it means that any option listed after
- the above ones won't get parsed. */
- if ( !fct_clp__add_options(&(nk->cl_parser), FCT_CLP_OPTIONS) )
- {
- status =0;
- goto finally;
- }
- fct_clp__parse(&(nk->cl_parser), nk->cl_argc, nk->cl_argv);
- if ( fct_clp__is_error(&(nk->cl_parser)) )
- {
- char *err = fct_clp__get_error(&(nk->cl_parser));
- fprintf(stderr, "error: %s", err);
- status =0;
- goto finally;
- }
- num_params = fct_clp__param_cnt(&(nk->cl_parser));
- for ( param_i =0; param_i != num_params; ++param_i )
- {
- char const *param = fct_clp__param_at(&(nk->cl_parser), param_i);
- fctkern__add_prefix_filter(nk, param);
- }
- if ( fctkern__cl_is(nk, FCT_OPT_VERSION) )
- {
- (void)printf("Built using FCTX version %s.\n", FCT_VERSION_STR);
- status = -1;
- goto finally;
- }
- if ( fctkern__cl_is(nk, FCT_OPT_HELP) )
- {
- fctkern__write_help(nk, stdout);
- status = -1;
- goto finally;
- }
- if ( !fctkern__cl_parse_config_logger(nk) )
- {
- status = -1;
- goto finally;
- }
- status =1;
- nk->cl_is_parsed =1;
-finally:
- return status;
-}
-
-
-
-/* Parses the command line and sets up the framework. The argc and argv
-should be directly from the program's main. */
-static int
-fctkern__init(fctkern_t *nk, int argc, const char *argv[])
-{
- if ( argc == 0 && argv == NULL )
- {
- return 0;
- }
- memset(nk, 0, sizeof(fctkern_t));
- fct_clp__init(&(nk->cl_parser), NULL);
- fct_nlist__init(&(nk->logger_list));
- nk->lt_usr = NULL; /* Supplied via 'install' mechanics. */
- nk->lt_sys = FCT_LOGGER_TYPES;
- fct_nlist__init2(&(nk->prefix_list), 0);
- fct_nlist__init2(&(nk->ts_list), 0);
- nk->cl_is_parsed =0;
- /* Save a copy of the arguments. We do a delay parse of the command
- line arguments in order to allow the client code to optionally configure
- the command line parser.*/
- nk->cl_argc = argc;
- nk->cl_argv = argv;
- fct_namespace_init(&(nk->ns));
- return 1;
-}
-
-
-/* Takes OWNERSHIP of the test suite after we have finished executing
-its contents. This way we can build up all kinds of summaries at the end
-of a run. */
-static void
-fctkern__add_ts(fctkern_t *nk, fct_ts_t *ts)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( ts != NULL );
- fct_nlist__append(&(nk->ts_list), ts);
-}
-
-
-/* Returns FCT_TRUE if the supplied test_name passes the filters set on
-this test suite. If there are no filters, we return FCT_TRUE always. */
-static nbool_t
-fctkern__pass_filter(fctkern_t *nk, char const *test_name)
-{
- size_t prefix_i =0;
- size_t prefix_list_size =0;
- FCT_ASSERT( nk != NULL && "invalid arg");
- FCT_ASSERT( test_name != NULL );
- FCT_ASSERT( strlen(test_name) > 0 );
- prefix_list_size = fctkern__filter_cnt(nk);
- /* If there is no filter list, then we return FCT_TRUE always. */
- if ( prefix_list_size == 0 )
- {
- return FCT_TRUE;
- }
- /* Iterate through the prefix filter list, and see if we have
- anything that does not pass. All we require is ONE item that
- passes the test in order for us to succeed here. */
- for ( prefix_i = 0; prefix_i != prefix_list_size; ++prefix_i )
- {
- char const *prefix = (char const*)fct_nlist__at(
- &(nk->prefix_list), prefix_i
- );
- nbool_t pass = fct_filter_pass(prefix, test_name);
- if ( pass )
- {
- return FCT_TRUE;
- }
- }
- /* Otherwise, we never managed to find a prefix that satisfied the
- supplied test name. Therefore we have failed to pass to the filter
- list test. */
- return FCT_FALSE;
-}
-
-
-/* Returns the number of tests that were performed. */
-static size_t
-fctkern__tst_cnt(fctkern_t const *nk)
-{
- size_t tally =0;
- FCT_ASSERT( nk != NULL );
- FCT_NLIST_FOREACH_BGN(fct_ts_t *, ts, &(nk->ts_list))
- {
- tally += fct_ts__tst_cnt(ts);
- }
- FCT_NLIST_FOREACH_END();
- return tally;
-}
-
-
-/* Returns the number of tests that passed. */
-static size_t
-fctkern__tst_cnt_passed(fctkern_t const *nk)
-{
- size_t tally =0;
- FCT_ASSERT( nk != NULL );
-
- FCT_NLIST_FOREACH_BGN(fct_ts_t*, ts, &(nk->ts_list))
- {
- tally += fct_ts__tst_cnt_passed(ts);
- }
- FCT_NLIST_FOREACH_END();
-
- return tally;
-}
-
-
-/* Returns the number of tests that failed. */
-#define fctkern__tst_cnt_failed(nk) \
- (fctkern__tst_cnt(nk) - fctkern__tst_cnt_passed(nk))
-
-
-/* Returns the number of checks made throughout the entire test. */
-#if defined(FCT_USE_TEST_COUNT)
-static size_t
-fctkern__chk_cnt(fctkern_t const *nk)
-{
- size_t tally =0;
- FCT_ASSERT( nk != NULL );
-
- FCT_NLIST_FOREACH_BGN(fct_ts_t *, ts, &(nk->ts_list))
- {
- tally += fct_ts__chk_cnt(ts);
- }
- FCT_NLIST_FOREACH_END();
- return tally;
-}
-#endif /* FCT_USE_TEST_COUNT */
-
-
-/* Indicates the very end of all the tests. */
-#define fctkern__end(nk) /* unused */
-
-
-static void
-fctkern__log_suite_start(fctkern_t *nk, fct_ts_t const *ts)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( ts != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_suite_start(logger, ts);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-static void
-fctkern__log_suite_end(fctkern_t *nk, fct_ts_t const *ts)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( ts != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_suite_end(logger, ts);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-static void
-fctkern__log_suite_skip(fctkern_t *nk, char const *condition, char const *name)
-{
- if ( nk == NULL )
- {
- return;
- }
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_suite_skip(logger, condition, name);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-static void
-fctkern__log_test_skip(fctkern_t *nk, char const *condition, char const *name)
-{
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_skip(logger, condition, name);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-/* Use this for displaying information about a "Check" (i.e.
-a condition). */
-static void
-fctkern__log_chk(fctkern_t *nk, fctchk_t const *chk)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( chk != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_chk(logger, chk);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-/* Use this for displaying warning messages. */
-static void
-fctkern__log_warn(fctkern_t *nk, char const *warn)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( warn != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_warn(logger, warn);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-/* Called whenever a test is started. */
-static void
-fctkern__log_test_start(fctkern_t *nk, fct_test_t const *test)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( test != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_start(logger, test);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-static void
-fctkern__log_test_end(fctkern_t *nk, fct_test_t *test)
-{
- FCT_ASSERT( nk != NULL );
- FCT_ASSERT( test != NULL );
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &(nk->logger_list))
- {
- fct_logger__on_test_end(logger, test);
- }
- FCT_NLIST_FOREACH_END();
-}
-
-
-#define fctkern__log_start(_NK_) \
- {\
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &((_NK_)->logger_list))\
- {\
- fct_logger__on_fctx_start(logger, (_NK_));\
- }\
- FCT_NLIST_FOREACH_END();\
- }
-
-
-#define fctkern__log_end(_NK_) \
- {\
- FCT_NLIST_FOREACH_BGN(fct_logger_i*, logger, &((_NK_)->logger_list))\
- {\
- fct_logger__on_fctx_end(logger, (_NK_));\
- }\
- FCT_NLIST_FOREACH_END();\
- }
-
-
-
-
-/*
------------------------------------------------------------
-LOGGER INTERFACE
-
-Defines an interface to a logging system. A logger
-must define the following functions in order to hook
-into the logging system.
-
-See the "Standard Logger" and "Minimal Logger" as examples
-of the implementation.
------------------------------------------------------------
-*/
-
-/* Common event argument. The values of the each event may or may not be
-defined depending on the event in question. */
-struct _fct_logger_evt_t
-{
- fctkern_t const *kern;
- fctchk_t const *chk;
- fct_test_t const *test;
- fct_ts_t const *ts;
- char const *msg;
- char const *cndtn;
- char const *name;
-};
-
-
-typedef struct _fct_logger_i_vtable_t
-{
- /* 1
- * Fired when an "fct_chk*" (check) function is completed. The event
- * will contain a reference to the "chk" object created.
- * */
- void (*on_chk)(fct_logger_i *logger, fct_logger_evt_t const *e);
-
- /* 2
- * Fired when a test starts and before any checks are made. The
- * event will have its "test" object set. */
- void (*on_test_start)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 3 */
- void (*on_test_end)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 4 */
- void (*on_test_suite_start)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 5 */
- void (*on_test_suite_end)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 6 */
- void (*on_fctx_start)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 7 */
- void (*on_fctx_end)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 8
- Called when the logger object must "clean up". */
- void (*on_delete)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 9 */
- void (*on_warn)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* -- new in 1.2 -- */
- /* 10 */
- void (*on_test_suite_skip)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
- /* 11 */
- void (*on_test_skip)(
- fct_logger_i *logger,
- fct_logger_evt_t const *e
- );
-} fct_logger_i_vtable_t;
-
-#define _fct_logger_head \
- fct_logger_i_vtable_t vtable; \
- fct_logger_evt_t evt
-
-struct _fct_logger_i
-{
- _fct_logger_head;
-};
-
-
-static void
-fct_logger__stub(fct_logger_i *l, fct_logger_evt_t const *e)
-{
- fct_unused(l);
- fct_unused(e);
-}
-
-
-static fct_logger_i_vtable_t fct_logger_default_vtable =
-{
- fct_logger__stub, /* 1. on_chk */
- fct_logger__stub, /* 2. on_test_start */
- fct_logger__stub, /* 3. on_test_end */
- fct_logger__stub, /* 4. on_test_suite_start */
- fct_logger__stub, /* 5. on_test_suite_end */
- fct_logger__stub, /* 6. on_fctx_start */
- fct_logger__stub, /* 7. on_fctx_end */
- fct_logger__stub, /* 8. on_delete */
- fct_logger__stub, /* 9. on_warn */
- fct_logger__stub, /* 10. on_test_suite_skip */
- fct_logger__stub, /* 11. on_test_skip */
-};
-
-
-/* Initializes the elements of a logger interface so they are at their
-standard values. */
-static void
-fct_logger__init(fct_logger_i *logger)
-{
- FCT_ASSERT( logger != NULL );
- memcpy(
- &(logger->vtable),
- &fct_logger_default_vtable,
- sizeof(fct_logger_i_vtable_t)
- );
- memset(&(logger->evt),0, sizeof(fct_logger_evt_t));
-}
-
-static void
-fct_logger__del(fct_logger_i *logger)
-{
- if ( logger )
- {
- logger->vtable.on_delete(logger, &(logger->evt));
- }
-}
-
-
-static void
-fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test)
-{
- logger->evt.test = test;
- logger->vtable.on_test_start(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_test_end(fct_logger_i *logger, fct_test_t *test)
-{
- logger->evt.test = test;
- logger->vtable.on_test_end(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts)
-{
- logger->evt.ts = ts;
- logger->vtable.on_test_suite_start(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts)
-{
- logger->evt.ts = ts;
- logger->vtable.on_test_suite_end(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_test_suite_skip(
- fct_logger_i *logger,
- char const *condition,
- char const *name
-)
-{
- logger->evt.cndtn = condition;
- logger->evt.name = name;
- logger->vtable.on_test_suite_skip(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_test_skip(
- fct_logger_i *logger,
- char const *condition,
- char const *name
-)
-{
- logger->evt.cndtn = condition;
- logger->evt.name = name;
- logger->vtable.on_test_skip(logger, &(logger->evt));
-}
-
-
-static void
-fct_logger__on_chk(fct_logger_i *logger, fctchk_t const *chk)
-{
- logger->evt.chk = chk;
- logger->vtable.on_chk(logger, &(logger->evt));
-}
-
-/* When we start all our tests. */
-#define fct_logger__on_fctx_start(LOGGER, KERN) \
- (LOGGER)->evt.kern = (KERN);\
- (LOGGER)->vtable.on_fctx_start((LOGGER), &((LOGGER)->evt));
-
-
-/* When we have reached the end of ALL of our testing. */
-#define fct_logger__on_fctx_end(LOGGER, KERN) \
- (LOGGER)->evt.kern = (KERN);\
- (LOGGER)->vtable.on_fctx_end((LOGGER), &((LOGGER)->evt));
-
-
-static void
-fct_logger__on_warn(fct_logger_i *logger, char const *msg)
-{
- logger->evt.msg = msg;
- logger->vtable.on_warn(logger, &(logger->evt));
-}
-
-
-/* Commmon routine to record strings representing failures. The
-chk should be a failure before we call this, and the list is a list
-of char*'s that will eventually be free'd by the logger. */
-static void
-fct_logger_record_failure(fctchk_t const* chk, fct_nlist_t* fail_list)
-{
- /* For now we will truncate the string to some set amount, later
- we can work out a dynamic string object. */
- char *str = (char*)malloc(sizeof(char)*FCT_MAX_LOG_LINE);
- FCT_ASSERT( str != NULL );
- fct_snprintf(
- str,
- FCT_MAX_LOG_LINE,
- "%s(%d):\n %s",
- fctchk__file(chk),
- fctchk__lineno(chk),
- fctchk__msg(chk)
- );
- /* Append it to the listing ... */
- fct_nlist__append(fail_list, (void*)str);
-}
-
-
-/* Another common routine, to print the failures at the end of a run. */
-static void
-fct_logger_print_failures(fct_nlist_t const *fail_list)
-{
- puts(
- "\n----------------------------------------------------------------------------\n"
- );
- puts("FAILED TESTS\n\n");
- FCT_NLIST_FOREACH_BGN(char *, cndtn_str, fail_list)
- {
- printf("%s\n", cndtn_str);
- }
- FCT_NLIST_FOREACH_END();
-
- puts("\n");
-}
-
-
-
-
-/*
------------------------------------------------------------
-MINIMAL LOGGER
------------------------------------------------------------
-
-At the moment the MINIMAL LOGGER is currently disabled. Hope
-to bring it back online soon. The only reason it is
-disabled is that we don't currently have the ability to specify
-loggers.
-*/
-
-
-/* Minimal logger, reports the minimum amount of information needed
-to determine "something is happening". */
-struct _fct_minimal_logger_t
-{
- _fct_logger_head;
- /* A list of char*'s that needs to be cleaned up. */
- fct_nlist_t failed_cndtns_list;
-};
-
-
-static void
-fct_minimal_logger__on_chk(
- fct_logger_i *self_,
- fct_logger_evt_t const *e
-)
-{
- fct_minimal_logger_t *self = (fct_minimal_logger_t*)self_;
- if ( fctchk__is_pass(e->chk) )
- {
- fputs(".", stdout);
- }
- else
- {
- fputs("x", stdout);
- fct_logger_record_failure(e->chk, &(self->failed_cndtns_list));
-
- }
-}
-
-static void
-fct_minimal_logger__on_fctx_end(
- fct_logger_i *self_,
- fct_logger_evt_t const *e
-)
-{
- fct_minimal_logger_t *self = (fct_minimal_logger_t*)self_;
- fct_unused(e);
- if ( fct_nlist__size(&(self->failed_cndtns_list)) >0 )
- {
- fct_logger_print_failures(&(self->failed_cndtns_list));
- }
-}
-
-
-static void
-fct_minimal_logger__on_delete(
- fct_logger_i *self_,
- fct_logger_evt_t const *e
-)
-{
- fct_minimal_logger_t *self = (fct_minimal_logger_t*)self_;
- fct_unused(e);
- fct_nlist__final(&(self->failed_cndtns_list), free);
- free(self);
-
-}
-
-
-fct_logger_i*
-fct_minimal_logger_new(void)
-{
- fct_minimal_logger_t *self = (fct_minimal_logger_t*)\
- calloc(1,sizeof(fct_minimal_logger_t));
- if ( self == NULL )
- {
- return NULL;
- }
- fct_logger__init((fct_logger_i*)self);
- self->vtable.on_chk = fct_minimal_logger__on_chk;
- self->vtable.on_fctx_end = fct_minimal_logger__on_fctx_end;
- self->vtable.on_delete = fct_minimal_logger__on_delete;
- fct_nlist__init2(&(self->failed_cndtns_list), 0);
- return (fct_logger_i*)self;
-}
-
-
-/*
------------------------------------------------------------
-STANDARD LOGGER
------------------------------------------------------------
-*/
-
-struct _fct_standard_logger_t
-{
- _fct_logger_head;
-
- /* Start time. For now we use the low-accuracy time_t version. */
- fct_timer_t timer;
-
- /* A list of char*'s that needs to be cleaned up. */
- fct_nlist_t failed_cndtns_list;
-};
-
-
-#define FCT_STANDARD_LOGGER_MAX_LINE 68
-
-
-/* When a failure occurrs, we will record the details so we can display
-them when the log "finishes" up. */
-static void
-fct_standard_logger__on_chk(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
- /* Only record failures. */
- if ( !fctchk__is_pass(e->chk) )
- {
- fct_logger_record_failure(e->chk, &(logger->failed_cndtns_list));
- }
-}
-
-
-static void
-fct_standard_logger__on_test_skip(
- fct_logger_i* logger_,
- fct_logger_evt_t const *e
-)
-{
- char const *condition = e->cndtn;
- char const *name = e->name;
- char msg[256] = {'\0'};
- fct_unused(logger_);
- fct_unused(condition);
- fct_snprintf(msg, sizeof(msg), "%s (%s)", name, condition);
- msg[sizeof(msg)-1] = '\0';
- fct_dotted_line_start(FCT_STANDARD_LOGGER_MAX_LINE, msg);
- fct_dotted_line_end("- SKIP -");
-}
-
-
-static void
-fct_standard_logger__on_test_start(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_unused(logger_);
- fct_dotted_line_start(
- FCT_STANDARD_LOGGER_MAX_LINE,
- fct_test__name(e->test)
- );
-}
-
-
-static void
-fct_standard_logger__on_test_end(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- nbool_t is_pass;
- fct_unused(logger_);
- is_pass = fct_test__is_pass(e->test);
- fct_dotted_line_end((is_pass) ? "PASS" : "FAIL ***" );
-}
-
-
-static void
-fct_standard_logger__on_fctx_start(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
- fct_unused(e);
- fct_timer__start(&(logger->timer));
-}
-
-
-static void
-fct_standard_logger__on_fctx_end(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
- nbool_t is_success =1;
- double elasped_time =0;
- size_t num_tests =0;
- size_t num_passed =0;
-
- fct_timer__stop(&(logger->timer));
-
- is_success = fct_nlist__size(&(logger->failed_cndtns_list)) ==0;
-
- if ( !is_success )
- {
- fct_logger_print_failures(&(logger->failed_cndtns_list));
- }
- puts(
- "\n----------------------------------------------------------------------------\n"
- );
- num_tests = fctkern__tst_cnt(e->kern);
- num_passed = fctkern__tst_cnt_passed(e->kern);
- printf(
- "%s (%lu/%lu tests",
- (is_success) ? "PASSED" : "FAILED",
- (unsigned long) num_passed,
- (unsigned long) num_tests
- );
- elasped_time = fct_timer__duration(&(logger->timer));
- if ( elasped_time > 0.0000001 )
- {
- printf(" in %.6fs)\n", elasped_time);
- }
- else
- {
- /* Don't bother displaying the time to execute. */
- puts(")\n");
- }
-}
-
-
-static void
-fct_standard_logger__on_delete(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
- fct_unused(e);
- fct_nlist__final(&(logger->failed_cndtns_list), free);
- free(logger);
- logger_ =NULL;
-}
-
-
-static void
-fct_standard_logger__on_warn(
- fct_logger_i* logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_unused(logger_);
- (void)printf("WARNING: %s", e->msg);
-}
-
-
-fct_logger_i*
-fct_standard_logger_new(void)
-{
- fct_standard_logger_t *logger = (fct_standard_logger_t *)calloc(
- 1, sizeof(fct_standard_logger_t)
- );
- if ( logger == NULL )
- {
- return NULL;
- }
- fct_logger__init((fct_logger_i*)logger);
- logger->vtable.on_chk = fct_standard_logger__on_chk;
- logger->vtable.on_test_start = fct_standard_logger__on_test_start;
- logger->vtable.on_test_end = fct_standard_logger__on_test_end;
- logger->vtable.on_fctx_start = fct_standard_logger__on_fctx_start;
- logger->vtable.on_fctx_end = fct_standard_logger__on_fctx_end;
- logger->vtable.on_delete = fct_standard_logger__on_delete;
- logger->vtable.on_warn = fct_standard_logger__on_warn;
- logger->vtable.on_test_skip = fct_standard_logger__on_test_skip;
- fct_nlist__init2(&(logger->failed_cndtns_list), 0);
- fct_timer__init(&(logger->timer));
- return (fct_logger_i*)logger;
-}
-
-
-/*
------------------------------------------------------------
-JUNIT LOGGER
------------------------------------------------------------
-*/
-
-
-/* JUnit logger */
-struct _fct_junit_logger_t
-{
- _fct_logger_head;
-};
-
-
-static void
-fct_junit_logger__on_test_suite_start(
- fct_logger_i *l,
- fct_logger_evt_t const *e
-)
-{
- fct_unused(l);
- fct_unused(e);
- FCT_SWITCH_STDOUT_TO_BUFFER();
- FCT_SWITCH_STDERR_TO_BUFFER();
-}
-
-
-static void
-fct_junit_logger__on_test_suite_end(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_ts_t const *ts = e->ts; /* Test Suite */
- nbool_t is_pass;
- double elasped_time = 0;
- char std_buffer[1024];
- int read_length;
- int first_out_line;
-
- fct_unused(logger_);
-
- elasped_time = fct_ts__duration(ts);
-
- FCT_SWITCH_STDOUT_TO_STDOUT();
- FCT_SWITCH_STDERR_TO_STDERR();
-
- /* opening testsuite tag */
- printf("\t<testsuite errors=\"%lu\" failures=\"0\" tests=\"%lu\" "
- "name=\"%s\" time=\"%.4f\">\n",
- (unsigned long) fct_ts__tst_cnt(ts)
- - fct_ts__tst_cnt_passed(ts),
- (unsigned long) fct_ts__tst_cnt(ts),
- fct_ts__name(ts),
- elasped_time);
-
- FCT_NLIST_FOREACH_BGN(fct_test_t*, test, &(ts->test_list))
- {
- is_pass = fct_test__is_pass(test);
-
- /* opening testcase tag */
- if (is_pass)
- {
- printf("\t\t<testcase name=\"%s\" time=\"%.3f\"",
- fct_test__name(test),
- fct_test__duration(test)
- );
- }
- else
- {
- printf("\t\t<testcase name=\"%s\" time=\"%.3f\">\n",
- fct_test__name(test),
- fct_test__duration(test)
- );
- }
-
- FCT_NLIST_FOREACH_BGN(fctchk_t*, chk, &(test->failed_chks))
- {
- /* error tag */
- printf("\t\t\t<error message=\"%s\" "
- "type=\"fctx\">", chk->msg);
- printf("file:%s, line:%d", chk->file, chk->lineno);
- printf("</error>\n");
- }
- FCT_NLIST_FOREACH_END();
-
- /* closing testcase tag */
- if (is_pass)
- {
- printf(" />\n");
- }
- else
- {
- printf("\t\t</testcase>\n");
- }
- }
- FCT_NLIST_FOREACH_END();
-
- /* print the std streams */
- first_out_line = 1;
- printf("\t\t<system-out>\n\t\t\t<![CDATA[");
- while ( (read_length = _fct_read(fct_stdout_pipe[0], std_buffer, 1024)) > 0)
- {
- if (first_out_line)
- {
- printf("\n");
- first_out_line = 0;
- }
- printf("%.*s", read_length, std_buffer);
- }
- printf("]]>\n\t\t</system-out>\n");
-
- first_out_line = 1;
- printf("\t\t<system-err>\n\t\t\t<![CDATA[");
- while ((read_length = _fct_read(fct_stderr_pipe[0], std_buffer, 1024)) > 0)
- {
- if (first_out_line)
- {
- printf("\n");
- first_out_line = 0;
- }
- printf("%.*s", read_length, std_buffer);
- }
- printf("]]>\n\t\t</system-err>\n");
-
- /* closing testsuite tag */
- printf("\t</testsuite>\n");
-}
-
-static void
-fct_junit_logger__on_fct_start(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_unused(logger_);
- fct_unused(e);
- printf("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
- printf("<testsuites>\n");
-}
-
-static void
-fct_junit_logger__on_fctx_end(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_unused(logger_);
- fct_unused(e);
- printf("</testsuites>\n");
-}
-
-static void
-fct_junit_logger__on_delete(
- fct_logger_i *logger_,
- fct_logger_evt_t const *e
-)
-{
- fct_junit_logger_t *logger = (fct_junit_logger_t*)logger_;
- fct_unused(e);
- free(logger);
- logger_ =NULL;
-}
-
-
-fct_junit_logger_t *
-fct_junit_logger_new(void)
-{
- fct_junit_logger_t *logger =
- (fct_junit_logger_t *)calloc(1, sizeof(fct_junit_logger_t));
- if ( logger == NULL )
- {
- return NULL;
- }
- fct_logger__init((fct_logger_i*)logger);
- logger->vtable.on_test_suite_start = fct_junit_logger__on_test_suite_start;
- logger->vtable.on_test_suite_end = fct_junit_logger__on_test_suite_end;
- logger->vtable.on_fctx_start = fct_junit_logger__on_fct_start;
- logger->vtable.on_fctx_end = fct_junit_logger__on_fctx_end;
- logger->vtable.on_delete = fct_junit_logger__on_delete;
- return logger;
-}
-
-
-/*
-------------------------------------------------------------
-MACRO MAGIC
-------------------------------------------------------------
-This is where the show begins!
-*/
-
-/* This macro invokes a bunch of functions that need to be referenced in
-order to avoid a "unreferenced local function has been removed" warning.
-The logical acrobatics below try and make it appear to the compiler that
-they are needed, but at runtime, only the cheap, first call is made. */
-#define FCT_REFERENCE_FUNCS() \
- {\
- int check = 0 && fctstr_ieq(NULL, NULL);\
- if ( check ) {\
- _fct_cmt("not to be executed");\
- (void)_fct_chk_empty_str(NULL);\
- (void)_fct_chk_full_str(NULL);\
- (void)fct_test__start_timer(NULL);\
- (void)fct_test__stop_timer(NULL);\
- (void)fct_ts_new(NULL);\
- (void)fct_ts__test_begin(NULL);\
- (void)fct_ts__add_test(NULL, NULL);\
- (void)fct_ts__test_end(NULL);\
- (void)fct_ts__inc_total_test_num(NULL);\
- (void)fct_ts__make_abort_test(NULL);\
- (void)fct_ts__setup_abort(NULL);\
- (void)fct_ts__setup_end(NULL);\
- (void)fct_ts__teardown_end(NULL);\
- (void)fct_ts__cnt_end(NULL);\
- (void)fct_ts__is_test_cnt(NULL, 0);\
- (void)fct_xchk_fn(0, "");\
- (void)fct_xchk2_fn(NULL, 0, "");\
- (void)fctkern__cl_parse(NULL);\
- (void)fctkern__add_ts(NULL, NULL);\
- (void)fctkern__pass_filter(NULL, NULL);\
- (void)fctkern__log_suite_start(NULL, NULL);\
- (void)fctkern__log_suite_end(NULL, NULL);\
- (void)fctkern__log_test_skip(NULL, NULL, NULL);\
- (void)fctkern__log_test_start(NULL, NULL);\
- (void)fctkern__log_test_end(NULL, NULL);\
- (void)fctstr_endswith(NULL,NULL);\
- (void)fctstr_iendswith(NULL,NULL);\
- (void)fctstr_ieq(NULL,NULL);\
- (void)fctstr_incl(NULL, NULL);\
- (void)fctstr_iincl(NULL, NULL);\
- (void)fctstr_iendswith(NULL,NULL);\
- (void)fctstr_istartswith(NULL,NULL);\
- (void)fctstr_clone_lower(NULL);\
- (void)fctstr_startswith(NULL,NULL);\
- (void)fctkern__init(NULL, 0, NULL);\
- (void)fctkern__cl_is(NULL, "");\
- (void)fctkern__cl_val2(NULL, NULL, NULL);\
- fctkern__log_suite_skip(NULL, NULL, NULL);\
- (void)fct_clp__is_param(NULL,NULL);\
- _fct_cmt("should never construct an object");\
- (void)fct_test_new(NULL);\
- (void)fct_ts__chk_cnt(NULL);\
- }\
- }
-
-
-#define FCT_INIT(_ARGC_, _ARGV_) \
- fctkern_t fctkern__; \
- fctkern_t* fctkern_ptr__ = &fctkern__; \
- FCT_REFERENCE_FUNCS(); \
- if ( !fctkern__init(fctkern_ptr__, argc, (const char **)argv) ) {\
- (void)fprintf( \
- stderr, "FATAL ERROR: Unable to initialize FCTX Kernel."\
- ); \
- exit(EXIT_FAILURE); \
- } \
-
-
-#define FCT_FINAL() \
- fctkern_ptr__->ns.num_total_failed = fctkern__tst_cnt_failed( \
- (fctkern_ptr__) \
- ); \
- fctkern__log_end(fctkern_ptr__); \
- fctkern__end(fctkern_ptr__); \
- fctkern__final(fctkern_ptr__); \
- FCT_ASSERT( !((int)fctkern_ptr__->ns.num_total_failed < 0) \
- && "or we got truncated!"); \
- if ( fctkern_ptr__->ns.num_total_failed == \
- fctkern_ptr__->num_expected_failures) { \
- fctkern_ptr__->ns.num_total_failed = 0; \
- } \
-
-
-
-#define FCT_NUM_FAILED() \
- fctkern_ptr__->ns.num_total_failed \
-
-
-
-/* Typically used internally only, this mentions to FCTX that you EXPECT
-to _NUM_FAILS_. If you the expected matches the actual, a 0 value is returned
-from the program. */
-#define FCT_EXPECTED_FAILURES(_NUM_FAILS_) \
- ((fctkern_ptr__->num_expected_failures = (_NUM_FAILS_)))
-
-
-#define FCT_BGN_FN(_FNNAME_) \
- int _FNNAME_(int argc, char* argv[])\
- { \
- FCT_INIT(argc, argv)
-
-#define FCT_END_FN() FCT_END()
-
-/* This defines our start. The fctkern__ is a kernal object
-that lives throughout the lifetime of our program. The
-fctkern_ptr__ makes it easier to abstract out macros. */
-#define FCT_BGN() FCT_BGN_FN(main)
-
-
-/* Silence Intel complaints about unspecified operand order in user's code */
-#ifndef __INTEL_COMPILER
-# define FCT_END_WARNINGFIX_BGN
-# define FCT_END_WARNINGFIX_END
-#else
-# define FCT_END_WARNINGFIX_BGN _Pragma("warning(push,disable:981)");
-# define FCT_END_WARNINGFIX_END _Pragma("warning(pop)");
-#endif
-
-/* Ends the test suite by returning the number failed. The "chk_cnt" call is
-made in order allow strict compilers to pass when it encounters unreferenced
-functions. */
-#define FCT_END() \
- { \
- FCT_END_WARNINGFIX_BGN \
- FCT_FINAL(); \
- return FCT_NUM_FAILED();\
- FCT_END_WARNINGFIX_END \
- }\
-}
-
-#define fctlog_install(_CUST_LOGGER_LIST_) \
- fctkern_ptr__->lt_usr = (_CUST_LOGGER_LIST_)
-
-/* Re-parses the command line options with the addition of user defined
-options. */
-#define fctcl_install(_CLO_INIT_) \
- {\
- fctkern_ptr__->cl_user_opts = (_CLO_INIT_);\
- _fct_cmt("Delay parse in order to allow for user customization.");\
- if ( !fctkern__cl_is_parsed((fctkern_ptr__)) ) {\
- int status = fctkern__cl_parse((fctkern_ptr__));\
- _fct_cmt("Need to parse command line before we start logger.");\
- fctkern__log_start((fctkern_ptr__));\
- switch( status ) {\
- case -1:\
- case 0:\
- fctkern__final(fctkern_ptr__);\
- exit( (status == 0) ? (EXIT_FAILURE) : (EXIT_SUCCESS) );\
- break;\
- default:\
- fct_pass();\
- }\
- }\
- }
-
-
-#define fctcl_is(_OPT_STR_) (fctkern__cl_is(fctkern_ptr__, (_OPT_STR_)))
-
-#define fctcl_val(_OPT_STR_) (fctcl_val2((_OPT_STR_), NULL))
-
-#define fctcl_val2(_OPT_STR_, _DEF_STR_) \
- (fctkern__cl_val2(fctkern_ptr__, (_OPT_STR_), (_DEF_STR_)))
-
-
-/* We delay the first parse of the command line until we get the first
-test fixture. This allows the user to possibly add their own parse
-specification. */
-#define FCT_FIXTURE_SUITE_BGN(_NAME_) \
- {\
- fctkern_ptr__->ns.ts_curr = fct_ts_new( #_NAME_ );\
- _fct_cmt("Delay parse in order to allow for user customization.");\
- if ( !fctkern__cl_is_parsed((fctkern_ptr__)) ) {\
- int status = fctkern__cl_parse((fctkern_ptr__));\
- _fct_cmt("Need to parse command line before we start logger.");\
- fctkern__log_start((fctkern_ptr__));\
- switch( status ) {\
- case -1:\
- case 0:\
- fct_ts__del((fctkern_ptr__->ns.ts_curr));\
- fctkern__final(fctkern_ptr__);\
- exit( (status == 0) ? (EXIT_FAILURE) : (EXIT_SUCCESS) );\
- break;\
- default:\
- fct_pass();\
- }\
- }\
- if ( fctkern_ptr__->ns.ts_curr == NULL ) {\
- fctkern__log_warn((fctkern_ptr__), "out of memory");\
- }\
- else\
- {\
- fctkern__log_suite_start((fctkern_ptr__), fctkern_ptr__->ns.ts_curr);\
- for (;;)\
- {\
- fctkern_ptr__->ns.test_num = -1;\
- if ( fct_ts__is_ending_mode(fctkern_ptr__->ns.ts_curr) \
- || fct_ts__is_abort_mode(fctkern_ptr__->ns.ts_curr) )\
- {\
- _fct_cmt("flag the test suite as complete.");\
- fct_ts__end(fctkern_ptr__->ns.ts_curr);\
- break;\
- }
-
-
-
-/* Closes off a "Fixture" test suite. */
-#define FCT_FIXTURE_SUITE_END() \
- if ( fct_ts__is_cnt_mode(fctkern_ptr__->ns.ts_curr) )\
- {\
- fct_ts__cnt_end(fctkern_ptr__->ns.ts_curr);\
- }\
- }\
- fctkern__add_ts((fctkern_ptr__), fctkern_ptr__->ns.ts_curr);\
- fctkern__log_suite_end((fctkern_ptr__), fctkern_ptr__->ns.ts_curr);\
- fct_ts__end(fctkern_ptr__->ns.ts_curr);\
- fctkern_ptr__->ns.ts_curr = NULL;\
- }\
- }
-
-#define FCT_FIXTURE_SUITE_BGN_IF(_CONDITION_, _NAME_) \
- fctkern_ptr__->ns.ts_is_skip_suite = !(_CONDITION_);\
- fctkern_ptr__->ns.ts_skip_cndtn = #_CONDITION_;\
- if ( fctkern_ptr__->ns.ts_is_skip_suite ) {\
- fctkern__log_suite_skip((fctkern_ptr__), #_CONDITION_, #_NAME_);\
- }\
- FCT_FIXTURE_SUITE_BGN(_NAME_);
-
-#define FCT_FIXTURE_SUITE_END_IF() \
- FCT_FIXTURE_SUITE_END();\
- fctkern_ptr__->ns.ts_is_skip_suite =0;\
- fctkern_ptr__->ns.ts_skip_cndtn =NULL;\
-
-#define FCT_SETUP_BGN()\
- if ( fct_ts__is_setup_mode(fctkern_ptr__->ns.ts_curr) ) {
-
-#define FCT_SETUP_END() \
- fct_ts__setup_end(fctkern_ptr__->ns.ts_curr); }
-
-#define FCT_TEARDOWN_BGN() \
- if ( fct_ts__is_teardown_mode(fctkern_ptr__->ns.ts_curr) ) {\
-
-#define FCT_TEARDOWN_END() \
- fct_ts__teardown_end(fctkern_ptr__->ns.ts_curr); \
- continue; \
- }
-
-/* Lets you create a test suite, where maybe you don't want a fixture. We
-do it by 'stubbing' out the setup/teardown logic. */
-#define FCT_SUITE_BGN(Name) \
- FCT_FIXTURE_SUITE_BGN(Name) {\
- FCT_SETUP_BGN() {_fct_cmt("stubbed"); } FCT_SETUP_END()\
- FCT_TEARDOWN_BGN() {_fct_cmt("stubbed");} FCT_TEARDOWN_END()\
-
-#define FCT_SUITE_END() } FCT_FIXTURE_SUITE_END()
-
-#define FCT_SUITE_BGN_IF(_CONDITION_, _NAME_) \
- FCT_FIXTURE_SUITE_BGN_IF(_CONDITION_, (_NAME_)) {\
- FCT_SETUP_BGN() {_fct_cmt("stubbed"); } FCT_SETUP_END()\
- FCT_TEARDOWN_BGN() {_fct_cmt("stubbed");} FCT_TEARDOWN_END()\
-
-#define FCT_SUITE_END_IF() } FCT_FIXTURE_SUITE_END_IF()
-
-typedef enum
-{
- FCT_TEST_END_FLAG_Default = 0x0000,
- FCT_TEST_END_FLAG_ClearFail = 0x0001
-} FCT_TEST_END_FLAG;
-
-
-#define FCT_TEST_BGN_IF(_CONDITION_, _NAME_) { \
- fctkern_ptr__->ns.test_is_skip = !(_CONDITION_);\
- fctkern_ptr__->ns.test_skip_cndtn = #_CONDITION_;\
- FCT_TEST_BGN(_NAME_) {\
-
-#define FCT_TEST_END_IF() \
- } FCT_TEST_END();\
- fctkern_ptr__->ns.test_is_skip = 0;\
- fctkern_ptr__->ns.test_skip_cndtn = NULL;\
- }
-
-
-/* Depending on whether or not we are counting the tests, we will have to
-first determine if the test is the "current" count. Then we have to determine
-if we can pass the filter. Finally we will execute everything so that when a
-check fails, we can "break" out to the end of the test. And in between all
-that we do a memory check and fail a test if we can't build a fct_test
-object (should be rare). */
-#define FCT_TEST_BGN(_NAME_) \
- {\
- fctkern_ptr__->ns.curr_test_name = #_NAME_;\
- ++(fctkern_ptr__->ns.test_num);\
- if ( fct_ts__is_cnt_mode(fctkern_ptr__->ns.ts_curr) )\
- {\
- fct_ts__inc_total_test_num(fctkern_ptr__->ns.ts_curr);\
- }\
- else if ( fct_ts__is_test_mode(fctkern_ptr__->ns.ts_curr) \
- && fct_ts__is_test_cnt(fctkern_ptr__->ns.ts_curr, fctkern_ptr__->ns.test_num) )\
- {\
- fct_ts__test_begin(fctkern_ptr__->ns.ts_curr);\
- if ( fctkern__pass_filter(fctkern_ptr__, fctkern_ptr__->ns.curr_test_name ) )\
- {\
- fctkern_ptr__->ns.curr_test = fct_test_new( fctkern_ptr__->ns.curr_test_name );\
- if ( fctkern_ptr__->ns.curr_test == NULL ) {\
- fctkern__log_warn(fctkern_ptr__, "out of memory");\
- } else if ( fctkern_ptr__->ns.ts_is_skip_suite \
- || fctkern_ptr__->ns.test_is_skip ) {\
- fct_ts__test_begin(fctkern_ptr__->ns.ts_curr);\
- fctkern__log_test_skip(\
- fctkern_ptr__,\
- fctkern_ptr__->ns.curr_test_name,\
- (fctkern_ptr__->ns.test_is_skip) ?\
- (fctkern_ptr__->ns.test_skip_cndtn) :\
- (fctkern_ptr__->ns.ts_skip_cndtn)\
- );\
- fct_ts__test_end(fctkern_ptr__->ns.ts_curr);\
- continue;\
- } else {\
- fctkern__log_test_start(fctkern_ptr__, fctkern_ptr__->ns.curr_test);\
- fct_test__start_timer(fctkern_ptr__->ns.curr_test);\
- for (;;) \
- {
-
-
-
-
-#define FCT_TEST_END() \
- break;\
- }\
- fct_test__stop_timer(fctkern_ptr__->ns.curr_test);\
- }\
- fct_ts__add_test(fctkern_ptr__->ns.ts_curr, fctkern_ptr__->ns.curr_test);\
- fctkern__log_test_end(fctkern_ptr__, fctkern_ptr__->ns.curr_test);\
- }\
- fct_ts__test_end(fctkern_ptr__->ns.ts_curr);\
- continue;\
- }\
- }\
-
-
-
-/*
----------------------------------------------------------
-CHECKING MACROS
-----------------------------------------------------------
-
-The chk variants will continue on while the req variants will abort
-a test if a chk condition fails. The req variants are useful when you
-no longer want to keep checking conditions because a critical condition
-is not being met. */
-
-
-/* To support older compilers that do not have macro variable argument lists
-we have to use a function. The macro manages to store away the line/file
-location into a global before it runs this function, a trick I picked up from
-the error handling in the APR library. The unfortunate thing is that we can
-not carry forth the actual test through a "stringize" operation, but if you
-wanted to do that you should use fct_chk. */
-
-static int fct_xchk_lineno =0;
-static char const *fct_xchk_file = NULL;
-static fct_test_t *fct_xchk_test = NULL;
-static fctkern_t *fct_xchk_kern =NULL;
-
-
-static int
-_fct_xchk_fn_varg(
- char const *condition,
- int is_pass,
- char const *format,
- va_list args
-)
-{
- fctchk_t *chk =NULL;
- chk = fctchk_new(
- is_pass,
- condition,
- fct_xchk_file,
- fct_xchk_lineno,
- format,
- args
- );
- if ( chk == NULL )
- {
- fctkern__log_warn(fct_xchk_kern, "out of memory (aborting test)");
- goto finally;
- }
-
- fct_test__add(fct_xchk_test, chk);
- fctkern__log_chk(fct_xchk_kern, chk);
-finally:
- fct_xchk_lineno =0;
- fct_xchk_file =NULL;
- fct_xchk_test =NULL;
- fct_xchk_kern =NULL;
- return is_pass;
-}
-
-
-static int
-fct_xchk2_fn(const char *condition, int is_pass, char const *format, ...)
-{
- int r =0;
- va_list args;
- va_start(args, format);
- r = _fct_xchk_fn_varg(condition, is_pass, format, args);
- va_end(args);
- return r;
-}
-
-
-static int
-fct_xchk_fn(int is_pass, char const *format, ...)
-{
- int r=0;
- va_list args;
- va_start(args, format);
- r = _fct_xchk_fn_varg("<none-from-xchk>", is_pass, format, args);
- va_end(args);
- return r;
-}
-
-
-/* Call this with the following argument list:
-
- fct_xchk(test_condition, format_str, ...)
-
-the bulk of this macro presets some globals to allow us to support
-variable argument lists on older compilers. The idea came from the APR
-libraries error checking routines. */
-#define fct_xchk fct_xchk_kern = fctkern_ptr__,\
- fct_xchk_test = fctkern_ptr__->ns.curr_test,\
- fct_xchk_lineno =__LINE__,\
- fct_xchk_file=__FILE__,\
- fct_xchk_fn
-
-#define fct_xchk2 fct_xchk_kern = fctkern_ptr__,\
- fct_xchk_test = fctkern_ptr__->ns.curr_test,\
- fct_xchk_lineno =__LINE__,\
- fct_xchk_file=__FILE__,\
- fct_xchk2_fn
-
-
-/* This checks the condition and reports the condition as a string
-if it fails. */
-#define fct_chk(_CNDTN_) (fct_xchk((_CNDTN_) ? 1 : 0, #_CNDTN_))
-
-#define _fct_req(_CNDTN_) \
- if ( !(fct_xchk((_CNDTN_) ? 1 : 0, #_CNDTN_)) ) { break; }
-
-
-/* When in test mode, construct a mock test object for fct_xchk to operate
-with. If we fail a setup up, then we go directly to a teardown mode. */
-#define fct_req(_CNDTN_) \
- if ( fct_ts__is_test_mode(fctkern_ptr__->ns.ts_curr) ) { \
- _fct_req((_CNDTN_)); \
- } \
- else if ( fct_ts__is_setup_mode(fctkern_ptr__->ns.ts_curr) \
- || fct_ts__is_teardown_mode(fctkern_ptr__->ns.ts_curr) ) { \
- fctkern_ptr__->ns.curr_test = fct_ts__make_abort_test( \
- fctkern_ptr__->ns.ts_curr \
- ); \
- if ( !(fct_xchk((_CNDTN_) ? 1 : 0, #_CNDTN_)) ) { \
- fct_ts__setup_abort(fctkern_ptr__->ns.ts_curr); \
- fct_ts__add_test( \
- fctkern_ptr__->ns.ts_curr, fctkern_ptr__->ns.curr_test \
- ); \
- } \
- } else { \
- assert("invalid condition for fct_req!"); \
- _fct_req((_CNDTN_)); \
- }
-
-
-#define fct_chk_eq_dbl(V1, V2) \
- fct_xchk(\
- ((int)(fabs((V1)-(V2)) < DBL_EPSILON)),\
- "chk_eq_dbl: %f != %f",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_neq_dbl(V1, V2) \
- fct_xchk(\
- ((int)(fabs((V1)-(V2)) >= DBL_EPSILON)),\
- "chk_neq_dbl: %f == %f",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_eq_str(V1, V2) \
- fct_xchk(fctstr_eq((V1), (V2)),\
- "chk_eq_str: '%s' != '%s'",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_neq_str(V1, V2) \
- fct_xchk(!fctstr_eq((V1), (V2)),\
- "chk_neq_str: '%s' == '%s'",\
- (V1),\
- (V2)\
- )
-
-/* To quiet warnings with GCC, who think we are being silly and passing
-in NULL to strlen, we will filter the predicate through these little
-functions */
-static int
-_fct_chk_empty_str(char const *s)
-{
- if ( s == NULL )
- {
- return 1;
- }
- return strlen(s) ==0;
-}
-static int
-_fct_chk_full_str(char const *s)
-{
- if ( s == NULL )
- {
- return 0;
- }
- return strlen(s) >0;
-}
-
-
-#define fct_chk_empty_str(V) \
- fct_xchk(_fct_chk_empty_str((V)),\
- "string not empty: '%s'",\
- (V)\
- )
-
-#define fct_chk_full_str(V) \
- fct_xchk(_fct_chk_full_str((V)),\
- "string is full: '%s'",\
- (V)\
- )
-
-
-#define fct_chk_eq_istr(V1, V2) \
- fct_xchk(fctstr_ieq((V1), (V2)),\
- "chk_eq_str: '%s' != '%s'",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_neq_istr(V1, V2) \
- fct_xchk(!fctstr_ieq((V1), (V2)),\
- "chk_neq_str: '%s' == '%s'",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_endswith_str(STR, CHECK)\
- fct_xchk(fctstr_endswith((STR),(CHECK)),\
- "fct_chk_endswith_str: '%s' doesn't end with '%s'",\
- (STR),\
- (CHECK)\
- )
-
-
-#define fct_chk_iendswith_str(STR, CHECK)\
- fct_xchk(fctstr_iendswith((STR), (CHECK)),\
- "fch_chk_iendswith_str: '%s' doesn't end with '%s'.",\
- (STR),\
- (CHECK)\
- )
-
-#define fct_chk_excl_str(STR, CHECK_EXCLUDE) \
- fct_xchk(!fctstr_incl((STR), (CHECK_EXCLUDE)),\
- "fct_chk_excl_str: '%s' is included in '%s'",\
- (STR),\
- (CHECK_EXCLUDE)\
- )
-
-#define fct_chk_excl_istr(ISTR, ICHECK_EXCLUDE) \
- fct_xchk(!fctstr_iincl((ISTR), (ICHECK_EXCLUDE)),\
- "fct_chk_excl_istr (case insensitive): '%s' is "\
- "included in'%s'",\
- (ISTR),\
- (ICHECK_EXCLUDE)\
- )
-
-#define fct_chk_incl_str(STR, CHECK_INCLUDE) \
- fct_xchk(fctstr_incl((STR), (CHECK_INCLUDE)),\
- "fct_chk_incl_str: '%s' does not include '%s'",\
- (STR),\
- (CHECK_INCLUDE)\
- )
-
-
-#define fct_chk_incl_istr(ISTR, ICHECK_INCLUDE) \
- fct_xchk(fctstr_iincl((ISTR), (ICHECK_INCLUDE)),\
- "fct_chk_incl_istr (case insensitive): '%s' does "\
- "not include '%s'",\
- (ISTR),\
- (ICHECK_INCLUDE)\
- )
-
-
-#define fct_chk_startswith_str(STR, CHECK)\
- fct_xchk(fctstr_startswith((STR), (CHECK)),\
- "'%s' does not start with '%s'",\
- (STR),\
- (CHECK)\
- )
-
-
-#define fct_chk_startswith_istr(STR, CHECK)\
- fct_xchk(fctstr_istartswith((STR), (CHECK)),\
- "case insensitive check: '%s' does not start with '%s'",\
- (STR),\
- (CHECK)\
- )
-
-#define fct_chk_eq_int(V1, V2) \
- fct_xchk(\
- ((V1) == (V2)),\
- "chq_eq_int: %d != %d",\
- (V1),\
- (V2)\
- )
-
-
-#define fct_chk_neq_int(V1, V2) \
- fct_xchk(\
- ((V1) != (V2)),\
- "chq_neq_int: %d == %d",\
- (V1),\
- (V2)\
- )
-
-#define fct_chk_ex(EXCEPTION, CODE) \
- { \
- bool pass_chk_ex = false; \
- try { \
- CODE; \
- pass_chk_ex = false; \
- } catch ( EXCEPTION ) { \
- pass_chk_ex = true; \
- } catch ( ... ) { \
- pass_chk_ex = false; \
- } \
- fct_xchk( \
- pass_chk_ex, \
- "%s exception not generated", \
- #EXCEPTION \
- ); \
- } \
-
-/*
----------------------------------------------------------
-GUT CHECK MACROS
-----------------------------------------------------------
-
-The following macros are used to help check the "guts" of
-the FCT, and to confirm that it all works according to spec.
-*/
-
-/* Generates a message to STDERR and exits the application with a
-non-zero number. */
-#define _FCT_GUTCHK(_CNDTN_) \
- if ( !(_CNDTN_) ) {\
- fprintf(stderr, "gutchk fail: '" #_CNDTN_ "' was not true.\n");\
- exit(1);\
- }\
- else {\
- fprintf(stdout, "gutchk pass: '" #_CNDTN_ "'\n");\
- }
-
-/*
----------------------------------------------------------
-MULTI-FILE TEST SUITE MACROS
-----------------------------------------------------------
-
-I struggled trying to figure this out in a way that was
-as simple as possible. I wanted to be able to define
-the test suite in one object file, then refer it within
-the other one within the minimum amount of typing.
-
-Unfortunately without resorting to some supermacro
-work, I could only find a happy comprimise.
-
-See test_multi.c for an example.
-*/
-
-/* The following macros are used in your separate object
-file to define your test suite. */
-
-
-#define FCTMF_FIXTURE_SUITE_BGN(NAME) \
- void NAME (fctkern_t *fctkern_ptr__) {\
- FCT_REFERENCE_FUNCS();\
- FCT_FIXTURE_SUITE_BGN( NAME ) {
-
-#define FCTMF_FIXTURE_SUITE_END() \
- } FCT_FIXTURE_SUITE_END();\
- }
-
-#define FCTMF_SUITE_BGN(NAME) \
- void NAME (fctkern_t *fctkern_ptr__) {\
- FCT_REFERENCE_FUNCS();\
- FCT_SUITE_BGN( NAME ) {
-#define FCTMF_SUITE_END() \
- } FCT_SUITE_END(); \
- }
-
-
-/* Deprecated, no longer required. */
-#define FCTMF_SUITE_DEF(NAME)
-
-
-/* Executes a test suite defined by FCTMF_SUITE* */
-#define FCTMF_SUITE_CALL(NAME) {\
- void NAME (fctkern_t *);\
- NAME (fctkern_ptr__);\
- }
-
-
-/*
----------------------------------------------------------
-FCT QUICK TEST API
-----------------------------------------------------------
-The goal of these little macros is to try and get you
-up and running with a test as quick as possible.
-
-The basic idea is that there is one test per test suite.
-*/
-
-#define FCT_QTEST_BGN(NAME) \
- FCT_SUITE_BGN(NAME) {\
- FCT_TEST_BGN(NAME) {\
-
-#define FCT_QTEST_END() \
- } FCT_TEST_END();\
- } FCT_SUITE_END();
-
-
-#define FCT_QTEST_BGN_IF(_CONDITION_, _NAME_) \
- FCT_SUITE_BGN(_NAME_) {\
- FCT_TEST_BGN_IF(_CONDITION_, _NAME_) {\
-
-#define FCT_QTEST_END_IF() \
- } FCT_TEST_END_IF();\
- } FCT_SUITE_END();
-
-#endif /* !FCT_INCLUDED__IMB */
diff --git a/tests/scripts/generate_code.pl b/tests/scripts/generate_code.pl
index 4565c61..43c71fc 100755
--- a/tests/scripts/generate_code.pl
+++ b/tests/scripts/generate_code.pl
@@ -9,9 +9,8 @@
my $test_file = $data_name.".c";
my $test_helper_file = $suite_dir."/helpers.function";
my $test_case_file = $suite_dir."/".$suite_name.".function";
-my $test_data_file = $suite_dir."/".$data_name.".data";
-
-open(TEST_DATA, "$test_data_file") or die "Opening test cases '$test_data_file': $!";
+my $test_case_data = $suite_dir."/".$data_name.".data";
+my $test_main_file = $suite_dir."/main_test.function";
my $line_separator = $/;
undef $/;
@@ -20,9 +19,18 @@
my $test_helpers = <TEST_HELPERS>;
close(TEST_HELPERS);
+open(TEST_MAIN, "$test_main_file") or die "Opening test main '$test_main_file': $!";
+my $test_main = <TEST_MAIN>;
+close(TEST_MAIN);
+
open(TEST_CASES, "$test_case_file") or die "Opening test cases '$test_case_file': $!";
my $test_cases = <TEST_CASES>;
close(TEST_CASES);
+
+open(TEST_DATA, "$test_case_data") or die "Opening test data '$test_case_data': $!";
+my $test_data = <TEST_DATA>;
+close(TEST_DATA);
+
my ( $suite_header ) = $test_cases =~ /BEGIN_HEADER\n(.*?)\nEND_HEADER/s;
my ( $suite_defines ) = $test_cases =~ /BEGIN_DEPENDENCIES\n(.*?)\nEND_DEPENDENCIES/s;
@@ -31,10 +39,13 @@
{
( $requirements ) = $suite_defines =~ /^depends_on:(.*)$/;
}
-
+
my @var_req_arr = split(/:/, $requirements);
my $suite_pre_code;
my $suite_post_code;
+my $dispatch_code;
+my $mapping_code;
+my %mapping_values;
while (@var_req_arr)
{
@@ -48,114 +59,164 @@
open(TEST_FILE, ">$test_file") or die "Opening destination file '$test_file': $!";
print TEST_FILE << "END";
-#include "fct.h"
#include <polarssl/config.h>
$suite_header
$test_helpers
-FCT_BGN()
-{
$suite_pre_code
-#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
- unsigned char buf[1000000];
- memory_buffer_alloc_init( buf, sizeof(buf) );
-#endif
-
-
- FCT_SUITE_BGN($suite_name)
- {
END
-while (my $line = <TEST_DATA>)
+while($test_cases =~ /BEGIN_CASE *([\w:]*)\n(\w+):([^\n]*)\n\{\n(.*?)\}\nEND_CASE/sg)
{
- my $description = $line;
- $line = <TEST_DATA>;
+ my $function_deps = $1;
+ my $function_name = $2;
+ my $function_params = $3;
+ my $function_code = $4;
+ my $function_pre_code;
+ my $function_post_code;
+ my @param_decl;
+ my $param_defs;
+ my $param_checks;
+ my @dispatch_params;
+ my @var_def_arr = split(/:/, $function_params);
+ my $i = 1;
+ my $mapping_regex = "".$function_name;
+ my $mapping_count = 0;
- my $test_name = $description;
- $test_name =~ tr/A-Z \-/a-z__/;
- $test_name =~ tr/a-z0-9_//cd;
-
- # Carve the defines required for this test case
- my $requirements;
- if ($line =~ /^depends_on:/)
+ if ($function_deps =~ /^depends_on:/)
{
- my $depends_on_line = $line;
- $line = <TEST_DATA>;
-
- ( $requirements ) = $depends_on_line =~ /^depends_on:(.*)$/;
- }
-
- my @var_req_arr = split(/:/, $requirements);
- my $pre_code;
- my $post_code;
-
- while (@var_req_arr)
- {
- my $req = shift @var_req_arr;
-
- $pre_code .= "#ifdef $req\n";
- $post_code .= "#endif /* $req */\n";
+ ( $function_deps ) = $function_deps =~ /^depends_on:(.*)$/;
}
- my $command_line = $line;
- $line = <TEST_DATA>;
-
- # Carve the case name and variable values
- #
- my ( $case, $var_value ) = $command_line =~ /^([\w_]+):(.*)$/;
-
- # Escape the escaped colons (Not really escaped now)
- #
- $var_value =~ s/\\:/{colon_sign}/g;
-
- # Carve the case and variable definition
- #
- my ( $var_def, $case_code ) = $test_cases =~ /BEGIN_CASE\n$case:([^\n]*)\n(.*?)\nEND_CASE/s;
-
- my @var_def_arr = split(/:/, $var_def);
- my @var_value_arr = split(/:/, $var_value);
-
- while (@var_def_arr)
+ foreach my $req (split(/:/, $function_deps))
{
- my $def = shift @var_def_arr;
- my $val = shift @var_value_arr;
-
- $case_code =~ s/\{$def\}/$val/g;
+ $function_pre_code .= "#ifdef $req\n";
+ $function_post_code .= "#endif /* $req */\n";
}
- $case_code = "int ${test_name}_code_present = 0;\nTEST_ASSERT( ${test_name}_code_present == 1 );" if ($case_code =~ /^\s*$/);
- $case_code =~ s/{colon_sign}/:/g;
- $case_code =~ s/TEST_ASSERT/fct_chk/g;
- $case_code =~ s/TEST_EQUALS/fct_chk/g;
+ foreach my $def (@var_def_arr)
+ {
+ # Handle the different parameter types
- $case_code =~ s/^/ /gm;
+ if( substr($def, 0, 1) eq "#" )
+ {
+ $param_defs .= " int param$i;\n";
+ $param_checks .= " if( verify_int( params[$i], ¶m$i ) != 0 ) return( 2 );\n";
+ push @dispatch_params, "param$i";
+ $def =~ s/#//;
+ push @param_decl, "int $def";
+ $mapping_regex .= ":([\\d\\w |\\+\\-\\(\\)]+)";
+ $mapping_count++;
+ }
+ else
+ {
+ $param_defs .= " char *param$i = params[$i];\n";
+ $param_checks .= " if( verify_string( ¶m$i ) != 0 ) return( 2 );\n";
+ push @dispatch_params, "param$i";
+ push @param_decl, "char *$def";
+ $mapping_regex .= ":[^:]+";
+ }
+ $i++;
- print TEST_FILE << "END";
-$pre_code
- FCT_TEST_BGN($test_name)
-$case_code
- FCT_TEST_END();
-$post_code
+ $function_code =~ s/\{$def\}/$def/g;
+ }
+
+ # Find non-integer values we should map for this function
+ if( $mapping_count)
+ {
+ my @res = $test_data =~ /^$mapping_regex/msg;
+ foreach my $value (@res)
+ {
+ $mapping_values{$value} = 1 if ($value !~ /^\d+$/);
+ }
+ }
+
+ my $call_params = join ", ", @dispatch_params;
+ my $param_count = @var_def_arr + 1;
+ $dispatch_code .= << "END";
+if( strcmp( params[0], "$function_name" ) == 0 )
+{
+$function_pre_code
+$param_defs
+ if( cnt != $param_count )
+ {
+ fprintf( stderr, "\\nIncorrect argument count (%d != %d)\\n", cnt, $param_count );
+ return( 2 );
+ }
+
+$param_checks
+ ret = test_suite_$function_name( $call_params );
+ return ( ret != 0 );
+$function_post_code
+ return ( 3 );
+}
+else
+END
+
+ my $function_def = "int test_suite_$function_name(";
+ $function_def .= join ", ", @param_decl;
+ $function_def .= ")\n{\n";
+
+ $function_code = $function_pre_code . $function_def . $function_code . "\n return( 0 );\n}\n";
+ $function_code .= $function_post_code;
+ $test_main =~ s/FUNCTION_CODE/$function_code\n\nFUNCTION_CODE/;
+}
+
+# Find specific case dependencies that we should be able to check
+# and make check code
+my $dep_check_code;
+
+my @res = $test_data =~ /^depends_on:([\w:]+)/msg;
+my %case_deps;
+foreach my $deps (@res)
+{
+ foreach my $dep (split(/:/, $deps))
+ {
+ $case_deps{$dep} = 1;
+ }
+}
+while( my ($key, $value) = each(%case_deps) )
+{
+ $dep_check_code .= << "END";
+ if( strcmp( str, "$key" ) == 0 )
+ {
+#if defined($key)
+ return( 0 );
+#else
+ return( 1 );
+#endif
+ }
END
}
+# Make mapping code
+while( my ($key, $value) = each(%mapping_values) )
+{
+ $mapping_code .= << "END";
+ if( strcmp( str, "$key" ) == 0 )
+ {
+ *value = ( $key );
+ return( 0 );
+ }
+END
+}
+
+$dispatch_code =~ s/^(.+)/ $1/mg;
+
+$test_main =~ s/TEST_FILENAME/$test_case_data/;
+$test_main =~ s/FUNCTION_CODE//;
+$test_main =~ s/DEP_CHECK_CODE/$dep_check_code/;
+$test_main =~ s/DISPATCH_FUNCTION/$dispatch_code/;
+$test_main =~ s/MAPPING_CODE/$mapping_code/;
+
print TEST_FILE << "END";
- }
- FCT_SUITE_END();
-
-#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C) && defined(POLARSSL_MEMORY_DEBUG)
- memory_buffer_alloc_status();
-#endif
-
$suite_post_code
-}
-FCT_END();
+$test_main
END
-close(TEST_DATA);
close(TEST_FILE);
diff --git a/tests/suites/helpers.function b/tests/suites/helpers.function
index 66af8af..881a0ac 100644
--- a/tests/suites/helpers.function
+++ b/tests/suites/helpers.function
@@ -9,6 +9,10 @@
#include <inttypes.h>
#endif
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
/*
* 32-bit integer manipulation macros (big endian)
*/
diff --git a/tests/suites/main_test.function b/tests/suites/main_test.function
new file mode 100644
index 0000000..ca2e252
--- /dev/null
+++ b/tests/suites/main_test.function
@@ -0,0 +1,283 @@
+#include <stdio.h>
+#include <string.h>
+
+static int test_errors = 0;
+
+static int test_assert( int correct, char *test )
+{
+ if( correct )
+ return( 0 );
+
+ test_errors++;
+// if( test_errors == 1 )
+ printf( "FAILED\n %s\n\n", test );
+
+ return( 1 );
+}
+
+#define TEST_ASSERT( TEST ) (test_assert((TEST) ? 1 : 0, #TEST))
+
+int verify_string( char **str )
+{
+ if( (*str)[0] != '"' ||
+ (*str)[strlen( *str ) - 1] != '"' )
+ {
+ printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
+ return( -1 );
+ }
+
+ (*str)++;
+ (*str)[strlen( *str ) - 1] = '\0';
+
+ return( 0 );
+}
+
+int verify_int( char *str, int *value )
+{
+ size_t i;
+ int minus = 0;
+ int digits = 1;
+ int hex = 0;
+
+ for( i = 0; i < strlen( str ); i++ )
+ {
+ if( i == 0 && str[i] == '-' )
+ {
+ minus = 1;
+ continue;
+ }
+
+ if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
+ str[i - 1] == '0' && str[i] == 'x' )
+ {
+ hex = 1;
+ continue;
+ }
+
+ if( str[i] < '0' || str[i] > '9' )
+ {
+ digits = 0;
+ break;
+ }
+ }
+
+ if( digits )
+ {
+ if( hex )
+ *value = strtol( str, NULL, 16 );
+ else
+ *value = strtol( str, NULL, 10 );
+
+ return( 0 );
+ }
+
+MAPPING_CODE
+
+ printf( "Expected integer for parameter and got: %s\n", str );
+ return( -1 );
+}
+
+int dep_check( char *str )
+{
+ if( str == NULL )
+ return( 1 );
+
+DEP_CHECK_CODE
+
+ return( 1 );
+}
+
+FUNCTION_CODE
+int dispatch_test(int cnt, char *params[50])
+{
+ int ret;
+
+DISPATCH_FUNCTION
+ {
+ fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
+ fflush( stdout );
+ return( 1 );
+ }
+
+ return( ret );
+}
+
+int get_line( FILE *f, char *buf, size_t len )
+{
+ char *ret;
+
+ ret = fgets( buf, len, f );
+ if( ret == NULL )
+ return( -1 );
+
+ if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
+ buf[strlen(buf) - 1] = '\0';
+ if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
+ buf[strlen(buf) - 1] = '\0';
+
+ return( 0 );
+}
+
+int parse_arguments( char *buf, size_t len, char *params[50] )
+{
+ int cnt = 0, i;
+ char *cur = buf;
+ char *p = buf, *q;
+
+ params[cnt++] = cur;
+
+ while( *p != '\0' && p < buf + len )
+ {
+ if( *p == '\\' )
+ {
+ *p++;
+ *p++;
+ continue;
+ }
+ if( *p == ':' )
+ {
+ if( p + 1 < buf + len )
+ {
+ cur = p + 1;
+ params[cnt++] = cur;
+ }
+ *p = '\0';
+ }
+
+ *p++;
+ }
+
+ // Replace newlines, question marks and colons in strings
+ for( i = 0; i < cnt; i++ )
+ {
+ p = params[i];
+ q = params[i];
+
+ while( *p != '\0' )
+ {
+ if( *p == '\\' && *(p + 1) == 'n' )
+ {
+ p += 2;
+ *(q++) = '\n';
+ }
+ else if( *p == '\\' && *(p + 1) == ':' )
+ {
+ p += 2;
+ *(q++) = ':';
+ }
+ else if( *p == '\\' && *(p + 1) == '?' )
+ {
+ p += 2;
+ *(q++) = '?';
+ }
+ else
+ *(q++) = *(p++);
+ }
+ *q = '\0';
+ }
+
+ return( cnt );
+}
+
+int main()
+{
+ int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
+ const char *filename = "TEST_FILENAME";
+ FILE *file;
+ char buf[5000];
+ char *params[50];
+
+#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
+ unsigned char buf[1000000];
+ memory_buffer_alloc_init( buf, sizeof(buf) );
+#endif
+
+ file = fopen( filename, "r" );
+ if( file == NULL )
+ {
+ fprintf( stderr, "Failed to open\n" );
+ return( 1 );
+ }
+
+ while( !feof( file ) )
+ {
+ int skip = 0;
+
+ if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
+ break;
+ fprintf( stdout, "%.66s", buf );
+ fprintf( stdout, " " );
+ for( i = strlen( buf ) + 1; i < 67; i++ )
+ fprintf( stdout, "." );
+ fprintf( stdout, " " );
+ fflush( stdout );
+
+ total_tests++;
+
+ if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
+ break;
+ cnt = parse_arguments( buf, strlen(buf), params );
+
+ if( strcmp( params[0], "depends_on" ) == 0 )
+ {
+ for( i = 1; i < cnt; i++ )
+ if( dep_check( params[i] ) != 0 )
+ skip = 1;
+
+ if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
+ break;
+ cnt = parse_arguments( buf, strlen(buf), params );
+ }
+
+ if( skip == 0 )
+ {
+ test_errors = 0;
+ ret = dispatch_test( cnt, params );
+ }
+
+ if( skip == 1 || ret == 3 )
+ {
+ total_skipped++;
+ fprintf( stdout, "-------\n" );
+ fflush( stdout );
+ }
+ else if( ret == 0 && test_errors == 0 )
+ {
+ fprintf( stdout, "PASS\n" );
+ fflush( stdout );
+ }
+ else if( ret == 2 )
+ {
+ fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
+ fclose(file);
+ exit( 2 );
+ }
+ else
+ total_errors++;
+
+ if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
+ break;
+ if( strlen(buf) != 0 )
+ {
+ fprintf( stderr, "Should be empty %d\n", strlen(buf) );
+ return( 1 );
+ }
+ }
+ fclose(file);
+
+ fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
+ if( total_errors == 0 )
+ fprintf( stdout, "PASSED" );
+ else
+ fprintf( stdout, "FAILED" );
+
+ fprintf( stdout, " (%d / %d tests (%d skipped))\n",
+ total_tests - total_errors, total_tests, total_skipped );
+
+#if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C) && defined(POLARSSL_MEMORY_DEBUG)
+ memory_buffer_alloc_status();
+#endif
+
+ return( total_errors != 0 );
+}
+