proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-05-29 15:10:02 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1151 from arrbee/fix-diff-constructor-names

Browse Source 
Fix diff constructor names
This commit is contained in:
Vicent Martí 2012-12-17 11:10:25 -08:00
commit e62171e2fc
11 changed files with 159 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/Makefile
View File

@ -1,7 +1,7 @@
.PHONY: all .PHONY: all
CC = gcc CC = gcc
CFLAGS = -g -I../include -I../src -Wall -Wextra -Wmissing-prototypes CFLAGS = -g -I../include -I../src -Wall -Wextra -Wmissing-prototypes -Wno-missing-field-initializers
LFLAGS = -L../build -lgit2 -lz LFLAGS = -L../build -lgit2 -lz
APPS = general showindex diff APPS = general showindex diff

14
examples/diff.c
View File

@ -110,12 +110,12 @@ static int check_uint16_param(const char *arg, const char *pattern, uint16_t *va
return 1; return 1;
} }
static int check_str_param(const char *arg, const char *pattern, char **val) static int check_str_param(const char *arg, const char *pattern, const char **val)
{ {
size_t len = strlen(pattern); size_t len = strlen(pattern);
if (strncmp(arg, pattern, len)) if (strncmp(arg, pattern, len))
return 0; return 0;
*val = (char *)(arg + len); *val = (const char *)(arg + len);
return 1; return 1;
} }
@ -206,20 +206,20 @@ int main(int argc, char *argv[])
if (t1 && t2) if (t1 && t2)
check(git_diff_tree_to_tree(&diff, repo, t1, t2, &opts), "Diff"); check(git_diff_tree_to_tree(&diff, repo, t1, t2, &opts), "Diff");
else if (t1 && cached) else if (t1 && cached)
check(git_diff_index_to_tree(&diff, repo, t1, NULL, &opts), "Diff"); check(git_diff_tree_to_index(&diff, repo, t1, NULL, &opts), "Diff");
else if (t1) { else if (t1) {
git_diff_list *diff2; git_diff_list *diff2;
check(git_diff_index_to_tree(&diff, repo, t1, NULL, &opts), "Diff"); check(git_diff_tree_to_index(&diff, repo, t1, NULL, &opts), "Diff");
check(git_diff_workdir_to_index(&diff2, repo, NULL, &opts), "Diff"); check(git_diff_index_to_workdir(&diff2, repo, NULL, &opts), "Diff");
check(git_diff_merge(diff, diff2), "Merge diffs"); check(git_diff_merge(diff, diff2), "Merge diffs");
git_diff_list_free(diff2); git_diff_list_free(diff2);
} }
else if (cached) { else if (cached) {
check(resolve_to_tree(repo, "HEAD", &t1), "looking up HEAD"); check(resolve_to_tree(repo, "HEAD", &t1), "looking up HEAD");
check(git_diff_index_to_tree(&diff, repo, t1, NULL, &opts), "Diff"); check(git_diff_tree_to_index(&diff, repo, t1, NULL, &opts), "Diff");
} }
else else
check(git_diff_workdir_to_index(&diff, repo, NULL, &opts), "Diff"); check(git_diff_index_to_workdir(&diff, repo, NULL, &opts), "Diff");
if (color >= 0) if (color >= 0)
fputs(colors[0], stdout); fputs(colors[0], stdout);

151
include/git2/diff.h
View File

@ -139,7 +139,8 @@ typedef enum {
* - `new_prefix` is the virtual "directory" to prefix to new file names * - `new_prefix` is the virtual "directory" to prefix to new file names
* in hunk headers (default "b") * in hunk headers (default "b")
* - `pathspec` is an array of paths / fnmatch patterns to constrain diff * - `pathspec` is an array of paths / fnmatch patterns to constrain diff
* - `max_size` is a file size above which a blob will be marked as binary * - `max_size` is a file size (in bytes) above which a blob will be marked
* as binary automatically; pass a negative value to disable.
*/ */
typedef struct { typedef struct {
unsigned int version; /**< version for the struct */ unsigned int version; /**< version for the struct */
@ -148,8 +149,8 @@ typedef struct {
uint16_t interhunk_lines; /**< defaults to 0 */ uint16_t interhunk_lines; /**< defaults to 0 */
const char *old_prefix; /**< defaults to "a" */ const char *old_prefix; /**< defaults to "a" */
const char *new_prefix; /**< defaults to "b" */ const char *new_prefix; /**< defaults to "b" */
git_strarray pathspec; /**< defaults to show all paths */ git_strarray pathspec; /**< defaults to include all paths */
git_off_t max_size; /**< defaults to 512mb */ git_off_t max_size; /**< defaults to 512MB */
} git_diff_options; } git_diff_options;
#define GIT_DIFF_OPTIONS_VERSION 1 #define GIT_DIFF_OPTIONS_VERSION 1
@ -157,14 +158,19 @@ typedef struct {
/** /**
* The diff list object that contains all individual file deltas. * The diff list object that contains all individual file deltas.
*
* This is an opaque structure which will be allocated by one of the diff
* generator functions below (such as `git_diff_tree_to_tree`). You are
* responsible for releasing the object memory when done, using the
* `git_diff_list_free()` function.
*/ */
typedef struct git_diff_list git_diff_list; typedef struct git_diff_list git_diff_list;
/** /**
* Flags that can be set for the file on side of a diff. * Flags for the file object on each side of a diff.
* *
* Most of the flags are just for internal consumption by libgit2, * Note: most of these flags are just for **internal** consumption by
* but some of them may be interesting to external users. * libgit2, but some of them may be interesting to external users.
*/ */
typedef enum { typedef enum {
GIT_DIFF_FILE_VALID_OID = (1 << 0), /** `oid` value is known correct */ GIT_DIFF_FILE_VALID_OID = (1 << 0), /** `oid` value is known correct */
@ -187,34 +193,38 @@ typedef enum {
* DELETED pairs). * DELETED pairs).
*/ */
typedef enum { typedef enum {
GIT_DELTA_UNMODIFIED = 0, GIT_DELTA_UNMODIFIED = 0, /** no changes */
GIT_DELTA_ADDED = 1, GIT_DELTA_ADDED = 1, /** entry does not exist in old version */
GIT_DELTA_DELETED = 2, GIT_DELTA_DELETED = 2, /** entry does not exist in new version */
GIT_DELTA_MODIFIED = 3, GIT_DELTA_MODIFIED = 3, /** entry content changed between old and new */
GIT_DELTA_RENAMED = 4, GIT_DELTA_RENAMED = 4, /** entry was renamed between old and new */
GIT_DELTA_COPIED = 5, GIT_DELTA_COPIED = 5, /** entry was copied from another old entry */
GIT_DELTA_IGNORED = 6, GIT_DELTA_IGNORED = 6, /** entry is ignored item in workdir */
GIT_DELTA_UNTRACKED = 7, GIT_DELTA_UNTRACKED = 7, /** entry is untracked item in workdir */
GIT_DELTA_TYPECHANGE = 8, GIT_DELTA_TYPECHANGE = 8, /** type of entry changed between old and new */
} git_delta_t; } git_delta_t;
/** /**
* Description of one side of a diff. * Description of one side of a diff entry.
* *
* The `oid` is the `git_oid` of the item. If it represents an absent side * Although this is called a "file", it may actually represent a file, a
* of a diff (e.g. the `old_file` of a `GIT_DELTA_ADDED` delta), then the * symbolic link, a submodule commit id, or even a tree (although that only
* oid will be zeroes. * if you are tracking type changes or ignored/untracked directories).
* *
* `path` is the NUL-terminated path to the file relative to the working * The `oid` is the `git_oid` of the item. If the entry represents an
* absent side of a diff (e.g. the `old_file` of a `GIT_DELTA_ADDED` delta),
* then the oid will be zeroes.
*
* `path` is the NUL-terminated path to the entry relative to the working
* directory of the repository. * directory of the repository.
* *
* `size` is the size of the file in bytes. * `size` is the size of the entry in bytes.
* *
* `flags` is a combination of the `git_diff_file_flag_t` types, but those * `flags` is a combination of the `git_diff_file_flag_t` types, but those
* are largely internal values. * are largely internal values.
* *
* `mode` is, roughly, the stat() st_mode value for the item. This will be * `mode` is, roughly, the stat() `st_mode` value for the item. This will
* restricted to one of the `git_filemode_t` values. * be restricted to one of the `git_filemode_t` values.
*/ */
typedef struct { typedef struct {
git_oid oid; git_oid oid;
@ -225,17 +235,27 @@ typedef struct {
} git_diff_file; } git_diff_file;
/** /**
* Description of changes to one file. * Description of changes to one entry.
* *
* When iterating over a diff list object, this will generally be passed to * When iterating over a diff list object, this will be passed to most
* most callback functions and you can use the contents to understand * callback functions and you can use the contents to understand exactly
* exactly what has changed. * what has changed.
* *
* Under some circumstances, not all fields will be filled in, but the code * The `old_file` repesents the "from" side of the diff and the `new_file`
* generally tries to fill in as much as possible. One example is that the * repesents to "to" side of the diff. What those means depend on the
* "binary" field will not actually look at file contents if you do not * function that was used to generate the diff and will be documented below.
* pass in hunk and/or line callbacks to the diff foreach iteration function. * You can also use the `GIT_DIFF_REVERSE` flag to flip it around.
* It will just use the git attributes for those files. *
* Although the two sides of the delta are named "old_file" and "new_file",
* they actually may correspond to entries that represent a file, a symbolic
* link, a submodule commit id, or even a tree (if you are tracking type
* changes or ignored/untracked directories).
*
* Under some circumstances, in the name of efficiency, not all fields will
* be filled in, but we generally try to fill in as much as possible. One
* example is that the "binary" field will not examine file contents if you
* do not pass in hunk and/or line callbacks to the diff foreach iteration
* function. It will just use the git attributes for those files.
*/ */
typedef struct { typedef struct {
git_diff_file old_file; git_diff_file old_file;
@ -247,6 +267,10 @@ typedef struct {
/** /**
* When iterating over a diff, callback that will be made per file. * When iterating over a diff, callback that will be made per file.
*
* @param delta A pointer to the delta data for the file
* @param progress Goes from 0 to 1 over the diff list
* @param payload User-specified pointer from foreach function
*/ */
typedef int (*git_diff_file_cb)( typedef int (*git_diff_file_cb)(
const git_diff_delta *delta, const git_diff_delta *delta,
@ -257,10 +281,10 @@ typedef int (*git_diff_file_cb)(
* Structure describing a hunk of a diff. * Structure describing a hunk of a diff.
*/ */
typedef struct { typedef struct {
int old_start; int old_start; /** Starting line number in old_file */
int old_lines; int old_lines; /** Number of lines in old_file */
int new_start; int new_start; /** Starting line number in new_file */
int new_lines; int new_lines; /** Number of lines in new_file */
} git_diff_range; } git_diff_range;
/** /**
@ -308,12 +332,12 @@ typedef enum {
* of lines of file and hunk headers. * of lines of file and hunk headers.
*/ */
typedef int (*git_diff_data_cb)( typedef int (*git_diff_data_cb)(
const git_diff_delta *delta, const git_diff_delta *delta, /** delta that contains this data */
const git_diff_range *range, const git_diff_range *range, /** range of lines containing this data */
char line_origin, /**< GIT_DIFF_LINE_... value from above */ char line_origin, /** git_diff_list_t value from above */
const char *content, const char *content, /** diff data - not NUL terminated */
size_t content_len, size_t content_len, /** number of bytes of diff data */
void *payload); void *payload); /** user reference data */
/** /**
* The diff patch is used to store all the text diffs for a delta. * The diff patch is used to store all the text diffs for a delta.
@ -381,9 +405,12 @@ typedef struct {
GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff); GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff);
/** /**
* Compute a difference between two tree objects. * Create a diff list with the difference between two tree objects.
* *
* This is equivalent to `git diff <treeish> <treeish>` * This is equivalent to `git diff <old-tree> <new-tree>`
*
* The first tree will be used for the "old_file" side of the delta and the
* second tree will be used for the "new_file" side of the delta.
* *
* @param diff Output pointer to a git_diff_list pointer to be allocated. * @param diff Output pointer to a git_diff_list pointer to be allocated.
* @param repo The repository containing the trees. * @param repo The repository containing the trees.
@ -399,18 +426,21 @@ GIT_EXTERN(int) git_diff_tree_to_tree(
const git_diff_options *opts); /**< can be NULL for defaults */ const git_diff_options *opts); /**< can be NULL for defaults */
/** /**
* Compute a difference between a tree and the repository index. * Create a diff list between a tree and repository index.
* *
* This is equivalent to `git diff --cached <treeish>` or if you pass * This is equivalent to `git diff --cached <treeish>` or if you pass
* the HEAD tree, then like `git diff --cached`. * the HEAD tree, then like `git diff --cached`.
* *
* The tree you pass will be used for the "old_file" side of the delta, and
* the index will be used for the "new_file" side of the delta.
*
* @param diff Output pointer to a git_diff_list pointer to be allocated. * @param diff Output pointer to a git_diff_list pointer to be allocated.
* @param repo The repository containing the tree and index. * @param repo The repository containing the tree and index.
* @param old_tree A git_tree object to diff from. * @param old_tree A git_tree object to diff from.
* @param index The index to diff with; repo index used if NULL. * @param index The index to diff with; repo index used if NULL.
* @param opts Structure with options to influence diff or NULL for defaults. * @param opts Structure with options to influence diff or NULL for defaults.
*/ */
GIT_EXTERN(int) git_diff_index_to_tree( GIT_EXTERN(int) git_diff_tree_to_index(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_tree *old_tree, git_tree *old_tree,
@ -418,40 +448,45 @@ GIT_EXTERN(int) git_diff_index_to_tree(
const git_diff_options *opts); /**< can be NULL for defaults */ const git_diff_options *opts); /**< can be NULL for defaults */
/** /**
* Compute a difference between the working directory and the repository index. * Create a diff list between the repository index and the workdir directory.
* *
* This matches the `git diff` command. See the note below on * This matches the `git diff` command. See the note below on
* `git_diff_workdir_to_tree` for a discussion of the difference between * `git_diff_tree_to_workdir` for a discussion of the difference between
* `git diff` and `git diff HEAD` and how to emulate a `git diff <treeish>` * `git diff` and `git diff HEAD` and how to emulate a `git diff <treeish>`
* using libgit2. * using libgit2.
* *
* The index will be used for the "old_file" side of the delta, and the
* working directory will be used for the "new_file" side of the delta.
*
* @param diff Output pointer to a git_diff_list pointer to be allocated. * @param diff Output pointer to a git_diff_list pointer to be allocated.
* @param repo The repository. * @param repo The repository.
* @param index The index to diff from; repo index used if NULL. * @param index The index to diff from; repo index used if NULL.
* @param opts Structure with options to influence diff or NULL for defaults. * @param opts Structure with options to influence diff or NULL for defaults.
*/ */
GIT_EXTERN(int) git_diff_workdir_to_index( GIT_EXTERN(int) git_diff_index_to_workdir(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_index *index, git_index *index,
const git_diff_options *opts); /**< can be NULL for defaults */ const git_diff_options *opts); /**< can be NULL for defaults */
/** /**
* Compute a difference between the working directory and a tree. * Create a diff list between a tree and the working directory.
* *
* This is *NOT* the same as `git diff <treeish>`. Running `git diff HEAD` * The tree you provide will be used for the "old_file" side of the delta,
* or the like actually uses information from the index, along with the tree * and the working directory will be used for the "new_file" side.
* and workdir dir info. *
* Please note: this is *NOT* the same as `git diff <treeish>`. Running
* `git diff HEAD` or the like actually uses information from the index,
* along with the tree and working directory info.
* *
* This function returns strictly the differences between the tree and the * This function returns strictly the differences between the tree and the
* files contained in the working directory, regardless of the state of * files contained in the working directory, regardless of the state of
* files in the index. It may come as a surprise, but there is no direct * files in the index. It may come as a surprise, but there is no direct
* equivalent in core git. * equivalent in core git.
* *
* To emulate `git diff <treeish>`, you should call both * To emulate `git diff <treeish>`, call both `git_diff_tree_to_index` and
* `git_diff_index_to_tree` and `git_diff_workdir_to_index`, then call * `git_diff_index_to_workdir`, then call `git_diff_merge` on the results.
* `git_diff_merge` on the results. That will yield a `git_diff_list` that * That will yield a `git_diff_list` that matches the git output.
* matches the git output.
* *
* If this seems confusing, take the case of a file with a staged deletion * If this seems confusing, take the case of a file with a staged deletion
* where the file has then been put back into the working dir and modified. * where the file has then been put back into the working dir and modified.
@ -463,7 +498,7 @@ GIT_EXTERN(int) git_diff_workdir_to_index(
* @param old_tree A git_tree object to diff from. * @param old_tree A git_tree object to diff from.
* @param opts Structure with options to influence diff or NULL for defaults. * @param opts Structure with options to influence diff or NULL for defaults.
*/ */
GIT_EXTERN(int) git_diff_workdir_to_tree( GIT_EXTERN(int) git_diff_tree_to_workdir(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_tree *old_tree, git_tree *old_tree,

2
src/checkout.c
View File

@ -632,7 +632,7 @@ int git_checkout_index(
if (opts && opts->paths.count > 0) if (opts && opts->paths.count > 0)
diff_opts.pathspec = opts->paths; diff_opts.pathspec = opts->paths;
if ((error = git_diff_workdir_to_index(&diff, repo, index, &diff_opts)) < 0) if ((error = git_diff_index_to_workdir(&diff, repo, index, &diff_opts)) < 0)
goto cleanup; goto cleanup;
if ((error = git_buf_puts(&workdir, git_repository_workdir(repo))) < 0) if ((error = git_buf_puts(&workdir, git_repository_workdir(repo))) < 0)

6
src/diff.c
View File

@ -784,7 +784,7 @@ int git_diff_tree_to_tree(
return error; return error;
} }
int git_diff_index_to_tree( int git_diff_tree_to_index(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_tree *old_tree, git_tree *old_tree,
@ -806,7 +806,7 @@ int git_diff_index_to_tree(
return error; return error;
} }
int git_diff_workdir_to_index( int git_diff_index_to_workdir(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_index *index, git_index *index,
@ -828,7 +828,7 @@ int git_diff_workdir_to_index(
} }
int git_diff_workdir_to_tree( int git_diff_tree_to_workdir(
git_diff_list **diff, git_diff_list **diff,
git_repository *repo, git_repository *repo,
git_tree *old_tree, git_tree *old_tree,

6
src/stash.c
View File

@ -251,7 +251,7 @@ static int build_untracked_tree(
if (git_commit_tree(&i_tree, i_commit) < 0) if (git_commit_tree(&i_tree, i_commit) < 0)
goto cleanup; goto cleanup;
if (git_diff_workdir_to_tree(&diff, git_index_owner(index), i_tree, &opts) < 0) if (git_diff_tree_to_workdir(&diff, git_index_owner(index), i_tree, &opts) < 0)
goto cleanup; goto cleanup;
if (git_diff_foreach(diff, update_index_cb, NULL, NULL, &data) < 0) if (git_diff_foreach(diff, update_index_cb, NULL, NULL, &data) < 0)
@ -323,10 +323,10 @@ static int build_workdir_tree(
if (git_commit_tree(&b_tree, b_commit) < 0) if (git_commit_tree(&b_tree, b_commit) < 0)
goto cleanup; goto cleanup;
if (git_diff_index_to_tree(&diff, repo, b_tree, NULL, &opts) < 0) if (git_diff_tree_to_index(&diff, repo, b_tree, NULL, &opts) < 0)
goto cleanup; goto cleanup;
if (git_diff_workdir_to_index(&diff2, repo, NULL, &opts) < 0) if (git_diff_index_to_workdir(&diff2, repo, NULL, &opts) < 0)
goto cleanup; goto cleanup;
if (git_diff_merge(diff, diff2) < 0) if (git_diff_merge(diff, diff2) < 0)

4
src/status.c
View File

@ -145,11 +145,11 @@ int git_status_foreach_ext(
/* TODO: support EXCLUDE_SUBMODULES flag */ /* TODO: support EXCLUDE_SUBMODULES flag */
if (show != GIT_STATUS_SHOW_WORKDIR_ONLY && if (show != GIT_STATUS_SHOW_WORKDIR_ONLY &&
(err = git_diff_index_to_tree(&idx2head, repo, head, NULL, &diffopt)) < 0) (err = git_diff_tree_to_index(&idx2head, repo, head, NULL, &diffopt)) < 0)
goto cleanup; goto cleanup;
if (show != GIT_STATUS_SHOW_INDEX_ONLY && if (show != GIT_STATUS_SHOW_INDEX_ONLY &&
(err = git_diff_workdir_to_index(&wd2idx, repo, NULL, &diffopt)) < 0) (err = git_diff_index_to_workdir(&wd2idx, repo, NULL, &diffopt)) < 0)
goto cleanup; goto cleanup;
usercb.cb = cb; usercb.cb = cb;

4
src/submodule.c
View File

@ -1454,7 +1454,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
if (sm->ignore == GIT_SUBMODULE_IGNORE_NONE) if (sm->ignore == GIT_SUBMODULE_IGNORE_NONE)
opt.flags |= GIT_DIFF_INCLUDE_UNTRACKED; opt.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
error = git_diff_index_to_tree(&diff, sm_repo, sm_head, NULL, &opt); error = git_diff_tree_to_index(&diff, sm_repo, sm_head, NULL, &opt);
if (!error) { if (!error) {
if (git_diff_num_deltas(diff) > 0) if (git_diff_num_deltas(diff) > 0)
@ -1471,7 +1471,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
/* perform index-to-workdir diff on submodule */ /* perform index-to-workdir diff on submodule */
error = git_diff_workdir_to_index(&diff, sm_repo, NULL, &opt); error = git_diff_index_to_workdir(&diff, sm_repo, NULL, &opt);
if (!error) { if (!error) {
size_t untracked = size_t untracked =

22
tests-clar/diff/diffiter.c
View File

@ -16,7 +16,7 @@ void test_diff_diffiter__create(void)
git_diff_list *diff; git_diff_list *diff;
size_t d, num_d; size_t d, num_d;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, NULL));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) { for (d = 0; d < num_d; ++d) {
@ -34,7 +34,7 @@ void test_diff_diffiter__iterate_files(void)
size_t d, num_d; size_t d, num_d;
int count = 0; int count = 0;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, NULL));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(6, (int)num_d); cl_assert_equal_i(6, (int)num_d);
@ -57,7 +57,7 @@ void test_diff_diffiter__iterate_files_2(void)
size_t d, num_d; size_t d, num_d;
int count = 0; int count = 0;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, NULL));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(8, (int)num_d); cl_assert_equal_i(8, (int)num_d);
@ -85,7 +85,7 @@ void test_diff_diffiter__iterate_files_and_hunks(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
@ -138,7 +138,7 @@ void test_diff_diffiter__max_size_threshold(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) { for (d = 0; d < num_d; ++d) {
@ -173,7 +173,7 @@ void test_diff_diffiter__max_size_threshold(void)
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
opts.max_size = 50; /* treat anything over 50 bytes as binary! */ opts.max_size = 50; /* treat anything over 50 bytes as binary! */
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) { for (d = 0; d < num_d; ++d) {
@ -216,7 +216,7 @@ void test_diff_diffiter__iterate_all(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) { for (d = 0; d < num_d; ++d) {
@ -292,7 +292,7 @@ void test_diff_diffiter__iterate_randomly_while_saving_state(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
@ -419,7 +419,7 @@ void test_diff_diffiter__iterate_and_generate_patch_text(void)
git_diff_list *diff; git_diff_list *diff;
size_t d, num_d; size_t d, num_d;
cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, NULL));
num_d = git_diff_num_deltas(diff); num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(8, (int)num_d); cl_assert_equal_i(8, (int)num_d);
@ -452,13 +452,13 @@ void test_diff_diffiter__checks_options_version(void)
opts.version = 0; opts.version = 0;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_fail(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_fail(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
giterr_clear(); giterr_clear();
opts.version = 1024; opts.version = 1024;
cl_git_fail(git_diff_workdir_to_index(&diff, repo, NULL, &opts)); cl_git_fail(git_diff_index_to_workdir(&diff, repo, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
} }

10
tests-clar/diff/index.c
View File

@ -32,7 +32,7 @@ void test_diff_index__0(void)
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
cl_git_pass(git_diff_foreach( cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp)); diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
@ -60,7 +60,7 @@ void test_diff_index__0(void)
diff = NULL; diff = NULL;
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, b, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
cl_git_pass(git_diff_foreach( cl_git_pass(git_diff_foreach(
diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp)); diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
@ -125,7 +125,7 @@ void test_diff_index__1(void)
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
cl_assert_equal_i( cl_assert_equal_i(
GIT_EUSER, GIT_EUSER,
@ -150,13 +150,13 @@ void test_diff_index__checks_options_version(void)
const git_error *err; const git_error *err;
opts.version = 0; opts.version = 0;
cl_git_fail(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts)); cl_git_fail(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
giterr_clear(); giterr_clear();
opts.version = 1024; opts.version = 1024;
cl_git_fail(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts)); cl_git_fail(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
} }

62
tests-clar/diff/workdir.c
View File

@ -26,7 +26,7 @@ void test_diff_workdir__to_index(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -84,7 +84,7 @@ void test_diff_workdir__to_tree(void)
opts.interhunk_lines = 1; opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
/* You can't really generate the equivalent of git_diff_workdir_to_tree() /* You can't really generate the equivalent of git_diff_tree_to_workdir()
* using C git. It really wants to interpose the index into the diff. * using C git. It really wants to interpose the index into the diff.
* *
* To validate the following results with command line git, I ran the * To validate the following results with command line git, I ran the
@ -94,7 +94,7 @@ void test_diff_workdir__to_tree(void)
* The results are documented at the bottom of this file in the * The results are documented at the bottom of this file in the
* long comment entitled "PREPARATION OF TEST DATA". * long comment entitled "PREPARATION OF TEST DATA".
*/ */
cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -127,8 +127,8 @@ void test_diff_workdir__to_tree(void)
* a workdir to tree diff (even though it is not really). This is what * a workdir to tree diff (even though it is not really). This is what
* you would get from "git diff --name-status 26a125ee1bf" * you would get from "git diff --name-status 26a125ee1bf"
*/ */
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
cl_git_pass(git_diff_workdir_to_index(&diff2, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));
cl_git_pass(git_diff_merge(diff, diff2)); cl_git_pass(git_diff_merge(diff, diff2));
git_diff_list_free(diff2); git_diff_list_free(diff2);
@ -164,8 +164,8 @@ void test_diff_workdir__to_tree(void)
/* Again, emulating "git diff <sha>" for testing purposes using /* Again, emulating "git diff <sha>" for testing purposes using
* "git diff --name-status 0017bd4ab1ec3" instead. * "git diff --name-status 0017bd4ab1ec3" instead.
*/ */
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, b, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
cl_git_pass(git_diff_workdir_to_index(&diff2, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));
cl_git_pass(git_diff_merge(diff, diff2)); cl_git_pass(git_diff_merge(diff, diff2));
git_diff_list_free(diff2); git_diff_list_free(diff2);
@ -216,7 +216,7 @@ void test_diff_workdir__to_index_with_pathspec(void)
opts.pathspec.strings = &pathspec; opts.pathspec.strings = &pathspec;
opts.pathspec.count = 1; opts.pathspec.count = 1;
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -239,7 +239,7 @@ void test_diff_workdir__to_index_with_pathspec(void)
pathspec = "modified_file"; pathspec = "modified_file";
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -262,7 +262,7 @@ void test_diff_workdir__to_index_with_pathspec(void)
pathspec = "subdir"; pathspec = "subdir";
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -285,7 +285,7 @@ void test_diff_workdir__to_index_with_pathspec(void)
pathspec = "*_deleted"; pathspec = "*_deleted";
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -324,7 +324,7 @@ void test_diff_workdir__filemode_changes(void)
/* test once with no mods */ /* test once with no mods */
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -347,7 +347,7 @@ void test_diff_workdir__filemode_changes(void)
cl_assert(cl_toggle_filemode("issue_592/a.txt")); cl_assert(cl_toggle_filemode("issue_592/a.txt"));
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -386,7 +386,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
/* test once with no mods */ /* test once with no mods */
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach( cl_git_pass(git_diff_foreach(
@ -402,7 +402,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
cl_assert(cl_toggle_filemode("issue_592/a.txt")); cl_assert(cl_toggle_filemode("issue_592/a.txt"));
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, NULL)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach( cl_git_pass(git_diff_foreach(
@ -442,8 +442,8 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
opts.pathspec.strings = &pathspec; opts.pathspec.strings = &pathspec;
opts.pathspec.count = 1; opts.pathspec.count = 1;
cl_git_pass(git_diff_index_to_tree(&diff_i2t, g_repo, tree, NULL, &opts)); cl_git_pass(git_diff_tree_to_index(&diff_i2t, g_repo, tree, NULL, &opts));
cl_git_pass(git_diff_workdir_to_index(&diff_w2i, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff_w2i, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -529,7 +529,7 @@ void test_diff_workdir__eof_newline_changes(void)
opts.pathspec.strings = &pathspec; opts.pathspec.strings = &pathspec;
opts.pathspec.count = 1; opts.pathspec.count = 1;
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -556,7 +556,7 @@ void test_diff_workdir__eof_newline_changes(void)
cl_git_append2file("status/current_file", "\n"); cl_git_append2file("status/current_file", "\n");
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -583,7 +583,7 @@ void test_diff_workdir__eof_newline_changes(void)
cl_git_rewritefile("status/current_file", "current_file"); cl_git_rewritefile("status/current_file", "current_file");
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
for (use_iterator = 0; use_iterator <= 1; use_iterator++) { for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -611,7 +611,7 @@ void test_diff_workdir__eof_newline_changes(void)
/* PREPARATION OF TEST DATA /* PREPARATION OF TEST DATA
* *
* Since there is no command line equivalent of git_diff_workdir_to_tree, * Since there is no command line equivalent of git_diff_tree_to_workdir,
* it was a bit of a pain to confirm that I was getting the expected * it was a bit of a pain to confirm that I was getting the expected
* results in the first part of this tests. Here is what I ended up * results in the first part of this tests. Here is what I ended up
* doing to set my expectation for the file counts and results: * doing to set my expectation for the file counts and results:
@ -699,13 +699,13 @@ void test_diff_workdir__larger_hunks(void)
/* okay, this is a bit silly, but oh well */ /* okay, this is a bit silly, but oh well */
switch (i) { switch (i) {
case 0: case 0:
cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
break; break;
case 1: case 1:
cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
break; break;
case 2: case 2:
cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, b, &opts)); cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, b, &opts));
break; break;
} }
@ -748,7 +748,7 @@ void test_diff_workdir__larger_hunks(void)
/* Set up a test that exercises this code. The easiest test using existing /* Set up a test that exercises this code. The easiest test using existing
* test data is probably to create a sandbox of submod2 and then run a * test data is probably to create a sandbox of submod2 and then run a
* git_diff_workdir_to_tree against tree * git_diff_tree_to_workdir against tree
* 873585b94bdeabccea991ea5e3ec1a277895b698. As for what you should actually * 873585b94bdeabccea991ea5e3ec1a277895b698. As for what you should actually
* test, you can start by just checking that the number of lines of diff * test, you can start by just checking that the number of lines of diff
* content matches the actual output of git diff. That will at least * content matches the actual output of git diff. That will at least
@ -784,7 +784,7 @@ void test_diff_workdir__submodules(void)
GIT_DIFF_RECURSE_UNTRACKED_DIRS | GIT_DIFF_RECURSE_UNTRACKED_DIRS |
GIT_DIFF_INCLUDE_UNTRACKED_CONTENT; GIT_DIFF_INCLUDE_UNTRACKED_CONTENT;
cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
/* diff_print(stderr, diff); */ /* diff_print(stderr, diff); */
@ -829,12 +829,12 @@ void test_diff_workdir__cannot_diff_against_a_bare_repository(void)
g_repo = cl_git_sandbox_init("testrepo.git"); g_repo = cl_git_sandbox_init("testrepo.git");
cl_assert_equal_i( cl_assert_equal_i(
GIT_EBAREREPO, git_diff_workdir_to_index(&diff, g_repo, NULL, &opts)); GIT_EBAREREPO, git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_git_pass(git_repository_head_tree(&tree, g_repo)); cl_git_pass(git_repository_head_tree(&tree, g_repo));
cl_assert_equal_i( cl_assert_equal_i(
GIT_EBAREREPO, git_diff_workdir_to_tree(&diff, g_repo, tree, &opts)); GIT_EBAREREPO, git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
git_tree_free(tree); git_tree_free(tree);
} }
@ -850,7 +850,7 @@ void test_diff_workdir__to_null_tree(void)
g_repo = cl_git_sandbox_init("status"); g_repo = cl_git_sandbox_init("status");
cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
memset(&exp, 0, sizeof(exp)); memset(&exp, 0, sizeof(exp));
@ -871,13 +871,13 @@ void test_diff_workdir__checks_options_version(void)
g_repo = cl_git_sandbox_init("status"); g_repo = cl_git_sandbox_init("status");
opts.version = 0; opts.version = 0;
cl_git_fail(git_diff_workdir_to_tree(&diff, g_repo, NULL, &opts)); cl_git_fail(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
giterr_clear(); giterr_clear();
opts.version = 1024; opts.version = 1024;
cl_git_fail(git_diff_workdir_to_tree(&diff, g_repo, NULL, &opts)); cl_git_fail(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
err = giterr_last(); err = giterr_last();
cl_assert_equal_i(GITERR_INVALID, err->klass); cl_assert_equal_i(GITERR_INVALID, err->klass);
} }