mirror of
https://git.proxmox.com/git/libgit2
synced 2025-05-06 11:19:47 +00:00
3454 lines
120 KiB
C
3454 lines
120 KiB
C
#include <assert.h>
|
|
#include <setjmp.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <stdarg.h>
|
|
|
|
/* required for sandboxing */
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#ifdef _WIN32
|
|
# include <windows.h>
|
|
# include <io.h>
|
|
# include <shellapi.h>
|
|
# include <direct.h>
|
|
|
|
# define _MAIN_CC __cdecl
|
|
|
|
# define stat(path, st) _stat(path, st)
|
|
# define mkdir(path, mode) _mkdir(path)
|
|
# define chdir(path) _chdir(path)
|
|
# define access(path, mode) _access(path, mode)
|
|
# define strdup(str) _strdup(str)
|
|
# define strcasecmp(a,b) _stricmp(a,b)
|
|
|
|
# ifndef __MINGW32__
|
|
# pragma comment(lib, "shell32")
|
|
# define strncpy(to, from, to_size) strncpy_s(to, to_size, from, _TRUNCATE)
|
|
# define W_OK 02
|
|
# define S_ISDIR(x) ((x & _S_IFDIR) != 0)
|
|
# define snprint_eq(buf,sz,fmt,a,b) _snprintf_s(buf,sz,_TRUNCATE,fmt,a,b)
|
|
# else
|
|
# define snprint_eq snprintf
|
|
# endif
|
|
typedef struct _stat STAT_T;
|
|
#else
|
|
# include <sys/wait.h> /* waitpid(2) */
|
|
# include <unistd.h>
|
|
# define _MAIN_CC
|
|
# define snprint_eq snprintf
|
|
typedef struct stat STAT_T;
|
|
#endif
|
|
|
|
#include "clar.h"
|
|
|
|
static void fs_rm(const char *_source);
|
|
static void fs_copy(const char *_source, const char *dest);
|
|
|
|
static const char *
|
|
fixture_path(const char *base, const char *fixture_name);
|
|
|
|
struct clar_error {
|
|
const char *test;
|
|
int test_number;
|
|
const char *suite;
|
|
const char *file;
|
|
int line_number;
|
|
const char *error_msg;
|
|
char *description;
|
|
|
|
struct clar_error *next;
|
|
};
|
|
|
|
static struct {
|
|
const char *active_test;
|
|
const char *active_suite;
|
|
|
|
int suite_errors;
|
|
int total_errors;
|
|
|
|
int test_count;
|
|
|
|
int report_errors_only;
|
|
int exit_on_error;
|
|
|
|
struct clar_error *errors;
|
|
struct clar_error *last_error;
|
|
|
|
void (*local_cleanup)(void *);
|
|
void *local_cleanup_payload;
|
|
|
|
jmp_buf trampoline;
|
|
int trampoline_enabled;
|
|
} _clar;
|
|
|
|
struct clar_func {
|
|
const char *name;
|
|
void (*ptr)(void);
|
|
};
|
|
|
|
struct clar_suite {
|
|
int index;
|
|
const char *name;
|
|
struct clar_func initialize;
|
|
struct clar_func cleanup;
|
|
const char **categories;
|
|
const struct clar_func *tests;
|
|
size_t test_count;
|
|
};
|
|
|
|
/* From clar_print_*.c */
|
|
static void clar_print_init(int test_count, int suite_count, const char *suite_names);
|
|
static void clar_print_shutdown(int test_count, int suite_count, int error_count);
|
|
static void clar_print_error(int num, const struct clar_error *error);
|
|
static void clar_print_ontest(const char *test_name, int test_number, int failed);
|
|
static void clar_print_onsuite(const char *suite_name, int suite_index);
|
|
static void clar_print_onabort(const char *msg, ...);
|
|
|
|
/* From clar_sandbox.c */
|
|
static void clar_unsandbox(void);
|
|
static int clar_sandbox(void);
|
|
|
|
/* From clar_categorize.c */
|
|
static int clar_category_is_suite_enabled(const struct clar_suite *);
|
|
static void clar_category_enable(const char *category);
|
|
static void clar_category_enable_all(size_t, const struct clar_suite *);
|
|
static void clar_category_print_enabled(const char *prefix);
|
|
|
|
/* Event callback overrides */
|
|
#define clar_on_test() /* nop */
|
|
#define clar_on_suite() /* nop */
|
|
|
|
/* Autogenerated test data by clar */
|
|
static const struct clar_func _clar_cb_attr_file[] = {
|
|
{"assign_variants", &test_attr_file__assign_variants},
|
|
{"check_attr_examples", &test_attr_file__check_attr_examples},
|
|
{"match_variants", &test_attr_file__match_variants},
|
|
{"simple_read", &test_attr_file__simple_read}
|
|
};
|
|
static const struct clar_func _clar_cb_attr_flags[] = {
|
|
{"bare", &test_attr_flags__bare},
|
|
{"index_vs_workdir", &test_attr_flags__index_vs_workdir},
|
|
{"subdir", &test_attr_flags__subdir}
|
|
};
|
|
static const struct clar_func _clar_cb_attr_lookup[] = {
|
|
{"assign_variants", &test_attr_lookup__assign_variants},
|
|
{"check_attr_examples", &test_attr_lookup__check_attr_examples},
|
|
{"from_buffer", &test_attr_lookup__from_buffer},
|
|
{"match_variants", &test_attr_lookup__match_variants},
|
|
{"simple", &test_attr_lookup__simple}
|
|
};
|
|
static const struct clar_func _clar_cb_attr_repo[] = {
|
|
{"bad_macros", &test_attr_repo__bad_macros},
|
|
{"foreach", &test_attr_repo__foreach},
|
|
{"get_many", &test_attr_repo__get_many},
|
|
{"get_one", &test_attr_repo__get_one},
|
|
{"macros", &test_attr_repo__macros},
|
|
{"manpage_example", &test_attr_repo__manpage_example},
|
|
{"staging_properly_normalizes_line_endings_according_to_gitattributes_directives", &test_attr_repo__staging_properly_normalizes_line_endings_according_to_gitattributes_directives}
|
|
};
|
|
static const struct clar_func _clar_cb_buf_basic[] = {
|
|
{"printf", &test_buf_basic__printf},
|
|
{"resize", &test_buf_basic__resize}
|
|
};
|
|
static const struct clar_func _clar_cb_buf_splice[] = {
|
|
{"append", &test_buf_splice__append},
|
|
{"dont_do_anything", &test_buf_splice__dont_do_anything},
|
|
{"insert_at", &test_buf_splice__insert_at},
|
|
{"preprend", &test_buf_splice__preprend},
|
|
{"remove_at", &test_buf_splice__remove_at},
|
|
{"replace", &test_buf_splice__replace},
|
|
{"replace_with_longer", &test_buf_splice__replace_with_longer},
|
|
{"replace_with_shorter", &test_buf_splice__replace_with_shorter},
|
|
{"truncate", &test_buf_splice__truncate}
|
|
};
|
|
static const struct clar_func _clar_cb_checkout_head[] = {
|
|
{"checking_out_an_orphaned_head_returns_GIT_EORPHANEDHEAD", &test_checkout_head__checking_out_an_orphaned_head_returns_GIT_EORPHANEDHEAD}
|
|
};
|
|
static const struct clar_func _clar_cb_checkout_index[] = {
|
|
{"calls_progress_callback", &test_checkout_index__calls_progress_callback},
|
|
{"can_create_missing_files", &test_checkout_index__can_create_missing_files},
|
|
{"can_notify_of_skipped_files", &test_checkout_index__can_notify_of_skipped_files},
|
|
{"can_overcome_name_clashes", &test_checkout_index__can_overcome_name_clashes},
|
|
{"can_overwrite_modified_file", &test_checkout_index__can_overwrite_modified_file},
|
|
{"can_remove_untracked_files", &test_checkout_index__can_remove_untracked_files},
|
|
{"cannot_checkout_a_bare_repository", &test_checkout_index__cannot_checkout_a_bare_repository},
|
|
{"donot_overwrite_modified_file_by_default", &test_checkout_index__donot_overwrite_modified_file_by_default},
|
|
{"honor_coreautocrlf_setting_set_to_true", &test_checkout_index__honor_coreautocrlf_setting_set_to_true},
|
|
{"honor_coresymlinks_setting_set_to_false", &test_checkout_index__honor_coresymlinks_setting_set_to_false},
|
|
{"honor_coresymlinks_setting_set_to_true", &test_checkout_index__honor_coresymlinks_setting_set_to_true},
|
|
{"honor_the_gitattributes_directives", &test_checkout_index__honor_the_gitattributes_directives},
|
|
{"honor_the_specified_pathspecs", &test_checkout_index__honor_the_specified_pathspecs},
|
|
{"options_dir_modes", &test_checkout_index__options_dir_modes},
|
|
{"options_disable_filters", &test_checkout_index__options_disable_filters},
|
|
{"options_open_flags", &test_checkout_index__options_open_flags},
|
|
{"options_override_file_modes", &test_checkout_index__options_override_file_modes},
|
|
{"wont_notify_of_expected_line_ending_changes", &test_checkout_index__wont_notify_of_expected_line_ending_changes}
|
|
};
|
|
static const struct clar_func _clar_cb_checkout_tree[] = {
|
|
{"calls_progress_callback", &test_checkout_tree__calls_progress_callback},
|
|
{"can_checkout_a_subdirectory_from_a_commit", &test_checkout_tree__can_checkout_a_subdirectory_from_a_commit},
|
|
{"can_checkout_a_subdirectory_from_a_subtree", &test_checkout_tree__can_checkout_a_subdirectory_from_a_subtree},
|
|
{"cannot_checkout_a_non_treeish", &test_checkout_tree__cannot_checkout_a_non_treeish}
|
|
};
|
|
static const struct clar_func _clar_cb_checkout_typechange[] = {
|
|
{"checkout_typechanges", &test_checkout_typechange__checkout_typechanges}
|
|
};
|
|
static const struct clar_func _clar_cb_clone_network[] = {
|
|
{"can_checkout_a_cloned_repo", &test_clone_network__can_checkout_a_cloned_repo},
|
|
{"can_prevent_the_checkout_of_a_standard_repo", &test_clone_network__can_prevent_the_checkout_of_a_standard_repo},
|
|
{"cope_with_already_existing_directory", &test_clone_network__cope_with_already_existing_directory},
|
|
{"empty_repository", &test_clone_network__empty_repository},
|
|
{"network_bare", &test_clone_network__network_bare},
|
|
{"network_full", &test_clone_network__network_full}
|
|
};
|
|
static const struct clar_func _clar_cb_clone_nonetwork[] = {
|
|
{"bad_url", &test_clone_nonetwork__bad_url},
|
|
{"fail_when_the_target_is_a_file", &test_clone_nonetwork__fail_when_the_target_is_a_file},
|
|
{"fail_with_already_existing_but_non_empty_directory", &test_clone_nonetwork__fail_with_already_existing_but_non_empty_directory},
|
|
{"local", &test_clone_nonetwork__local},
|
|
{"local_bare", &test_clone_nonetwork__local_bare}
|
|
};
|
|
static const struct clar_func _clar_cb_commit_commit[] = {
|
|
{"create_unexisting_update_ref", &test_commit_commit__create_unexisting_update_ref}
|
|
};
|
|
static const struct clar_func _clar_cb_commit_parent[] = {
|
|
{"can_retrieve_nth_generation_parent", &test_commit_parent__can_retrieve_nth_generation_parent}
|
|
};
|
|
static const struct clar_func _clar_cb_commit_parse[] = {
|
|
{"details0", &test_commit_parse__details0},
|
|
{"entire_commit", &test_commit_parse__entire_commit},
|
|
{"header", &test_commit_parse__header},
|
|
{"signature", &test_commit_parse__signature}
|
|
};
|
|
static const struct clar_func _clar_cb_commit_signature[] = {
|
|
{"angle_brackets_in_email_are_not_supported", &test_commit_signature__angle_brackets_in_email_are_not_supported},
|
|
{"angle_brackets_in_names_are_not_supported", &test_commit_signature__angle_brackets_in_names_are_not_supported},
|
|
{"create_empties", &test_commit_signature__create_empties},
|
|
{"create_one_char", &test_commit_signature__create_one_char},
|
|
{"create_two_char", &test_commit_signature__create_two_char},
|
|
{"create_zero_char", &test_commit_signature__create_zero_char},
|
|
{"leading_and_trailing_spaces_are_trimmed", &test_commit_signature__leading_and_trailing_spaces_are_trimmed}
|
|
};
|
|
static const struct clar_func _clar_cb_commit_write[] = {
|
|
{"from_memory", &test_commit_write__from_memory},
|
|
{"root", &test_commit_write__root}
|
|
};
|
|
static const struct clar_func _clar_cb_config_add[] = {
|
|
{"to_existing_section", &test_config_add__to_existing_section},
|
|
{"to_new_section", &test_config_add__to_new_section}
|
|
};
|
|
static const struct clar_func _clar_cb_config_configlevel[] = {
|
|
{"adding_the_same_level_twice_returns_EEXISTS", &test_config_configlevel__adding_the_same_level_twice_returns_EEXISTS},
|
|
{"can_read_from_a_single_level_focused_file_after_parent_config_has_been_freed", &test_config_configlevel__can_read_from_a_single_level_focused_file_after_parent_config_has_been_freed},
|
|
{"can_replace_a_config_file_at_an_existing_level", &test_config_configlevel__can_replace_a_config_file_at_an_existing_level},
|
|
{"fetching_a_level_from_an_empty_compound_config_returns_ENOTFOUND", &test_config_configlevel__fetching_a_level_from_an_empty_compound_config_returns_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_config_multivar[] = {
|
|
{"add", &test_config_multivar__add},
|
|
{"foreach", &test_config_multivar__foreach},
|
|
{"get", &test_config_multivar__get},
|
|
{"replace", &test_config_multivar__replace},
|
|
{"replace_multiple", &test_config_multivar__replace_multiple}
|
|
};
|
|
static const struct clar_func _clar_cb_config_new[] = {
|
|
{"write_new_config", &test_config_new__write_new_config}
|
|
};
|
|
static const struct clar_func _clar_cb_config_read[] = {
|
|
{"blank_lines", &test_config_read__blank_lines},
|
|
{"can_load_and_parse_an_empty_config_file", &test_config_read__can_load_and_parse_an_empty_config_file},
|
|
{"cannot_load_a_non_existing_config_file", &test_config_read__cannot_load_a_non_existing_config_file},
|
|
{"case_sensitive", &test_config_read__case_sensitive},
|
|
{"empty_files", &test_config_read__empty_files},
|
|
{"escaping_quotes", &test_config_read__escaping_quotes},
|
|
{"fallback_from_local_to_global_and_from_global_to_system", &test_config_read__fallback_from_local_to_global_and_from_global_to_system},
|
|
{"foreach", &test_config_read__foreach},
|
|
{"foreach_match", &test_config_read__foreach_match},
|
|
{"header_in_last_line", &test_config_read__header_in_last_line},
|
|
{"invalid_ext_headers", &test_config_read__invalid_ext_headers},
|
|
{"local_config_overrides_global_config_overrides_system_config", &test_config_read__local_config_overrides_global_config_overrides_system_config},
|
|
{"lone_variable", &test_config_read__lone_variable},
|
|
{"multiline_value", &test_config_read__multiline_value},
|
|
{"number_suffixes", &test_config_read__number_suffixes},
|
|
{"prefixes", &test_config_read__prefixes},
|
|
{"read_git_config_entry", &test_config_read__read_git_config_entry},
|
|
{"simple_read", &test_config_read__simple_read},
|
|
{"simple_read_from_specific_level", &test_config_read__simple_read_from_specific_level},
|
|
{"subsection_header", &test_config_read__subsection_header},
|
|
{"whitespace_not_required_around_assignment", &test_config_read__whitespace_not_required_around_assignment}
|
|
};
|
|
static const struct clar_func _clar_cb_config_refresh[] = {
|
|
{"delete_value", &test_config_refresh__delete_value},
|
|
{"update_value", &test_config_refresh__update_value}
|
|
};
|
|
static const struct clar_func _clar_cb_config_stress[] = {
|
|
{"comments", &test_config_stress__comments},
|
|
{"dont_break_on_invalid_input", &test_config_stress__dont_break_on_invalid_input},
|
|
{"escape_subsection_names", &test_config_stress__escape_subsection_names}
|
|
};
|
|
static const struct clar_func _clar_cb_config_write[] = {
|
|
{"add_value_at_file_with_no_clrf_at_the_end", &test_config_write__add_value_at_file_with_no_clrf_at_the_end},
|
|
{"add_value_at_specific_level", &test_config_write__add_value_at_specific_level},
|
|
{"delete_inexistent", &test_config_write__delete_inexistent},
|
|
{"delete_value", &test_config_write__delete_value},
|
|
{"delete_value_at_specific_level", &test_config_write__delete_value_at_specific_level},
|
|
{"escape_value", &test_config_write__escape_value},
|
|
{"replace_value", &test_config_write__replace_value},
|
|
{"value_containing_quotes", &test_config_write__value_containing_quotes},
|
|
{"write_subsection", &test_config_write__write_subsection}
|
|
};
|
|
static const struct clar_func _clar_cb_core_buffer[] = {
|
|
{"0", &test_core_buffer__0},
|
|
{"1", &test_core_buffer__1},
|
|
{"10", &test_core_buffer__10},
|
|
{"11", &test_core_buffer__11},
|
|
{"2", &test_core_buffer__2},
|
|
{"3", &test_core_buffer__3},
|
|
{"4", &test_core_buffer__4},
|
|
{"5", &test_core_buffer__5},
|
|
{"6", &test_core_buffer__6},
|
|
{"7", &test_core_buffer__7},
|
|
{"8", &test_core_buffer__8},
|
|
{"9", &test_core_buffer__9},
|
|
{"base64", &test_core_buffer__base64},
|
|
{"puts_escaped", &test_core_buffer__puts_escaped},
|
|
{"rfind_variants", &test_core_buffer__rfind_variants},
|
|
{"unescape", &test_core_buffer__unescape}
|
|
};
|
|
static const struct clar_func _clar_cb_core_copy[] = {
|
|
{"file", &test_core_copy__file},
|
|
{"file_in_dir", &test_core_copy__file_in_dir},
|
|
{"tree", &test_core_copy__tree}
|
|
};
|
|
static const struct clar_func _clar_cb_core_dirent[] = {
|
|
{"dont_traverse_dot", &test_core_dirent__dont_traverse_dot},
|
|
{"dont_traverse_empty_folders", &test_core_dirent__dont_traverse_empty_folders},
|
|
{"length_limits", &test_core_dirent__length_limits},
|
|
{"traverse_slash_terminated_folder", &test_core_dirent__traverse_slash_terminated_folder},
|
|
{"traverse_subfolder", &test_core_dirent__traverse_subfolder},
|
|
{"traverse_weird_filenames", &test_core_dirent__traverse_weird_filenames}
|
|
};
|
|
static const struct clar_func _clar_cb_core_env[] = {
|
|
{"0", &test_core_env__0},
|
|
{"1", &test_core_env__1}
|
|
};
|
|
static const struct clar_func _clar_cb_core_errors[] = {
|
|
{"new_school", &test_core_errors__new_school},
|
|
{"public_api", &test_core_errors__public_api}
|
|
};
|
|
static const struct clar_func _clar_cb_core_filebuf[] = {
|
|
{"0", &test_core_filebuf__0},
|
|
{"1", &test_core_filebuf__1},
|
|
{"2", &test_core_filebuf__2},
|
|
{"4", &test_core_filebuf__4},
|
|
{"5", &test_core_filebuf__5}
|
|
};
|
|
static const struct clar_func _clar_cb_core_hex[] = {
|
|
{"fromhex", &test_core_hex__fromhex}
|
|
};
|
|
static const struct clar_func _clar_cb_core_mkdir[] = {
|
|
{"basic", &test_core_mkdir__basic},
|
|
{"chmods", &test_core_mkdir__chmods},
|
|
{"with_base", &test_core_mkdir__with_base}
|
|
};
|
|
static const struct clar_func _clar_cb_core_oid[] = {
|
|
{"streq", &test_core_oid__streq}
|
|
};
|
|
static const struct clar_func _clar_cb_core_path[] = {
|
|
{"00_dirname", &test_core_path__00_dirname},
|
|
{"01_basename", &test_core_path__01_basename},
|
|
{"02_topdir", &test_core_path__02_topdir},
|
|
{"05_joins", &test_core_path__05_joins},
|
|
{"06_long_joins", &test_core_path__06_long_joins},
|
|
{"07_path_to_dir", &test_core_path__07_path_to_dir},
|
|
{"08_self_join", &test_core_path__08_self_join},
|
|
{"09_percent_decode", &test_core_path__09_percent_decode},
|
|
{"10_fromurl", &test_core_path__10_fromurl},
|
|
{"11_walkup", &test_core_path__11_walkup},
|
|
{"12_offset_to_path_root", &test_core_path__12_offset_to_path_root},
|
|
{"13_cannot_prettify_a_non_existing_file", &test_core_path__13_cannot_prettify_a_non_existing_file},
|
|
{"14_apply_relative", &test_core_path__14_apply_relative}
|
|
};
|
|
static const struct clar_func _clar_cb_core_pool[] = {
|
|
{"0", &test_core_pool__0},
|
|
{"1", &test_core_pool__1},
|
|
{"2", &test_core_pool__2}
|
|
};
|
|
static const struct clar_func _clar_cb_core_rmdir[] = {
|
|
{"can_remove_empty_parents", &test_core_rmdir__can_remove_empty_parents},
|
|
{"can_skip_non_empty_dir", &test_core_rmdir__can_skip_non_empty_dir},
|
|
{"delete_recursive", &test_core_rmdir__delete_recursive},
|
|
{"fail_to_delete_non_empty_dir", &test_core_rmdir__fail_to_delete_non_empty_dir}
|
|
};
|
|
static const struct clar_func _clar_cb_core_stat[] = {
|
|
{"0", &test_core_stat__0}
|
|
};
|
|
static const struct clar_func _clar_cb_core_string[] = {
|
|
{"0", &test_core_string__0},
|
|
{"1", &test_core_string__1}
|
|
};
|
|
static const struct clar_func _clar_cb_core_strmap[] = {
|
|
{"0", &test_core_strmap__0},
|
|
{"1", &test_core_strmap__1},
|
|
{"2", &test_core_strmap__2},
|
|
{"3", &test_core_strmap__3}
|
|
};
|
|
static const struct clar_func _clar_cb_core_strtol[] = {
|
|
{"int32", &test_core_strtol__int32},
|
|
{"int64", &test_core_strtol__int64}
|
|
};
|
|
static const struct clar_func _clar_cb_core_vector[] = {
|
|
{"0", &test_core_vector__0},
|
|
{"1", &test_core_vector__1},
|
|
{"2", &test_core_vector__2},
|
|
{"3", &test_core_vector__3},
|
|
{"4", &test_core_vector__4},
|
|
{"5", &test_core_vector__5},
|
|
{"remove_matching", &test_core_vector__remove_matching}
|
|
};
|
|
static const struct clar_func _clar_cb_date_date[] = {
|
|
{"overflow", &test_date_date__overflow}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_blob[] = {
|
|
{"can_compare_a_binary_blob_and_a_text_blob", &test_diff_blob__can_compare_a_binary_blob_and_a_text_blob},
|
|
{"can_compare_against_null_blobs", &test_diff_blob__can_compare_against_null_blobs},
|
|
{"can_compare_identical_blobs", &test_diff_blob__can_compare_identical_blobs},
|
|
{"can_compare_text_blobs", &test_diff_blob__can_compare_text_blobs},
|
|
{"can_compare_two_binary_blobs", &test_diff_blob__can_compare_two_binary_blobs},
|
|
{"comparing_two_text_blobs_honors_interhunkcontext", &test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_diffiter[] = {
|
|
{"create", &test_diff_diffiter__create},
|
|
{"iterate_all", &test_diff_diffiter__iterate_all},
|
|
{"iterate_and_generate_patch_text", &test_diff_diffiter__iterate_and_generate_patch_text},
|
|
{"iterate_files", &test_diff_diffiter__iterate_files},
|
|
{"iterate_files_2", &test_diff_diffiter__iterate_files_2},
|
|
{"iterate_files_and_hunks", &test_diff_diffiter__iterate_files_and_hunks},
|
|
{"iterate_randomly_while_saving_state", &test_diff_diffiter__iterate_randomly_while_saving_state},
|
|
{"max_size_threshold", &test_diff_diffiter__max_size_threshold}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_index[] = {
|
|
{"0", &test_diff_index__0},
|
|
{"1", &test_diff_index__1}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_iterator[] = {
|
|
{"index_0", &test_diff_iterator__index_0},
|
|
{"index_1", &test_diff_iterator__index_1},
|
|
{"index_range", &test_diff_iterator__index_range},
|
|
{"index_range_empty_0", &test_diff_iterator__index_range_empty_0},
|
|
{"index_range_empty_1", &test_diff_iterator__index_range_empty_1},
|
|
{"index_range_empty_2", &test_diff_iterator__index_range_empty_2},
|
|
{"tree_0", &test_diff_iterator__tree_0},
|
|
{"tree_1", &test_diff_iterator__tree_1},
|
|
{"tree_2", &test_diff_iterator__tree_2},
|
|
{"tree_3", &test_diff_iterator__tree_3},
|
|
{"tree_4", &test_diff_iterator__tree_4},
|
|
{"tree_4_ranged", &test_diff_iterator__tree_4_ranged},
|
|
{"tree_range_empty_0", &test_diff_iterator__tree_range_empty_0},
|
|
{"tree_range_empty_1", &test_diff_iterator__tree_range_empty_1},
|
|
{"tree_range_empty_2", &test_diff_iterator__tree_range_empty_2},
|
|
{"tree_ranged_0", &test_diff_iterator__tree_ranged_0},
|
|
{"tree_ranged_1", &test_diff_iterator__tree_ranged_1},
|
|
{"tree_special_functions", &test_diff_iterator__tree_special_functions},
|
|
{"workdir_0", &test_diff_iterator__workdir_0},
|
|
{"workdir_1", &test_diff_iterator__workdir_1},
|
|
{"workdir_1_ranged_0", &test_diff_iterator__workdir_1_ranged_0},
|
|
{"workdir_1_ranged_1", &test_diff_iterator__workdir_1_ranged_1},
|
|
{"workdir_1_ranged_3", &test_diff_iterator__workdir_1_ranged_3},
|
|
{"workdir_1_ranged_4", &test_diff_iterator__workdir_1_ranged_4},
|
|
{"workdir_1_ranged_5", &test_diff_iterator__workdir_1_ranged_5},
|
|
{"workdir_1_ranged_empty_0", &test_diff_iterator__workdir_1_ranged_empty_0},
|
|
{"workdir_1_ranged_empty_1", &test_diff_iterator__workdir_1_ranged_empty_1},
|
|
{"workdir_1_ranged_empty_2", &test_diff_iterator__workdir_1_ranged_empty_2}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_patch[] = {
|
|
{"can_properly_display_the_removal_of_a_file", &test_diff_patch__can_properly_display_the_removal_of_a_file},
|
|
{"to_string", &test_diff_patch__to_string}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_rename[] = {
|
|
{"match_oid", &test_diff_rename__match_oid}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_tree[] = {
|
|
{"0", &test_diff_tree__0},
|
|
{"bare", &test_diff_tree__bare},
|
|
{"larger_hunks", &test_diff_tree__larger_hunks},
|
|
{"merge", &test_diff_tree__merge},
|
|
{"options", &test_diff_tree__options}
|
|
};
|
|
static const struct clar_func _clar_cb_diff_workdir[] = {
|
|
{"cannot_diff_against_a_bare_repository", &test_diff_workdir__cannot_diff_against_a_bare_repository},
|
|
{"eof_newline_changes", &test_diff_workdir__eof_newline_changes},
|
|
{"filemode_changes", &test_diff_workdir__filemode_changes},
|
|
{"filemode_changes_with_filemode_false", &test_diff_workdir__filemode_changes_with_filemode_false},
|
|
{"head_index_and_workdir_all_differ", &test_diff_workdir__head_index_and_workdir_all_differ},
|
|
{"larger_hunks", &test_diff_workdir__larger_hunks},
|
|
{"submodules", &test_diff_workdir__submodules},
|
|
{"to_index", &test_diff_workdir__to_index},
|
|
{"to_index_with_pathspec", &test_diff_workdir__to_index_with_pathspec},
|
|
{"to_tree", &test_diff_workdir__to_tree}
|
|
};
|
|
static const struct clar_func _clar_cb_fetchhead_network[] = {
|
|
{"explicit_spec", &test_fetchhead_network__explicit_spec},
|
|
{"no_merges", &test_fetchhead_network__no_merges},
|
|
{"wildcard_spec", &test_fetchhead_network__wildcard_spec}
|
|
};
|
|
static const struct clar_func _clar_cb_fetchhead_nonetwork[] = {
|
|
{"write", &test_fetchhead_nonetwork__write}
|
|
};
|
|
static const struct clar_func _clar_cb_index_conflicts[] = {
|
|
{"add", &test_index_conflicts__add},
|
|
{"add_fixes_incorrect_stage", &test_index_conflicts__add_fixes_incorrect_stage},
|
|
{"get", &test_index_conflicts__get},
|
|
{"moved_to_reuc", &test_index_conflicts__moved_to_reuc},
|
|
{"partial", &test_index_conflicts__partial},
|
|
{"remove", &test_index_conflicts__remove},
|
|
{"remove_all_conflicts", &test_index_conflicts__remove_all_conflicts}
|
|
};
|
|
static const struct clar_func _clar_cb_index_filemodes[] = {
|
|
{"read", &test_index_filemodes__read},
|
|
{"trusted", &test_index_filemodes__trusted},
|
|
{"untrusted", &test_index_filemodes__untrusted}
|
|
};
|
|
static const struct clar_func _clar_cb_index_inmemory[] = {
|
|
{"can_create_an_inmemory_index", &test_index_inmemory__can_create_an_inmemory_index},
|
|
{"cannot_add_from_workdir_to_an_inmemory_index", &test_index_inmemory__cannot_add_from_workdir_to_an_inmemory_index}
|
|
};
|
|
static const struct clar_func _clar_cb_index_read_tree[] = {
|
|
{"read_write_involution", &test_index_read_tree__read_write_involution}
|
|
};
|
|
static const struct clar_func _clar_cb_index_rename[] = {
|
|
{"single_file", &test_index_rename__single_file}
|
|
};
|
|
static const struct clar_func _clar_cb_index_reuc[] = {
|
|
{"ignore_case", &test_index_reuc__ignore_case},
|
|
{"read_byindex", &test_index_reuc__read_byindex},
|
|
{"read_bypath", &test_index_reuc__read_bypath},
|
|
{"remove", &test_index_reuc__remove},
|
|
{"updates_existing", &test_index_reuc__updates_existing},
|
|
{"write", &test_index_reuc__write}
|
|
};
|
|
static const struct clar_func _clar_cb_index_stage[] = {
|
|
{"add_always_adds_stage_0", &test_index_stage__add_always_adds_stage_0},
|
|
{"find_gets_first_stage", &test_index_stage__find_gets_first_stage}
|
|
};
|
|
static const struct clar_func _clar_cb_index_tests[] = {
|
|
{"add", &test_index_tests__add},
|
|
{"add_from_workdir_to_a_bare_repository_returns_EBAREPO", &test_index_tests__add_from_workdir_to_a_bare_repository_returns_EBAREPO},
|
|
{"default_test_index", &test_index_tests__default_test_index},
|
|
{"empty_index", &test_index_tests__empty_index},
|
|
{"find_in_empty", &test_index_tests__find_in_empty},
|
|
{"find_in_existing", &test_index_tests__find_in_existing},
|
|
{"gitgit_index", &test_index_tests__gitgit_index},
|
|
{"sort0", &test_index_tests__sort0},
|
|
{"sort1", &test_index_tests__sort1},
|
|
{"write", &test_index_tests__write},
|
|
{"write_invalid_filename", &test_index_tests__write_invalid_filename}
|
|
};
|
|
static const struct clar_func _clar_cb_network_createremotethenload[] = {
|
|
{"parsing", &test_network_createremotethenload__parsing}
|
|
};
|
|
static const struct clar_func _clar_cb_network_fetch[] = {
|
|
{"default_git", &test_network_fetch__default_git},
|
|
{"default_http", &test_network_fetch__default_http},
|
|
{"no_tags_git", &test_network_fetch__no_tags_git},
|
|
{"no_tags_http", &test_network_fetch__no_tags_http}
|
|
};
|
|
static const struct clar_func _clar_cb_network_fetchlocal[] = {
|
|
{"complete", &test_network_fetchlocal__complete},
|
|
{"partial", &test_network_fetchlocal__partial}
|
|
};
|
|
static const struct clar_func _clar_cb_network_refspecs[] = {
|
|
{"parsing", &test_network_refspecs__parsing}
|
|
};
|
|
static const struct clar_func _clar_cb_network_remotelocal[] = {
|
|
{"connected", &test_network_remotelocal__connected},
|
|
{"nested_tags_are_completely_peeled", &test_network_remotelocal__nested_tags_are_completely_peeled},
|
|
{"retrieve_advertised_references", &test_network_remotelocal__retrieve_advertised_references},
|
|
{"retrieve_advertised_references_from_spaced_repository", &test_network_remotelocal__retrieve_advertised_references_from_spaced_repository}
|
|
};
|
|
static const struct clar_func _clar_cb_network_remoterename[] = {
|
|
{"cannot_overwrite_an_existing_remote", &test_network_remoterename__cannot_overwrite_an_existing_remote},
|
|
{"new_name_can_contain_dots", &test_network_remoterename__new_name_can_contain_dots},
|
|
{"new_name_must_conform_to_reference_naming_conventions", &test_network_remoterename__new_name_must_conform_to_reference_naming_conventions},
|
|
{"renamed_name_is_persisted", &test_network_remoterename__renamed_name_is_persisted},
|
|
{"renaming_a_remote_moves_related_configuration_section", &test_network_remoterename__renaming_a_remote_moves_related_configuration_section},
|
|
{"renaming_a_remote_moves_the_underlying_reference", &test_network_remoterename__renaming_a_remote_moves_the_underlying_reference},
|
|
{"renaming_a_remote_notifies_of_non_default_fetchrefspec", &test_network_remoterename__renaming_a_remote_notifies_of_non_default_fetchrefspec},
|
|
{"renaming_a_remote_updates_branch_related_configuration_entries", &test_network_remoterename__renaming_a_remote_updates_branch_related_configuration_entries},
|
|
{"renaming_a_remote_updates_default_fetchrefspec", &test_network_remoterename__renaming_a_remote_updates_default_fetchrefspec},
|
|
{"renaming_a_remote_without_a_fetchrefspec_doesnt_create_one", &test_network_remoterename__renaming_a_remote_without_a_fetchrefspec_doesnt_create_one},
|
|
{"renaming_an_inmemory_nameless_remote_notifies_the_inability_to_update_the_fetch_refspec", &test_network_remoterename__renaming_an_inmemory_nameless_remote_notifies_the_inability_to_update_the_fetch_refspec},
|
|
{"renaming_an_inmemory_remote_persists_it", &test_network_remoterename__renaming_an_inmemory_remote_persists_it}
|
|
};
|
|
static const struct clar_func _clar_cb_network_remotes[] = {
|
|
{"add", &test_network_remotes__add},
|
|
{"cannot_add_a_nameless_remote", &test_network_remotes__cannot_add_a_nameless_remote},
|
|
{"cannot_load_with_an_empty_url", &test_network_remotes__cannot_load_with_an_empty_url},
|
|
{"cannot_save_a_nameless_remote", &test_network_remotes__cannot_save_a_nameless_remote},
|
|
{"fnmatch", &test_network_remotes__fnmatch},
|
|
{"list", &test_network_remotes__list},
|
|
{"loading_a_missing_remote_returns_ENOTFOUND", &test_network_remotes__loading_a_missing_remote_returns_ENOTFOUND},
|
|
{"missing_refspecs", &test_network_remotes__missing_refspecs},
|
|
{"parsing", &test_network_remotes__parsing},
|
|
{"parsing_local_path_fails_if_path_not_found", &test_network_remotes__parsing_local_path_fails_if_path_not_found},
|
|
{"parsing_ssh_remote", &test_network_remotes__parsing_ssh_remote},
|
|
{"pushurl", &test_network_remotes__pushurl},
|
|
{"refspec_parsing", &test_network_remotes__refspec_parsing},
|
|
{"save", &test_network_remotes__save},
|
|
{"set_fetchspec", &test_network_remotes__set_fetchspec},
|
|
{"set_pushspec", &test_network_remotes__set_pushspec},
|
|
{"supported_transport_methods_are_supported", &test_network_remotes__supported_transport_methods_are_supported},
|
|
{"tagopt", &test_network_remotes__tagopt},
|
|
{"transform", &test_network_remotes__transform},
|
|
{"transform_r", &test_network_remotes__transform_r},
|
|
{"unsupported_transport_methods_are_unsupported", &test_network_remotes__unsupported_transport_methods_are_unsupported}
|
|
};
|
|
static const struct clar_func _clar_cb_notes_notes[] = {
|
|
{"can_cancel_foreach", &test_notes_notes__can_cancel_foreach},
|
|
{"can_insert_a_note_in_an_existing_fanout", &test_notes_notes__can_insert_a_note_in_an_existing_fanout},
|
|
{"can_insert_a_note_with_a_custom_namespace", &test_notes_notes__can_insert_a_note_with_a_custom_namespace},
|
|
{"can_read_a_note_in_an_existing_fanout", &test_notes_notes__can_read_a_note_in_an_existing_fanout},
|
|
{"can_remove_a_note_in_an_existing_fanout", &test_notes_notes__can_remove_a_note_in_an_existing_fanout},
|
|
{"can_retrieve_a_list_of_notes_for_a_given_namespace", &test_notes_notes__can_retrieve_a_list_of_notes_for_a_given_namespace},
|
|
{"creating_a_note_on_a_target_which_already_has_one_returns_EEXISTS", &test_notes_notes__creating_a_note_on_a_target_which_already_has_one_returns_EEXISTS},
|
|
{"inserting_a_note_without_passing_a_namespace_uses_the_default_namespace", &test_notes_notes__inserting_a_note_without_passing_a_namespace_uses_the_default_namespace},
|
|
{"removing_a_note_which_doesnt_exists_returns_ENOTFOUND", &test_notes_notes__removing_a_note_which_doesnt_exists_returns_ENOTFOUND},
|
|
{"retrieving_a_list_of_notes_for_an_unknown_namespace_returns_ENOTFOUND", &test_notes_notes__retrieving_a_list_of_notes_for_an_unknown_namespace_returns_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_notes_notesref[] = {
|
|
{"config_corenotesref", &test_notes_notesref__config_corenotesref}
|
|
};
|
|
static const struct clar_func _clar_cb_object_blob_filter[] = {
|
|
{"stats", &test_object_blob_filter__stats},
|
|
{"to_odb", &test_object_blob_filter__to_odb},
|
|
{"unfiltered", &test_object_blob_filter__unfiltered}
|
|
};
|
|
static const struct clar_func _clar_cb_object_blob_fromchunks[] = {
|
|
{"can_create_a_blob_from_a_in_memory_chunk_provider", &test_object_blob_fromchunks__can_create_a_blob_from_a_in_memory_chunk_provider},
|
|
{"creating_a_blob_from_chunks_honors_the_attributes_directives", &test_object_blob_fromchunks__creating_a_blob_from_chunks_honors_the_attributes_directives}
|
|
};
|
|
static const struct clar_func _clar_cb_object_blob_write[] = {
|
|
{"can_create_a_blob_in_a_bare_repo_from_a_absolute_filepath", &test_object_blob_write__can_create_a_blob_in_a_bare_repo_from_a_absolute_filepath},
|
|
{"can_create_a_blob_in_a_standard_repo_from_a_absolute_filepath_pointing_outside_of_the_working_directory", &test_object_blob_write__can_create_a_blob_in_a_standard_repo_from_a_absolute_filepath_pointing_outside_of_the_working_directory},
|
|
{"can_create_a_blob_in_a_standard_repo_from_a_file_located_in_the_working_directory", &test_object_blob_write__can_create_a_blob_in_a_standard_repo_from_a_file_located_in_the_working_directory}
|
|
};
|
|
static const struct clar_func _clar_cb_object_commit_commitstagedfile[] = {
|
|
{"generate_predictable_object_ids", &test_object_commit_commitstagedfile__generate_predictable_object_ids}
|
|
};
|
|
static const struct clar_func _clar_cb_object_lookup[] = {
|
|
{"lookup_nonexisting_returns_enotfound", &test_object_lookup__lookup_nonexisting_returns_enotfound},
|
|
{"lookup_wrong_type_by_abbreviated_id_returns_enotfound", &test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound},
|
|
{"lookup_wrong_type_eventually_returns_enotfound", &test_object_lookup__lookup_wrong_type_eventually_returns_enotfound},
|
|
{"lookup_wrong_type_returns_enotfound", &test_object_lookup__lookup_wrong_type_returns_enotfound}
|
|
};
|
|
static const struct clar_func _clar_cb_object_message[] = {
|
|
{"consecutive_blank_lines_at_the_beginning_should_be_removed", &test_object_message__consecutive_blank_lines_at_the_beginning_should_be_removed},
|
|
{"consecutive_blank_lines_at_the_end_should_be_removed", &test_object_message__consecutive_blank_lines_at_the_end_should_be_removed},
|
|
{"consecutive_blank_lines_should_be_unified", &test_object_message__consecutive_blank_lines_should_be_unified},
|
|
{"consecutive_text_lines_should_be_unchanged", &test_object_message__consecutive_text_lines_should_be_unchanged},
|
|
{"keep_comments", &test_object_message__keep_comments},
|
|
{"lines_with_intermediate_spaces_should_be_unchanged", &test_object_message__lines_with_intermediate_spaces_should_be_unchanged},
|
|
{"lines_with_spaces_at_the_beginning_should_be_unchanged", &test_object_message__lines_with_spaces_at_the_beginning_should_be_unchanged},
|
|
{"long_lines_without_spaces_should_be_unchanged", &test_object_message__long_lines_without_spaces_should_be_unchanged},
|
|
{"message_prettify", &test_object_message__message_prettify},
|
|
{"only_consecutive_blank_lines_should_be_completely_removed", &test_object_message__only_consecutive_blank_lines_should_be_completely_removed},
|
|
{"spaces_with_newline_at_end_should_be_replaced_with_empty_string", &test_object_message__spaces_with_newline_at_end_should_be_replaced_with_empty_string},
|
|
{"spaces_without_newline_at_end_should_be_replaced_with_empty_string", &test_object_message__spaces_without_newline_at_end_should_be_replaced_with_empty_string},
|
|
{"strip_comments", &test_object_message__strip_comments},
|
|
{"text_plus_spaces_ending_with_newline_should_be_cleaned_and_newline_must_remain", &test_object_message__text_plus_spaces_ending_with_newline_should_be_cleaned_and_newline_must_remain},
|
|
{"text_plus_spaces_without_newline_should_not_show_spaces_and_end_with_newline", &test_object_message__text_plus_spaces_without_newline_should_not_show_spaces_and_end_with_newline},
|
|
{"text_without_newline_at_end_should_end_with_newline", &test_object_message__text_without_newline_at_end_should_end_with_newline}
|
|
};
|
|
static const struct clar_func _clar_cb_object_peel[] = {
|
|
{"can_peel_a_commit", &test_object_peel__can_peel_a_commit},
|
|
{"can_peel_a_tag", &test_object_peel__can_peel_a_tag},
|
|
{"cannot_peel_a_blob", &test_object_peel__cannot_peel_a_blob},
|
|
{"cannot_peel_a_tree", &test_object_peel__cannot_peel_a_tree},
|
|
{"peeling_an_object_into_its_own_type_returns_another_instance_of_it", &test_object_peel__peeling_an_object_into_its_own_type_returns_another_instance_of_it},
|
|
{"target_any_object_for_type_change", &test_object_peel__target_any_object_for_type_change}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_chars[] = {
|
|
{"build_valid_oid_from_raw_bytes", &test_object_raw_chars__build_valid_oid_from_raw_bytes},
|
|
{"find_invalid_chars_in_oid", &test_object_raw_chars__find_invalid_chars_in_oid}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_compare[] = {
|
|
{"compare_allocfmt_oids", &test_object_raw_compare__compare_allocfmt_oids},
|
|
{"compare_fmt_oids", &test_object_raw_compare__compare_fmt_oids},
|
|
{"compare_pathfmt_oids", &test_object_raw_compare__compare_pathfmt_oids},
|
|
{"succeed_on_copy_oid", &test_object_raw_compare__succeed_on_copy_oid},
|
|
{"succeed_on_oid_comparison_equal", &test_object_raw_compare__succeed_on_oid_comparison_equal},
|
|
{"succeed_on_oid_comparison_greater", &test_object_raw_compare__succeed_on_oid_comparison_greater},
|
|
{"succeed_on_oid_comparison_lesser", &test_object_raw_compare__succeed_on_oid_comparison_lesser}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_convert[] = {
|
|
{"succeed_on_oid_to_string_conversion", &test_object_raw_convert__succeed_on_oid_to_string_conversion},
|
|
{"succeed_on_oid_to_string_conversion_big", &test_object_raw_convert__succeed_on_oid_to_string_conversion_big}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_fromstr[] = {
|
|
{"fail_on_invalid_oid_string", &test_object_raw_fromstr__fail_on_invalid_oid_string},
|
|
{"succeed_on_valid_oid_string", &test_object_raw_fromstr__succeed_on_valid_oid_string}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_hash[] = {
|
|
{"hash_buffer_in_single_call", &test_object_raw_hash__hash_buffer_in_single_call},
|
|
{"hash_by_blocks", &test_object_raw_hash__hash_by_blocks},
|
|
{"hash_commit_object", &test_object_raw_hash__hash_commit_object},
|
|
{"hash_junk_data", &test_object_raw_hash__hash_junk_data},
|
|
{"hash_multi_byte_object", &test_object_raw_hash__hash_multi_byte_object},
|
|
{"hash_one_byte_object", &test_object_raw_hash__hash_one_byte_object},
|
|
{"hash_tag_object", &test_object_raw_hash__hash_tag_object},
|
|
{"hash_tree_object", &test_object_raw_hash__hash_tree_object},
|
|
{"hash_two_byte_object", &test_object_raw_hash__hash_two_byte_object},
|
|
{"hash_vector", &test_object_raw_hash__hash_vector},
|
|
{"hash_zero_length_object", &test_object_raw_hash__hash_zero_length_object}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_short[] = {
|
|
{"oid_shortener_no_duplicates", &test_object_raw_short__oid_shortener_no_duplicates},
|
|
{"oid_shortener_stresstest_git_oid_shorten", &test_object_raw_short__oid_shortener_stresstest_git_oid_shorten}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_size[] = {
|
|
{"validate_oid_size", &test_object_raw_size__validate_oid_size}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_type2string[] = {
|
|
{"check_type_is_loose", &test_object_raw_type2string__check_type_is_loose},
|
|
{"convert_string_to_type", &test_object_raw_type2string__convert_string_to_type},
|
|
{"convert_type_to_string", &test_object_raw_type2string__convert_type_to_string}
|
|
};
|
|
static const struct clar_func _clar_cb_object_raw_write[] = {
|
|
{"loose_object", &test_object_raw_write__loose_object},
|
|
{"loose_tag", &test_object_raw_write__loose_tag},
|
|
{"loose_tree", &test_object_raw_write__loose_tree},
|
|
{"one_byte", &test_object_raw_write__one_byte},
|
|
{"several_bytes", &test_object_raw_write__several_bytes},
|
|
{"two_byte", &test_object_raw_write__two_byte},
|
|
{"zero_length", &test_object_raw_write__zero_length}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tag_list[] = {
|
|
{"list_all", &test_object_tag_list__list_all},
|
|
{"list_by_pattern", &test_object_tag_list__list_by_pattern}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tag_peel[] = {
|
|
{"can_peel_several_nested_tags_to_a_commit", &test_object_tag_peel__can_peel_several_nested_tags_to_a_commit},
|
|
{"can_peel_to_a_commit", &test_object_tag_peel__can_peel_to_a_commit},
|
|
{"can_peel_to_a_non_commit", &test_object_tag_peel__can_peel_to_a_non_commit}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tag_read[] = {
|
|
{"parse", &test_object_tag_read__parse},
|
|
{"parse_without_message", &test_object_tag_read__parse_without_message},
|
|
{"parse_without_tagger", &test_object_tag_read__parse_without_tagger}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tag_write[] = {
|
|
{"basic", &test_object_tag_write__basic},
|
|
{"delete", &test_object_tag_write__delete},
|
|
{"lightweight", &test_object_tag_write__lightweight},
|
|
{"lightweight_over_existing", &test_object_tag_write__lightweight_over_existing},
|
|
{"overwrite", &test_object_tag_write__overwrite},
|
|
{"replace", &test_object_tag_write__replace}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_attributes[] = {
|
|
{"ensure_correctness_of_attributes_on_insertion", &test_object_tree_attributes__ensure_correctness_of_attributes_on_insertion},
|
|
{"group_writable_tree_entries_created_with_an_antique_git_version_can_still_be_accessed", &test_object_tree_attributes__group_writable_tree_entries_created_with_an_antique_git_version_can_still_be_accessed},
|
|
{"normalize_attributes_when_creating_a_tree_from_an_existing_one", &test_object_tree_attributes__normalize_attributes_when_creating_a_tree_from_an_existing_one},
|
|
{"normalize_attributes_when_inserting_in_a_new_tree", &test_object_tree_attributes__normalize_attributes_when_inserting_in_a_new_tree}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_duplicateentries[] = {
|
|
{"cannot_create_a_duplicate_entry_building_a_tree_from_a_index_with_conflicts", &test_object_tree_duplicateentries__cannot_create_a_duplicate_entry_building_a_tree_from_a_index_with_conflicts},
|
|
{"cannot_create_a_duplicate_entry_through_the_treebuilder", &test_object_tree_duplicateentries__cannot_create_a_duplicate_entry_through_the_treebuilder}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_frompath[] = {
|
|
{"fail_when_processing_an_invalid_path", &test_object_tree_frompath__fail_when_processing_an_invalid_path},
|
|
{"retrieve_tree_from_path_to_treeentry", &test_object_tree_frompath__retrieve_tree_from_path_to_treeentry}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_read[] = {
|
|
{"loaded", &test_object_tree_read__loaded},
|
|
{"two", &test_object_tree_read__two}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_walk[] = {
|
|
{"0", &test_object_tree_walk__0},
|
|
{"1", &test_object_tree_walk__1}
|
|
};
|
|
static const struct clar_func _clar_cb_object_tree_write[] = {
|
|
{"from_memory", &test_object_tree_write__from_memory},
|
|
{"sorted_subtrees", &test_object_tree_write__sorted_subtrees},
|
|
{"subtree", &test_object_tree_write__subtree}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_alternates[] = {
|
|
{"chained", &test_odb_alternates__chained},
|
|
{"long_chain", &test_odb_alternates__long_chain}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_foreach[] = {
|
|
{"foreach", &test_odb_foreach__foreach},
|
|
{"interrupt_foreach", &test_odb_foreach__interrupt_foreach},
|
|
{"one_pack", &test_odb_foreach__one_pack}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_loose[] = {
|
|
{"exists", &test_odb_loose__exists},
|
|
{"simple_reads", &test_odb_loose__simple_reads}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_mixed[] = {
|
|
{"dup_oid", &test_odb_mixed__dup_oid}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_packed[] = {
|
|
{"mass_read", &test_odb_packed__mass_read},
|
|
{"read_header_0", &test_odb_packed__read_header_0},
|
|
{"read_header_1", &test_odb_packed__read_header_1}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_packed_one[] = {
|
|
{"mass_read", &test_odb_packed_one__mass_read},
|
|
{"read_header_0", &test_odb_packed_one__read_header_0}
|
|
};
|
|
static const struct clar_func _clar_cb_odb_sorting[] = {
|
|
{"alternate_backends_sorting", &test_odb_sorting__alternate_backends_sorting},
|
|
{"basic_backends_sorting", &test_odb_sorting__basic_backends_sorting}
|
|
};
|
|
static const struct clar_func _clar_cb_pack_packbuilder[] = {
|
|
{"create_pack", &test_pack_packbuilder__create_pack},
|
|
{"foreach", &test_pack_packbuilder__foreach}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_create[] = {
|
|
{"can_create_a_local_branch", &test_refs_branches_create__can_create_a_local_branch},
|
|
{"can_force_create_over_an_existing_branch", &test_refs_branches_create__can_force_create_over_an_existing_branch},
|
|
{"can_not_create_a_branch_if_its_name_collide_with_an_existing_one", &test_refs_branches_create__can_not_create_a_branch_if_its_name_collide_with_an_existing_one}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_delete[] = {
|
|
{"can_delete_a_branch_even_if_HEAD_is_missing", &test_refs_branches_delete__can_delete_a_branch_even_if_HEAD_is_missing},
|
|
{"can_delete_a_branch_pointed_at_by_detached_HEAD", &test_refs_branches_delete__can_delete_a_branch_pointed_at_by_detached_HEAD},
|
|
{"can_delete_a_branch_when_HEAD_is_orphaned", &test_refs_branches_delete__can_delete_a_branch_when_HEAD_is_orphaned},
|
|
{"can_delete_a_local_branch", &test_refs_branches_delete__can_delete_a_local_branch},
|
|
{"can_delete_a_remote_branch", &test_refs_branches_delete__can_delete_a_remote_branch},
|
|
{"can_not_delete_a_branch_pointed_at_by_HEAD", &test_refs_branches_delete__can_not_delete_a_branch_pointed_at_by_HEAD},
|
|
{"deleting_a_branch_removes_related_configuration_data", &test_refs_branches_delete__deleting_a_branch_removes_related_configuration_data}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_foreach[] = {
|
|
{"can_cancel", &test_refs_branches_foreach__can_cancel},
|
|
{"retrieve_all_branches", &test_refs_branches_foreach__retrieve_all_branches},
|
|
{"retrieve_local_branches", &test_refs_branches_foreach__retrieve_local_branches},
|
|
{"retrieve_remote_branches", &test_refs_branches_foreach__retrieve_remote_branches},
|
|
{"retrieve_remote_symbolic_HEAD_when_present", &test_refs_branches_foreach__retrieve_remote_symbolic_HEAD_when_present}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_ishead[] = {
|
|
{"can_properly_handle_missing_HEAD", &test_refs_branches_ishead__can_properly_handle_missing_HEAD},
|
|
{"can_properly_handle_orphaned_HEAD", &test_refs_branches_ishead__can_properly_handle_orphaned_HEAD},
|
|
{"can_tell_if_a_branch_is_not_pointed_at_by_HEAD", &test_refs_branches_ishead__can_tell_if_a_branch_is_not_pointed_at_by_HEAD},
|
|
{"can_tell_if_a_branch_is_pointed_at_by_HEAD", &test_refs_branches_ishead__can_tell_if_a_branch_is_pointed_at_by_HEAD},
|
|
{"only_direct_references_are_considered", &test_refs_branches_ishead__only_direct_references_are_considered},
|
|
{"wont_be_fooled_by_a_non_branch", &test_refs_branches_ishead__wont_be_fooled_by_a_non_branch}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_lookup[] = {
|
|
{"can_retrieve_a_local_branch", &test_refs_branches_lookup__can_retrieve_a_local_branch},
|
|
{"can_retrieve_a_remote_tracking_branch", &test_refs_branches_lookup__can_retrieve_a_remote_tracking_branch},
|
|
{"trying_to_retrieve_an_unknown_branch_returns_ENOTFOUND", &test_refs_branches_lookup__trying_to_retrieve_an_unknown_branch_returns_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_move[] = {
|
|
{"can_force_move_over_an_existing_branch", &test_refs_branches_move__can_force_move_over_an_existing_branch},
|
|
{"can_move_a_local_branch", &test_refs_branches_move__can_move_a_local_branch},
|
|
{"can_move_a_local_branch_to_a_different_namespace", &test_refs_branches_move__can_move_a_local_branch_to_a_different_namespace},
|
|
{"can_move_a_local_branch_to_a_partially_colliding_namespace", &test_refs_branches_move__can_move_a_local_branch_to_a_partially_colliding_namespace},
|
|
{"can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one", &test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one},
|
|
{"can_not_move_a_non_branch", &test_refs_branches_move__can_not_move_a_non_branch},
|
|
{"moving_a_branch_moves_related_configuration_data", &test_refs_branches_move__moving_a_branch_moves_related_configuration_data},
|
|
{"moving_the_branch_pointed_at_by_HEAD_updates_HEAD", &test_refs_branches_move__moving_the_branch_pointed_at_by_HEAD_updates_HEAD}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_branches_tracking[] = {
|
|
{"can_retrieve_the_local_tracking_reference_of_a_local_branch", &test_refs_branches_tracking__can_retrieve_the_local_tracking_reference_of_a_local_branch},
|
|
{"can_retrieve_the_remote_tracking_reference_of_a_local_branch", &test_refs_branches_tracking__can_retrieve_the_remote_tracking_reference_of_a_local_branch},
|
|
{"cannot_retrieve_a_remote_tracking_reference_from_a_non_branch", &test_refs_branches_tracking__cannot_retrieve_a_remote_tracking_reference_from_a_non_branch},
|
|
{"trying_to_retrieve_a_remote_tracking_reference_from_a_branch_with_no_fetchspec_returns_GIT_ENOTFOUND", &test_refs_branches_tracking__trying_to_retrieve_a_remote_tracking_reference_from_a_branch_with_no_fetchspec_returns_GIT_ENOTFOUND},
|
|
{"trying_to_retrieve_a_remote_tracking_reference_from_a_plain_local_branch_returns_GIT_ENOTFOUND", &test_refs_branches_tracking__trying_to_retrieve_a_remote_tracking_reference_from_a_plain_local_branch_returns_GIT_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_crashes[] = {
|
|
{"double_free", &test_refs_crashes__double_free}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_create[] = {
|
|
{"deep_symbolic", &test_refs_create__deep_symbolic},
|
|
{"oid", &test_refs_create__oid},
|
|
{"oid_unknown", &test_refs_create__oid_unknown},
|
|
{"propagate_eexists", &test_refs_create__propagate_eexists},
|
|
{"symbolic", &test_refs_create__symbolic}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_delete[] = {
|
|
{"packed_loose", &test_refs_delete__packed_loose},
|
|
{"packed_only", &test_refs_delete__packed_only}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_foreachglob[] = {
|
|
{"can_cancel", &test_refs_foreachglob__can_cancel},
|
|
{"retrieve_all_refs", &test_refs_foreachglob__retrieve_all_refs},
|
|
{"retrieve_local_branches", &test_refs_foreachglob__retrieve_local_branches},
|
|
{"retrieve_partially_named_references", &test_refs_foreachglob__retrieve_partially_named_references},
|
|
{"retrieve_remote_branches", &test_refs_foreachglob__retrieve_remote_branches}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_isvalidname[] = {
|
|
{"can_detect_invalid_formats", &test_refs_isvalidname__can_detect_invalid_formats},
|
|
{"wont_hopefully_choke_on_valid_formats", &test_refs_isvalidname__wont_hopefully_choke_on_valid_formats}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_list[] = {
|
|
{"all", &test_refs_list__all},
|
|
{"do_not_retrieve_references_which_name_end_with_a_lock_extension", &test_refs_list__do_not_retrieve_references_which_name_end_with_a_lock_extension},
|
|
{"symbolic_only", &test_refs_list__symbolic_only}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_listall[] = {
|
|
{"from_repository_opened_through_gitdir_path", &test_refs_listall__from_repository_opened_through_gitdir_path},
|
|
{"from_repository_opened_through_workdir_path", &test_refs_listall__from_repository_opened_through_workdir_path}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_lookup[] = {
|
|
{"oid", &test_refs_lookup__oid},
|
|
{"with_resolve", &test_refs_lookup__with_resolve}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_normalize[] = {
|
|
{"buffer_has_to_be_big_enough_to_hold_the_normalized_version", &test_refs_normalize__buffer_has_to_be_big_enough_to_hold_the_normalized_version},
|
|
{"can_normalize_a_direct_reference_name", &test_refs_normalize__can_normalize_a_direct_reference_name},
|
|
{"cannot_normalize_any_direct_reference_name", &test_refs_normalize__cannot_normalize_any_direct_reference_name},
|
|
{"jgit_suite", &test_refs_normalize__jgit_suite},
|
|
{"refspec_pattern", &test_refs_normalize__refspec_pattern},
|
|
{"symbolic", &test_refs_normalize__symbolic}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_overwrite[] = {
|
|
{"object_id", &test_refs_overwrite__object_id},
|
|
{"object_id_with_symbolic", &test_refs_overwrite__object_id_with_symbolic},
|
|
{"symbolic", &test_refs_overwrite__symbolic},
|
|
{"symbolic_with_object_id", &test_refs_overwrite__symbolic_with_object_id}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_pack[] = {
|
|
{"empty", &test_refs_pack__empty},
|
|
{"loose", &test_refs_pack__loose}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_peel[] = {
|
|
{"can_peel_a_branch", &test_refs_peel__can_peel_a_branch},
|
|
{"can_peel_a_symbolic_reference", &test_refs_peel__can_peel_a_symbolic_reference},
|
|
{"can_peel_a_tag", &test_refs_peel__can_peel_a_tag},
|
|
{"can_peel_into_any_non_tag_object", &test_refs_peel__can_peel_into_any_non_tag_object},
|
|
{"cannot_peel_into_a_non_existing_target", &test_refs_peel__cannot_peel_into_a_non_existing_target}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_read[] = {
|
|
{"can_determine_if_a_reference_is_a_local_branch", &test_refs_read__can_determine_if_a_reference_is_a_local_branch},
|
|
{"chomped", &test_refs_read__chomped},
|
|
{"head_then_master", &test_refs_read__head_then_master},
|
|
{"loose_first", &test_refs_read__loose_first},
|
|
{"loose_tag", &test_refs_read__loose_tag},
|
|
{"master_then_head", &test_refs_read__master_then_head},
|
|
{"nested_symbolic", &test_refs_read__nested_symbolic},
|
|
{"nonexisting_tag", &test_refs_read__nonexisting_tag},
|
|
{"packed", &test_refs_read__packed},
|
|
{"symbolic", &test_refs_read__symbolic},
|
|
{"trailing", &test_refs_read__trailing},
|
|
{"unfound_return_ENOTFOUND", &test_refs_read__unfound_return_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_reflog_drop[] = {
|
|
{"can_drop_all_the_entries", &test_refs_reflog_drop__can_drop_all_the_entries},
|
|
{"can_drop_an_entry", &test_refs_reflog_drop__can_drop_an_entry},
|
|
{"can_drop_an_entry_and_rewrite_the_log_history", &test_refs_reflog_drop__can_drop_an_entry_and_rewrite_the_log_history},
|
|
{"can_drop_the_oldest_entry", &test_refs_reflog_drop__can_drop_the_oldest_entry},
|
|
{"can_drop_the_oldest_entry_and_rewrite_the_log_history", &test_refs_reflog_drop__can_drop_the_oldest_entry_and_rewrite_the_log_history},
|
|
{"can_persist_deletion_on_disk", &test_refs_reflog_drop__can_persist_deletion_on_disk},
|
|
{"dropping_a_non_exisiting_entry_from_the_log_returns_ENOTFOUND", &test_refs_reflog_drop__dropping_a_non_exisiting_entry_from_the_log_returns_ENOTFOUND}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_reflog_reflog[] = {
|
|
{"append_then_read", &test_refs_reflog_reflog__append_then_read},
|
|
{"cannot_write_a_moved_reflog", &test_refs_reflog_reflog__cannot_write_a_moved_reflog},
|
|
{"reading_the_reflog_from_a_reference_with_no_log_returns_an_empty_one", &test_refs_reflog_reflog__reading_the_reflog_from_a_reference_with_no_log_returns_an_empty_one},
|
|
{"reference_has_reflog", &test_refs_reflog_reflog__reference_has_reflog},
|
|
{"renaming_the_reference_moves_the_reflog", &test_refs_reflog_reflog__renaming_the_reference_moves_the_reflog}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_rename[] = {
|
|
{"force_loose", &test_refs_rename__force_loose},
|
|
{"force_loose_packed", &test_refs_rename__force_loose_packed},
|
|
{"invalid_name", &test_refs_rename__invalid_name},
|
|
{"loose", &test_refs_rename__loose},
|
|
{"move_up", &test_refs_rename__move_up},
|
|
{"name_collision", &test_refs_rename__name_collision},
|
|
{"overwrite", &test_refs_rename__overwrite},
|
|
{"packed", &test_refs_rename__packed},
|
|
{"packed_doesnt_pack_others", &test_refs_rename__packed_doesnt_pack_others},
|
|
{"prefix", &test_refs_rename__prefix},
|
|
{"propagate_eexists", &test_refs_rename__propagate_eexists}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_revparse[] = {
|
|
{"a_too_short_objectid_returns_EAMBIGUOUS", &test_refs_revparse__a_too_short_objectid_returns_EAMBIGUOUS},
|
|
{"chaining", &test_refs_revparse__chaining},
|
|
{"colon", &test_refs_revparse__colon},
|
|
{"date", &test_refs_revparse__date},
|
|
{"describe_output", &test_refs_revparse__describe_output},
|
|
{"disambiguation", &test_refs_revparse__disambiguation},
|
|
{"full_refs", &test_refs_revparse__full_refs},
|
|
{"head", &test_refs_revparse__head},
|
|
{"invalid_reference_name", &test_refs_revparse__invalid_reference_name},
|
|
{"issue_994", &test_refs_revparse__issue_994},
|
|
{"linear_history", &test_refs_revparse__linear_history},
|
|
{"nonexistant_object", &test_refs_revparse__nonexistant_object},
|
|
{"not_tag", &test_refs_revparse__not_tag},
|
|
{"nth_parent", &test_refs_revparse__nth_parent},
|
|
{"ordinal", &test_refs_revparse__ordinal},
|
|
{"partial_refs", &test_refs_revparse__partial_refs},
|
|
{"previous_head", &test_refs_revparse__previous_head},
|
|
{"reflog_of_a_ref_under_refs", &test_refs_revparse__reflog_of_a_ref_under_refs},
|
|
{"revwalk", &test_refs_revparse__revwalk},
|
|
{"shas", &test_refs_revparse__shas},
|
|
{"to_type", &test_refs_revparse__to_type},
|
|
{"upstream", &test_refs_revparse__upstream}
|
|
};
|
|
static const struct clar_func _clar_cb_refs_unicode[] = {
|
|
{"create_and_lookup", &test_refs_unicode__create_and_lookup}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_discover[] = {
|
|
{"0", &test_repo_discover__0}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_getters[] = {
|
|
{"is_empty_can_detect_used_repositories", &test_repo_getters__is_empty_can_detect_used_repositories},
|
|
{"is_empty_correctly_deals_with_pristine_looking_repos", &test_repo_getters__is_empty_correctly_deals_with_pristine_looking_repos},
|
|
{"retrieving_the_odb_honors_the_refcount", &test_repo_getters__retrieving_the_odb_honors_the_refcount}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_hashfile[] = {
|
|
{"filtered", &test_repo_hashfile__filtered},
|
|
{"simple", &test_repo_hashfile__simple}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_head[] = {
|
|
{"can_tell_if_an_orphaned_head_is_detached", &test_repo_head__can_tell_if_an_orphaned_head_is_detached},
|
|
{"detach_head_Detaches_HEAD_and_make_it_point_to_the_peeled_commit", &test_repo_head__detach_head_Detaches_HEAD_and_make_it_point_to_the_peeled_commit},
|
|
{"detach_head_Fails_if_HEAD_and_point_to_a_non_commitish", &test_repo_head__detach_head_Fails_if_HEAD_and_point_to_a_non_commitish},
|
|
{"detaching_an_orphaned_head_returns_GIT_EORPHANEDHEAD", &test_repo_head__detaching_an_orphaned_head_returns_GIT_EORPHANEDHEAD},
|
|
{"head_detached", &test_repo_head__head_detached},
|
|
{"head_orphan", &test_repo_head__head_orphan},
|
|
{"retrieving_a_missing_head_returns_GIT_ENOTFOUND", &test_repo_head__retrieving_a_missing_head_returns_GIT_ENOTFOUND},
|
|
{"retrieving_an_orphaned_head_returns_GIT_EORPHANEDHEAD", &test_repo_head__retrieving_an_orphaned_head_returns_GIT_EORPHANEDHEAD},
|
|
{"set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_doesnt_exist", &test_repo_head__set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_doesnt_exist},
|
|
{"set_head_Attaches_HEAD_when_the_reference_points_to_a_branch", &test_repo_head__set_head_Attaches_HEAD_when_the_reference_points_to_a_branch},
|
|
{"set_head_Detaches_HEAD_when_the_reference_doesnt_point_to_a_branch", &test_repo_head__set_head_Detaches_HEAD_when_the_reference_doesnt_point_to_a_branch},
|
|
{"set_head_Fails_when_the_reference_points_to_a_non_commitish", &test_repo_head__set_head_Fails_when_the_reference_points_to_a_non_commitish},
|
|
{"set_head_Returns_ENOTFOUND_when_the_reference_doesnt_exist", &test_repo_head__set_head_Returns_ENOTFOUND_when_the_reference_doesnt_exist},
|
|
{"set_head_detached_Detaches_HEAD_and_make_it_point_to_the_peeled_commit", &test_repo_head__set_head_detached_Detaches_HEAD_and_make_it_point_to_the_peeled_commit},
|
|
{"set_head_detached_Fails_when_the_object_isnt_a_commitish", &test_repo_head__set_head_detached_Fails_when_the_object_isnt_a_commitish},
|
|
{"set_head_detached_Return_ENOTFOUND_when_the_object_doesnt_exist", &test_repo_head__set_head_detached_Return_ENOTFOUND_when_the_object_doesnt_exist}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_headtree[] = {
|
|
{"can_retrieve_the_root_tree_from_a_detached_head", &test_repo_headtree__can_retrieve_the_root_tree_from_a_detached_head},
|
|
{"can_retrieve_the_root_tree_from_a_non_detached_head", &test_repo_headtree__can_retrieve_the_root_tree_from_a_non_detached_head},
|
|
{"when_head_is_missing_returns_ENOTFOUND", &test_repo_headtree__when_head_is_missing_returns_ENOTFOUND},
|
|
{"when_head_is_orphaned_returns_EORPHANEDHEAD", &test_repo_headtree__when_head_is_orphaned_returns_EORPHANEDHEAD}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_init[] = {
|
|
{"additional_templates", &test_repo_init__additional_templates},
|
|
{"bare_repo", &test_repo_init__bare_repo},
|
|
{"bare_repo_escaping_current_workdir", &test_repo_init__bare_repo_escaping_current_workdir},
|
|
{"bare_repo_noslash", &test_repo_init__bare_repo_noslash},
|
|
{"can_reinit_an_initialized_repository", &test_repo_init__can_reinit_an_initialized_repository},
|
|
{"detect_filemode", &test_repo_init__detect_filemode},
|
|
{"detect_ignorecase", &test_repo_init__detect_ignorecase},
|
|
{"extended_0", &test_repo_init__extended_0},
|
|
{"extended_1", &test_repo_init__extended_1},
|
|
{"extended_with_template", &test_repo_init__extended_with_template},
|
|
{"reinit_bare_repo", &test_repo_init__reinit_bare_repo},
|
|
{"reinit_doesnot_overwrite_ignorecase", &test_repo_init__reinit_doesnot_overwrite_ignorecase},
|
|
{"reinit_overwrites_filemode", &test_repo_init__reinit_overwrites_filemode},
|
|
{"reinit_too_recent_bare_repo", &test_repo_init__reinit_too_recent_bare_repo},
|
|
{"sets_logAllRefUpdates_according_to_type_of_repository", &test_repo_init__sets_logAllRefUpdates_according_to_type_of_repository},
|
|
{"standard_repo", &test_repo_init__standard_repo},
|
|
{"standard_repo_noslash", &test_repo_init__standard_repo_noslash}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_message[] = {
|
|
{"message", &test_repo_message__message},
|
|
{"none", &test_repo_message__none}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_open[] = {
|
|
{"bad_gitlinks", &test_repo_open__bad_gitlinks},
|
|
{"bare_empty_repo", &test_repo_open__bare_empty_repo},
|
|
{"failures", &test_repo_open__failures},
|
|
{"from_git_new_workdir", &test_repo_open__from_git_new_workdir},
|
|
{"gitlinked", &test_repo_open__gitlinked},
|
|
{"open_with_discover", &test_repo_open__open_with_discover},
|
|
{"opening_a_non_existing_repository_returns_ENOTFOUND", &test_repo_open__opening_a_non_existing_repository_returns_ENOTFOUND},
|
|
{"standard_empty_repo_through_gitdir", &test_repo_open__standard_empty_repo_through_gitdir},
|
|
{"standard_empty_repo_through_workdir", &test_repo_open__standard_empty_repo_through_workdir},
|
|
{"win32_path", &test_repo_open__win32_path}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_setters[] = {
|
|
{"setting_a_new_index_on_a_repo_which_has_already_loaded_one_properly_honors_the_refcount", &test_repo_setters__setting_a_new_index_on_a_repo_which_has_already_loaded_one_properly_honors_the_refcount},
|
|
{"setting_a_new_odb_on_a_repo_which_already_loaded_one_properly_honors_the_refcount", &test_repo_setters__setting_a_new_odb_on_a_repo_which_already_loaded_one_properly_honors_the_refcount},
|
|
{"setting_a_workdir_creates_a_gitlink", &test_repo_setters__setting_a_workdir_creates_a_gitlink},
|
|
{"setting_a_workdir_prettifies_its_path", &test_repo_setters__setting_a_workdir_prettifies_its_path},
|
|
{"setting_a_workdir_turns_a_bare_repository_into_a_standard_one", &test_repo_setters__setting_a_workdir_turns_a_bare_repository_into_a_standard_one}
|
|
};
|
|
static const struct clar_func _clar_cb_repo_state[] = {
|
|
{"apply_mailbox", &test_repo_state__apply_mailbox},
|
|
{"apply_mailbox_or_rebase", &test_repo_state__apply_mailbox_or_rebase},
|
|
{"bisect", &test_repo_state__bisect},
|
|
{"cherry_pick", &test_repo_state__cherry_pick},
|
|
{"merge", &test_repo_state__merge},
|
|
{"none_with_HEAD_attached", &test_repo_state__none_with_HEAD_attached},
|
|
{"none_with_HEAD_detached", &test_repo_state__none_with_HEAD_detached},
|
|
{"rebase", &test_repo_state__rebase},
|
|
{"rebase_interactive", &test_repo_state__rebase_interactive},
|
|
{"rebase_merge", &test_repo_state__rebase_merge},
|
|
{"revert", &test_repo_state__revert}
|
|
};
|
|
static const struct clar_func _clar_cb_reset_hard[] = {
|
|
{"cannot_reset_in_a_bare_repository", &test_reset_hard__cannot_reset_in_a_bare_repository},
|
|
{"cleans_up_merge", &test_reset_hard__cleans_up_merge},
|
|
{"resetting_reverts_modified_files", &test_reset_hard__resetting_reverts_modified_files}
|
|
};
|
|
static const struct clar_func _clar_cb_reset_mixed[] = {
|
|
{"cannot_reset_in_a_bare_repository", &test_reset_mixed__cannot_reset_in_a_bare_repository},
|
|
{"resetting_refreshes_the_index_to_the_commit_tree", &test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree}
|
|
};
|
|
static const struct clar_func _clar_cb_reset_soft[] = {
|
|
{"can_reset_the_detached_Head_to_the_specified_commit", &test_reset_soft__can_reset_the_detached_Head_to_the_specified_commit},
|
|
{"can_reset_the_non_detached_Head_to_the_specified_commit", &test_reset_soft__can_reset_the_non_detached_Head_to_the_specified_commit},
|
|
{"cannot_reset_to_a_tag_not_pointing_at_a_commit", &test_reset_soft__cannot_reset_to_a_tag_not_pointing_at_a_commit},
|
|
{"fails_when_merging", &test_reset_soft__fails_when_merging},
|
|
{"resetting_against_an_orphaned_head_repo_makes_the_head_no_longer_orphaned", &test_reset_soft__resetting_against_an_orphaned_head_repo_makes_the_head_no_longer_orphaned},
|
|
{"resetting_to_a_tag_sets_the_Head_to_the_peeled_commit", &test_reset_soft__resetting_to_a_tag_sets_the_Head_to_the_peeled_commit},
|
|
{"resetting_to_the_commit_pointed_at_by_the_Head_does_not_change_the_target_of_the_Head", &test_reset_soft__resetting_to_the_commit_pointed_at_by_the_Head_does_not_change_the_target_of_the_Head}
|
|
};
|
|
static const struct clar_func _clar_cb_revwalk_basic[] = {
|
|
{"disallow_non_commit", &test_revwalk_basic__disallow_non_commit},
|
|
{"glob_heads", &test_revwalk_basic__glob_heads},
|
|
{"push_head", &test_revwalk_basic__push_head},
|
|
{"push_head_hide_ref", &test_revwalk_basic__push_head_hide_ref},
|
|
{"push_head_hide_ref_nobase", &test_revwalk_basic__push_head_hide_ref_nobase},
|
|
{"sorting_modes", &test_revwalk_basic__sorting_modes}
|
|
};
|
|
static const struct clar_func _clar_cb_revwalk_mergebase[] = {
|
|
{"many_merge_branch", &test_revwalk_mergebase__many_merge_branch},
|
|
{"many_no_common_ancestor_returns_ENOTFOUND", &test_revwalk_mergebase__many_no_common_ancestor_returns_ENOTFOUND},
|
|
{"merged_branch", &test_revwalk_mergebase__merged_branch},
|
|
{"no_common_ancestor_returns_ENOTFOUND", &test_revwalk_mergebase__no_common_ancestor_returns_ENOTFOUND},
|
|
{"no_off_by_one_missing", &test_revwalk_mergebase__no_off_by_one_missing},
|
|
{"single1", &test_revwalk_mergebase__single1},
|
|
{"single2", &test_revwalk_mergebase__single2}
|
|
};
|
|
static const struct clar_func _clar_cb_revwalk_signatureparsing[] = {
|
|
{"do_not_choke_when_name_contains_angle_brackets", &test_revwalk_signatureparsing__do_not_choke_when_name_contains_angle_brackets}
|
|
};
|
|
static const struct clar_func _clar_cb_stash_drop[] = {
|
|
{"can_purge_the_stash_from_the_bottom", &test_stash_drop__can_purge_the_stash_from_the_bottom},
|
|
{"can_purge_the_stash_from_the_top", &test_stash_drop__can_purge_the_stash_from_the_top},
|
|
{"cannot_drop_a_non_existing_stashed_state", &test_stash_drop__cannot_drop_a_non_existing_stashed_state},
|
|
{"cannot_drop_from_an_empty_stash", &test_stash_drop__cannot_drop_from_an_empty_stash},
|
|
{"dropping_an_entry_rewrites_reflog_history", &test_stash_drop__dropping_an_entry_rewrites_reflog_history},
|
|
{"dropping_the_last_entry_removes_the_stash", &test_stash_drop__dropping_the_last_entry_removes_the_stash}
|
|
};
|
|
static const struct clar_func _clar_cb_stash_foreach[] = {
|
|
{"can_enumerate_a_repository", &test_stash_foreach__can_enumerate_a_repository},
|
|
{"enumerating_a_empty_repository_doesnt_fail", &test_stash_foreach__enumerating_a_empty_repository_doesnt_fail}
|
|
};
|
|
static const struct clar_func _clar_cb_stash_save[] = {
|
|
{"can_accept_a_message", &test_stash_save__can_accept_a_message},
|
|
{"can_include_untracked_and_ignored_files", &test_stash_save__can_include_untracked_and_ignored_files},
|
|
{"can_include_untracked_files", &test_stash_save__can_include_untracked_files},
|
|
{"can_keep_index", &test_stash_save__can_keep_index},
|
|
{"can_stage_normal_then_stage_untracked", &test_stash_save__can_stage_normal_then_stage_untracked},
|
|
{"can_stash_against_a_detached_head", &test_stash_save__can_stash_against_a_detached_head},
|
|
{"cannot_stash_against_a_bare_repository", &test_stash_save__cannot_stash_against_a_bare_repository},
|
|
{"cannot_stash_against_an_unborn_branch", &test_stash_save__cannot_stash_against_an_unborn_branch},
|
|
{"cannot_stash_when_there_are_no_local_change", &test_stash_save__cannot_stash_when_there_are_no_local_change},
|
|
{"does_not_keep_index_by_default", &test_stash_save__does_not_keep_index_by_default},
|
|
{"including_untracked_without_any_untracked_file_creates_an_empty_tree", &test_stash_save__including_untracked_without_any_untracked_file_creates_an_empty_tree},
|
|
{"stashing_updates_the_reflog", &test_stash_save__stashing_updates_the_reflog}
|
|
};
|
|
static const struct clar_func _clar_cb_status_ignore[] = {
|
|
{"0", &test_status_ignore__0},
|
|
{"1", &test_status_ignore__1},
|
|
{"add_internal_as_first_thing", &test_status_ignore__add_internal_as_first_thing},
|
|
{"adding_internal_ignores", &test_status_ignore__adding_internal_ignores},
|
|
{"empty_repo_with_gitignore_rewrite", &test_status_ignore__empty_repo_with_gitignore_rewrite},
|
|
{"ignore_pattern_contains_space", &test_status_ignore__ignore_pattern_contains_space},
|
|
{"ignore_pattern_ignorecase", &test_status_ignore__ignore_pattern_ignorecase},
|
|
{"internal_ignores_inside_deep_paths", &test_status_ignore__internal_ignores_inside_deep_paths},
|
|
{"subdirectories", &test_status_ignore__subdirectories}
|
|
};
|
|
static const struct clar_func _clar_cb_status_single[] = {
|
|
{"hash_single_empty_file", &test_status_single__hash_single_empty_file},
|
|
{"hash_single_file", &test_status_single__hash_single_file}
|
|
};
|
|
static const struct clar_func _clar_cb_status_submodules[] = {
|
|
{"0", &test_status_submodules__0},
|
|
{"1", &test_status_submodules__1},
|
|
{"api", &test_status_submodules__api},
|
|
{"single_file", &test_status_submodules__single_file}
|
|
};
|
|
static const struct clar_func _clar_cb_status_worktree[] = {
|
|
{"bracket_in_filename", &test_status_worktree__bracket_in_filename},
|
|
{"cannot_retrieve_the_status_of_a_bare_repository", &test_status_worktree__cannot_retrieve_the_status_of_a_bare_repository},
|
|
{"disable_pathspec_match", &test_status_worktree__disable_pathspec_match},
|
|
{"empty_repository", &test_status_worktree__empty_repository},
|
|
{"filemode_changes", &test_status_worktree__filemode_changes},
|
|
{"first_commit_in_progress", &test_status_worktree__first_commit_in_progress},
|
|
{"ignores", &test_status_worktree__ignores},
|
|
{"interruptable_foreach", &test_status_worktree__interruptable_foreach},
|
|
{"issue_592", &test_status_worktree__issue_592},
|
|
{"issue_592_2", &test_status_worktree__issue_592_2},
|
|
{"issue_592_3", &test_status_worktree__issue_592_3},
|
|
{"issue_592_4", &test_status_worktree__issue_592_4},
|
|
{"issue_592_5", &test_status_worktree__issue_592_5},
|
|
{"issue_592_ignored_dirs_with_tracked_content", &test_status_worktree__issue_592_ignored_dirs_with_tracked_content},
|
|
{"issue_592_ignores_0", &test_status_worktree__issue_592_ignores_0},
|
|
{"line_endings_dont_count_as_changes_with_autocrlf", &test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf},
|
|
{"new_staged_file_must_handle_crlf", &test_status_worktree__new_staged_file_must_handle_crlf},
|
|
{"purged_worktree", &test_status_worktree__purged_worktree},
|
|
{"single_file", &test_status_worktree__single_file},
|
|
{"single_file_empty_repo", &test_status_worktree__single_file_empty_repo},
|
|
{"single_folder", &test_status_worktree__single_folder},
|
|
{"single_nonexistent_file", &test_status_worktree__single_nonexistent_file},
|
|
{"single_nonexistent_file_empty_repo", &test_status_worktree__single_nonexistent_file_empty_repo},
|
|
{"space_in_filename", &test_status_worktree__space_in_filename},
|
|
{"status_file_with_clean_index_and_empty_workdir", &test_status_worktree__status_file_with_clean_index_and_empty_workdir},
|
|
{"status_file_without_index_or_workdir", &test_status_worktree__status_file_without_index_or_workdir},
|
|
{"swap_subdir_and_file", &test_status_worktree__swap_subdir_and_file},
|
|
{"swap_subdir_with_recurse_and_pathspec", &test_status_worktree__swap_subdir_with_recurse_and_pathspec},
|
|
{"whole_repository", &test_status_worktree__whole_repository}
|
|
};
|
|
static const struct clar_func _clar_cb_submodule_lookup[] = {
|
|
{"accessors", &test_submodule_lookup__accessors},
|
|
{"foreach", &test_submodule_lookup__foreach},
|
|
{"simple_lookup", &test_submodule_lookup__simple_lookup}
|
|
};
|
|
static const struct clar_func _clar_cb_submodule_modify[] = {
|
|
{"add", &test_submodule_modify__add},
|
|
{"edit_and_save", &test_submodule_modify__edit_and_save},
|
|
{"init", &test_submodule_modify__init},
|
|
{"sync", &test_submodule_modify__sync}
|
|
};
|
|
static const struct clar_func _clar_cb_submodule_status[] = {
|
|
{"ignore_all", &test_submodule_status__ignore_all},
|
|
{"ignore_dirty", &test_submodule_status__ignore_dirty},
|
|
{"ignore_none", &test_submodule_status__ignore_none},
|
|
{"ignore_untracked", &test_submodule_status__ignore_untracked},
|
|
{"unchanged", &test_submodule_status__unchanged}
|
|
};
|
|
static const struct clar_func _clar_cb_threads_basic[] = {
|
|
{"cache", &test_threads_basic__cache}
|
|
};
|
|
|
|
static const char *_clar_cat_clone_network[] = { "network", NULL };static const char *_clar_cat_fetchhead_network[] = { "network", NULL };static const char *_clar_cat_network_fetch[] = { "network", NULL };
|
|
|
|
static const struct clar_suite _clar_suites[] = {
|
|
{
|
|
0,
|
|
"attr::file",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_attr_file, 4
|
|
},
|
|
{
|
|
1,
|
|
"attr::flags",
|
|
{NULL, NULL},
|
|
{"cleanup", &test_attr_flags__cleanup},
|
|
NULL,
|
|
_clar_cb_attr_flags, 3
|
|
},
|
|
{
|
|
2,
|
|
"attr::lookup",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_attr_lookup, 5
|
|
},
|
|
{
|
|
3,
|
|
"attr::repo",
|
|
{"initialize", &test_attr_repo__initialize},
|
|
{"cleanup", &test_attr_repo__cleanup},
|
|
NULL,
|
|
_clar_cb_attr_repo, 7
|
|
},
|
|
{
|
|
4,
|
|
"buf::basic",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_buf_basic, 2
|
|
},
|
|
{
|
|
5,
|
|
"buf::splice",
|
|
{"initialize", &test_buf_splice__initialize},
|
|
{"cleanup", &test_buf_splice__cleanup},
|
|
NULL,
|
|
_clar_cb_buf_splice, 9
|
|
},
|
|
{
|
|
6,
|
|
"checkout::head",
|
|
{"initialize", &test_checkout_head__initialize},
|
|
{"cleanup", &test_checkout_head__cleanup},
|
|
NULL,
|
|
_clar_cb_checkout_head, 1
|
|
},
|
|
{
|
|
7,
|
|
"checkout::index",
|
|
{"initialize", &test_checkout_index__initialize},
|
|
{"cleanup", &test_checkout_index__cleanup},
|
|
NULL,
|
|
_clar_cb_checkout_index, 18
|
|
},
|
|
{
|
|
8,
|
|
"checkout::tree",
|
|
{"initialize", &test_checkout_tree__initialize},
|
|
{"cleanup", &test_checkout_tree__cleanup},
|
|
NULL,
|
|
_clar_cb_checkout_tree, 4
|
|
},
|
|
{
|
|
9,
|
|
"checkout::typechange",
|
|
{"initialize", &test_checkout_typechange__initialize},
|
|
{"cleanup", &test_checkout_typechange__cleanup},
|
|
NULL,
|
|
_clar_cb_checkout_typechange, 1
|
|
},
|
|
{
|
|
10,
|
|
"clone::network",
|
|
{"initialize", &test_clone_network__initialize},
|
|
{NULL, NULL},
|
|
_clar_cat_clone_network,
|
|
_clar_cb_clone_network, 6
|
|
},
|
|
{
|
|
11,
|
|
"clone::nonetwork",
|
|
{"initialize", &test_clone_nonetwork__initialize},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_clone_nonetwork, 5
|
|
},
|
|
{
|
|
12,
|
|
"commit::commit",
|
|
{"initialize", &test_commit_commit__initialize},
|
|
{"cleanup", &test_commit_commit__cleanup},
|
|
NULL,
|
|
_clar_cb_commit_commit, 1
|
|
},
|
|
{
|
|
13,
|
|
"commit::parent",
|
|
{"initialize", &test_commit_parent__initialize},
|
|
{"cleanup", &test_commit_parent__cleanup},
|
|
NULL,
|
|
_clar_cb_commit_parent, 1
|
|
},
|
|
{
|
|
14,
|
|
"commit::parse",
|
|
{"initialize", &test_commit_parse__initialize},
|
|
{"cleanup", &test_commit_parse__cleanup},
|
|
NULL,
|
|
_clar_cb_commit_parse, 4
|
|
},
|
|
{
|
|
15,
|
|
"commit::signature",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_commit_signature, 7
|
|
},
|
|
{
|
|
16,
|
|
"commit::write",
|
|
{"initialize", &test_commit_write__initialize},
|
|
{"cleanup", &test_commit_write__cleanup},
|
|
NULL,
|
|
_clar_cb_commit_write, 2
|
|
},
|
|
{
|
|
17,
|
|
"config::add",
|
|
{"initialize", &test_config_add__initialize},
|
|
{"cleanup", &test_config_add__cleanup},
|
|
NULL,
|
|
_clar_cb_config_add, 2
|
|
},
|
|
{
|
|
18,
|
|
"config::configlevel",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_config_configlevel, 4
|
|
},
|
|
{
|
|
19,
|
|
"config::multivar",
|
|
{"initialize", &test_config_multivar__initialize},
|
|
{"cleanup", &test_config_multivar__cleanup},
|
|
NULL,
|
|
_clar_cb_config_multivar, 5
|
|
},
|
|
{
|
|
20,
|
|
"config::new",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_config_new, 1
|
|
},
|
|
{
|
|
21,
|
|
"config::read",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_config_read, 21
|
|
},
|
|
{
|
|
22,
|
|
"config::refresh",
|
|
{"initialize", &test_config_refresh__initialize},
|
|
{"cleanup", &test_config_refresh__cleanup},
|
|
NULL,
|
|
_clar_cb_config_refresh, 2
|
|
},
|
|
{
|
|
23,
|
|
"config::stress",
|
|
{"initialize", &test_config_stress__initialize},
|
|
{"cleanup", &test_config_stress__cleanup},
|
|
NULL,
|
|
_clar_cb_config_stress, 3
|
|
},
|
|
{
|
|
24,
|
|
"config::write",
|
|
{"initialize", &test_config_write__initialize},
|
|
{"cleanup", &test_config_write__cleanup},
|
|
NULL,
|
|
_clar_cb_config_write, 9
|
|
},
|
|
{
|
|
25,
|
|
"core::buffer",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_buffer, 16
|
|
},
|
|
{
|
|
26,
|
|
"core::copy",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_copy, 3
|
|
},
|
|
{
|
|
27,
|
|
"core::dirent",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_dirent, 6
|
|
},
|
|
{
|
|
28,
|
|
"core::env",
|
|
{"initialize", &test_core_env__initialize},
|
|
{"cleanup", &test_core_env__cleanup},
|
|
NULL,
|
|
_clar_cb_core_env, 2
|
|
},
|
|
{
|
|
29,
|
|
"core::errors",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_errors, 2
|
|
},
|
|
{
|
|
30,
|
|
"core::filebuf",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_filebuf, 5
|
|
},
|
|
{
|
|
31,
|
|
"core::hex",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_hex, 1
|
|
},
|
|
{
|
|
32,
|
|
"core::mkdir",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_mkdir, 3
|
|
},
|
|
{
|
|
33,
|
|
"core::oid",
|
|
{"initialize", &test_core_oid__initialize},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_oid, 1
|
|
},
|
|
{
|
|
34,
|
|
"core::path",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_path, 13
|
|
},
|
|
{
|
|
35,
|
|
"core::pool",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_pool, 3
|
|
},
|
|
{
|
|
36,
|
|
"core::rmdir",
|
|
{"initialize", &test_core_rmdir__initialize},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_rmdir, 4
|
|
},
|
|
{
|
|
37,
|
|
"core::stat",
|
|
{"initialize", &test_core_stat__initialize},
|
|
{"cleanup", &test_core_stat__cleanup},
|
|
NULL,
|
|
_clar_cb_core_stat, 1
|
|
},
|
|
{
|
|
38,
|
|
"core::string",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_string, 2
|
|
},
|
|
{
|
|
39,
|
|
"core::strmap",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_strmap, 4
|
|
},
|
|
{
|
|
40,
|
|
"core::strtol",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_strtol, 2
|
|
},
|
|
{
|
|
41,
|
|
"core::vector",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_core_vector, 7
|
|
},
|
|
{
|
|
42,
|
|
"date::date",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_date_date, 1
|
|
},
|
|
{
|
|
43,
|
|
"diff::blob",
|
|
{"initialize", &test_diff_blob__initialize},
|
|
{"cleanup", &test_diff_blob__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_blob, 6
|
|
},
|
|
{
|
|
44,
|
|
"diff::diffiter",
|
|
{"initialize", &test_diff_diffiter__initialize},
|
|
{"cleanup", &test_diff_diffiter__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_diffiter, 8
|
|
},
|
|
{
|
|
45,
|
|
"diff::index",
|
|
{"initialize", &test_diff_index__initialize},
|
|
{"cleanup", &test_diff_index__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_index, 2
|
|
},
|
|
{
|
|
46,
|
|
"diff::iterator",
|
|
{"initialize", &test_diff_iterator__initialize},
|
|
{"cleanup", &test_diff_iterator__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_iterator, 28
|
|
},
|
|
{
|
|
47,
|
|
"diff::patch",
|
|
{"initialize", &test_diff_patch__initialize},
|
|
{"cleanup", &test_diff_patch__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_patch, 2
|
|
},
|
|
{
|
|
48,
|
|
"diff::rename",
|
|
{"initialize", &test_diff_rename__initialize},
|
|
{"cleanup", &test_diff_rename__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_rename, 1
|
|
},
|
|
{
|
|
49,
|
|
"diff::tree",
|
|
{"initialize", &test_diff_tree__initialize},
|
|
{"cleanup", &test_diff_tree__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_tree, 5
|
|
},
|
|
{
|
|
50,
|
|
"diff::workdir",
|
|
{"initialize", &test_diff_workdir__initialize},
|
|
{"cleanup", &test_diff_workdir__cleanup},
|
|
NULL,
|
|
_clar_cb_diff_workdir, 10
|
|
},
|
|
{
|
|
51,
|
|
"fetchhead::network",
|
|
{"initialize", &test_fetchhead_network__initialize},
|
|
{NULL, NULL},
|
|
_clar_cat_fetchhead_network,
|
|
_clar_cb_fetchhead_network, 3
|
|
},
|
|
{
|
|
52,
|
|
"fetchhead::nonetwork",
|
|
{"initialize", &test_fetchhead_nonetwork__initialize},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_fetchhead_nonetwork, 1
|
|
},
|
|
{
|
|
53,
|
|
"index::conflicts",
|
|
{"initialize", &test_index_conflicts__initialize},
|
|
{"cleanup", &test_index_conflicts__cleanup},
|
|
NULL,
|
|
_clar_cb_index_conflicts, 7
|
|
},
|
|
{
|
|
54,
|
|
"index::filemodes",
|
|
{"initialize", &test_index_filemodes__initialize},
|
|
{"cleanup", &test_index_filemodes__cleanup},
|
|
NULL,
|
|
_clar_cb_index_filemodes, 3
|
|
},
|
|
{
|
|
55,
|
|
"index::inmemory",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_index_inmemory, 2
|
|
},
|
|
{
|
|
56,
|
|
"index::read::tree",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_index_read_tree, 1
|
|
},
|
|
{
|
|
57,
|
|
"index::rename",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_index_rename, 1
|
|
},
|
|
{
|
|
58,
|
|
"index::reuc",
|
|
{"initialize", &test_index_reuc__initialize},
|
|
{"cleanup", &test_index_reuc__cleanup},
|
|
NULL,
|
|
_clar_cb_index_reuc, 6
|
|
},
|
|
{
|
|
59,
|
|
"index::stage",
|
|
{"initialize", &test_index_stage__initialize},
|
|
{"cleanup", &test_index_stage__cleanup},
|
|
NULL,
|
|
_clar_cb_index_stage, 2
|
|
},
|
|
{
|
|
60,
|
|
"index::tests",
|
|
{"initialize", &test_index_tests__initialize},
|
|
{"cleanup", &test_index_tests__cleanup},
|
|
NULL,
|
|
_clar_cb_index_tests, 11
|
|
},
|
|
{
|
|
61,
|
|
"network::createremotethenload",
|
|
{"initialize", &test_network_createremotethenload__initialize},
|
|
{"cleanup", &test_network_createremotethenload__cleanup},
|
|
NULL,
|
|
_clar_cb_network_createremotethenload, 1
|
|
},
|
|
{
|
|
62,
|
|
"network::fetch",
|
|
{"initialize", &test_network_fetch__initialize},
|
|
{"cleanup", &test_network_fetch__cleanup},
|
|
_clar_cat_network_fetch,
|
|
_clar_cb_network_fetch, 4
|
|
},
|
|
{
|
|
63,
|
|
"network::fetchlocal",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_network_fetchlocal, 2
|
|
},
|
|
{
|
|
64,
|
|
"network::refspecs",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_network_refspecs, 1
|
|
},
|
|
{
|
|
65,
|
|
"network::remotelocal",
|
|
{"initialize", &test_network_remotelocal__initialize},
|
|
{"cleanup", &test_network_remotelocal__cleanup},
|
|
NULL,
|
|
_clar_cb_network_remotelocal, 4
|
|
},
|
|
{
|
|
66,
|
|
"network::remoterename",
|
|
{"initialize", &test_network_remoterename__initialize},
|
|
{"cleanup", &test_network_remoterename__cleanup},
|
|
NULL,
|
|
_clar_cb_network_remoterename, 12
|
|
},
|
|
{
|
|
67,
|
|
"network::remotes",
|
|
{"initialize", &test_network_remotes__initialize},
|
|
{"cleanup", &test_network_remotes__cleanup},
|
|
NULL,
|
|
_clar_cb_network_remotes, 21
|
|
},
|
|
{
|
|
68,
|
|
"notes::notes",
|
|
{"initialize", &test_notes_notes__initialize},
|
|
{"cleanup", &test_notes_notes__cleanup},
|
|
NULL,
|
|
_clar_cb_notes_notes, 10
|
|
},
|
|
{
|
|
69,
|
|
"notes::notesref",
|
|
{"initialize", &test_notes_notesref__initialize},
|
|
{"cleanup", &test_notes_notesref__cleanup},
|
|
NULL,
|
|
_clar_cb_notes_notesref, 1
|
|
},
|
|
{
|
|
70,
|
|
"object::blob::filter",
|
|
{"initialize", &test_object_blob_filter__initialize},
|
|
{"cleanup", &test_object_blob_filter__cleanup},
|
|
NULL,
|
|
_clar_cb_object_blob_filter, 3
|
|
},
|
|
{
|
|
71,
|
|
"object::blob::fromchunks",
|
|
{"initialize", &test_object_blob_fromchunks__initialize},
|
|
{"cleanup", &test_object_blob_fromchunks__cleanup},
|
|
NULL,
|
|
_clar_cb_object_blob_fromchunks, 2
|
|
},
|
|
{
|
|
72,
|
|
"object::blob::write",
|
|
{NULL, NULL},
|
|
{"cleanup", &test_object_blob_write__cleanup},
|
|
NULL,
|
|
_clar_cb_object_blob_write, 3
|
|
},
|
|
{
|
|
73,
|
|
"object::commit::commitstagedfile",
|
|
{"initialize", &test_object_commit_commitstagedfile__initialize},
|
|
{"cleanup", &test_object_commit_commitstagedfile__cleanup},
|
|
NULL,
|
|
_clar_cb_object_commit_commitstagedfile, 1
|
|
},
|
|
{
|
|
74,
|
|
"object::lookup",
|
|
{"initialize", &test_object_lookup__initialize},
|
|
{"cleanup", &test_object_lookup__cleanup},
|
|
NULL,
|
|
_clar_cb_object_lookup, 4
|
|
},
|
|
{
|
|
75,
|
|
"object::message",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_message, 16
|
|
},
|
|
{
|
|
76,
|
|
"object::peel",
|
|
{"initialize", &test_object_peel__initialize},
|
|
{"cleanup", &test_object_peel__cleanup},
|
|
NULL,
|
|
_clar_cb_object_peel, 6
|
|
},
|
|
{
|
|
77,
|
|
"object::raw::chars",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_chars, 2
|
|
},
|
|
{
|
|
78,
|
|
"object::raw::compare",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_compare, 7
|
|
},
|
|
{
|
|
79,
|
|
"object::raw::convert",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_convert, 2
|
|
},
|
|
{
|
|
80,
|
|
"object::raw::fromstr",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_fromstr, 2
|
|
},
|
|
{
|
|
81,
|
|
"object::raw::hash",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_hash, 11
|
|
},
|
|
{
|
|
82,
|
|
"object::raw::short",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_short, 2
|
|
},
|
|
{
|
|
83,
|
|
"object::raw::size",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_size, 1
|
|
},
|
|
{
|
|
84,
|
|
"object::raw::type2string",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_type2string, 3
|
|
},
|
|
{
|
|
85,
|
|
"object::raw::write",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_raw_write, 7
|
|
},
|
|
{
|
|
86,
|
|
"object::tag::list",
|
|
{"initialize", &test_object_tag_list__initialize},
|
|
{"cleanup", &test_object_tag_list__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tag_list, 2
|
|
},
|
|
{
|
|
87,
|
|
"object::tag::peel",
|
|
{"initialize", &test_object_tag_peel__initialize},
|
|
{"cleanup", &test_object_tag_peel__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tag_peel, 3
|
|
},
|
|
{
|
|
88,
|
|
"object::tag::read",
|
|
{"initialize", &test_object_tag_read__initialize},
|
|
{"cleanup", &test_object_tag_read__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tag_read, 3
|
|
},
|
|
{
|
|
89,
|
|
"object::tag::write",
|
|
{"initialize", &test_object_tag_write__initialize},
|
|
{"cleanup", &test_object_tag_write__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tag_write, 6
|
|
},
|
|
{
|
|
90,
|
|
"object::tree::attributes",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_object_tree_attributes, 4
|
|
},
|
|
{
|
|
91,
|
|
"object::tree::duplicateentries",
|
|
{"initialize", &test_object_tree_duplicateentries__initialize},
|
|
{"cleanup", &test_object_tree_duplicateentries__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tree_duplicateentries, 2
|
|
},
|
|
{
|
|
92,
|
|
"object::tree::frompath",
|
|
{"initialize", &test_object_tree_frompath__initialize},
|
|
{"cleanup", &test_object_tree_frompath__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tree_frompath, 2
|
|
},
|
|
{
|
|
93,
|
|
"object::tree::read",
|
|
{"initialize", &test_object_tree_read__initialize},
|
|
{"cleanup", &test_object_tree_read__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tree_read, 2
|
|
},
|
|
{
|
|
94,
|
|
"object::tree::walk",
|
|
{"initialize", &test_object_tree_walk__initialize},
|
|
{"cleanup", &test_object_tree_walk__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tree_walk, 2
|
|
},
|
|
{
|
|
95,
|
|
"object::tree::write",
|
|
{"initialize", &test_object_tree_write__initialize},
|
|
{"cleanup", &test_object_tree_write__cleanup},
|
|
NULL,
|
|
_clar_cb_object_tree_write, 3
|
|
},
|
|
{
|
|
96,
|
|
"odb::alternates",
|
|
{NULL, NULL},
|
|
{"cleanup", &test_odb_alternates__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_alternates, 2
|
|
},
|
|
{
|
|
97,
|
|
"odb::foreach",
|
|
{NULL, NULL},
|
|
{"cleanup", &test_odb_foreach__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_foreach, 3
|
|
},
|
|
{
|
|
98,
|
|
"odb::loose",
|
|
{"initialize", &test_odb_loose__initialize},
|
|
{"cleanup", &test_odb_loose__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_loose, 2
|
|
},
|
|
{
|
|
99,
|
|
"odb::mixed",
|
|
{"initialize", &test_odb_mixed__initialize},
|
|
{"cleanup", &test_odb_mixed__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_mixed, 1
|
|
},
|
|
{
|
|
100,
|
|
"odb::packed",
|
|
{"initialize", &test_odb_packed__initialize},
|
|
{"cleanup", &test_odb_packed__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_packed, 3
|
|
},
|
|
{
|
|
101,
|
|
"odb::packed::one",
|
|
{"initialize", &test_odb_packed_one__initialize},
|
|
{"cleanup", &test_odb_packed_one__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_packed_one, 2
|
|
},
|
|
{
|
|
102,
|
|
"odb::sorting",
|
|
{"initialize", &test_odb_sorting__initialize},
|
|
{"cleanup", &test_odb_sorting__cleanup},
|
|
NULL,
|
|
_clar_cb_odb_sorting, 2
|
|
},
|
|
{
|
|
103,
|
|
"pack::packbuilder",
|
|
{"initialize", &test_pack_packbuilder__initialize},
|
|
{"cleanup", &test_pack_packbuilder__cleanup},
|
|
NULL,
|
|
_clar_cb_pack_packbuilder, 2
|
|
},
|
|
{
|
|
104,
|
|
"refs::branches::create",
|
|
{"initialize", &test_refs_branches_create__initialize},
|
|
{"cleanup", &test_refs_branches_create__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_create, 3
|
|
},
|
|
{
|
|
105,
|
|
"refs::branches::delete",
|
|
{"initialize", &test_refs_branches_delete__initialize},
|
|
{"cleanup", &test_refs_branches_delete__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_delete, 7
|
|
},
|
|
{
|
|
106,
|
|
"refs::branches::foreach",
|
|
{"initialize", &test_refs_branches_foreach__initialize},
|
|
{"cleanup", &test_refs_branches_foreach__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_foreach, 5
|
|
},
|
|
{
|
|
107,
|
|
"refs::branches::ishead",
|
|
{"initialize", &test_refs_branches_ishead__initialize},
|
|
{"cleanup", &test_refs_branches_ishead__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_ishead, 6
|
|
},
|
|
{
|
|
108,
|
|
"refs::branches::lookup",
|
|
{"initialize", &test_refs_branches_lookup__initialize},
|
|
{"cleanup", &test_refs_branches_lookup__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_lookup, 3
|
|
},
|
|
{
|
|
109,
|
|
"refs::branches::move",
|
|
{"initialize", &test_refs_branches_move__initialize},
|
|
{"cleanup", &test_refs_branches_move__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_move, 8
|
|
},
|
|
{
|
|
110,
|
|
"refs::branches::tracking",
|
|
{"initialize", &test_refs_branches_tracking__initialize},
|
|
{"cleanup", &test_refs_branches_tracking__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_branches_tracking, 5
|
|
},
|
|
{
|
|
111,
|
|
"refs::crashes",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_refs_crashes, 1
|
|
},
|
|
{
|
|
112,
|
|
"refs::create",
|
|
{"initialize", &test_refs_create__initialize},
|
|
{"cleanup", &test_refs_create__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_create, 5
|
|
},
|
|
{
|
|
113,
|
|
"refs::delete",
|
|
{"initialize", &test_refs_delete__initialize},
|
|
{"cleanup", &test_refs_delete__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_delete, 2
|
|
},
|
|
{
|
|
114,
|
|
"refs::foreachglob",
|
|
{"initialize", &test_refs_foreachglob__initialize},
|
|
{"cleanup", &test_refs_foreachglob__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_foreachglob, 5
|
|
},
|
|
{
|
|
115,
|
|
"refs::isvalidname",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_refs_isvalidname, 2
|
|
},
|
|
{
|
|
116,
|
|
"refs::list",
|
|
{"initialize", &test_refs_list__initialize},
|
|
{"cleanup", &test_refs_list__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_list, 3
|
|
},
|
|
{
|
|
117,
|
|
"refs::listall",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_refs_listall, 2
|
|
},
|
|
{
|
|
118,
|
|
"refs::lookup",
|
|
{"initialize", &test_refs_lookup__initialize},
|
|
{"cleanup", &test_refs_lookup__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_lookup, 2
|
|
},
|
|
{
|
|
119,
|
|
"refs::normalize",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_refs_normalize, 6
|
|
},
|
|
{
|
|
120,
|
|
"refs::overwrite",
|
|
{"initialize", &test_refs_overwrite__initialize},
|
|
{"cleanup", &test_refs_overwrite__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_overwrite, 4
|
|
},
|
|
{
|
|
121,
|
|
"refs::pack",
|
|
{"initialize", &test_refs_pack__initialize},
|
|
{"cleanup", &test_refs_pack__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_pack, 2
|
|
},
|
|
{
|
|
122,
|
|
"refs::peel",
|
|
{"initialize", &test_refs_peel__initialize},
|
|
{"cleanup", &test_refs_peel__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_peel, 5
|
|
},
|
|
{
|
|
123,
|
|
"refs::read",
|
|
{"initialize", &test_refs_read__initialize},
|
|
{"cleanup", &test_refs_read__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_read, 12
|
|
},
|
|
{
|
|
124,
|
|
"refs::reflog::drop",
|
|
{"initialize", &test_refs_reflog_drop__initialize},
|
|
{"cleanup", &test_refs_reflog_drop__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_reflog_drop, 7
|
|
},
|
|
{
|
|
125,
|
|
"refs::reflog::reflog",
|
|
{"initialize", &test_refs_reflog_reflog__initialize},
|
|
{"cleanup", &test_refs_reflog_reflog__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_reflog_reflog, 5
|
|
},
|
|
{
|
|
126,
|
|
"refs::rename",
|
|
{"initialize", &test_refs_rename__initialize},
|
|
{"cleanup", &test_refs_rename__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_rename, 11
|
|
},
|
|
{
|
|
127,
|
|
"refs::revparse",
|
|
{"initialize", &test_refs_revparse__initialize},
|
|
{"cleanup", &test_refs_revparse__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_revparse, 22
|
|
},
|
|
{
|
|
128,
|
|
"refs::unicode",
|
|
{"initialize", &test_refs_unicode__initialize},
|
|
{"cleanup", &test_refs_unicode__cleanup},
|
|
NULL,
|
|
_clar_cb_refs_unicode, 1
|
|
},
|
|
{
|
|
129,
|
|
"repo::discover",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_repo_discover, 1
|
|
},
|
|
{
|
|
130,
|
|
"repo::getters",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_repo_getters, 3
|
|
},
|
|
{
|
|
131,
|
|
"repo::hashfile",
|
|
{"initialize", &test_repo_hashfile__initialize},
|
|
{"cleanup", &test_repo_hashfile__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_hashfile, 2
|
|
},
|
|
{
|
|
132,
|
|
"repo::head",
|
|
{"initialize", &test_repo_head__initialize},
|
|
{"cleanup", &test_repo_head__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_head, 16
|
|
},
|
|
{
|
|
133,
|
|
"repo::headtree",
|
|
{"initialize", &test_repo_headtree__initialize},
|
|
{"cleanup", &test_repo_headtree__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_headtree, 4
|
|
},
|
|
{
|
|
134,
|
|
"repo::init",
|
|
{"initialize", &test_repo_init__initialize},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_repo_init, 17
|
|
},
|
|
{
|
|
135,
|
|
"repo::message",
|
|
{"initialize", &test_repo_message__initialize},
|
|
{"cleanup", &test_repo_message__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_message, 2
|
|
},
|
|
{
|
|
136,
|
|
"repo::open",
|
|
{NULL, NULL},
|
|
{"cleanup", &test_repo_open__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_open, 10
|
|
},
|
|
{
|
|
137,
|
|
"repo::setters",
|
|
{"initialize", &test_repo_setters__initialize},
|
|
{"cleanup", &test_repo_setters__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_setters, 5
|
|
},
|
|
{
|
|
138,
|
|
"repo::state",
|
|
{"initialize", &test_repo_state__initialize},
|
|
{"cleanup", &test_repo_state__cleanup},
|
|
NULL,
|
|
_clar_cb_repo_state, 11
|
|
},
|
|
{
|
|
139,
|
|
"reset::hard",
|
|
{"initialize", &test_reset_hard__initialize},
|
|
{"cleanup", &test_reset_hard__cleanup},
|
|
NULL,
|
|
_clar_cb_reset_hard, 3
|
|
},
|
|
{
|
|
140,
|
|
"reset::mixed",
|
|
{"initialize", &test_reset_mixed__initialize},
|
|
{"cleanup", &test_reset_mixed__cleanup},
|
|
NULL,
|
|
_clar_cb_reset_mixed, 2
|
|
},
|
|
{
|
|
141,
|
|
"reset::soft",
|
|
{"initialize", &test_reset_soft__initialize},
|
|
{"cleanup", &test_reset_soft__cleanup},
|
|
NULL,
|
|
_clar_cb_reset_soft, 7
|
|
},
|
|
{
|
|
142,
|
|
"revwalk::basic",
|
|
{"initialize", &test_revwalk_basic__initialize},
|
|
{"cleanup", &test_revwalk_basic__cleanup},
|
|
NULL,
|
|
_clar_cb_revwalk_basic, 6
|
|
},
|
|
{
|
|
143,
|
|
"revwalk::mergebase",
|
|
{"initialize", &test_revwalk_mergebase__initialize},
|
|
{"cleanup", &test_revwalk_mergebase__cleanup},
|
|
NULL,
|
|
_clar_cb_revwalk_mergebase, 7
|
|
},
|
|
{
|
|
144,
|
|
"revwalk::signatureparsing",
|
|
{"initialize", &test_revwalk_signatureparsing__initialize},
|
|
{"cleanup", &test_revwalk_signatureparsing__cleanup},
|
|
NULL,
|
|
_clar_cb_revwalk_signatureparsing, 1
|
|
},
|
|
{
|
|
145,
|
|
"stash::drop",
|
|
{"initialize", &test_stash_drop__initialize},
|
|
{"cleanup", &test_stash_drop__cleanup},
|
|
NULL,
|
|
_clar_cb_stash_drop, 6
|
|
},
|
|
{
|
|
146,
|
|
"stash::foreach",
|
|
{"initialize", &test_stash_foreach__initialize},
|
|
{"cleanup", &test_stash_foreach__cleanup},
|
|
NULL,
|
|
_clar_cb_stash_foreach, 2
|
|
},
|
|
{
|
|
147,
|
|
"stash::save",
|
|
{"initialize", &test_stash_save__initialize},
|
|
{"cleanup", &test_stash_save__cleanup},
|
|
NULL,
|
|
_clar_cb_stash_save, 12
|
|
},
|
|
{
|
|
148,
|
|
"status::ignore",
|
|
{"initialize", &test_status_ignore__initialize},
|
|
{"cleanup", &test_status_ignore__cleanup},
|
|
NULL,
|
|
_clar_cb_status_ignore, 9
|
|
},
|
|
{
|
|
149,
|
|
"status::single",
|
|
{NULL, NULL},
|
|
{NULL, NULL},
|
|
NULL,
|
|
_clar_cb_status_single, 2
|
|
},
|
|
{
|
|
150,
|
|
"status::submodules",
|
|
{"initialize", &test_status_submodules__initialize},
|
|
{"cleanup", &test_status_submodules__cleanup},
|
|
NULL,
|
|
_clar_cb_status_submodules, 4
|
|
},
|
|
{
|
|
151,
|
|
"status::worktree",
|
|
{"initialize", &test_status_worktree__initialize},
|
|
{"cleanup", &test_status_worktree__cleanup},
|
|
NULL,
|
|
_clar_cb_status_worktree, 29
|
|
},
|
|
{
|
|
152,
|
|
"submodule::lookup",
|
|
{"initialize", &test_submodule_lookup__initialize},
|
|
{"cleanup", &test_submodule_lookup__cleanup},
|
|
NULL,
|
|
_clar_cb_submodule_lookup, 3
|
|
},
|
|
{
|
|
153,
|
|
"submodule::modify",
|
|
{"initialize", &test_submodule_modify__initialize},
|
|
{"cleanup", &test_submodule_modify__cleanup},
|
|
NULL,
|
|
_clar_cb_submodule_modify, 4
|
|
},
|
|
{
|
|
154,
|
|
"submodule::status",
|
|
{"initialize", &test_submodule_status__initialize},
|
|
{"cleanup", &test_submodule_status__cleanup},
|
|
NULL,
|
|
_clar_cb_submodule_status, 5
|
|
},
|
|
{
|
|
155,
|
|
"threads::basic",
|
|
{"initialize", &test_threads_basic__initialize},
|
|
{"cleanup", &test_threads_basic__cleanup},
|
|
NULL,
|
|
_clar_cb_threads_basic, 1
|
|
}
|
|
};
|
|
|
|
static size_t _clar_suite_count = 156;
|
|
static size_t _clar_callback_count = 784;
|
|
|
|
/* Core test functions */
|
|
static void
|
|
clar_report_errors(void)
|
|
{
|
|
int i = 1;
|
|
struct clar_error *error, *next;
|
|
|
|
error = _clar.errors;
|
|
while (error != NULL) {
|
|
next = error->next;
|
|
clar_print_error(i++, error);
|
|
free(error->description);
|
|
free(error);
|
|
error = next;
|
|
}
|
|
|
|
_clar.errors = _clar.last_error = NULL;
|
|
}
|
|
|
|
static void
|
|
clar_run_test(
|
|
const struct clar_func *test,
|
|
const struct clar_func *initialize,
|
|
const struct clar_func *cleanup)
|
|
{
|
|
int error_st = _clar.suite_errors;
|
|
|
|
clar_on_test();
|
|
_clar.trampoline_enabled = 1;
|
|
|
|
if (setjmp(_clar.trampoline) == 0) {
|
|
if (initialize->ptr != NULL)
|
|
initialize->ptr();
|
|
|
|
test->ptr();
|
|
}
|
|
|
|
_clar.trampoline_enabled = 0;
|
|
|
|
if (_clar.local_cleanup != NULL)
|
|
_clar.local_cleanup(_clar.local_cleanup_payload);
|
|
|
|
if (cleanup->ptr != NULL)
|
|
cleanup->ptr();
|
|
|
|
_clar.test_count++;
|
|
|
|
/* remove any local-set cleanup methods */
|
|
_clar.local_cleanup = NULL;
|
|
_clar.local_cleanup_payload = NULL;
|
|
|
|
if (_clar.report_errors_only)
|
|
clar_report_errors();
|
|
else
|
|
clar_print_ontest(
|
|
test->name,
|
|
_clar.test_count,
|
|
(_clar.suite_errors > error_st)
|
|
);
|
|
}
|
|
|
|
static void
|
|
clar_run_suite(const struct clar_suite *suite)
|
|
{
|
|
const struct clar_func *test = suite->tests;
|
|
size_t i;
|
|
|
|
if (!clar_category_is_suite_enabled(suite))
|
|
return;
|
|
|
|
if (_clar.exit_on_error && _clar.total_errors)
|
|
return;
|
|
|
|
if (!_clar.report_errors_only)
|
|
clar_print_onsuite(suite->name, suite->index);
|
|
clar_on_suite();
|
|
|
|
_clar.active_suite = suite->name;
|
|
_clar.suite_errors = 0;
|
|
|
|
for (i = 0; i < suite->test_count; ++i) {
|
|
_clar.active_test = test[i].name;
|
|
clar_run_test(&test[i], &suite->initialize, &suite->cleanup);
|
|
|
|
if (_clar.exit_on_error && _clar.total_errors)
|
|
return;
|
|
}
|
|
}
|
|
|
|
#if 0 /* temporarily disabled */
|
|
static void
|
|
clar_run_single(const struct clar_func *test,
|
|
const struct clar_suite *suite)
|
|
{
|
|
_clar.suite_errors = 0;
|
|
_clar.active_suite = suite->name;
|
|
_clar.active_test = test->name;
|
|
|
|
clar_run_test(test, &suite->initialize, &suite->cleanup);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
clar_usage(const char *arg)
|
|
{
|
|
printf("Usage: %s [options]\n\n", arg);
|
|
printf("Options:\n");
|
|
printf(" -sXX\t\tRun only the suite number or name XX\n");
|
|
printf(" -i<name>\tInclude category <name> tests\n");
|
|
printf(" -q \t\tOnly report tests that had an error\n");
|
|
printf(" -Q \t\tQuit as soon as a test fails\n");
|
|
printf(" -l \t\tPrint suite names and category names\n");
|
|
exit(-1);
|
|
}
|
|
|
|
static void
|
|
clar_parse_args(int argc, char **argv)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < argc; ++i) {
|
|
char *argument = argv[i];
|
|
|
|
if (argument[0] != '-')
|
|
clar_usage(argv[0]);
|
|
|
|
switch (argument[1]) {
|
|
case 's': { /* given suite number, name, or prefix */
|
|
int num = 0, offset = (argument[2] == '=') ? 3 : 2;
|
|
int len = 0, is_num = 1, has_colon = 0, j;
|
|
|
|
for (argument += offset; *argument; ++argument) {
|
|
len++;
|
|
if (*argument >= '0' && *argument <= '9')
|
|
num = (num * 10) + (*argument - '0');
|
|
else {
|
|
is_num = 0;
|
|
if (*argument == ':')
|
|
has_colon = 1;
|
|
}
|
|
}
|
|
|
|
argument = argv[i] + offset;
|
|
|
|
if (!len)
|
|
clar_usage(argv[0]);
|
|
else if (is_num) {
|
|
if ((size_t)num >= _clar_suite_count) {
|
|
clar_print_onabort("Suite number %d does not exist.\n", num);
|
|
exit(-1);
|
|
}
|
|
clar_run_suite(&_clar_suites[num]);
|
|
}
|
|
else if (!has_colon || argument[-1] == ':') {
|
|
for (j = 0; j < (int)_clar_suite_count; ++j)
|
|
if (strncmp(argument, _clar_suites[j].name, len) == 0)
|
|
clar_run_suite(&_clar_suites[j]);
|
|
}
|
|
else {
|
|
for (j = 0; j < (int)_clar_suite_count; ++j)
|
|
if (strcmp(argument, _clar_suites[j].name) == 0) {
|
|
clar_run_suite(&_clar_suites[j]);
|
|
break;
|
|
}
|
|
}
|
|
if (_clar.active_suite == NULL) {
|
|
clar_print_onabort("No suite matching '%s' found.\n", argument);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 'q':
|
|
_clar.report_errors_only = 1;
|
|
break;
|
|
|
|
case 'Q':
|
|
_clar.exit_on_error = 1;
|
|
break;
|
|
|
|
case 'i': {
|
|
int offset = (argument[2] == '=') ? 3 : 2;
|
|
if (strcasecmp("all", argument + offset) == 0)
|
|
clar_category_enable_all(_clar_suite_count, _clar_suites);
|
|
else
|
|
clar_category_enable(argument + offset);
|
|
break;
|
|
}
|
|
|
|
case 'l': {
|
|
size_t j;
|
|
printf("Test suites (use -s<name> to run just one):\n");
|
|
for (j = 0; j < _clar_suite_count; ++j)
|
|
printf(" %3d: %s\n", (int)j, _clar_suites[j].name);
|
|
|
|
printf("\nCategories (use -i<category> to include):\n");
|
|
clar_category_enable_all(_clar_suite_count, _clar_suites);
|
|
clar_category_print_enabled(" - ");
|
|
|
|
exit(0);
|
|
}
|
|
|
|
default:
|
|
clar_usage(argv[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
clar_test(int argc, char **argv)
|
|
{
|
|
clar_print_init(
|
|
(int)_clar_callback_count,
|
|
(int)_clar_suite_count,
|
|
""
|
|
);
|
|
|
|
if (clar_sandbox() < 0) {
|
|
clar_print_onabort("Failed to sandbox the test runner.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
clar_on_init();
|
|
|
|
if (argc > 1)
|
|
clar_parse_args(argc, argv);
|
|
|
|
if (_clar.active_suite == NULL) {
|
|
size_t i;
|
|
for (i = 0; i < _clar_suite_count; ++i)
|
|
clar_run_suite(&_clar_suites[i]);
|
|
}
|
|
|
|
clar_print_shutdown(
|
|
_clar.test_count,
|
|
(int)_clar_suite_count,
|
|
_clar.total_errors
|
|
);
|
|
|
|
clar_on_shutdown();
|
|
|
|
clar_unsandbox();
|
|
return _clar.total_errors;
|
|
}
|
|
|
|
void
|
|
clar__assert(
|
|
int condition,
|
|
const char *file,
|
|
int line,
|
|
const char *error_msg,
|
|
const char *description,
|
|
int should_abort)
|
|
{
|
|
struct clar_error *error;
|
|
|
|
if (condition)
|
|
return;
|
|
|
|
error = calloc(1, sizeof(struct clar_error));
|
|
|
|
if (_clar.errors == NULL)
|
|
_clar.errors = error;
|
|
|
|
if (_clar.last_error != NULL)
|
|
_clar.last_error->next = error;
|
|
|
|
_clar.last_error = error;
|
|
|
|
error->test = _clar.active_test;
|
|
error->test_number = _clar.test_count;
|
|
error->suite = _clar.active_suite;
|
|
error->file = file;
|
|
error->line_number = line;
|
|
error->error_msg = error_msg;
|
|
|
|
if (description != NULL)
|
|
error->description = strdup(description);
|
|
|
|
_clar.suite_errors++;
|
|
_clar.total_errors++;
|
|
|
|
if (should_abort) {
|
|
if (!_clar.trampoline_enabled) {
|
|
clar_print_onabort(
|
|
"Fatal error: a cleanup method raised an exception.");
|
|
clar_report_errors();
|
|
exit(-1);
|
|
}
|
|
|
|
longjmp(_clar.trampoline, -1);
|
|
}
|
|
}
|
|
|
|
void clar__assert_equal_s(
|
|
const char *s1,
|
|
const char *s2,
|
|
const char *file,
|
|
int line,
|
|
const char *err,
|
|
int should_abort)
|
|
{
|
|
int match = (s1 == NULL || s2 == NULL) ? (s1 == s2) : (strcmp(s1, s2) == 0);
|
|
|
|
if (!match) {
|
|
char buf[4096];
|
|
snprint_eq(buf, 4096, "'%s' != '%s'", s1, s2);
|
|
clar__assert(0, file, line, err, buf, should_abort);
|
|
}
|
|
}
|
|
|
|
void clar__assert_equal_i(
|
|
int i1,
|
|
int i2,
|
|
const char *file,
|
|
int line,
|
|
const char *err,
|
|
int should_abort)
|
|
{
|
|
if (i1 != i2) {
|
|
char buf[128];
|
|
snprint_eq(buf, 128, "%d != %d", i1, i2);
|
|
clar__assert(0, file, line, err, buf, should_abort);
|
|
}
|
|
}
|
|
|
|
void cl_set_cleanup(void (*cleanup)(void *), void *opaque)
|
|
{
|
|
_clar.local_cleanup = cleanup;
|
|
_clar.local_cleanup_payload = opaque;
|
|
}
|
|
|
|
static char _clar_path[4096];
|
|
|
|
static int
|
|
is_valid_tmp_path(const char *path)
|
|
{
|
|
STAT_T st;
|
|
|
|
if (stat(path, &st) != 0)
|
|
return 0;
|
|
|
|
if (!S_ISDIR(st.st_mode))
|
|
return 0;
|
|
|
|
return (access(path, W_OK) == 0);
|
|
}
|
|
|
|
static int
|
|
find_tmp_path(char *buffer, size_t length)
|
|
{
|
|
#ifndef _WIN32
|
|
static const size_t var_count = 4;
|
|
static const char *env_vars[] = {
|
|
"TMPDIR", "TMP", "TEMP", "USERPROFILE"
|
|
};
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < var_count; ++i) {
|
|
const char *env = getenv(env_vars[i]);
|
|
if (!env)
|
|
continue;
|
|
|
|
if (is_valid_tmp_path(env)) {
|
|
strncpy(buffer, env, length);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* If the environment doesn't say anything, try to use /tmp */
|
|
if (is_valid_tmp_path("/tmp")) {
|
|
strncpy(buffer, "/tmp", length);
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
if (GetTempPath((DWORD)length, buffer))
|
|
return 0;
|
|
#endif
|
|
|
|
/* This system doesn't like us, try to use the current directory */
|
|
if (is_valid_tmp_path(".")) {
|
|
strncpy(buffer, ".", length);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void clar_unsandbox(void)
|
|
{
|
|
if (_clar_path[0] == '\0')
|
|
return;
|
|
|
|
#ifdef _WIN32
|
|
chdir("..");
|
|
#endif
|
|
|
|
fs_rm(_clar_path);
|
|
}
|
|
|
|
static int build_sandbox_path(void)
|
|
{
|
|
const char path_tail[] = "clar_tmp_XXXXXX";
|
|
size_t len;
|
|
|
|
if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0)
|
|
return -1;
|
|
|
|
len = strlen(_clar_path);
|
|
|
|
#ifdef _WIN32
|
|
{ /* normalize path to POSIX forward slashes */
|
|
size_t i;
|
|
for (i = 0; i < len; ++i) {
|
|
if (_clar_path[i] == '\\')
|
|
_clar_path[i] = '/';
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (_clar_path[len - 1] != '/') {
|
|
_clar_path[len++] = '/';
|
|
}
|
|
|
|
strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
|
|
|
|
#if defined(__MINGW32__)
|
|
if (_mktemp(_clar_path) == NULL)
|
|
return -1;
|
|
|
|
if (mkdir(_clar_path, 0700) != 0)
|
|
return -1;
|
|
#elif defined(_WIN32)
|
|
if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0)
|
|
return -1;
|
|
|
|
if (mkdir(_clar_path, 0700) != 0)
|
|
return -1;
|
|
#else
|
|
if (mkdtemp(_clar_path) == NULL)
|
|
return -1;
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int clar_sandbox(void)
|
|
{
|
|
if (_clar_path[0] == '\0' && build_sandbox_path() < 0)
|
|
return -1;
|
|
|
|
if (chdir(_clar_path) != 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static const char *
|
|
fixture_path(const char *base, const char *fixture_name)
|
|
{
|
|
static char _path[4096];
|
|
size_t root_len;
|
|
|
|
root_len = strlen(base);
|
|
strncpy(_path, base, sizeof(_path));
|
|
|
|
if (_path[root_len - 1] != '/')
|
|
_path[root_len++] = '/';
|
|
|
|
if (fixture_name[0] == '/')
|
|
fixture_name++;
|
|
|
|
strncpy(_path + root_len,
|
|
fixture_name,
|
|
sizeof(_path) - root_len);
|
|
|
|
return _path;
|
|
}
|
|
|
|
#ifdef CLAR_FIXTURE_PATH
|
|
const char *cl_fixture(const char *fixture_name)
|
|
{
|
|
return fixture_path(CLAR_FIXTURE_PATH, fixture_name);
|
|
}
|
|
|
|
void cl_fixture_sandbox(const char *fixture_name)
|
|
{
|
|
fs_copy(cl_fixture(fixture_name), _clar_path);
|
|
}
|
|
|
|
void cl_fixture_cleanup(const char *fixture_name)
|
|
{
|
|
fs_rm(fixture_path(_clar_path, fixture_name));
|
|
}
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
|
|
#define RM_RETRY_COUNT 5
|
|
#define RM_RETRY_DELAY 10
|
|
|
|
#ifdef __MINGW32__
|
|
|
|
/* These security-enhanced functions are not available
|
|
* in MinGW, so just use the vanilla ones */
|
|
#define wcscpy_s(a, b, c) wcscpy((a), (c))
|
|
#define wcscat_s(a, b, c) wcscat((a), (c))
|
|
|
|
#endif /* __MINGW32__ */
|
|
|
|
static int
|
|
fs__dotordotdot(WCHAR *_tocheck)
|
|
{
|
|
return _tocheck[0] == '.' &&
|
|
(_tocheck[1] == '\0' ||
|
|
(_tocheck[1] == '.' && _tocheck[2] == '\0'));
|
|
}
|
|
|
|
static int
|
|
fs_rmdir_rmdir(WCHAR *_wpath)
|
|
{
|
|
unsigned retries = 1;
|
|
|
|
while (!RemoveDirectoryW(_wpath)) {
|
|
/* Only retry when we have retries remaining, and the
|
|
* error was ERROR_DIR_NOT_EMPTY. */
|
|
if (retries++ > RM_RETRY_COUNT ||
|
|
ERROR_DIR_NOT_EMPTY != GetLastError())
|
|
return -1;
|
|
|
|
/* Give whatever has a handle to a child item some time
|
|
* to release it before trying again */
|
|
Sleep(RM_RETRY_DELAY * retries * retries);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
fs_rmdir_helper(WCHAR *_wsource)
|
|
{
|
|
WCHAR buffer[MAX_PATH];
|
|
HANDLE find_handle;
|
|
WIN32_FIND_DATAW find_data;
|
|
int buffer_prefix_len;
|
|
|
|
/* Set up the buffer and capture the length */
|
|
wcscpy_s(buffer, MAX_PATH, _wsource);
|
|
wcscat_s(buffer, MAX_PATH, L"\\");
|
|
buffer_prefix_len = wcslen(buffer);
|
|
|
|
/* FindFirstFile needs a wildcard to match multiple items */
|
|
wcscat_s(buffer, MAX_PATH, L"*");
|
|
find_handle = FindFirstFileW(buffer, &find_data);
|
|
cl_assert(INVALID_HANDLE_VALUE != find_handle);
|
|
|
|
do {
|
|
/* FindFirstFile/FindNextFile gives back . and ..
|
|
* entries at the beginning */
|
|
if (fs__dotordotdot(find_data.cFileName))
|
|
continue;
|
|
|
|
wcscpy_s(buffer + buffer_prefix_len, MAX_PATH - buffer_prefix_len, find_data.cFileName);
|
|
|
|
if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
|
|
fs_rmdir_helper(buffer);
|
|
else {
|
|
/* If set, the +R bit must be cleared before deleting */
|
|
if (FILE_ATTRIBUTE_READONLY & find_data.dwFileAttributes)
|
|
cl_assert(SetFileAttributesW(buffer, find_data.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY));
|
|
|
|
cl_assert(DeleteFileW(buffer));
|
|
}
|
|
}
|
|
while (FindNextFileW(find_handle, &find_data));
|
|
|
|
/* Ensure that we successfully completed the enumeration */
|
|
cl_assert(ERROR_NO_MORE_FILES == GetLastError());
|
|
|
|
/* Close the find handle */
|
|
FindClose(find_handle);
|
|
|
|
/* Now that the directory is empty, remove it */
|
|
cl_assert(0 == fs_rmdir_rmdir(_wsource));
|
|
}
|
|
|
|
static int
|
|
fs_rm_wait(WCHAR *_wpath)
|
|
{
|
|
unsigned retries = 1;
|
|
DWORD last_error;
|
|
|
|
do {
|
|
if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(_wpath))
|
|
last_error = GetLastError();
|
|
else
|
|
last_error = ERROR_SUCCESS;
|
|
|
|
/* Is the item gone? */
|
|
if (ERROR_FILE_NOT_FOUND == last_error ||
|
|
ERROR_PATH_NOT_FOUND == last_error)
|
|
return 0;
|
|
|
|
Sleep(RM_RETRY_DELAY * retries * retries);
|
|
}
|
|
while (retries++ <= RM_RETRY_COUNT);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
fs_rm(const char *_source)
|
|
{
|
|
WCHAR wsource[MAX_PATH];
|
|
DWORD attrs;
|
|
|
|
/* The input path is UTF-8. Convert it to wide characters
|
|
* for use with the Windows API */
|
|
cl_assert(MultiByteToWideChar(CP_UTF8,
|
|
MB_ERR_INVALID_CHARS,
|
|
_source,
|
|
-1, /* Indicates NULL termination */
|
|
wsource,
|
|
MAX_PATH));
|
|
|
|
/* Does the item exist? If not, we have no work to do */
|
|
attrs = GetFileAttributesW(wsource);
|
|
|
|
if (INVALID_FILE_ATTRIBUTES == attrs)
|
|
return;
|
|
|
|
if (FILE_ATTRIBUTE_DIRECTORY & attrs)
|
|
fs_rmdir_helper(wsource);
|
|
else {
|
|
/* The item is a file. Strip the +R bit */
|
|
if (FILE_ATTRIBUTE_READONLY & attrs)
|
|
cl_assert(SetFileAttributesW(wsource, attrs & ~FILE_ATTRIBUTE_READONLY));
|
|
|
|
cl_assert(DeleteFileW(wsource));
|
|
}
|
|
|
|
/* Wait for the DeleteFile or RemoveDirectory call to complete */
|
|
cl_assert(0 == fs_rm_wait(wsource));
|
|
}
|
|
|
|
static void
|
|
fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest)
|
|
{
|
|
WCHAR buf_source[MAX_PATH], buf_dest[MAX_PATH];
|
|
HANDLE find_handle;
|
|
WIN32_FIND_DATAW find_data;
|
|
int buf_source_prefix_len, buf_dest_prefix_len;
|
|
|
|
wcscpy_s(buf_source, MAX_PATH, _wsource);
|
|
wcscat_s(buf_source, MAX_PATH, L"\\");
|
|
buf_source_prefix_len = wcslen(buf_source);
|
|
|
|
wcscpy_s(buf_dest, MAX_PATH, _wdest);
|
|
wcscat_s(buf_dest, MAX_PATH, L"\\");
|
|
buf_dest_prefix_len = wcslen(buf_dest);
|
|
|
|
/* Get an enumerator for the items in the source. */
|
|
wcscat_s(buf_source, MAX_PATH, L"*");
|
|
find_handle = FindFirstFileW(buf_source, &find_data);
|
|
cl_assert(INVALID_HANDLE_VALUE != find_handle);
|
|
|
|
/* Create the target directory. */
|
|
cl_assert(CreateDirectoryW(_wdest, NULL));
|
|
|
|
do {
|
|
/* FindFirstFile/FindNextFile gives back . and ..
|
|
* entries at the beginning */
|
|
if (fs__dotordotdot(find_data.cFileName))
|
|
continue;
|
|
|
|
wcscpy_s(buf_source + buf_source_prefix_len, MAX_PATH - buf_source_prefix_len, find_data.cFileName);
|
|
wcscpy_s(buf_dest + buf_dest_prefix_len, MAX_PATH - buf_dest_prefix_len, find_data.cFileName);
|
|
|
|
if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
|
|
fs_copydir_helper(buf_source, buf_dest);
|
|
else
|
|
cl_assert(CopyFileW(buf_source, buf_dest, TRUE));
|
|
}
|
|
while (FindNextFileW(find_handle, &find_data));
|
|
|
|
/* Ensure that we successfully completed the enumeration */
|
|
cl_assert(ERROR_NO_MORE_FILES == GetLastError());
|
|
|
|
/* Close the find handle */
|
|
FindClose(find_handle);
|
|
}
|
|
|
|
static void
|
|
fs_copy(const char *_source, const char *_dest)
|
|
{
|
|
WCHAR wsource[MAX_PATH], wdest[MAX_PATH];
|
|
DWORD source_attrs, dest_attrs;
|
|
HANDLE find_handle;
|
|
WIN32_FIND_DATAW find_data;
|
|
|
|
/* The input paths are UTF-8. Convert them to wide characters
|
|
* for use with the Windows API. */
|
|
cl_assert(MultiByteToWideChar(CP_UTF8,
|
|
MB_ERR_INVALID_CHARS,
|
|
_source,
|
|
-1,
|
|
wsource,
|
|
MAX_PATH));
|
|
|
|
cl_assert(MultiByteToWideChar(CP_UTF8,
|
|
MB_ERR_INVALID_CHARS,
|
|
_dest,
|
|
-1,
|
|
wdest,
|
|
MAX_PATH));
|
|
|
|
/* Check the source for existence */
|
|
source_attrs = GetFileAttributesW(wsource);
|
|
cl_assert(INVALID_FILE_ATTRIBUTES != source_attrs);
|
|
|
|
/* Check the target for existence */
|
|
dest_attrs = GetFileAttributesW(wdest);
|
|
|
|
if (INVALID_FILE_ATTRIBUTES != dest_attrs) {
|
|
/* Target exists; append last path part of source to target.
|
|
* Use FindFirstFile to parse the path */
|
|
find_handle = FindFirstFileW(wsource, &find_data);
|
|
cl_assert(INVALID_HANDLE_VALUE != find_handle);
|
|
wcscat_s(wdest, MAX_PATH, L"\\");
|
|
wcscat_s(wdest, MAX_PATH, find_data.cFileName);
|
|
FindClose(find_handle);
|
|
|
|
/* Check the new target for existence */
|
|
cl_assert(INVALID_FILE_ATTRIBUTES == GetFileAttributesW(wdest));
|
|
}
|
|
|
|
if (FILE_ATTRIBUTE_DIRECTORY & source_attrs)
|
|
fs_copydir_helper(wsource, wdest);
|
|
else
|
|
cl_assert(CopyFileW(wsource, wdest, TRUE));
|
|
}
|
|
|
|
void
|
|
cl_fs_cleanup(void)
|
|
{
|
|
fs_rm(fixture_path(_clar_path, "*"));
|
|
}
|
|
|
|
#else
|
|
static int
|
|
shell_out(char * const argv[])
|
|
{
|
|
int status;
|
|
pid_t pid;
|
|
|
|
pid = fork();
|
|
|
|
if (pid < 0) {
|
|
fprintf(stderr,
|
|
"System error: `fork()` call failed.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (pid == 0) {
|
|
execv(argv[0], argv);
|
|
}
|
|
|
|
waitpid(pid, &status, 0);
|
|
return WEXITSTATUS(status);
|
|
}
|
|
|
|
static void
|
|
fs_copy(const char *_source, const char *dest)
|
|
{
|
|
char *argv[5];
|
|
char *source;
|
|
size_t source_len;
|
|
|
|
source = strdup(_source);
|
|
source_len = strlen(source);
|
|
|
|
if (source[source_len - 1] == '/')
|
|
source[source_len - 1] = 0;
|
|
|
|
argv[0] = "/bin/cp";
|
|
argv[1] = "-R";
|
|
argv[2] = source;
|
|
argv[3] = (char *)dest;
|
|
argv[4] = NULL;
|
|
|
|
cl_must_pass_(
|
|
shell_out(argv),
|
|
"Failed to copy test fixtures to sandbox"
|
|
);
|
|
|
|
free(source);
|
|
}
|
|
|
|
static void
|
|
fs_rm(const char *source)
|
|
{
|
|
char *argv[4];
|
|
|
|
argv[0] = "/bin/rm";
|
|
argv[1] = "-Rf";
|
|
argv[2] = (char *)source;
|
|
argv[3] = NULL;
|
|
|
|
cl_must_pass_(
|
|
shell_out(argv),
|
|
"Failed to cleanup the sandbox"
|
|
);
|
|
}
|
|
|
|
void
|
|
cl_fs_cleanup(void)
|
|
{
|
|
clar_unsandbox();
|
|
clar_sandbox();
|
|
}
|
|
#endif
|
|
|
|
#define CLAR_CATEGORY_DEFAULT "default"
|
|
|
|
typedef struct {
|
|
const char **names;
|
|
int count;
|
|
int alloc;
|
|
} clar_category_list;
|
|
|
|
static clar_category_list _clar_categorize_enabled;
|
|
|
|
static int clar_category_in_list(clar_category_list *list, const char *cat)
|
|
{
|
|
int i;
|
|
for (i = 0; i < list->count; ++i)
|
|
if (strcasecmp(cat, list->names[i]) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static void clar_category_add_to_list(clar_category_list *list, const char *cat)
|
|
{
|
|
if (clar_category_in_list(list, cat))
|
|
return;
|
|
|
|
if (list->count >= list->alloc) {
|
|
list->alloc += 10;
|
|
list->names = (const char **)realloc(
|
|
(void *)list->names, list->alloc * sizeof(const char *));
|
|
}
|
|
|
|
list->names[list->count++] = cat;
|
|
}
|
|
|
|
static void clar_category_enable(const char *category)
|
|
{
|
|
clar_category_add_to_list(&_clar_categorize_enabled, category);
|
|
}
|
|
|
|
static void clar_category_enable_all(size_t suite_count, const struct clar_suite *suites)
|
|
{
|
|
size_t i;
|
|
const char **cat;
|
|
|
|
clar_category_enable(CLAR_CATEGORY_DEFAULT);
|
|
|
|
for (i = 0; i < suite_count; i++)
|
|
for (cat = suites[i].categories; cat && *cat; cat++)
|
|
clar_category_enable(*cat);
|
|
}
|
|
|
|
static int _MAIN_CC clar_category_cmp(const void *a, const void *b)
|
|
{
|
|
return - strcasecmp(a,b);
|
|
}
|
|
|
|
static void clar_category_print_enabled(const char *prefix)
|
|
{
|
|
int i;
|
|
|
|
qsort((void *)_clar_categorize_enabled.names,
|
|
_clar_categorize_enabled.count,
|
|
sizeof(const char *), clar_category_cmp);
|
|
|
|
for (i = 0; i < _clar_categorize_enabled.count; ++i)
|
|
printf("%s%s\n", prefix, _clar_categorize_enabled.names[i]);
|
|
}
|
|
|
|
static int clar_category_is_suite_enabled(const struct clar_suite *suite)
|
|
{
|
|
const char **scan;
|
|
|
|
if (!_clar_categorize_enabled.count)
|
|
clar_category_enable(CLAR_CATEGORY_DEFAULT);
|
|
|
|
if (!suite->categories)
|
|
return clar_category_in_list(
|
|
&_clar_categorize_enabled, CLAR_CATEGORY_DEFAULT);
|
|
|
|
for (scan = suite->categories; *scan != NULL; scan++)
|
|
if (clar_category_in_list(&_clar_categorize_enabled, *scan))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void clar_print_init(int test_count, int suite_count, const char *suite_names)
|
|
{
|
|
(void)test_count;
|
|
printf("Loaded %d suites: %s\n", (int)suite_count, suite_names);
|
|
printf("Started\n");
|
|
}
|
|
|
|
static void clar_print_shutdown(int test_count, int suite_count, int error_count)
|
|
{
|
|
(void)test_count;
|
|
(void)suite_count;
|
|
(void)error_count;
|
|
|
|
printf("\n\n");
|
|
clar_report_errors();
|
|
}
|
|
|
|
static void clar_print_error(int num, const struct clar_error *error)
|
|
{
|
|
printf(" %d) Failure:\n", num);
|
|
|
|
printf("%s::%s (%s) [%s:%d] [-t%d]\n",
|
|
error->suite,
|
|
error->test,
|
|
"no description",
|
|
error->file,
|
|
error->line_number,
|
|
error->test_number);
|
|
|
|
printf(" %s\n", error->error_msg);
|
|
|
|
if (error->description != NULL)
|
|
printf(" %s\n", error->description);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
static void clar_print_ontest(const char *test_name, int test_number, int failed)
|
|
{
|
|
(void)test_name;
|
|
(void)test_number;
|
|
printf("%c", failed ? 'F' : '.');
|
|
}
|
|
|
|
static void clar_print_onsuite(const char *suite_name, int suite_index)
|
|
{
|
|
/* noop */
|
|
(void)suite_index;
|
|
(void)suite_name;
|
|
}
|
|
|
|
static void clar_print_onabort(const char *msg, ...)
|
|
{
|
|
va_list argp;
|
|
va_start(argp, msg);
|
|
vfprintf(stderr, msg, argp);
|
|
va_end(argp);
|
|
}
|
|
|
|
|
|
int _MAIN_CC main(int argc, char *argv[])
|
|
{
|
|
return clar_test(argc, argv);
|
|
}
|