thodg/libgit2/tests/core/structinit.c

• Show log

  Commit

• Hash : 89a34828
  Author :
  Date : 2017-06-16T13:34:43
  

  diff: implement function to calculate patch ID The upstream git project provides the ability to calculate a so-called patch ID. Quoting from git-patch-id(1): A "patch ID" is nothing but a sum of SHA-1 of the file diffs associated with a patch, with whitespace and line numbers ignored." Patch IDs can be used to identify two patches which are probably the same thing, e.g. when a patch has been cherry-picked to another branch. This commit implements a new function `git_diff_patchid`, which gets a patch and derives an OID from the diff. Note the different terminology here: a patch in libgit2 are the differences in a single file and a diff can contain multiple patches for different files. The implementation matches the upstream implementation and should derive the same OID for the same diff. In fact, some code has been directly derived from the upstream implementation. The upstream implementation has two different modes to calculate patch IDs, which is the stable and unstable mode. The old way of calculating the patch IDs was unstable in a sense that a different ordering the diffs was leading to different results. This oversight was fixed in git 1.9, but as git tries hard to never break existing workflows, the old and unstable way is still default. The newer and stable way does not care for ordering of the diff hunks, and in fact it is the mode that should probably be used today. So right now, we only implement the stable way of generating the patch ID.

Download

• tests/core/structinit.c

• #include "clar_libgit2.h"
  #include <git2/sys/config.h>
  #include <git2/sys/filter.h>
  #include <git2/sys/odb_backend.h>
  #include <git2/sys/refdb_backend.h>
  #include <git2/sys/transport.h>
  
  #define STRINGIFY(s) #s
  
  /* Checks two conditions for the specified structure:
   *     1. That the initializers for the latest version produces the same
   *        in-memory representation.
   *     2. That the function-based initializer supports all versions from 1...n,
   *        where n is the latest version (often represented by GIT_*_VERSION).
   *
   * Parameters:
   *     structname: The name of the structure to test, e.g. git_blame_options.
   *     structver: The latest version of the specified structure.
   *     macroinit: The macro that initializes the latest version of the structure.
   *     funcinitname: The function that initializes the structure. Must have the
   *                   signature "int (structname* instance, int version)".
   */
  #define CHECK_MACRO_FUNC_INIT_EQUAL(structname, structver, macroinit, funcinitname) \
  do { \
  	structname structname##_macro_latest = macroinit; \
  	structname structname##_func_latest; \
  	int structname##_curr_ver = structver - 1; \
  	memset(&structname##_func_latest, 0, sizeof(structname##_func_latest)); \
  	cl_git_pass(funcinitname(&structname##_func_latest, structver)); \
  	options_cmp(&structname##_macro_latest, &structname##_func_latest, \
  		sizeof(structname), STRINGIFY(structname)); \
  	\
  	while (structname##_curr_ver > 0) \
  	{ \
  		structname macro; \
  		cl_git_pass(funcinitname(&macro, structname##_curr_ver)); \
  		structname##_curr_ver--; \
  	}\
  } while(0)
  
  static void options_cmp(void *one, void *two, size_t size, const char *name)
  {
  	size_t i;
  
  	for (i = 0; i < size; i++) {
  		if (((char *)one)[i] != ((char *)two)[i]) {
  			char desc[1024];
  
  			p_snprintf(desc, 1024, "Difference in %s at byte %" PRIuZ ": macro=%u / func=%u",
  				name, i, ((char *)one)[i], ((char *)two)[i]);
  			clar__fail(__FILE__, __LINE__,
  				"Difference between macro and function options initializer",
  				desc, 0);
  			return;
  		}
  	}
  }
  
  void test_core_structinit__compare(void)
  {
  	/* These tests assume that they can memcmp() two structures that were
  	 * initialized with the same static initializer.  Eg,
  	 * git_blame_options = GIT_BLAME_OPTIONS_INIT;
  	 *
  	 * This assumption fails when there is padding between structure members,
  	 * which is not guaranteed to be initialized to anything sane at all.
  	 *
  	 * Assume most compilers, in a debug build, will clear that memory for
  	 * us or set it to sentinal markers.  Etc.
  	 */
  #if !defined(DEBUG) && !defined(_DEBUG)
  	clar__skip();
  #endif
  
  	/* blame */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_blame_options, GIT_BLAME_OPTIONS_VERSION, \
  		GIT_BLAME_OPTIONS_INIT, git_blame_init_options);
  
  	/* checkout */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, \
  		GIT_CHECKOUT_OPTIONS_INIT, git_checkout_init_options);
  
  	/* clone */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_clone_options, GIT_CLONE_OPTIONS_VERSION, \
  		GIT_CLONE_OPTIONS_INIT, git_clone_init_options);
  
  	/* diff */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_diff_options, GIT_DIFF_OPTIONS_VERSION, \
  		GIT_DIFF_OPTIONS_INIT, git_diff_init_options);
  
  	/* diff_find */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_diff_find_options, GIT_DIFF_FIND_OPTIONS_VERSION, \
  		GIT_DIFF_FIND_OPTIONS_INIT, git_diff_find_init_options);
  
  	/* filter */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_filter, GIT_FILTER_VERSION, \
  		GIT_FILTER_INIT, git_filter_init);
  
  	/* merge_file_input */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_merge_file_input, GIT_MERGE_FILE_INPUT_VERSION, \
  		GIT_MERGE_FILE_INPUT_INIT, git_merge_file_init_input);
  
  	/* merge_file */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_merge_file_options, GIT_MERGE_FILE_OPTIONS_VERSION, \
  		GIT_MERGE_FILE_OPTIONS_INIT, git_merge_file_init_options);
  
  	/* merge_tree */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_merge_options, GIT_MERGE_OPTIONS_VERSION, \
  		GIT_MERGE_OPTIONS_INIT, git_merge_init_options);
  
  	/* push */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_push_options, GIT_PUSH_OPTIONS_VERSION, \
  		GIT_PUSH_OPTIONS_INIT, git_push_init_options);
  
  	/* remote */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_remote_callbacks, GIT_REMOTE_CALLBACKS_VERSION, \
  		GIT_REMOTE_CALLBACKS_INIT, git_remote_init_callbacks);
  
  	/* repository_init */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_repository_init_options, GIT_REPOSITORY_INIT_OPTIONS_VERSION, \
  		GIT_REPOSITORY_INIT_OPTIONS_INIT, git_repository_init_init_options);
  
  	/* revert */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_revert_options, GIT_REVERT_OPTIONS_VERSION, \
  		GIT_REVERT_OPTIONS_INIT, git_revert_init_options);
  
  	/* stash apply */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_stash_apply_options, GIT_STASH_APPLY_OPTIONS_VERSION, \
  		GIT_STASH_APPLY_OPTIONS_INIT, git_stash_apply_init_options);
  
  	/* status */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_status_options, GIT_STATUS_OPTIONS_VERSION, \
  		GIT_STATUS_OPTIONS_INIT, git_status_init_options);
  
  	/* transport */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_transport, GIT_TRANSPORT_VERSION, \
  		GIT_TRANSPORT_INIT, git_transport_init);
  
  	/* config_backend */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_config_backend, GIT_CONFIG_BACKEND_VERSION, \
  		GIT_CONFIG_BACKEND_INIT, git_config_init_backend);
  
  	/* odb_backend */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_odb_backend, GIT_ODB_BACKEND_VERSION, \
  		GIT_ODB_BACKEND_INIT, git_odb_init_backend);
  
  	/* refdb_backend */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_refdb_backend, GIT_REFDB_BACKEND_VERSION, \
  		GIT_REFDB_BACKEND_INIT, git_refdb_init_backend);
  
  	/* submodule update */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_submodule_update_options, GIT_SUBMODULE_UPDATE_OPTIONS_VERSION, \
  		GIT_SUBMODULE_UPDATE_OPTIONS_INIT, git_submodule_update_init_options);
  
  	/* submodule update */
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_proxy_options, GIT_PROXY_OPTIONS_VERSION, \
  		GIT_PROXY_OPTIONS_INIT, git_proxy_init_options);
  
  	CHECK_MACRO_FUNC_INIT_EQUAL( \
  		git_diff_patchid_options, GIT_DIFF_PATCHID_OPTIONS_VERSION, \
  		GIT_DIFF_PATCHID_OPTIONS_INIT, git_diff_patchid_init_options);
  }
  

Download