tests_shared.h

/*
 * tests_shared.h
 *
 * Functions, types, and macros that are used by both the C and C++ test rigs.
 *
 * Version: 2.2.5
 *
 * ----------------------------------------------------------------------------
 *
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2018-2024 Ryan M. Lederman <lederman@gmail.com>
 * Copyright (c) 2018-2024 Jeffrey H. Johnson <trnsz@pobox.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * ----------------------------------------------------------------------------
 */
 
#ifndef _SIR_TESTS_SHARED_H_INCLUDED
# define _SIR_TESTS_SHARED_H_INCLUDED
 
# include "sir.h"
# include "sir/errors.h"
# include "sir/internal.h"
# include "sir/helpers.h"
# include "sir/ansimacros.h"
# include "sir/filesystem.h"
 
# if !defined(__WIN__) || defined(__ORANGEC__)
#  if !defined(__ORANGEC__)
#   include <dirent.h>
#  endif
# elif defined(__WIN__)
#  include <math.h>
# endif
 
# if defined(__cplusplus)
extern "C" {
# endif
 
# define SIR_TESTLOGDIR "./logs/"
 
# define MAKE_LOG_NAME(name) SIR_TESTLOGDIR name
 
# define TEST_S(n) ((n) > 1 ? "tests" : "test")
 
# define PRN_STR(str) ((str) ? (str) : SIR_RED("NULL"))
 
# define PRN_PASS(pass) ((pass) ? SIR_GREENB("PASS") : SIR_REDB("FAIL"))
 
# define INDENT_ITEM "\t  " SIR_BULLET " "
 
# define SIR_MAXTESTNAME 32
 
# define SIR_CL_MAXFLAG  32
 
# define SIR_CL_MAXUSAGE 256
 
# define SIR_CL_PERFFLAG      "--perf"
# define SIR_CL_ONLYFLAG      "--only"
# define SIR_CL_LISTFLAG      "--list"
# define SIR_CL_LEAVELOGSFLAG "--leave-logs"
# define SIR_CL_WAITFLAG      "--wait"
# define SIR_CL_VERSIONFLAG   "--version"
# define SIR_CL_HELPFLAG      "--help"
 
# define SIR_CL_ONLYUSAGE     SIR_ULINE("name") " [, " SIR_ULINE("name") ", ...]"
 
# define SIR_CL_PERFNAME      "performance"
 
# define SIR_CL_PERFDESC      "Only run the performance measurement test"
# define SIR_CL_ONLYDESC      "Only run the test(s) specified"
# define SIR_CL_LISTDESC      "Prints a list of available test names for use with '" SIR_BOLD("--only") "'"
# define SIR_CL_LEAVELOGSDESC "Log files are not deleted so that they may be examined"
# define SIR_CL_WAITDESC      "After running test(s), wait for a keypress before exiting"
# define SIR_CL_VERSIONDESC   "Prints the version of libsir that the test suite was built with"
# define SIR_CL_HELPDESC      "Shows this message"
 
# define TEST_MSG(msg, ...) (void)printf("\t" msg SIR_EOL, __VA_ARGS__)
 
# define TEST_MSG_0(msg) (void)printf("\t" msg SIR_EOL)
 
# define ERROR_MSG(msg, ...) TEST_MSG(SIR_RED(msg), __VA_ARGS__)
 
# define ERROR_MSG_0(msg) TEST_MSG_0(SIR_RED(msg))
 
# if !defined(SIR_NO_TEXT_STYLING)
#  define PASSFAIL_MSG(expr, msg, ...) \
     (void)printf(expr ? SIR_GREEN(msg) : SIR_RED(msg), __VA_ARGS__)
# else
#  define PASSFAIL_MSG(expr, msg, ...) \
     (void)printf(msg, __VA_ARGS__)
# endif
 
# define PRINT_EXPECTED_ERROR() (void)print_test_error(true, true)
 
# define PRINT_RESULT_RETURN(pass) print_test_error(pass, false)
 
# if !defined(__WIN__)
#  define HANDLE_OS_ERROR(clib, msg, ...) \
    do { \
        SIR_UNUSED(clib); \
        (void)_sir_handleerr(errno); \
        ERROR_MSG(msg ":", __VA_ARGS__); \
        (void)print_test_error(false, false); \
    } while (false)
# else /* __WIN__ */
#  define HANDLE_OS_ERROR(clib, msg, ...) \
    do { \
        clib ? (void)_sir_handleerr(errno) : (void)_sir_handlewin32err(GetLastError()); \
        ERROR_MSG(msg ":", __VA_ARGS__); \
        (void)print_test_error(false, false); \
    } while (false)
# endif
 
# if !defined(__cplusplus)
typedef bool (*sir_test_fn)(void);
# else
typedef bool (*sir_test_fn)();
# endif
 
typedef struct {
    const char* const name; 
    sir_test_fn fn;         
    bool run;               
    bool pass;              
} sir_test;
 
typedef struct {
    const char* const flag;  
    const char* const usage; 
    const char* const desc;  
} sir_cl_arg;
 
typedef struct {
    bool leave_logs; 
    bool wait;       
    bool only;       
    size_t to_run;   
} sir_cl_config;
 
void print_intro(size_t tgt_tests);
 
void print_test_intro(size_t num, size_t tgt_tests, const char* const name);
 
void print_test_outro(size_t num, size_t tgt_tests, const char* const name, bool pass);
 
void print_test_summary(size_t tgt_tests, size_t passed, double elapsed);
 
void print_failed_test_intro(size_t tgt_tests, size_t passed);
 
void print_failed_test(const char* const name);
 
bool mark_test_to_run(const char* const name, sir_test* tests, size_t num_tests);
 
void print_test_list(const sir_test* tests, size_t num_tests);
 
void print_usage_info(const sir_cl_arg* args, size_t num_args);
 
bool print_test_error(bool result, bool expected);
 
void print_libsir_version(void);
 
const sir_cl_arg* find_cl_arg(const char* flag, const sir_cl_arg* args, size_t num_args);
 
bool parse_cmd_line(int argc, char** argv, const sir_cl_arg* args, size_t num_args,
    sir_test* tests, size_t num_tests, sir_cl_config* config);
 
void wait_for_keypress(void);
 
static inline
void sir_timer_start(sir_time* timer) {
    (void)_sir_msec_since(NULL, timer);
}
 
static inline
double sir_timer_elapsed(const sir_time* timer) {
    sir_time now;
    return _sir_msec_since(timer, &now);
}
 
long sir_timer_getres(void);
 
void sir_sleep_msec(uint32_t msec);
 
size_t sir_readline(FILE* f, char* buf, size_t size);
 
uint32_t getrand(uint32_t upper_bound);
 
static inline
bool getrand_bool(uint32_t upper_bound) {
    return ((!upper_bound) ? true : getrand(upper_bound) % 2 == 0);
}
 
void rmfile(const char* filename, bool leave_logs);
 
bool enumfiles(const char* path, const char* search, bool del, unsigned* count);
 
# if defined(__cplusplus)
}
# endif
 
#endif /* !_SIR_TESTS_SHARED_H_INCLUDED */