Skip to content

G
git2
Commit d4723c89 by Carlos Martín Nieto
Options

Merge pull request #3177 from ethomson/binary_diff 

Binary diffs: store deltas in the diff structure, include binary data in diff callbacks
parents ae22ef0e 0e522f6e
Showing with 914 additions and 364 deletions
CHANGELOG.md
......@@ -65,6 +65,10 @@ support for HTTPS connections insead of OpenSSL.
configuration. This allows modifying URL prefixes to a custom
value via gitconfig.
* `git_diff_foreach`, `git_diff_blobs`, `git_diff_blob_to_buffer`,
and `git_diff_buffers` now accept a new binary callback of type
`git_diff_binary_cb` that includes the binary diff information.
### API additions
* The `git_merge_options` gained a `file_flags` member.
......
include/git2/diff.h
......@@ -426,6 +426,53 @@ typedef int (*git_diff_file_cb)(
void *payload);
/**
* When producing a binary diff, the binary data returned will be
* either the deflated full ("literal") contents of the file, or
* the deflated binary delta between the two sides (whichever is
* smaller).
*/
typedef enum {
/** There is no binary delta. */
GIT_DIFF_BINARY_NONE,
/** The binary data is the literal contents of the file. */
GIT_DIFF_BINARY_LITERAL,
/** The binary data is the delta from one side to the other. */
GIT_DIFF_BINARY_DELTA,
} git_diff_binary_t;
/** The contents of one of the files in a binary diff. */
typedef struct {
/** The type of binary data for this file. */
git_diff_binary_t type;
/** The binary data, deflated. */
const char *data;
/** The length of the binary data. */
size_t datalen;
/** The length of the binary data after inflation. */
size_t inflatedlen;
} git_diff_binary_file;
/** Structure describing the binary contents of a diff. */
typedef struct {
git_diff_binary_file old_file; /**< The contents of the old file. */
git_diff_binary_file new_file; /**< The contents of the new file. */
} git_diff_binary;
/**
* When iterating over a diff, callback that will be made for
* binary content within the diff.
*/
typedef int(*git_diff_binary_cb)(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *payload);
/**
* Structure describing a hunk of a diff.
*/
typedef struct {
......@@ -897,6 +944,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
*
* @param diff A git_diff generated by one of the above functions.
* @param file_cb Callback function to make per file in the diff.
* @param binary_cb Optional callback to make for binary files.
* @param hunk_cb Optional callback to make per hunk of text diff. This
* callback is called to describe a range of lines in the
* diff. It will not be issued for binary files.
......@@ -909,6 +957,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
GIT_EXTERN(int) git_diff_foreach(
git_diff *diff,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload);
......@@ -984,6 +1033,7 @@ GIT_EXTERN(int) git_diff_print(
* @param new_as_path Treat new blob as if it had this filename; can be NULL
* @param options Options for diff, or NULL for default options
* @param file_cb Callback for "file"; made once if there is a diff; can be NULL
* @param binary_cb Callback for binary files; can be NULL
* @param hunk_cb Callback for each hunk in diff; can be NULL
* @param line_cb Callback for each line in diff; can be NULL
* @param payload Payload passed to each callback function
......@@ -996,6 +1046,7 @@ GIT_EXTERN(int) git_diff_blobs(
const char *new_as_path,
const git_diff_options *options,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload);
......@@ -1019,6 +1070,7 @@ GIT_EXTERN(int) git_diff_blobs(
* @param buffer_as_path Treat buffer as if it had this filename; can be NULL
* @param options Options for diff, or NULL for default options
* @param file_cb Callback for "file"; made once if there is a diff; can be NULL
* @param binary_cb Callback for binary files; can be NULL
* @param hunk_cb Callback for each hunk in diff; can be NULL
* @param line_cb Callback for each line in diff; can be NULL
* @param payload Payload passed to each callback function
......@@ -1032,6 +1084,7 @@ GIT_EXTERN(int) git_diff_blob_to_buffer(
const char *buffer_as_path,
const git_diff_options *options,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload);
......@@ -1051,6 +1104,7 @@ GIT_EXTERN(int) git_diff_blob_to_buffer(
* @param new_as_path Treat buffer as if it had this filename; can be NULL
* @param options Options for diff, or NULL for default options
* @param file_cb Callback for "file"; made once if there is a diff; can be NULL
* @param binary_cb Callback for binary files; can be NULL
* @param hunk_cb Callback for each hunk in diff; can be NULL
* @param line_cb Callback for each line in diff; can be NULL
* @param payload Payload passed to each callback function
......@@ -1065,6 +1119,7 @@ GIT_EXTERN(int) git_diff_buffers(
const char *new_as_path,
const git_diff_options *options,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload);
......
src/blame.c
......@@ -496,8 +496,8 @@ int git_blame_buffer(
/* Diff to the reference blob */
git_diff_blob_to_buffer(reference->final_blob, blame->path,
buffer, buffer_len, blame->path,
&diffopts, NULL, buffer_hunk_cb, buffer_line_cb, blame);
buffer, buffer_len, blame->path, &diffopts,
NULL, NULL, buffer_hunk_cb, buffer_line_cb, blame);
*out = blame;
return 0;
......
src/diff_file.c
......@@ -89,10 +89,9 @@ static int diff_file_content_init_common(
int git_diff_file_content__init_from_diff(
git_diff_file_content *fc,
git_diff *diff,
size_t delta_index,
git_diff_delta *delta,
bool use_old)
{
git_diff_delta *delta = git_vector_get(&diff->deltas, delta_index);
bool has_data = true;
memset(fc, 0, sizeof(*fc));
......@@ -218,7 +217,9 @@ static int diff_file_content_commit_to_str(
return 0;
}
static int diff_file_content_load_blob(git_diff_file_content *fc)
static int diff_file_content_load_blob(
git_diff_file_content *fc,
git_diff_options *opts)
{
int error = 0;
git_odb_object *odb_obj = NULL;
......@@ -236,7 +237,8 @@ static int diff_file_content_load_blob(git_diff_file_content *fc)
return error;
}
if (diff_file_content_binary_by_size(fc))
if ((opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
diff_file_content_binary_by_size(fc))
return 0;
if (odb_obj != NULL) {
......@@ -283,7 +285,9 @@ static int diff_file_content_load_workdir_symlink(
}
static int diff_file_content_load_workdir_file(
git_diff_file_content *fc, git_buf *path)
git_diff_file_content *fc,
git_buf *path,
git_diff_options *diff_opts)
{
int error = 0;
git_filter_list *fl = NULL;
......@@ -297,7 +301,8 @@ static int diff_file_content_load_workdir_file(
!(fc->file->size = git_futils_filesize(fd)))
goto cleanup;
if (diff_file_content_binary_by_size(fc))
if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
diff_file_content_binary_by_size(fc))
goto cleanup;
if ((error = git_filter_list_load(
......@@ -339,7 +344,9 @@ cleanup:
return error;
}
static int diff_file_content_load_workdir(git_diff_file_content *fc)
static int diff_file_content_load_workdir(
git_diff_file_content *fc,
git_diff_options *diff_opts)
{
int error = 0;
git_buf path = GIT_BUF_INIT;
......@@ -357,7 +364,7 @@ static int diff_file_content_load_workdir(git_diff_file_content *fc)
if (S_ISLNK(fc->file->mode))
error = diff_file_content_load_workdir_symlink(fc, &path);
else
error = diff_file_content_load_workdir_file(fc, &path);
error = diff_file_content_load_workdir_file(fc, &path, diff_opts);
/* once data is loaded, update OID if we didn't have it previously */
if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
......@@ -370,20 +377,23 @@ static int diff_file_content_load_workdir(git_diff_file_content *fc)
return error;
}
int git_diff_file_content__load(git_diff_file_content *fc)
int git_diff_file_content__load(
git_diff_file_content *fc,
git_diff_options *diff_opts)
{
int error = 0;
if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
return 0;
if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0)
if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
(diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0)
return 0;
if (fc->src == GIT_ITERATOR_TYPE_WORKDIR)
error = diff_file_content_load_workdir(fc);
error = diff_file_content_load_workdir(fc, diff_opts);
else
error = diff_file_content_load_blob(fc);
error = diff_file_content_load_blob(fc, diff_opts);
if (error)
return error;
......
src/diff_file.h
......@@ -28,7 +28,7 @@ typedef struct {
extern int git_diff_file_content__init_from_diff(
git_diff_file_content *fc,
git_diff *diff,
size_t delta_index,
git_diff_delta *delta,
bool use_old);
typedef struct {
......@@ -49,7 +49,9 @@ extern int git_diff_file_content__init_from_src(
git_diff_file *as_file);
/* this loads the blob/file-on-disk as needed */
extern int git_diff_file_content__load(git_diff_file_content *fc);
extern int git_diff_file_content__load(
git_diff_file_content *fc,
git_diff_options *diff_opts);
/* this releases the blob/file-in-memory */
extern void git_diff_file_content__unload(git_diff_file_content *fc);
......
src/diff_patch.c
......@@ -11,41 +11,13 @@
#include "diff_driver.h"
#include "diff_patch.h"
#include "diff_xdiff.h"
#include "delta.h"
#include "zstream.h"
#include "fileops.h"
/* cached information about a hunk in a diff */
typedef struct diff_patch_hunk {
git_diff_hunk hunk;
size_t line_start;
size_t line_count;
} diff_patch_hunk;
struct git_patch {
git_refcount rc;
git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
git_diff_delta *delta;
size_t delta_index;
git_diff_file_content ofile;
git_diff_file_content nfile;
uint32_t flags;
git_array_t(diff_patch_hunk) hunks;
git_array_t(git_diff_line) lines;
size_t content_size, context_size, header_size;
git_pool flattened;
};
enum {
GIT_DIFF_PATCH_ALLOCATED = (1 << 0),
GIT_DIFF_PATCH_INITIALIZED = (1 << 1),
GIT_DIFF_PATCH_LOADED = (1 << 2),
GIT_DIFF_PATCH_DIFFABLE = (1 << 3),
GIT_DIFF_PATCH_DIFFED = (1 << 4),
GIT_DIFF_PATCH_FLATTENED = (1 << 5),
};
static void diff_output_init(
git_diff_output*, const git_diff_options*,
git_diff_file_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
git_diff_output*, const git_diff_options*, git_diff_file_cb,
git_diff_binary_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
static void diff_output_to_patch(git_diff_output *, git_patch *);
......@@ -67,15 +39,38 @@ static void diff_patch_init_common(git_patch *patch)
{
diff_patch_update_binary(patch);
if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0)
patch->flags |= GIT_DIFF_PATCH_LOADED; /* LOADED but not DIFFABLE */
patch->flags |= GIT_DIFF_PATCH_INITIALIZED;
if (patch->diff)
git_diff_addref(patch->diff);
}
static int diff_patch_normalize_options(
git_diff_options *out,
const git_diff_options *opts)
{
if (opts) {
GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
memcpy(out, opts, sizeof(git_diff_options));
} else {
git_diff_options default_opts = GIT_DIFF_OPTIONS_INIT;
memcpy(out, &default_opts, sizeof(git_diff_options));
}
out->old_prefix = opts && opts->old_prefix ?
git__strdup(opts->old_prefix) :
git__strdup(DIFF_OLD_PREFIX_DEFAULT);
out->new_prefix = opts && opts->new_prefix ?
git__strdup(opts->new_prefix) :
git__strdup(DIFF_NEW_PREFIX_DEFAULT);
GITERR_CHECK_ALLOC(out->old_prefix);
GITERR_CHECK_ALLOC(out->new_prefix);
return 0;
}
static int diff_patch_init_from_diff(
git_patch *patch, git_diff *diff, size_t delta_index)
{
......@@ -86,10 +81,12 @@ static int diff_patch_init_from_diff(
patch->delta = git_vector_get(&diff->deltas, delta_index);
patch->delta_index = delta_index;
if ((error = git_diff_file_content__init_from_diff(
&patch->ofile, diff, delta_index, true)) < 0 ||
if ((error = diff_patch_normalize_options(
&patch->diff_opts, &diff->opts)) < 0 ||
(error = git_diff_file_content__init_from_diff(
&patch->nfile, diff, delta_index, false)) < 0)
&patch->ofile, diff, patch->delta, true)) < 0 ||
(error = git_diff_file_content__init_from_diff(
&patch->nfile, diff, patch->delta, false)) < 0)
return error;
diff_patch_init_common(patch);
......@@ -116,6 +113,14 @@ static int diff_patch_alloc_from_diff(
return error;
}
GIT_INLINE(bool) should_skip_binary(git_patch *patch, git_diff_file *file)
{
if ((patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) != 0)
return false;
return (file->flags & GIT_DIFF_FLAG_BINARY) != 0;
}
static int diff_patch_load(git_patch *patch, git_diff_output *output)
{
int error = 0;
......@@ -128,7 +133,7 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
* binary, then there is no need to actually load the data
*/
if ((patch->ofile.opts_flags & GIT_DIFF_SKIP_BINARY_CHECK) != 0 &&
output && !output->hunk_cb && !output->data_cb)
output && !output->binary_cb && !output->hunk_cb && !output->data_cb)
return 0;
incomplete_data =
......@@ -141,25 +146,29 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
* need 2x data size and this minimizes peak memory footprint
*/
if (patch->ofile.src == GIT_ITERATOR_TYPE_WORKDIR) {
if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
if ((error = git_diff_file_content__load(
&patch->ofile, &patch->diff_opts)) < 0 ||
should_skip_binary(patch, patch->ofile.file))
goto cleanup;
}
if (patch->nfile.src == GIT_ITERATOR_TYPE_WORKDIR) {
if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
if ((error = git_diff_file_content__load(
&patch->nfile, &patch->diff_opts)) < 0 ||
should_skip_binary(patch, patch->nfile.file))
goto cleanup;
}
/* once workdir has been tried, load other data as needed */
if (patch->ofile.src != GIT_ITERATOR_TYPE_WORKDIR) {
if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
if ((error = git_diff_file_content__load(
&patch->ofile, &patch->diff_opts)) < 0 ||
should_skip_binary(patch, patch->ofile.file))
goto cleanup;
}
if (patch->nfile.src != GIT_ITERATOR_TYPE_WORKDIR) {
if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
if ((error = git_diff_file_content__load(
&patch->nfile, &patch->diff_opts)) < 0 ||
should_skip_binary(patch, patch->nfile.file))
goto cleanup;
}
......@@ -177,10 +186,14 @@ cleanup:
diff_patch_update_binary(patch);
if (!error) {
bool skip_binary =
(patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
(patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) == 0;
/* patch is diffable only for non-binary, modified files where
* at least one side has data and the data actually changed
*/
if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) == 0 &&
if (!skip_binary &&
patch->delta->status != GIT_DELTA_UNMODIFIED &&
(patch->ofile.map.len || patch->nfile.map.len) &&
(patch->ofile.map.len != patch->nfile.map.len ||
......@@ -207,6 +220,98 @@ static int diff_patch_invoke_file_callback(
"git_patch");
}
static int create_binary(
git_diff_binary_t *out_type,
char **out_data,
size_t *out_datalen,
size_t *out_inflatedlen,
const char *a_data,
size_t a_datalen,
const char *b_data,
size_t b_datalen)
{
git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT;
unsigned long delta_data_len;
int error;
/* The git_delta function accepts unsigned long only */
if (!git__is_ulong(a_datalen) || !git__is_ulong(b_datalen))
return GIT_EBUFS;
if ((error = git_zstream_deflatebuf(&deflate, b_data, b_datalen)) < 0)
goto done;
/* The git_delta function accepts unsigned long only */
if (!git__is_ulong(deflate.size)) {
error = GIT_EBUFS;
goto done;
}
if (a_datalen && b_datalen) {
void *delta_data = git_delta(
a_data, (unsigned long)a_datalen,
b_data, (unsigned long)b_datalen,
&delta_data_len, (unsigned long)deflate.size);
if (delta_data) {
error = git_zstream_deflatebuf(
&delta, delta_data, (size_t)delta_data_len);
git__free(delta_data);
if (error < 0)
goto done;
}
}
if (delta.size && delta.size < deflate.size) {
*out_type = GIT_DIFF_BINARY_DELTA;
*out_datalen = delta.size;
*out_data = git_buf_detach(&delta);
*out_inflatedlen = delta_data_len;
} else {
*out_type = GIT_DIFF_BINARY_LITERAL;
*out_datalen = deflate.size;
*out_data = git_buf_detach(&deflate);
*out_inflatedlen = b_datalen;
}
done:
git_buf_free(&deflate);
git_buf_free(&delta);
return error;
}
static int diff_binary(git_diff_output *output, git_patch *patch)
{
git_diff_binary binary = { 0 };
const char *old_data = patch->ofile.map.data;
const char *new_data = patch->nfile.map.data;
size_t old_len = patch->ofile.map.len,
new_len = patch->nfile.map.len;
int error;
/* Create the old->new delta (as the "new" side of the patch),
* and the new->old delta (as the "old" side)
*/
if ((error = create_binary(&binary.old_file.type,
(char **)&binary.old_file.data,
&binary.old_file.datalen,
&binary.old_file.inflatedlen,
new_data, new_len, old_data, old_len)) < 0 ||
(error = create_binary(&binary.new_file.type,
(char **)&binary.new_file.data,
&binary.new_file.datalen,
&binary.new_file.inflatedlen,
old_data, old_len, new_data, new_len)) < 0)
return error;
return giterr_set_after_callback_function(
output->binary_cb(patch->delta, &binary, output->payload),
"git_patch");
}
static int diff_patch_generate(git_patch *patch, git_diff_output *output)
{
int error = 0;
......@@ -214,8 +319,8 @@ static int diff_patch_generate(git_patch *patch, git_diff_output *output)
if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0)
return 0;
/* if we are not looking at the hunks and lines, don't do the diff */
if (!output->hunk_cb && !output->data_cb)
/* if we are not looking at the binary or text data, don't do the diff */
if (!output->binary_cb && !output->hunk_cb && !output->data_cb)
return 0;
if ((patch->flags & GIT_DIFF_PATCH_LOADED) == 0 &&
......@@ -225,10 +330,16 @@ static int diff_patch_generate(git_patch *patch, git_diff_output *output)
if ((patch->flags & GIT_DIFF_PATCH_DIFFABLE) == 0)
return 0;
if (output->diff_cb != NULL &&
(error = output->diff_cb(output, patch)) < 0)
patch->flags |= GIT_DIFF_PATCH_DIFFED;
if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
if (output->binary_cb)
error = diff_binary(output, patch);
}
else {
if (output->diff_cb)
error = output->diff_cb(output, patch);
}
patch->flags |= GIT_DIFF_PATCH_DIFFED;
return error;
}
......@@ -245,6 +356,9 @@ static void diff_patch_free(git_patch *patch)
git_pool_clear(&patch->flattened);
git__free((char *)patch->diff_opts.old_prefix);
git__free((char *)patch->diff_opts.new_prefix);
if (patch->flags & GIT_DIFF_PATCH_ALLOCATED)
git__free(patch);
}
......@@ -260,6 +374,7 @@ static int diff_required(git_diff *diff, const char *action)
int git_diff_foreach(
git_diff *diff,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -275,7 +390,7 @@ int git_diff_foreach(
memset(&xo, 0, sizeof(xo));
memset(&patch, 0, sizeof(patch));
diff_output_init(
&xo.output, &diff->opts, file_cb, hunk_cb, data_cb, payload);
&xo.output, &diff->opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
git_xdiff_init(&xo, &diff->opts);
git_vector_foreach(&diff->deltas, idx, patch.delta) {
......@@ -284,12 +399,16 @@ int git_diff_foreach(
if (git_diff_delta__should_skip(&diff->opts, patch.delta))
continue;
if (binary_cb || hunk_cb || data_cb) {
if ((error = diff_patch_init_from_diff(&patch, diff, idx)) != 0 ||
(error = diff_patch_load(&patch, &xo.output)) != 0)
return error;
}
if ((error = diff_patch_invoke_file_callback(&patch, &xo.output)) == 0) {
if (hunk_cb || data_cb) {
if ((error = diff_patch_init_from_diff(&patch, diff, idx)) == 0)
if (binary_cb || hunk_cb || data_cb)
error = diff_patch_generate(&patch, &xo.output);
}
}
git_patch_free(&patch);
......@@ -350,7 +469,8 @@ static int diff_patch_from_sources(
git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file;
git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile;
GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
if ((error = diff_patch_normalize_options(&pd->patch.diff_opts, opts)) < 0)
return error;
if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
void *tmp = lfile; lfile = rfile; rfile = tmp;
......@@ -419,6 +539,7 @@ static int diff_from_sources(
git_diff_file_content_src *newsrc,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -429,7 +550,7 @@ static int diff_from_sources(
memset(&xo, 0, sizeof(xo));
diff_output_init(
&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
&xo.output, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
git_xdiff_init(&xo, opts);
memset(&pd, 0, sizeof(pd));
......@@ -477,6 +598,7 @@ int git_diff_blobs(
const char *new_path,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -486,7 +608,7 @@ int git_diff_blobs(
git_diff_file_content_src nsrc =
GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
return diff_from_sources(
&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
}
int git_patch_from_blobs(
......@@ -512,6 +634,7 @@ int git_diff_blob_to_buffer(
const char *buf_path,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -521,7 +644,7 @@ int git_diff_blob_to_buffer(
git_diff_file_content_src nsrc =
GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
return diff_from_sources(
&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
}
int git_patch_from_blob_and_buffer(
......@@ -549,6 +672,7 @@ int git_diff_buffers(
const char *new_path,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -558,7 +682,7 @@ int git_diff_buffers(
git_diff_file_content_src nsrc =
GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
return diff_from_sources(
&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
}
int git_patch_from_buffers(
......@@ -812,6 +936,7 @@ void git_patch__new_data(
int git_patch__invoke_callbacks(
git_patch *patch,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload)
......@@ -822,6 +947,13 @@ int git_patch__invoke_callbacks(
if (file_cb)
error = file_cb(patch->delta, 0, payload);
if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
if (binary_cb)
error = binary_cb(patch->delta, &patch->binary, payload);
return error;
}
if (!hunk_cb && !line_cb)
return error;
......@@ -855,6 +987,36 @@ static int diff_patch_file_cb(
return 0;
}
static int diff_patch_binary_cb(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *payload)
{
git_patch *patch = payload;
GIT_UNUSED(delta);
memcpy(&patch->binary, binary, sizeof(git_diff_binary));
if (binary->old_file.data) {
patch->binary.old_file.data = git__malloc(binary->old_file.datalen);
GITERR_CHECK_ALLOC(patch->binary.old_file.data);
memcpy((char *)patch->binary.old_file.data,
binary->old_file.data, binary->old_file.datalen);
}
if (binary->new_file.data) {
patch->binary.new_file.data = git__malloc(binary->new_file.datalen);
GITERR_CHECK_ALLOC(patch->binary.new_file.data);
memcpy((char *)patch->binary.new_file.data,
binary->new_file.data, binary->new_file.datalen);
}
return 0;
}
static int diff_patch_hunk_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk_,
......@@ -921,6 +1083,7 @@ static void diff_output_init(
git_diff_output *out,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb data_cb,
void *payload)
......@@ -930,6 +1093,7 @@ static void diff_output_init(
memset(out, 0, sizeof(*out));
out->file_cb = file_cb;
out->binary_cb = binary_cb;
out->hunk_cb = hunk_cb;
out->data_cb = data_cb;
out->payload = payload;
......@@ -938,6 +1102,11 @@ static void diff_output_init(
static void diff_output_to_patch(git_diff_output *out, git_patch *patch)
{
diff_output_init(
out, NULL,
diff_patch_file_cb, diff_patch_hunk_cb, diff_patch_line_cb, patch);
out,
NULL,
diff_patch_file_cb,
diff_patch_binary_cb,
diff_patch_hunk_cb,
diff_patch_line_cb,
patch);
}
src/diff_patch.h
......@@ -13,6 +13,38 @@
#include "array.h"
#include "git2/patch.h"
/* cached information about a hunk in a diff */
typedef struct diff_patch_hunk {
git_diff_hunk hunk;
size_t line_start;
size_t line_count;
} diff_patch_hunk;
enum {
GIT_DIFF_PATCH_ALLOCATED = (1 << 0),
GIT_DIFF_PATCH_INITIALIZED = (1 << 1),
GIT_DIFF_PATCH_LOADED = (1 << 2),
GIT_DIFF_PATCH_DIFFABLE = (1 << 3),
GIT_DIFF_PATCH_DIFFED = (1 << 4),
GIT_DIFF_PATCH_FLATTENED = (1 << 5),
};
struct git_patch {
git_refcount rc;
git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
git_diff_options diff_opts;
git_diff_delta *delta;
size_t delta_index;
git_diff_file_content ofile;
git_diff_file_content nfile;
uint32_t flags;
git_diff_binary binary;
git_array_t(diff_patch_hunk) hunks;
git_array_t(git_diff_line) lines;
size_t content_size, context_size, header_size;
git_pool flattened;
};
extern git_diff *git_patch__diff(git_patch *);
extern git_diff_driver *git_patch__driver(git_patch *);
......@@ -23,6 +55,7 @@ extern void git_patch__new_data(char **, size_t *, git_patch *);
extern int git_patch__invoke_callbacks(
git_patch *patch,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *payload);
......@@ -31,6 +64,7 @@ typedef struct git_diff_output git_diff_output;
struct git_diff_output {
/* these callbacks are issued with the diff data */
git_diff_file_cb file_cb;
git_diff_binary_cb binary_cb;
git_diff_hunk_cb hunk_cb;
git_diff_line_cb data_cb;
void *payload;
......
src/diff_print.c
......@@ -22,40 +22,36 @@ typedef struct {
uint32_t flags;
int oid_strlen;
git_diff_line line;
unsigned int
content_loaded : 1,
content_allocated : 1;
git_diff_file_content *ofile;
git_diff_file_content *nfile;
} diff_print_info;
static int diff_print_info_init(
static int diff_print_info_init__common(
diff_print_info *pi,
git_buf *out,
git_diff *diff,
git_repository *repo,
git_diff_format_t format,
git_diff_line_cb cb,
void *payload)
{
pi->diff = diff;
pi->format = format;
pi->print_cb = cb;
pi->payload = payload;
pi->buf = out;
if (diff)
pi->flags = diff->opts.flags;
else
pi->flags = 0;
if (diff && diff->opts.id_abbrev != 0)
pi->oid_strlen = diff->opts.id_abbrev;
else if (!diff || !diff->repo)
if (!pi->oid_strlen) {
if (!repo)
pi->oid_strlen = GIT_ABBREV_DEFAULT;
else if (git_repository__cvar(
&pi->oid_strlen, diff->repo, GIT_CVAR_ABBREV) < 0)
else if (git_repository__cvar(&pi->oid_strlen, repo, GIT_CVAR_ABBREV) < 0)
return -1;
}
pi->oid_strlen += 1; /* for NUL byte */
if (pi->oid_strlen < 2)
pi->oid_strlen = 2;
else if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
pi->oid_strlen = GIT_OID_HEXSZ + 1;
memset(&pi->line, 0, sizeof(pi->line));
......@@ -66,6 +62,52 @@ static int diff_print_info_init(
return 0;
}
static int diff_print_info_init_fromdiff(
diff_print_info *pi,
git_buf *out,
git_diff *diff,
git_diff_format_t format,
git_diff_line_cb cb,
void *payload)
{
git_repository *repo = diff ? diff->repo : NULL;
memset(pi, 0, sizeof(diff_print_info));
pi->diff = diff;
if (diff) {
pi->flags = diff->opts.flags;
pi->oid_strlen = diff->opts.id_abbrev;
}
return diff_print_info_init__common(pi, out, repo, format, cb, payload);
}
static int diff_print_info_init_frompatch(
diff_print_info *pi,
git_buf *out,
git_patch *patch,
git_diff_format_t format,
git_diff_line_cb cb,
void *payload)
{
git_repository *repo = patch && patch->diff ? patch->diff->repo : NULL;
memset(pi, 0, sizeof(diff_print_info));
pi->diff = patch->diff;
pi->flags = patch->diff_opts.flags;
pi->oid_strlen = patch->diff_opts.id_abbrev;
pi->content_loaded = 1;
pi->ofile = &patch->ofile;
pi->nfile = &patch->nfile;
return diff_print_info_init__common(pi, out, repo, format, cb, payload);
}
static char diff_pick_suffix(int mode)
{
if (S_ISDIR(mode))
......@@ -283,66 +325,22 @@ int git_diff_delta__format_file_header(
return git_buf_oom(out) ? -1 : 0;
}
static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
static int format_binary(
diff_print_info *pi,
git_diff_binary_t type,
const char *data,
size_t datalen,
size_t inflatedlen)
{
git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT, *out = NULL;
const void *old_data, *new_data;
git_off_t old_data_len, new_data_len;
unsigned long delta_data_len, inflated_len;
const char *out_type = "literal";
char *scan, *end;
int error;
old_data = old ? git_blob_rawcontent(old) : NULL;
new_data = new ? git_blob_rawcontent(new) : NULL;
old_data_len = old ? git_blob_rawsize(old) : 0;
new_data_len = new ? git_blob_rawsize(new) : 0;
/* The git_delta function accepts unsigned long only */
if (!git__is_ulong(old_data_len) || !git__is_ulong(new_data_len))
return GIT_EBUFS;
out = &deflate;
inflated_len = (unsigned long)new_data_len;
if ((error = git_zstream_deflatebuf(
out, new_data, (size_t)new_data_len)) < 0)
goto done;
/* The git_delta function accepts unsigned long only */
if (!git__is_ulong((git_off_t)deflate.size)) {
error = GIT_EBUFS;
goto done;
}
const char *typename = type == GIT_DIFF_BINARY_DELTA ?
"delta" : "literal";
const char *scan, *end;
int error = 0;
if (old && new) {
void *delta_data = git_delta(
old_data, (unsigned long)old_data_len,
new_data, (unsigned long)new_data_len,
&delta_data_len, (unsigned long)deflate.size);
if (delta_data) {
error = git_zstream_deflatebuf(
&delta, delta_data, (size_t)delta_data_len);
git__free(delta_data);
if (error < 0)
goto done;
if (delta.size < deflate.size) {
out = &delta;
out_type = "delta";
inflated_len = delta_data_len;
}
}
}
git_buf_printf(pi->buf, "%s %lu\n", out_type, inflated_len);
git_buf_printf(pi->buf, "%s %lu\n", typename, inflatedlen);
pi->line.num_lines++;
for (scan = out->ptr, end = out->ptr + out->size; scan < end; ) {
for (scan = data, end = data + datalen; scan < end; ) {
size_t chunk_len = end - scan;
if (chunk_len > 52)
chunk_len = 52;
......@@ -355,51 +353,74 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
git_buf_encode_base85(pi->buf, scan, chunk_len);
git_buf_putc(pi->buf, '\n');
if (git_buf_oom(pi->buf)) {
error = -1;
goto done;
}
if (git_buf_oom(pi->buf))
return -1;
scan += chunk_len;
pi->line.num_lines++;
}
done:
git_buf_free(&deflate);
git_buf_free(&delta);
return 0;
}
static int diff_print_load_content(
diff_print_info *pi,
git_diff_delta *delta)
{
git_diff_file_content *ofile, *nfile;
int error;
assert(pi->diff);
ofile = git__calloc(1, sizeof(git_diff_file_content));
nfile = git__calloc(1, sizeof(git_diff_file_content));
GITERR_CHECK_ALLOC(ofile);
GITERR_CHECK_ALLOC(nfile);
if ((error = git_diff_file_content__init_from_diff(
ofile, pi->diff, delta, true)) < 0 ||
(error = git_diff_file_content__init_from_diff(
nfile, pi->diff, delta, true)) < 0) {
git__free(ofile);
git__free(nfile);
return error;
}
pi->content_loaded = 1;
pi->content_allocated = 1;
pi->ofile = ofile;
pi->nfile = nfile;
return 0;
}
/* git diff --binary 8d7523f~2 8d7523f~1 */
static int diff_print_patch_file_binary(
diff_print_info *pi, const git_diff_delta *delta,
const char *oldpfx, const char *newpfx)
diff_print_info *pi, git_diff_delta *delta,
const char *old_pfx, const char *new_pfx,
const git_diff_binary *binary)
{
git_blob *old = NULL, *new = NULL;
const git_oid *old_id, *new_id;
int error;
size_t pre_binary_size;
int error;
if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0)
goto noshow;
if (!pi->content_loaded &&
(error = diff_print_load_content(pi, delta)) < 0)
return error;
pre_binary_size = pi->buf->size;
git_buf_printf(pi->buf, "GIT binary patch\n");
pi->line.num_lines++;
old_id = (delta->status != GIT_DELTA_ADDED) ? &delta->old_file.id : NULL;
new_id = (delta->status != GIT_DELTA_DELETED) ? &delta->new_file.id : NULL;
if (old_id && (error = git_blob_lookup(&old, pi->diff->repo, old_id)) < 0)
goto done;
if (new_id && (error = git_blob_lookup(&new, pi->diff->repo,new_id)) < 0)
goto done;
if ((error = print_binary_hunk(pi, old, new)) < 0 ||
if ((error = format_binary(pi, binary->new_file.type, binary->new_file.data,
binary->new_file.datalen, binary->new_file.inflatedlen)) < 0 ||
(error = git_buf_putc(pi->buf, '\n')) < 0 ||
(error = print_binary_hunk(pi, new, old)) < 0)
{
(error = format_binary(pi, binary->old_file.type, binary->old_file.data,
binary->old_file.datalen, binary->old_file.inflatedlen)) < 0) {
if (error == GIT_EBUFS) {
giterr_clear();
git_buf_truncate(pi->buf, pre_binary_size);
......@@ -408,17 +429,12 @@ static int diff_print_patch_file_binary(
}
pi->line.num_lines++;
done:
git_blob_free(old);
git_blob_free(new);
return error;
noshow:
pi->line.num_lines = 1;
return diff_delta_format_with_paths(
pi->buf, delta, oldpfx, newpfx,
pi->buf, delta, old_pfx, new_pfx,
"Binary files %s%s and %s%s differ\n");
}
......@@ -432,7 +448,8 @@ static int diff_print_patch_file(
const char *newpfx =
pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
bool binary = !!(delta->flags & GIT_DIFF_FLAG_BINARY);
bool binary = (delta->flags & GIT_DIFF_FLAG_BINARY) ||
(pi->flags & GIT_DIFF_FORCE_BINARY);
bool show_binary = !!(pi->flags & GIT_DIFF_SHOW_BINARY);
int oid_strlen = binary && show_binary ?
GIT_OID_HEXSZ + 1 : pi->oid_strlen;
......@@ -455,15 +472,25 @@ static int diff_print_patch_file(
pi->line.content = git_buf_cstr(pi->buf);
pi->line.content_len = git_buf_len(pi->buf);
if ((error = pi->print_cb(delta, NULL, &pi->line, pi->payload)) != 0)
return error;
return pi->print_cb(delta, NULL, &pi->line, pi->payload);
}
if (!binary)
return 0;
static int diff_print_patch_binary(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *data)
{
diff_print_info *pi = data;
const char *old_pfx =
pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
const char *new_pfx =
pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
int error;
git_buf_clear(pi->buf);
if ((error = diff_print_patch_file_binary(pi, delta, oldpfx, newpfx)) < 0)
if ((error = diff_print_patch_file_binary(
pi, (git_diff_delta *)delta, old_pfx, new_pfx, binary)) < 0)
return error;
pi->line.origin = GIT_DIFF_LINE_BINARY;
......@@ -515,12 +542,14 @@ int git_diff_print(
git_buf buf = GIT_BUF_INIT;
diff_print_info pi;
git_diff_file_cb print_file = NULL;
git_diff_binary_cb print_binary = NULL;
git_diff_hunk_cb print_hunk = NULL;
git_diff_line_cb print_line = NULL;
switch (format) {
case GIT_DIFF_FORMAT_PATCH:
print_file = diff_print_patch_file;
print_binary = diff_print_patch_binary;
print_hunk = diff_print_patch_hunk;
print_line = diff_print_patch_line;
break;
......@@ -541,11 +570,10 @@ int git_diff_print(
return -1;
}
if (!(error = diff_print_info_init(
&pi, &buf, diff, format, print_cb, payload)))
{
if (!(error = diff_print_info_init_fromdiff(
&pi, &buf, diff, format, print_cb, payload))) {
error = git_diff_foreach(
diff, print_file, print_hunk, print_line, &pi);
diff, print_file, print_binary, print_hunk, print_line, &pi);
if (error) /* make sure error message is set */
giterr_set_after_callback_function(error, "git_diff_print");
......@@ -568,13 +596,13 @@ int git_patch_print(
assert(patch && print_cb);
if (!(error = diff_print_info_init(
&pi, &temp, git_patch__diff(patch),
if (!(error = diff_print_info_init_frompatch(
&pi, &temp, patch,
GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
{
error = git_patch__invoke_callbacks(
patch, diff_print_patch_file, diff_print_patch_hunk,
diff_print_patch_line, &pi);
patch, diff_print_patch_file, diff_print_patch_binary,
diff_print_patch_hunk, diff_print_patch_line, &pi);
if (error) /* make sure error message is set */
giterr_set_after_callback_function(error, "git_patch_print");
......
src/index.c
......@@ -2727,7 +2727,7 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr
goto cleanup;
data.pathspec = &ps;
error = git_diff_foreach(diff, apply_each_file, NULL, NULL, &data);
error = git_diff_foreach(diff, apply_each_file, NULL, NULL, NULL, &data);
git_diff_free(diff);
if (error) /* make sure error is set if callback stopped iteration */
......
tests/diff/binary.c
......@@ -261,3 +261,232 @@ void test_diff_binary__delta_append(void)
git_index_free(index);
}
void test_diff_binary__index_to_workdir(void)
{
git_index *index;
git_diff *diff;
git_patch *patch;
git_buf actual = GIT_BUF_INIT;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
const char *expected =
"diff --git a/untimely.txt b/untimely.txt\n" \
"index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \
"GIT binary patch\n" \
"delta 32\n" \
"nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \
"\n" \
"delta 7\n" \
"Oc%18D`@*{63ljhg(E~C7\n";
opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
opts.id_abbrev = GIT_OID_HEXSZ;
repo = cl_git_sandbox_init("renames");
cl_git_pass(git_repository_index(&index, repo));
cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n");
cl_git_pass(git_diff_index_to_workdir(&diff, repo, index, &opts));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_buf(&actual, patch));
cl_assert_equal_s(expected, actual.ptr);
cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
cl_git_pass(git_index_write(index));
test_patch(
"19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13",
NULL,
&opts,
expected);
git_buf_free(&actual);
git_patch_free(patch);
git_diff_free(diff);
git_index_free(index);
}
static int print_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk,
const git_diff_line *line,
void *payload)
{
git_buf *buf = (git_buf *)payload;
if (hunk)
git_buf_put(buf, hunk->header, hunk->header_len);
if (line)
git_buf_put(buf, line->content, line->content_len);
return git_buf_oom(buf) ? -1 : 0;
}
void test_diff_binary__print_patch_from_diff(void)
{
git_index *index;
git_diff *diff;
git_buf actual = GIT_BUF_INIT;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
const char *expected =
"diff --git a/untimely.txt b/untimely.txt\n" \
"index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \
"GIT binary patch\n" \
"delta 32\n" \
"nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \
"\n" \
"delta 7\n" \
"Oc%18D`@*{63ljhg(E~C7\n";
opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
opts.id_abbrev = GIT_OID_HEXSZ;
repo = cl_git_sandbox_init("renames");
cl_git_pass(git_repository_index(&index, repo));
cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n");
cl_git_pass(git_diff_index_to_workdir(&diff, repo, index, &opts));
cl_git_pass(git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, print_cb, &actual));
cl_assert_equal_s(expected, actual.ptr);
git_buf_free(&actual);
git_diff_free(diff);
git_index_free(index);
}
struct diff_data {
char *old_path;
git_oid old_id;
git_buf old_binary_base85;
size_t old_binary_inflatedlen;
git_diff_binary_t old_binary_type;
char *new_path;
git_oid new_id;
git_buf new_binary_base85;
size_t new_binary_inflatedlen;
git_diff_binary_t new_binary_type;
};
static int file_cb(
const git_diff_delta *delta,
float progress,
void *payload)
{
struct diff_data *diff_data = payload;
if (delta->old_file.path)
diff_data->old_path = git__strdup(delta->old_file.path);
if (delta->new_file.path)
diff_data->new_path = git__strdup(delta->new_file.path);
git_oid_cpy(&diff_data->old_id, &delta->old_file.id);
git_oid_cpy(&diff_data->new_id, &delta->new_file.id);
return 0;
}
static int binary_cb(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *payload)
{
struct diff_data *diff_data = payload;
git_buf_encode_base85(&diff_data->old_binary_base85,
binary->old_file.data, binary->old_file.datalen);
diff_data->old_binary_inflatedlen = binary->old_file.inflatedlen;
diff_data->old_binary_type = binary->old_file.type;
git_buf_encode_base85(&diff_data->new_binary_base85,
binary->new_file.data, binary->new_file.datalen);
diff_data->new_binary_inflatedlen = binary->new_file.inflatedlen;
diff_data->new_binary_type = binary->new_file.type;
return 0;
}
static int hunk_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk,
void *payload)
{
cl_fail("did not expect hunk callback");
return 0;
}
static int line_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk,
const git_diff_line *line,
void *payload)
{
cl_fail("did not expect line callback");
return 0;
}
void test_diff_binary__blob_to_blob(void)
{
git_index *index;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_blob *old_blob, *new_blob;
git_oid old_id, new_id;
struct diff_data diff_data = {0};
const char *expected =
"diff --git a/untimely.txt b/untimely.txt\n" \
"index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \
"GIT binary patch\n" \
"delta 32\n" \
"nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \
"\n" \
"delta 7\n" \
"Oc%18D`@*{63ljhg(E~C7\n";
opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
opts.id_abbrev = GIT_OID_HEXSZ;
repo = cl_git_sandbox_init("renames");
cl_git_pass(git_repository_index(&index, repo));
cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n");
cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
cl_git_pass(git_index_write(index));
git_oid_fromstr(&old_id, "9a69d960ae94b060f56c2a8702545e2bb1abb935");
git_oid_fromstr(&new_id, "1111d4f11f4b35bf6759e0fb714fe09731ef0840");
cl_git_pass(git_blob_lookup(&old_blob, repo, &old_id));
cl_git_pass(git_blob_lookup(&new_blob, repo, &new_id));
cl_git_pass(git_diff_blobs(old_blob,
"untimely.txt", new_blob, "untimely.txt", &opts,
file_cb, binary_cb, hunk_cb, line_cb, &diff_data));
cl_assert_equal_s("untimely.txt", diff_data.old_path);
cl_assert_equal_oid(&old_id, &diff_data.old_id);
cl_assert_equal_i(GIT_DIFF_BINARY_DELTA, diff_data.old_binary_type);
cl_assert_equal_i(7, diff_data.old_binary_inflatedlen);
cl_assert_equal_s("c%18D`@*{63ljhg(E~C7",
diff_data.old_binary_base85.ptr);
cl_assert_equal_s("untimely.txt", diff_data.new_path);
cl_assert_equal_oid(&new_id, &diff_data.new_id);
cl_assert_equal_i(GIT_DIFF_BINARY_DELTA, diff_data.new_binary_type);
cl_assert_equal_i(32, diff_data.new_binary_inflatedlen);
cl_assert_equal_s("c%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW",
diff_data.new_binary_base85.ptr);
git_blob_free(old_blob);
git_blob_free(new_blob);
git__free(diff_data.old_path);
git__free(diff_data.new_path);
}
tests/diff/blob.c
......@@ -17,7 +17,7 @@ static void quick_diff_blob_to_str(
cl_git_pass(git_diff_blob_to_buffer(
blob, blob_path, str, len, str_path,
&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
&opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
}
void test_diff_blob__initialize(void)
......@@ -88,7 +88,7 @@ void test_diff_blob__can_compare_text_blobs(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
a, NULL, b, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(1, 6, 1, 5, 0, &expected);
/* same diff but use direct buffers */
......@@ -96,27 +96,27 @@ void test_diff_blob__can_compare_text_blobs(void)
cl_git_pass(git_diff_buffers(
git_blob_rawcontent(a), (size_t)git_blob_rawsize(a), NULL,
git_blob_rawcontent(b), (size_t)git_blob_rawsize(b), NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(1, 6, 1, 5, 0, &expected);
/* diff on tests/resources/attr/root_test2 */
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
b, NULL, c, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(1, 15, 3, 9, 3, &expected);
/* diff on tests/resources/attr/root_test3 */
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
a, NULL, c, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(1, 13, 0, 12, 1, &expected);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
c, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(2, 14, 4, 6, 4, &expected);
git_blob_free(a);
......@@ -206,7 +206,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
cl_git_pass(git_diff_blobs(
d, NULL, e, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
......@@ -222,7 +222,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
cl_git_pass(git_diff_blobs(
d, NULL, e, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
......@@ -238,7 +238,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
cl_git_pass(git_diff_blobs(
alien, NULL, NULL, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.files_binary);
......@@ -250,7 +250,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
cl_git_pass(git_diff_blobs(
NULL, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.files_binary);
......@@ -358,7 +358,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
cl_git_pass(git_diff_blobs(
d, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_identical_blobs_comparison(&expected);
cl_assert_equal_i(0, expected.files_binary);
......@@ -366,7 +366,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
NULL, NULL, NULL, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_identical_blobs_comparison(&expected);
cl_assert_equal_i(0, expected.files_binary);
......@@ -374,7 +374,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
alien, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_identical_blobs_comparison(&expected);
cl_assert(expected.files_binary > 0);
......@@ -441,7 +441,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
cl_git_pass(git_diff_blobs(
alien, NULL, heart, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_binary_blobs_comparison(&expected);
......@@ -449,7 +449,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
cl_git_pass(git_diff_blobs(
heart, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_binary_blobs_comparison(&expected);
......@@ -460,7 +460,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
{
cl_git_pass(git_diff_blobs(
alien, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_binary_blobs_comparison(&expected);
......@@ -468,7 +468,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
cl_git_pass(git_diff_blobs(
d, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_binary_blobs_comparison(&expected);
}
......@@ -510,7 +510,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
/* Test with default inter-hunk-context (not set) => default is 0 */
cl_git_pass(git_diff_blobs(
old_d, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(2, expected.hunks);
......@@ -519,7 +519,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
old_d, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(2, expected.hunks);
......@@ -528,7 +528,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
old_d, NULL, d, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
cl_assert_equal_i(1, expected.hunks);
......@@ -542,7 +542,7 @@ void test_diff_blob__checks_options_version_too_low(void)
opts.version = 0;
cl_git_fail(git_diff_blobs(
d, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass);
}
......@@ -554,7 +554,7 @@ void test_diff_blob__checks_options_version_too_high(void)
opts.version = 1024;
cl_git_fail(git_diff_blobs(
d, NULL, alien, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass);
}
......@@ -752,7 +752,7 @@ void test_diff_blob__binary_data_comparisons(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
bin, NULL, nonbin, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_binary_blobs_comparison(&expected);
/*
......@@ -773,7 +773,7 @@ void test_diff_blob__binary_data_comparisons(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
bin, NULL, nonbin, NULL, &opts,
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified_with_lines(&expected, 4);
/* cleanup */
......@@ -993,8 +993,8 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_buffers(
a, strlen(a), NULL, b, strlen(b), NULL,
&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
a, strlen(a), NULL, b, strlen(b), NULL, &opts,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(4, 9, 0, 4, 5, &expected);
opts.flags ^= GIT_DIFF_REVERSE;
......@@ -1002,7 +1002,7 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_buffers(
a, strlen(a), NULL, b, strlen(b), NULL,
&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
a, strlen(a), NULL, b, strlen(b), NULL, &opts,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
assert_one_modified(4, 9, 0, 5, 4, &expected);
}
tests/diff/diff_helpers.c
......@@ -91,6 +91,18 @@ int diff_print_file_cb(
return diff_file_cb(delta, progress, payload);
}
int diff_binary_cb(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *payload)
{
GIT_UNUSED(delta);
GIT_UNUSED(binary);
GIT_UNUSED(payload);
return 0;
}
int diff_hunk_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk,
......@@ -145,6 +157,7 @@ int diff_line_cb(
int diff_foreach_via_iterator(
git_diff *diff,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *data)
......
tests/diff/diff_helpers.h
......@@ -42,6 +42,11 @@ extern int diff_print_file_cb(
float progress,
void *cb_data);
extern int diff_binary_cb(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *cb_data);
extern int diff_hunk_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk,
......@@ -56,6 +61,7 @@ extern int diff_line_cb(
extern int diff_foreach_via_iterator(
git_diff *diff,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *data);
......
tests/diff/index.c
......@@ -35,7 +35,7 @@ void test_diff_index__0(void)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
/* to generate these values:
* - cd to tests/resources/status,
......@@ -63,7 +63,7 @@ void test_diff_index__0(void)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
/* to generate these values:
* - cd to tests/resources/status,
......@@ -127,8 +127,8 @@ void test_diff_index__1(void)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
cl_assert_equal_i(
1, git_diff_foreach(diff, diff_stop_after_2_files, NULL, NULL, &exp) );
cl_assert_equal_i(1, git_diff_foreach(
diff, diff_stop_after_2_files, NULL, NULL, NULL, &exp) );
cl_assert_equal_i(2, exp.files);
......@@ -193,7 +193,7 @@ static void do_conflicted_diff(diff_expects *exp, unsigned long flags)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, exp));
git_diff_free(diff);
git_tree_free(a);
......
tests/diff/notify.c
......@@ -59,7 +59,7 @@ static void test_notify(
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(expected_diffed_files_count, exp.files);
......@@ -222,7 +222,7 @@ void test_diff_notify__notify_cb_can_be_used_as_filtering_function(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(0, exp.files);
......
tests/diff/rename.c
......@@ -65,7 +65,7 @@ void test_diff_rename__match_oid(void)
*/
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -81,7 +81,7 @@ void test_diff_rename__match_oid(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -102,7 +102,7 @@ void test_diff_rename__match_oid(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -124,7 +124,7 @@ void test_diff_rename__match_oid(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -204,7 +204,7 @@ void test_diff_rename__not_exact_match(void)
*/
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -222,7 +222,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -243,7 +243,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -266,7 +266,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -297,7 +297,7 @@ void test_diff_rename__not_exact_match(void)
*/
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -317,7 +317,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -344,7 +344,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -369,7 +369,7 @@ void test_diff_rename__not_exact_match(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -469,7 +469,7 @@ void test_diff_rename__working_directory_changes(void)
/* git diff --no-renames 2bc7f351d20b53f1c72c16c4b036e491c478c49a */
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -482,7 +482,7 @@ void test_diff_rename__working_directory_changes(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -508,7 +508,7 @@ void test_diff_rename__working_directory_changes(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -527,7 +527,7 @@ void test_diff_rename__working_directory_changes(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -545,7 +545,7 @@ void test_diff_rename__working_directory_changes(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -575,7 +575,7 @@ void test_diff_rename__working_directory_changes(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -673,7 +673,7 @@ void test_diff_rename__file_exchange(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -682,7 +682,7 @@ void test_diff_rename__file_exchange(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -725,7 +725,7 @@ void test_diff_rename__file_exchange_three(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -734,7 +734,7 @@ void test_diff_rename__file_exchange_three(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(3, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -776,7 +776,7 @@ void test_diff_rename__file_partial_exchange(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -785,7 +785,7 @@ void test_diff_rename__file_partial_exchange(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
......@@ -833,7 +833,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -843,7 +843,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_COPIED]);
cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -885,7 +885,7 @@ void test_diff_rename__from_deleted_to_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -896,7 +896,7 @@ void test_diff_rename__from_deleted_to_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -998,8 +998,8 @@ void test_diff_rename__rejected_match_can_match_others(void)
cl_git_pass(git_diff_find_similar(diff, &findopts));
cl_git_pass(
git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
cl_git_pass(git_diff_foreach(
diff, test_names_expected, NULL, NULL, NULL, &expect));
git_diff_free(diff);
git_tree_free(tree);
......@@ -1072,8 +1072,8 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
cl_git_pass(git_diff_find_similar(diff, &findopts));
cl_git_pass(
git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
cl_git_pass(git_diff_foreach(
diff, test_names_expected, NULL, NULL, NULL, &expect));
cl_assert(expect.idx > 0);
git_diff_free(diff);
......@@ -1128,8 +1128,8 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
cl_git_pass(git_diff_find_similar(diff, &findopts));
cl_git_pass(
git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
cl_git_pass(git_diff_foreach(
diff, test_names_expected, NULL, NULL, NULL, &expect));
cl_assert(expect.idx == expect.len);
......@@ -1177,8 +1177,8 @@ void test_diff_rename__can_rename_from_rewrite(void)
cl_git_pass(git_diff_find_similar(diff, &findopts));
cl_git_pass(
git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
cl_git_pass(git_diff_foreach(
diff, test_names_expected, NULL, NULL, NULL, &expect));
cl_assert(expect.idx == expect.len);
......@@ -1210,7 +1210,7 @@ void test_diff_rename__case_changes_are_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1220,7 +1220,7 @@ void test_diff_rename__case_changes_are_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -1252,7 +1252,7 @@ void test_diff_rename__unmodified_can_be_renamed(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1262,13 +1262,13 @@ void test_diff_rename__unmodified_can_be_renamed(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -1317,7 +1317,7 @@ void test_diff_rename__rewrite_on_single_file(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
......@@ -1352,7 +1352,7 @@ void test_diff_rename__can_find_copy_to_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -1362,7 +1362,7 @@ void test_diff_rename__can_find_copy_to_split(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
......@@ -1401,7 +1401,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
......@@ -1411,7 +1411,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
......@@ -1451,7 +1451,7 @@ void test_diff_rename__matches_config_behavior(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1465,7 +1465,7 @@ void test_diff_rename__matches_config_behavior(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1479,7 +1479,7 @@ void test_diff_rename__matches_config_behavior(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -1492,7 +1492,7 @@ void test_diff_rename__matches_config_behavior(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, NULL));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -1535,7 +1535,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -1549,7 +1549,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -1590,7 +1590,7 @@ void test_diff_rename__by_config_doesnt_mess_with_whitespace_settings(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_find_similar(diff, &opts));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -1631,7 +1631,7 @@ static void expect_files_renamed(const char *one, const char *two, uint32_t whit
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
......@@ -1686,7 +1686,7 @@ static void expect_files_not_renamed(const char *one, const char *two, uint32_t
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
......
tests/diff/submodules.c
......@@ -465,7 +465,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
git_diff_free(diff);
......@@ -478,7 +478,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
git_diff_free(diff);
......@@ -488,7 +488,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
git_diff_free(diff);
......
tests/diff/tree.c
......@@ -49,7 +49,7 @@ void test_diff_tree__0(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(5, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
......@@ -71,7 +71,7 @@ void test_diff_tree__0(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(2, expect.files);
cl_assert_equal_i(0, expect.file_status[GIT_DELTA_ADDED]);
......@@ -158,7 +158,7 @@ void test_diff_tree__options(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, d, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &actual));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &actual));
expected = &test_expects[i];
cl_assert_equal_i(actual.files, expected->files);
......@@ -194,7 +194,7 @@ void test_diff_tree__bare(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(3, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
......@@ -235,7 +235,7 @@ void test_diff_tree__merge(void)
git_diff_free(diff2);
cl_git_pass(git_diff_foreach(
diff1, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
diff1, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(6, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
......@@ -332,7 +332,7 @@ void process_tree_to_tree_diffing(
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, NULL, NULL, &expect));
diff, diff_file_cb, NULL, NULL, NULL, &expect));
}
void test_diff_tree__symlink_blob_mode_changed_to_regular_file(void)
......@@ -441,8 +441,8 @@ void test_diff_tree__issue_1397(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(1, expect.files);
cl_assert_equal_i(0, expect.file_status[GIT_DELTA_DELETED]);
......@@ -472,8 +472,8 @@ void test_diff_tree__diff_configs(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(2, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
......@@ -492,8 +492,8 @@ void test_diff_tree__diff_configs(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(2, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
......@@ -513,8 +513,8 @@ void test_diff_tree__diff_configs(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
cl_assert_equal_i(2, expect.files);
cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
......
tests/diff/workdir.c
......@@ -30,10 +30,10 @@ void test_diff_workdir__to_index(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
/* to generate these values:
* - cd to tests/resources/status,
......@@ -94,7 +94,7 @@ void test_diff_workdir__to_index_with_conflicts(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, &opts));
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(9, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -129,7 +129,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(8, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
......@@ -158,7 +158,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(3, exp.file_status[GIT_DELTA_DELETED]);
......@@ -205,10 +205,10 @@ void test_diff_workdir__to_tree(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(14, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -241,10 +241,10 @@ void test_diff_workdir__to_tree(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(15, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
......@@ -278,10 +278,10 @@ void test_diff_workdir__to_tree(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(16, exp.files);
cl_assert_equal_i(5, exp.file_status[GIT_DELTA_ADDED]);
......@@ -312,7 +312,7 @@ void test_diff_workdir__to_tree(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(16, exp.files);
cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);
......@@ -359,9 +359,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
else
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(13, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -382,9 +382,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
else
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -405,9 +405,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
else
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -428,9 +428,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
else
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -465,10 +465,10 @@ void test_diff_workdir__filemode_changes(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -488,10 +488,10 @@ void test_diff_workdir__filemode_changes(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -521,7 +521,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -536,8 +536,8 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_git_pass(git_diff_foreach(diff,
diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -580,10 +580,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -601,10 +601,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -624,10 +624,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -666,10 +666,10 @@ void test_diff_workdir__eof_newline_changes(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -693,10 +693,10 @@ void test_diff_workdir__eof_newline_changes(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -720,10 +720,10 @@ void test_diff_workdir__eof_newline_changes(void)
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
else
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -913,7 +913,7 @@ void test_diff_workdir__submodules(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
/* so "git diff 873585" returns:
* M .gitmodules
......@@ -991,7 +991,7 @@ void test_diff_workdir__to_null_tree(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(exp.files, exp.file_status[GIT_DELTA_UNTRACKED]);
......@@ -1080,7 +1080,7 @@ void test_diff_workdir__to_index_issue_1397(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.hunks);
......@@ -1096,7 +1096,7 @@ void test_diff_workdir__to_index_issue_1397(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
......@@ -1133,7 +1133,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.hunks);
......@@ -1149,7 +1149,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.hunks);
......@@ -1203,7 +1203,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1223,7 +1223,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1243,7 +1243,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1267,7 +1267,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1290,7 +1290,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1310,7 +1310,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1333,7 +1333,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1354,7 +1354,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1505,7 +1505,7 @@ void test_diff_workdir__with_stale_index(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(17, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......@@ -1527,7 +1527,7 @@ void test_diff_workdir__with_stale_index(void)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
git_diff_free(diff);
......@@ -1568,7 +1568,7 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
*out, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
*out, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
cl_assert_equal_i(13, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
......
tests/stress/diff.c
......@@ -37,7 +37,7 @@ static void test_with_many(int expected_new)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(expected_new + 1, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(expected_new + 2, exp.files);
......@@ -47,7 +47,7 @@ static void test_with_many(int expected_new)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
cl_assert_equal_i(expected_new, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(expected_new + 1, exp.files);
......@@ -63,7 +63,7 @@ static void test_with_many(int expected_new)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
cl_assert_equal_i(expected_new + 1, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(expected_new + 2, exp.files);
......@@ -73,7 +73,7 @@ static void test_with_many(int expected_new)
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
diff, diff_file_cb, NULL, NULL, &exp));
diff, diff_file_cb, NULL, NULL, NULL, &exp));
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
cl_assert_equal_i(expected_new, exp.file_status[GIT_DELTA_ADDED]);
cl_assert_equal_i(expected_new + 1, exp.files);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment