blob.c 9.11 KB
Newer Older
1 2 3 4
#include "clar_libgit2.h"
#include "diff_helpers.h"

static git_repository *g_repo = NULL;
nulltoken committed
5
static diff_expects expected;
6
static git_diff_options opts;
7
static git_blob *d, *alien;
8 9 10

void test_diff_blob__initialize(void)
{
11
	git_oid oid;
12

13
	g_repo = cl_git_sandbox_init("attr");
14 15 16

	memset(&opts, 0, sizeof(opts));
	opts.context_lines = 1;
17
	opts.interhunk_lines = 0;
18

nulltoken committed
19
	memset(&expected, 0, sizeof(expected));
20 21

	/* tests/resources/attr/root_test4.txt */
22 23
	cl_git_pass(git_oid_fromstrn(&oid, "a0f7217a", 8));
	cl_git_pass(git_blob_lookup_prefix(&d, g_repo, &oid, 4));
24 25 26 27

	/* alien.png */
	cl_git_pass(git_oid_fromstrn(&oid, "edf3dcee", 8));
	cl_git_pass(git_blob_lookup_prefix(&alien, g_repo, &oid, 4));
28 29 30 31
}

void test_diff_blob__cleanup(void)
{
32
	git_blob_free(d);
33
	git_blob_free(alien);
34

35
	cl_git_sandbox_cleanup();
36 37
}

38
void test_diff_blob__can_compare_text_blobs(void)
39
{
40 41
	git_blob *a, *b, *c;
	git_oid a_oid, b_oid, c_oid;
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

	/* 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 */

57
	/* diff on tests/resources/attr/root_test1 */
58
	cl_git_pass(git_diff_blobs(
nulltoken committed
59
		a, b, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
60

Russell Belfer committed
61
	cl_assert_equal_i(1, expected.files);
62 63
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, expected.files_binary);
64

Russell Belfer committed
65 66 67 68 69
	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);
70

71
	/* diff on tests/resources/attr/root_test2 */
nulltoken committed
72
	memset(&expected, 0, sizeof(expected));
73
	cl_git_pass(git_diff_blobs(
nulltoken committed
74
		b, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
75

Russell Belfer committed
76
	cl_assert_equal_i(1, expected.files);
77 78
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, expected.files_binary);
79

Russell Belfer committed
80 81 82 83 84
	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);
85

86
	/* diff on tests/resources/attr/root_test3 */
nulltoken committed
87
	memset(&expected, 0, sizeof(expected));
88
	cl_git_pass(git_diff_blobs(
nulltoken committed
89
		a, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
90

Russell Belfer committed
91
	cl_assert_equal_i(1, expected.files);
92 93
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, expected.files_binary);
94

Russell Belfer committed
95 96 97 98 99
	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);
100

nulltoken committed
101
	memset(&expected, 0, sizeof(expected));
102
	cl_git_pass(git_diff_blobs(
nulltoken committed
103
		c, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
104

Russell Belfer committed
105
	cl_assert_equal_i(1, expected.files);
106 107
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, expected.files_binary);
108

Russell Belfer committed
109 110 111 112 113
	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);
114 115 116 117 118 119

	git_blob_free(a);
	git_blob_free(b);
	git_blob_free(c);
}

120 121 122 123 124
void test_diff_blob__can_compare_against_null_blobs(void)
{
	git_blob *e = NULL;

	cl_git_pass(git_diff_blobs(
nulltoken committed
125
		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
126

Russell Belfer committed
127
	cl_assert_equal_i(1, expected.files);
128 129
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(0, expected.files_binary);
130

Russell Belfer committed
131 132 133 134
	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);
135 136

	opts.flags |= GIT_DIFF_REVERSE;
nulltoken committed
137
	memset(&expected, 0, sizeof(expected));
138 139

	cl_git_pass(git_diff_blobs(
nulltoken committed
140
		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
141

Russell Belfer committed
142
	cl_assert_equal_i(1, expected.files);
143 144
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(0, expected.files_binary);
145

Russell Belfer committed
146 147 148 149
	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);
150 151

	opts.flags ^= GIT_DIFF_REVERSE;
nulltoken committed
152
	memset(&expected, 0, sizeof(expected));
153 154

	cl_git_pass(git_diff_blobs(
nulltoken committed
155
		alien, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
156

Russell Belfer committed
157
	cl_assert_equal_i(1, expected.files);
158 159
	cl_assert_equal_i(1, expected.files_binary);
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
Russell Belfer committed
160 161
	cl_assert_equal_i(0, expected.hunks);
	cl_assert_equal_i(0, expected.lines);
162

nulltoken committed
163
	memset(&expected, 0, sizeof(expected));
164 165

	cl_git_pass(git_diff_blobs(
nulltoken committed
166
		NULL, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
167

Russell Belfer committed
168
	cl_assert_equal_i(1, expected.files);
169 170
	cl_assert_equal_i(1, expected.files_binary);
	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
Russell Belfer committed
171 172
	cl_assert_equal_i(0, expected.hunks);
	cl_assert_equal_i(0, expected.lines);
173 174
}

175
static void assert_identical_blobs_comparison(diff_expects *expected)
176
{
177 178 179 180
	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);
181 182 183 184 185
}

void test_diff_blob__can_compare_identical_blobs(void)
{
	cl_git_pass(git_diff_blobs(
nulltoken committed
186
		d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
187

188 189
	cl_assert_equal_i(0, expected.files_binary);
	assert_identical_blobs_comparison(&expected);
190

nulltoken committed
191
	memset(&expected, 0, sizeof(expected));
192
	cl_git_pass(git_diff_blobs(
nulltoken committed
193
		NULL, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
194

195 196
	cl_assert_equal_i(0, expected.files_binary);
	assert_identical_blobs_comparison(&expected);
197

nulltoken committed
198
	memset(&expected, 0, sizeof(expected));
199
	cl_git_pass(git_diff_blobs(
nulltoken committed
200
		alien, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
201

202 203
	cl_assert(expected.files_binary > 0);
	assert_identical_blobs_comparison(&expected);
204 205
}

206
static void assert_binary_blobs_comparison(diff_expects *expected)
207
{
208
	cl_assert(expected->files_binary > 0);
209

210 211 212 213
	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);
214 215 216 217 218 219 220 221 222 223 224 225
}

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(
nulltoken committed
226
		alien, heart, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
227

228
	assert_binary_blobs_comparison(&expected);
229

nulltoken committed
230
	memset(&expected, 0, sizeof(expected));
231 232

	cl_git_pass(git_diff_blobs(
nulltoken committed
233
		heart, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
234

235
	assert_binary_blobs_comparison(&expected);
236 237 238 239 240 241 242

	git_blob_free(heart);
}

void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
{
	cl_git_pass(git_diff_blobs(
nulltoken committed
243
		alien, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
244

245
	assert_binary_blobs_comparison(&expected);
246

nulltoken committed
247
	memset(&expected, 0, sizeof(expected));
248 249

	cl_git_pass(git_diff_blobs(
nulltoken committed
250
		d, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
251

252
	assert_binary_blobs_comparison(&expected);
253
}
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292

/*
 * $ 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, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));

Russell Belfer committed
293
	cl_assert_equal_i(2, expected.hunks);
294 295 296 297 298 299 300

	/* 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, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));

Russell Belfer committed
301
	cl_assert_equal_i(2, expected.hunks);
302 303 304 305 306 307 308

	/* 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, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));

Russell Belfer committed
309
	cl_assert_equal_i(1, expected.hunks);
310 311 312

	git_blob_free(old_d);
}