mirror of
https://git.proxmox.com/git/libgit2
synced 2025-05-03 22:01:26 +00:00
74ded02457
This adds parameters to the four functions that allow for blob-to- blob and blob-to-buffer differencing (either via callbacks or by making a git_diff_patch object). These parameters let you say that filename we should pretend the blob has while doing the diff. If you pass NULL, there should be no change from the existing behavior, which is to skip using attributes for file type checks and just look at content. With the parameters, you can plug into the new diff driver functionality and get binary or non-binary behavior, plus function context regular expressions, etc. This commit also fixes things so that the git_diff_delta that is generated by these functions will actually be populated with the data that we know about the blobs (or buffers) so you can use it appropriately. It also fixes a bug in generating patches from the git_diff_patch objects created via these functions. Lastly, there is one other behavior change that may matter. If there is no difference between the two blobs, these functions no longer generate any diff callbacks / patches unless you have passed in GIT_DIFF_INCLUDE_UNMODIFIED. This is pretty natural, but could potentially change the behavior of existing usage.
1069 lines
33 KiB
C
1069 lines
33 KiB
C
#include "clar_libgit2.h"
|
|
#include "diff_helpers.h"
|
|
|
|
static git_repository *g_repo = NULL;
|
|
static diff_expects expected;
|
|
static git_diff_options opts;
|
|
static git_blob *d, *alien;
|
|
|
|
static void quick_diff_blob_to_str(
|
|
const git_blob *blob, const char *blob_path,
|
|
const char *str, size_t len, const char *str_path)
|
|
{
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
if (str && !len)
|
|
len = strlen(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));
|
|
}
|
|
|
|
void test_diff_blob__initialize(void)
|
|
{
|
|
git_oid oid;
|
|
|
|
g_repo = cl_git_sandbox_init("attr");
|
|
|
|
GIT_INIT_STRUCTURE(&opts, GIT_DIFF_OPTIONS_VERSION);
|
|
opts.context_lines = 1;
|
|
opts.interhunk_lines = 0;
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
/* tests/resources/attr/root_test4.txt */
|
|
cl_git_pass(git_oid_fromstrn(&oid, "a0f7217a", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&d, g_repo, &oid, 4));
|
|
|
|
/* alien.png */
|
|
cl_git_pass(git_oid_fromstrn(&oid, "edf3dcee", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&alien, g_repo, &oid, 4));
|
|
}
|
|
|
|
void test_diff_blob__cleanup(void)
|
|
{
|
|
git_blob_free(d);
|
|
d = NULL;
|
|
|
|
git_blob_free(alien);
|
|
alien = NULL;
|
|
|
|
cl_git_sandbox_cleanup();
|
|
}
|
|
|
|
void test_diff_blob__can_compare_text_blobs(void)
|
|
{
|
|
git_blob *a, *b, *c;
|
|
git_oid a_oid, b_oid, c_oid;
|
|
|
|
/* tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
|
|
|
|
/* tests/resources/attr/root_test2 */
|
|
cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4));
|
|
|
|
/* tests/resources/attr/root_test3 */
|
|
cl_git_pass(git_oid_fromstrn(&c_oid, "c96bbb2c2557a832", 16));
|
|
cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 8));
|
|
|
|
/* Doing the equivalent of a `git diff -U1` on these files */
|
|
|
|
/* diff on tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_diff_blobs(
|
|
a, NULL, b, NULL, &opts,
|
|
diff_file_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_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(6, expected.lines);
|
|
cl_assert_equal_i(1, expected.line_ctxt);
|
|
cl_assert_equal_i(5, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
/* 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));
|
|
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(15, expected.lines);
|
|
cl_assert_equal_i(3, expected.line_ctxt);
|
|
cl_assert_equal_i(9, expected.line_adds);
|
|
cl_assert_equal_i(3, expected.line_dels);
|
|
|
|
/* 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));
|
|
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(13, expected.lines);
|
|
cl_assert_equal_i(0, expected.line_ctxt);
|
|
cl_assert_equal_i(12, expected.line_adds);
|
|
cl_assert_equal_i(1, expected.line_dels);
|
|
|
|
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));
|
|
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(2, expected.hunks);
|
|
cl_assert_equal_i(14, expected.lines);
|
|
cl_assert_equal_i(4, expected.line_ctxt);
|
|
cl_assert_equal_i(6, expected.line_adds);
|
|
cl_assert_equal_i(4, expected.line_dels);
|
|
|
|
git_blob_free(a);
|
|
git_blob_free(b);
|
|
git_blob_free(c);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_text_blobs_with_patch(void)
|
|
{
|
|
git_blob *a, *b, *c;
|
|
git_oid a_oid, b_oid, c_oid;
|
|
git_diff_patch *p;
|
|
const git_diff_delta *delta;
|
|
size_t tc, ta, td;
|
|
|
|
/* tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
|
|
|
|
/* tests/resources/attr/root_test2 */
|
|
cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4));
|
|
|
|
/* tests/resources/attr/root_test3 */
|
|
cl_git_pass(git_oid_fromstrn(&c_oid, "c96bbb2c2557a832", 16));
|
|
cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 8));
|
|
|
|
/* Doing the equivalent of a `git diff -U1` on these files */
|
|
|
|
/* diff on tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, a, NULL, b, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
|
|
cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
|
|
cl_assert(git_oid_equal(git_blob_id(b), &delta->new_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(b), delta->new_file.size);
|
|
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(6, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
|
|
cl_git_pass(git_diff_patch_line_stats(&tc, &ta, &td, p));
|
|
cl_assert_equal_i(1, (int)tc);
|
|
cl_assert_equal_i(5, (int)ta);
|
|
cl_assert_equal_i(0, (int)td);
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff on tests/resources/attr/root_test2 */
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, b, NULL, c, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
|
|
cl_assert(git_oid_equal(git_blob_id(b), &delta->old_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(b), delta->old_file.size);
|
|
cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
|
|
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(15, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
|
|
cl_git_pass(git_diff_patch_line_stats(&tc, &ta, &td, p));
|
|
cl_assert_equal_i(3, (int)tc);
|
|
cl_assert_equal_i(9, (int)ta);
|
|
cl_assert_equal_i(3, (int)td);
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff on tests/resources/attr/root_test3 */
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, a, NULL, c, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
|
|
cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
|
|
cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
|
|
|
|
cl_git_pass(git_diff_patch_line_stats(&tc, &ta, &td, p));
|
|
cl_assert_equal_i(0, (int)tc);
|
|
cl_assert_equal_i(12, (int)ta);
|
|
cl_assert_equal_i(1, (int)td);
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
/* one more */
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, c, NULL, d, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
|
|
cl_assert(git_oid_equal(git_blob_id(c), &delta->old_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(c), delta->old_file.size);
|
|
cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(d), delta->new_file.size);
|
|
|
|
cl_assert_equal_i(2, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(5, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
cl_assert_equal_i(9, git_diff_patch_num_lines_in_hunk(p, 1));
|
|
|
|
cl_git_pass(git_diff_patch_line_stats(&tc, &ta, &td, p));
|
|
cl_assert_equal_i(4, (int)tc);
|
|
cl_assert_equal_i(6, (int)ta);
|
|
cl_assert_equal_i(4, (int)td);
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
git_blob_free(a);
|
|
git_blob_free(b);
|
|
git_blob_free(c);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_against_null_blobs(void)
|
|
{
|
|
git_blob *e = NULL;
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
d, NULL, e, NULL, &opts,
|
|
diff_file_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]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(14, expected.hunk_old_lines);
|
|
cl_assert_equal_i(14, expected.lines);
|
|
cl_assert_equal_i(14, expected.line_dels);
|
|
|
|
opts.flags |= GIT_DIFF_REVERSE;
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
d, NULL, e, NULL, &opts,
|
|
diff_file_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]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(14, expected.hunk_new_lines);
|
|
cl_assert_equal_i(14, expected.lines);
|
|
cl_assert_equal_i(14, expected.line_adds);
|
|
|
|
opts.flags ^= GIT_DIFF_REVERSE;
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
alien, NULL, NULL, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
|
|
cl_assert_equal_i(0, expected.hunks);
|
|
cl_assert_equal_i(0, expected.lines);
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
NULL, NULL, alien, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
|
|
cl_assert_equal_i(0, expected.hunks);
|
|
cl_assert_equal_i(0, expected.lines);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
|
|
{
|
|
git_blob *e = NULL;
|
|
git_diff_patch *p;
|
|
const git_diff_delta *delta;
|
|
int line;
|
|
char origin;
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, d, NULL, e, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_DELETED, delta->status);
|
|
cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(d), delta->old_file.size);
|
|
cl_assert(git_oid_iszero(&delta->new_file.oid));
|
|
cl_assert_equal_sz(0, delta->new_file.size);
|
|
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(14, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
|
|
for (line = 0; line < git_diff_patch_num_lines_in_hunk(p, 0); ++line) {
|
|
cl_git_pass(git_diff_patch_get_line_in_hunk(
|
|
&origin, NULL, NULL, NULL, NULL, p, 0, line));
|
|
cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin);
|
|
}
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
opts.flags |= GIT_DIFF_REVERSE;
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, d, NULL, e, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_ADDED, delta->status);
|
|
cl_assert(git_oid_iszero(&delta->old_file.oid));
|
|
cl_assert_equal_sz(0, delta->old_file.size);
|
|
cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
|
|
cl_assert_equal_sz(git_blob_rawsize(d), delta->new_file.size);
|
|
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(14, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
|
|
for (line = 0; line < git_diff_patch_num_lines_in_hunk(p, 0); ++line) {
|
|
cl_git_pass(git_diff_patch_get_line_in_hunk(
|
|
&origin, NULL, NULL, NULL, NULL, p, 0, line));
|
|
cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin);
|
|
}
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
opts.flags ^= GIT_DIFF_REVERSE;
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, alien, NULL, NULL, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_DELETED, delta->status);
|
|
cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
|
|
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, NULL, NULL, alien, NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_ADDED, delta->status);
|
|
cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
|
|
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
|
|
git_diff_patch_free(p);
|
|
}
|
|
|
|
static void assert_identical_blobs_comparison(diff_expects *expected)
|
|
{
|
|
cl_assert_equal_i(1, expected->files);
|
|
cl_assert_equal_i(1, expected->file_status[GIT_DELTA_UNMODIFIED]);
|
|
cl_assert_equal_i(0, expected->hunks);
|
|
cl_assert_equal_i(0, expected->lines);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_identical_blobs(void)
|
|
{
|
|
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
d, NULL, d, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
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));
|
|
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
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));
|
|
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert(expected.files_binary > 0);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_identical_blobs_with_patch(void)
|
|
{
|
|
git_diff_patch *p;
|
|
const git_diff_delta *delta;
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, d, NULL, d, NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
|
|
cl_assert_equal_sz(delta->old_file.size, git_blob_rawsize(d));
|
|
cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.oid));
|
|
cl_assert_equal_sz(delta->new_file.size, git_blob_rawsize(d));
|
|
cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
|
|
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, NULL, NULL, NULL, NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
|
|
delta = git_diff_patch_delta(p);
|
|
cl_assert(delta != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
|
|
cl_assert_equal_sz(0, delta->old_file.size);
|
|
cl_assert(git_oid_iszero(&delta->old_file.oid));
|
|
cl_assert_equal_sz(0, delta->new_file.size);
|
|
cl_assert(git_oid_iszero(&delta->new_file.oid));
|
|
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blobs(&p, alien, NULL, alien, NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
git_diff_patch_free(p);
|
|
}
|
|
|
|
static void assert_binary_blobs_comparison(diff_expects *expected)
|
|
{
|
|
cl_assert(expected->files_binary > 0);
|
|
|
|
cl_assert_equal_i(1, expected->files);
|
|
cl_assert_equal_i(1, expected->file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected->hunks);
|
|
cl_assert_equal_i(0, expected->lines);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_two_binary_blobs(void)
|
|
{
|
|
git_blob *heart;
|
|
git_oid h_oid;
|
|
|
|
/* heart.png */
|
|
cl_git_pass(git_oid_fromstrn(&h_oid, "de863bff", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&heart, g_repo, &h_oid, 4));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
alien, NULL, heart, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
heart, NULL, alien, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
git_blob_free(heart);
|
|
}
|
|
|
|
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));
|
|
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
|
|
cl_git_pass(git_diff_blobs(
|
|
d, NULL, alien, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
|
|
assert_binary_blobs_comparison(&expected);
|
|
}
|
|
|
|
/*
|
|
* $ git diff fe773770 a0f7217
|
|
* diff --git a/fe773770 b/a0f7217
|
|
* index fe77377..a0f7217 100644
|
|
* --- a/fe773770
|
|
* +++ b/a0f7217
|
|
* @@ -1,6 +1,6 @@
|
|
* Here is some stuff at the start
|
|
*
|
|
* -This should go in one hunk
|
|
* +This should go in one hunk (first)
|
|
*
|
|
* Some additional lines
|
|
*
|
|
* @@ -8,7 +8,7 @@ Down here below the other lines
|
|
*
|
|
* With even more at the end
|
|
*
|
|
* -Followed by a second hunk of stuff
|
|
* +Followed by a second hunk of stuff (second)
|
|
*
|
|
* That happens down here
|
|
*/
|
|
void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
|
|
{
|
|
git_blob *old_d;
|
|
git_oid old_d_oid;
|
|
|
|
opts.context_lines = 3;
|
|
|
|
/* tests/resources/attr/root_test1 from commit f5b0af1 */
|
|
cl_git_pass(git_oid_fromstrn(&old_d_oid, "fe773770", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&old_d, g_repo, &old_d_oid, 4));
|
|
|
|
/* 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));
|
|
|
|
cl_assert_equal_i(2, expected.hunks);
|
|
|
|
/* Test with inter-hunk-context explicitly set to 0 */
|
|
opts.interhunk_lines = 0;
|
|
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));
|
|
|
|
cl_assert_equal_i(2, expected.hunks);
|
|
|
|
/* Test with inter-hunk-context explicitly set to 1 */
|
|
opts.interhunk_lines = 1;
|
|
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));
|
|
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
|
|
git_blob_free(old_d);
|
|
}
|
|
|
|
void test_diff_blob__checks_options_version_too_low(void)
|
|
{
|
|
const git_error *err;
|
|
|
|
opts.version = 0;
|
|
cl_git_fail(git_diff_blobs(
|
|
d, NULL, alien, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
err = giterr_last();
|
|
cl_assert_equal_i(GITERR_INVALID, err->klass);
|
|
}
|
|
|
|
void test_diff_blob__checks_options_version_too_high(void)
|
|
{
|
|
const git_error *err;
|
|
|
|
opts.version = 1024;
|
|
cl_git_fail(git_diff_blobs(
|
|
d, NULL, alien, NULL, &opts,
|
|
diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
|
|
err = giterr_last();
|
|
cl_assert_equal_i(GITERR_INVALID, err->klass);
|
|
}
|
|
|
|
void test_diff_blob__can_correctly_detect_a_binary_blob_as_binary(void)
|
|
{
|
|
/* alien.png */
|
|
cl_assert_equal_i(true, git_blob_is_binary(alien));
|
|
}
|
|
|
|
void test_diff_blob__can_correctly_detect_a_textual_blob_as_non_binary(void)
|
|
{
|
|
/* tests/resources/attr/root_test4.txt */
|
|
cl_assert_equal_i(false, git_blob_is_binary(d));
|
|
}
|
|
|
|
/*
|
|
* git_diff_blob_to_buffer tests
|
|
*/
|
|
|
|
static void assert_changed_single_one_line_file(
|
|
diff_expects *expected, git_delta_t mod)
|
|
{
|
|
cl_assert_equal_i(1, expected->files);
|
|
cl_assert_equal_i(1, expected->file_status[mod]);
|
|
cl_assert_equal_i(1, expected->hunks);
|
|
cl_assert_equal_i(1, expected->lines);
|
|
|
|
if (mod == GIT_DELTA_ADDED)
|
|
cl_assert_equal_i(1, expected->line_adds);
|
|
else if (mod == GIT_DELTA_DELETED)
|
|
cl_assert_equal_i(1, expected->line_dels);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_blob_to_buffer(void)
|
|
{
|
|
git_blob *a;
|
|
git_oid a_oid;
|
|
const char *a_content = "Hello from the root\n";
|
|
const char *b_content = "Hello from the root\n\nSome additional lines\n\nDown here below\n\n";
|
|
|
|
/* tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
|
|
|
|
/* diff from blob a to content of b */
|
|
quick_diff_blob_to_str(a, NULL, b_content, 0, NULL);
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(6, expected.lines);
|
|
cl_assert_equal_i(1, expected.line_ctxt);
|
|
cl_assert_equal_i(5, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
/* diff from blob a to content of a */
|
|
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
|
|
quick_diff_blob_to_str(a, NULL, a_content, 0, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
|
|
/* diff from NULL blob to content of a */
|
|
memset(&expected, 0, sizeof(expected));
|
|
quick_diff_blob_to_str(NULL, NULL, a_content, 0, NULL);
|
|
assert_changed_single_one_line_file(&expected, GIT_DELTA_ADDED);
|
|
|
|
/* diff from blob a to NULL buffer */
|
|
memset(&expected, 0, sizeof(expected));
|
|
quick_diff_blob_to_str(a, NULL, NULL, 0, NULL);
|
|
assert_changed_single_one_line_file(&expected, GIT_DELTA_DELETED);
|
|
|
|
/* diff with reverse */
|
|
opts.flags ^= GIT_DIFF_REVERSE;
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
quick_diff_blob_to_str(a, NULL, NULL, 0, NULL);
|
|
assert_changed_single_one_line_file(&expected, GIT_DELTA_ADDED);
|
|
|
|
git_blob_free(a);
|
|
}
|
|
|
|
void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
|
|
{
|
|
git_diff_patch *p;
|
|
git_blob *a;
|
|
git_oid a_oid;
|
|
const char *a_content = "Hello from the root\n";
|
|
const char *b_content = "Hello from the root\n\nSome additional lines\n\nDown here below\n\n";
|
|
size_t tc, ta, td;
|
|
|
|
/* tests/resources/attr/root_test1 */
|
|
cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
|
|
|
|
/* diff from blob a to content of b */
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, a, NULL, b_content, strlen(b_content), NULL, &opts));
|
|
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_MODIFIED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(6, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
|
|
cl_git_pass(git_diff_patch_line_stats(&tc, &ta, &td, p));
|
|
cl_assert_equal_i(1, (int)tc);
|
|
cl_assert_equal_i(5, (int)ta);
|
|
cl_assert_equal_i(0, (int)td);
|
|
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff from blob a to content of a */
|
|
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, a, NULL, a_content, strlen(a_content), NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(0, (int)git_diff_patch_num_hunks(p));
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff from NULL blob to content of a */
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, NULL, NULL, a_content, strlen(a_content), NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_ADDED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(1, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff from blob a to NULL buffer */
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, a, NULL, NULL, 0, NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_DELETED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(1, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
git_diff_patch_free(p);
|
|
|
|
/* diff with reverse */
|
|
opts.flags ^= GIT_DIFF_REVERSE;
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, a, NULL, NULL, 0, NULL, &opts));
|
|
cl_assert(p != NULL);
|
|
cl_assert_equal_i(GIT_DELTA_ADDED, git_diff_patch_delta(p)->status);
|
|
cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(p));
|
|
cl_assert_equal_i(1, git_diff_patch_num_lines_in_hunk(p, 0));
|
|
git_diff_patch_free(p);
|
|
|
|
git_blob_free(a);
|
|
}
|
|
|
|
static void assert_one_modified_with_lines(diff_expects *expected, int lines)
|
|
{
|
|
cl_assert_equal_i(1, expected->files);
|
|
cl_assert_equal_i(1, expected->file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected->files_binary);
|
|
cl_assert_equal_i(lines, expected->lines);
|
|
}
|
|
|
|
void test_diff_blob__binary_data_comparisons(void)
|
|
{
|
|
git_blob *bin, *nonbin;
|
|
git_oid oid;
|
|
const char *nonbin_content = "Hello from the root\n";
|
|
size_t nonbin_len = 20;
|
|
const char *bin_content = "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00\n0123456789\n";
|
|
size_t bin_len = 33;
|
|
|
|
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
|
|
|
|
cl_git_pass(git_oid_fromstrn(&oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&nonbin, g_repo, &oid, 4));
|
|
|
|
cl_git_pass(git_oid_fromstrn(&oid, "b435cd56", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&bin, g_repo, &oid, 4));
|
|
|
|
/* non-binary to reference content */
|
|
|
|
quick_diff_blob_to_str(nonbin, NULL, nonbin_content, nonbin_len, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
/* binary to reference content */
|
|
|
|
quick_diff_blob_to_str(bin, NULL, bin_content, bin_len, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
|
|
cl_assert_equal_i(1, expected.files_binary);
|
|
|
|
/* non-binary to binary content */
|
|
|
|
quick_diff_blob_to_str(nonbin, NULL, bin_content, bin_len, NULL);
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
/* binary to non-binary content */
|
|
|
|
quick_diff_blob_to_str(bin, NULL, nonbin_content, nonbin_len, NULL);
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
/* non-binary to binary blob */
|
|
|
|
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));
|
|
assert_binary_blobs_comparison(&expected);
|
|
|
|
/*
|
|
* repeat with FORCE_TEXT
|
|
*/
|
|
|
|
opts.flags |= GIT_DIFF_FORCE_TEXT;
|
|
|
|
quick_diff_blob_to_str(bin, NULL, bin_content, bin_len, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
|
|
quick_diff_blob_to_str(nonbin, NULL, bin_content, bin_len, NULL);
|
|
assert_one_modified_with_lines(&expected, 4);
|
|
|
|
quick_diff_blob_to_str(bin, NULL, nonbin_content, nonbin_len, NULL);
|
|
assert_one_modified_with_lines(&expected, 4);
|
|
|
|
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));
|
|
assert_one_modified_with_lines(&expected, 4);
|
|
|
|
/* cleanup */
|
|
git_blob_free(bin);
|
|
git_blob_free(nonbin);
|
|
}
|
|
|
|
void test_diff_blob__using_path_and_attributes(void)
|
|
{
|
|
git_config *cfg;
|
|
git_blob *bin, *nonbin;
|
|
git_oid oid;
|
|
const char *nonbin_content = "Hello from the root\n";
|
|
const char *bin_content =
|
|
"0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00\n0123456789\n";
|
|
size_t bin_len = 33;
|
|
const char *changed;
|
|
git_diff_patch *p;
|
|
char *pout;
|
|
|
|
/* set up custom diff drivers and 'diff' attribute mappings for them */
|
|
|
|
cl_git_pass(git_repository_config(&cfg, g_repo));
|
|
cl_git_pass(git_config_set_bool(cfg, "diff.iam_binary.binary", 1));
|
|
cl_git_pass(git_config_set_bool(cfg, "diff.iam_text.binary", 0));
|
|
cl_git_pass(git_config_set_string(
|
|
cfg, "diff.iam_alphactx.xfuncname", "^[A-Za-z]"));
|
|
cl_git_pass(git_config_set_bool(cfg, "diff.iam_textalpha.binary", 0));
|
|
cl_git_pass(git_config_set_string(
|
|
cfg, "diff.iam_textalpha.xfuncname", "^[A-Za-z]"));
|
|
cl_git_pass(git_config_set_string(
|
|
cfg, "diff.iam_numctx.funcname", "^[0-9]"));
|
|
cl_git_pass(git_config_set_bool(cfg, "diff.iam_textnum.binary", 0));
|
|
cl_git_pass(git_config_set_string(
|
|
cfg, "diff.iam_textnum.funcname", "^[0-9]"));
|
|
git_config_free(cfg);
|
|
|
|
cl_git_append2file(
|
|
"attr/.gitattributes",
|
|
"\n\n# test_diff_blob__using_path_and_attributes extra\n\n"
|
|
"*.binary diff=iam_binary\n"
|
|
"*.textary diff=iam_text\n"
|
|
"*.alphary diff=iam_alphactx\n"
|
|
"*.textalphary diff=iam_textalpha\n"
|
|
"*.textnumary diff=iam_textnum\n"
|
|
"*.numary diff=iam_numctx\n\n");
|
|
|
|
opts.context_lines = 0;
|
|
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
|
|
|
|
cl_git_pass(git_oid_fromstrn(&oid, "45141a79", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&nonbin, g_repo, &oid, 4));
|
|
/* 20b: "Hello from the root\n" */
|
|
|
|
cl_git_pass(git_oid_fromstrn(&oid, "b435cd56", 8));
|
|
cl_git_pass(git_blob_lookup_prefix(&bin, g_repo, &oid, 4));
|
|
/* 33b: "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\n0123456789\n" */
|
|
|
|
/* non-binary to reference content */
|
|
|
|
quick_diff_blob_to_str(nonbin, NULL, nonbin_content, 0, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
|
|
/* binary to reference content */
|
|
|
|
quick_diff_blob_to_str(bin, NULL, bin_content, bin_len, NULL);
|
|
assert_identical_blobs_comparison(&expected);
|
|
cl_assert_equal_i(1, expected.files_binary);
|
|
|
|
/* add some text */
|
|
|
|
changed = "Hello from the root\nMore lines\nAnd more\nGo here\n";
|
|
|
|
quick_diff_blob_to_str(nonbin, NULL, changed, 0, NULL);
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(3, expected.lines);
|
|
cl_assert_equal_i(0, expected.line_ctxt);
|
|
cl_assert_equal_i(3, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
quick_diff_blob_to_str(nonbin, "foo/bar.binary", changed, 0, NULL);
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(1, expected.files_binary);
|
|
cl_assert_equal_i(0, expected.hunks);
|
|
cl_assert_equal_i(0, expected.lines);
|
|
cl_assert_equal_i(0, expected.line_ctxt);
|
|
cl_assert_equal_i(0, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
quick_diff_blob_to_str(nonbin, "foo/bar.textary", changed, 0, NULL);
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(3, expected.lines);
|
|
cl_assert_equal_i(0, expected.line_ctxt);
|
|
cl_assert_equal_i(3, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
quick_diff_blob_to_str(nonbin, "foo/bar.alphary", changed, 0, NULL);
|
|
cl_assert_equal_i(1, expected.files);
|
|
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
|
|
cl_assert_equal_i(0, expected.files_binary);
|
|
cl_assert_equal_i(1, expected.hunks);
|
|
cl_assert_equal_i(3, expected.lines);
|
|
cl_assert_equal_i(0, expected.line_ctxt);
|
|
cl_assert_equal_i(3, expected.line_adds);
|
|
cl_assert_equal_i(0, expected.line_dels);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, nonbin, "zzz.normal", changed, strlen(changed), NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.normal b/zzz.normal\n"
|
|
"index 45141a7..75b0dbb 100644\n"
|
|
"--- a/zzz.normal\n"
|
|
"+++ b/zzz.normal\n"
|
|
"@@ -1,0 +2,3 @@ Hello from the root\n"
|
|
"+More lines\n"
|
|
"+And more\n"
|
|
"+Go here\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, nonbin, "zzz.binary", changed, strlen(changed), NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.binary b/zzz.binary\n"
|
|
"index 45141a7..75b0dbb 100644\n"
|
|
"Binary files a/zzz.binary and b/zzz.binary differ\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, nonbin, "zzz.alphary", changed, strlen(changed), NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.alphary b/zzz.alphary\n"
|
|
"index 45141a7..75b0dbb 100644\n"
|
|
"--- a/zzz.alphary\n"
|
|
"+++ b/zzz.alphary\n"
|
|
"@@ -1,0 +2,3 @@ Hello from the root\n"
|
|
"+More lines\n"
|
|
"+And more\n"
|
|
"+Go here\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, nonbin, "zzz.numary", changed, strlen(changed), NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.numary b/zzz.numary\n"
|
|
"index 45141a7..75b0dbb 100644\n"
|
|
"--- a/zzz.numary\n"
|
|
"+++ b/zzz.numary\n"
|
|
"@@ -1,0 +2,3 @@\n"
|
|
"+More lines\n"
|
|
"+And more\n"
|
|
"+Go here\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
/* "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00\n0123456789\n"
|
|
* 33 bytes
|
|
*/
|
|
|
|
changed = "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00\nreplace a line\n";
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, bin, "zzz.normal", changed, 37, NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.normal b/zzz.normal\n"
|
|
"index b435cd5..1604519 100644\n"
|
|
"Binary files a/zzz.normal and b/zzz.normal differ\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, bin, "zzz.textary", changed, 37, NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.textary b/zzz.textary\n"
|
|
"index b435cd5..1604519 100644\n"
|
|
"--- a/zzz.textary\n"
|
|
"+++ b/zzz.textary\n"
|
|
"@@ -3 +3 @@\n"
|
|
"-0123456789\n"
|
|
"+replace a line\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, bin, "zzz.textalphary", changed, 37, NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.textalphary b/zzz.textalphary\n"
|
|
"index b435cd5..1604519 100644\n"
|
|
"--- a/zzz.textalphary\n"
|
|
"+++ b/zzz.textalphary\n"
|
|
"@@ -3 +3 @@\n"
|
|
"-0123456789\n"
|
|
"+replace a line\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
cl_git_pass(git_diff_patch_from_blob_and_buffer(
|
|
&p, bin, "zzz.textnumary", changed, 37, NULL, &opts));
|
|
cl_git_pass(git_diff_patch_to_str(&pout, p));
|
|
cl_assert_equal_s(
|
|
"diff --git a/zzz.textnumary b/zzz.textnumary\n"
|
|
"index b435cd5..1604519 100644\n"
|
|
"--- a/zzz.textnumary\n"
|
|
"+++ b/zzz.textnumary\n"
|
|
"@@ -3 +3 @@ 0123456789\n"
|
|
"-0123456789\n"
|
|
"+replace a line\n", pout);
|
|
git__free(pout);
|
|
git_diff_patch_free(p);
|
|
|
|
git_blob_free(nonbin);
|
|
git_blob_free(bin);
|
|
}
|