thodg/libgit2/tests-clar/diff/diff_helpers.c

• Show log

  Commit

• Hash : a5f9b5f8
  Author :
  Date : 2013-07-05T16:59:38
  

  Diff hunk context off by one on long lines The diff hunk context string that is returned to xdiff need not be NUL terminated because the xdiff code just copies the number of bytes that you report directly into the output. There was an off by one in the diff driver code when the header context was longer than the output buffer size, the output buffer length included the NUL byte which was copied into the hunk header. Fixes #1710

Download

• tests-clar/diff/diff_helpers.c

• #include "clar_libgit2.h"
  #include "diff_helpers.h"
  
  git_tree *resolve_commit_oid_to_tree(
  	git_repository *repo,
  	const char *partial_oid)
  {
  	size_t len = strlen(partial_oid);
  	git_oid oid;
  	git_object *obj = NULL;
  	git_tree *tree = NULL;
  
  	if (git_oid_fromstrn(&oid, partial_oid, len) == 0)
  		git_object_lookup_prefix(&obj, repo, &oid, len, GIT_OBJ_ANY);
  	cl_assert(obj);
  	if (git_object_type(obj) == GIT_OBJ_TREE)
  		return (git_tree *)obj;
  	cl_assert(git_object_type(obj) == GIT_OBJ_COMMIT);
  	cl_git_pass(git_commit_tree(&tree, (git_commit *)obj));
  	git_object_free(obj);
  	return tree;
  }
  
  int diff_file_cb(
  	const git_diff_delta *delta,
  	float progress,
  	void *payload)
  {
  	diff_expects *e = payload;
  
  	if (e->debug)
  		fprintf(stderr, "%c %s (%.3f)\n",
  			git_diff_status_char(delta->status),
  			delta->old_file.path, progress);
  
  	if (e->names)
  		cl_assert_equal_s(e->names[e->files], delta->old_file.path);
  	if (e->statuses)
  		cl_assert_equal_i(e->statuses[e->files], (int)delta->status);
  
  	e->files++;
  
  	if ((delta->flags & GIT_DIFF_FLAG_BINARY) != 0)
  		e->files_binary++;
  
  	cl_assert(delta->status <= GIT_DELTA_TYPECHANGE);
  
  	e->file_status[delta->status] += 1;
  
  	return 0;
  }
  
  int diff_print_file_cb(
  	const git_diff_delta *delta,
  	float progress,
  	void *payload)
  {
  	fprintf(stderr, "%c %s\n",
  		git_diff_status_char(delta->status), delta->old_file.path);
  	return diff_file_cb(delta, progress, payload);
  }
  
  int diff_hunk_cb(
  	const git_diff_delta *delta,
  	const git_diff_range *range,
  	const char *header,
  	size_t header_len,
  	void *payload)
  {
  	diff_expects *e = payload;
  
  	GIT_UNUSED(delta);
  
  	/* confirm no NUL bytes in header text */
  	while (header_len--) cl_assert('\0' != *header++);
  
  	e->hunks++;
  	e->hunk_old_lines += range->old_lines;
  	e->hunk_new_lines += range->new_lines;
  	return 0;
  }
  
  int diff_line_cb(
  	const git_diff_delta *delta,
  	const git_diff_range *range,
  	char line_origin,
  	const char *content,
  	size_t content_len,
  	void *payload)
  {
  	diff_expects *e = payload;
  
  	GIT_UNUSED(delta);
  	GIT_UNUSED(range);
  	GIT_UNUSED(content);
  	GIT_UNUSED(content_len);
  
  	e->lines++;
  	switch (line_origin) {
  	case GIT_DIFF_LINE_CONTEXT:
  	case GIT_DIFF_LINE_CONTEXT_EOFNL: /* techically not a line */
  		e->line_ctxt++;
  		break;
  	case GIT_DIFF_LINE_ADDITION:
  	case GIT_DIFF_LINE_ADD_EOFNL: /* technically not a line add */
  		e->line_adds++;
  		break;
  	case GIT_DIFF_LINE_DELETION:
  	case GIT_DIFF_LINE_DEL_EOFNL: /* technically not a line delete */
  		e->line_dels++;
  		break;
  	default:
  		break;
  	}
  	return 0;
  }
  
  int diff_foreach_via_iterator(
  	git_diff_list *diff,
  	git_diff_file_cb file_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_data_cb line_cb,
  	void *data)
  {
  	size_t d, num_d = git_diff_num_deltas(diff);
  
  	for (d = 0; d < num_d; ++d) {
  		git_diff_patch *patch;
  		const git_diff_delta *delta;
  		size_t h, num_h;
  
  		cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
  		cl_assert(delta);
  
  		/* call file_cb for this file */
  		if (file_cb != NULL && file_cb(delta, (float)d / num_d, data) != 0) {
  			git_diff_patch_free(patch);
  			goto abort;
  		}
  
  		/* if there are no changes, then the patch will be NULL */
  		if (!patch) {
  			cl_assert(delta->status == GIT_DELTA_UNMODIFIED ||
  					  (delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
  			continue;
  		}
  
  		if (!hunk_cb && !line_cb) {
  			git_diff_patch_free(patch);
  			continue;
  		}
  
  		num_h = git_diff_patch_num_hunks(patch);
  
  		for (h = 0; h < num_h; h++) {
  			const git_diff_range *range;
  			const char *hdr;
  			size_t hdr_len, l, num_l;
  
  			cl_git_pass(git_diff_patch_get_hunk(
  				&range, &hdr, &hdr_len, &num_l, patch, h));
  
  			if (hunk_cb && hunk_cb(delta, range, hdr, hdr_len, data) != 0) {
  				git_diff_patch_free(patch);
  				goto abort;
  			}
  
  			for (l = 0; l < num_l; ++l) {
  				char origin;
  				const char *line;
  				size_t line_len;
  				int old_lineno, new_lineno;
  
  				cl_git_pass(git_diff_patch_get_line_in_hunk(
  					&origin, &line, &line_len, &old_lineno, &new_lineno,
  					patch, h, l));
  
  				if (line_cb &&
  					line_cb(delta, range, origin, line, line_len, data) != 0) {
  					git_diff_patch_free(patch);
  					goto abort;
  				}
  			}
  		}
  
  		git_diff_patch_free(patch);
  	}
  
  	return 0;
  
  abort:
  	giterr_clear();
  	return GIT_EUSER;
  }
  
  static int diff_print_cb(
  	const git_diff_delta *delta,
  	const git_diff_range *range,
  	char line_origin, /**< GIT_DIFF_LINE_... value from above */
  	const char *content,
  	size_t content_len,
  	void *payload)
  {
  	GIT_UNUSED(payload);
  	GIT_UNUSED(delta);
  	GIT_UNUSED(range);
  	GIT_UNUSED(line_origin);
  	GIT_UNUSED(content_len);
  	fputs(content, (FILE *)payload);
  	return 0;
  }
  
  void diff_print(FILE *fp, git_diff_list *diff)
  {
  	cl_git_pass(git_diff_print_patch(diff, diff_print_cb, fp ? fp : stderr));
  }
  
  void diff_print_raw(FILE *fp, git_diff_list *diff)
  {
  	cl_git_pass(git_diff_print_raw(diff, diff_print_cb, fp ? fp : stderr));
  }
  

Download