thodg/libgit2/tests-clar/clar_main.c

• Show log

  Commit

• Hash : 1a90dcf6
  Author :
  Date : 2013-03-06T19:07:56
  

  use git_note_iterator type instead of non-public git_iterator one

Download

• tests-clar/clar_main.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);
  }
  

Download