buffer.c 27.8 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "buffer.h"
3
#include "buf_text.h"
4
#include "hashsig.h"
5
#include "fileops.h"
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#define TESTSTR "Have you seen that? Have you seeeen that??"
const char *test_string = TESTSTR;
const char *test_string_x2 = TESTSTR TESTSTR;

#define TESTSTR_4096 REP1024("1234")
#define TESTSTR_8192 REP1024("12341234")
const char *test_4096 = TESTSTR_4096;
const char *test_8192 = TESTSTR_8192;

/* test basic data concatenation */
void test_core_buffer__0(void)
{
	git_buf buf = GIT_BUF_INIT;

	cl_assert(buf.size == 0);

	git_buf_puts(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
25
	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
26 27 28

	git_buf_puts(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
29
	cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf));
30 31 32 33 34 35 36 37 38 39 40

	git_buf_free(&buf);
}

/* test git_buf_printf */
void test_core_buffer__1(void)
{
	git_buf buf = GIT_BUF_INIT;

	git_buf_printf(&buf, "%s %s %d ", "shoop", "da", 23);
	cl_assert(git_buf_oom(&buf) == 0);
41
	cl_assert_equal_s("shoop da 23 ", git_buf_cstr(&buf));
42 43 44

	git_buf_printf(&buf, "%s %d", "woop", 42);
	cl_assert(git_buf_oom(&buf) == 0);
45
	cl_assert_equal_s("shoop da 23 woop 42", git_buf_cstr(&buf));
46 47 48 49 50 51 52 53 54

	git_buf_free(&buf);
}

/* more thorough test of concatenation options */
void test_core_buffer__2(void)
{
	git_buf buf = GIT_BUF_INIT;
	int i;
55
	char data[128];
56 57 58 59 60 61 62 63 64

	cl_assert(buf.size == 0);

	/* this must be safe to do */
	git_buf_free(&buf);
	cl_assert(buf.size == 0);
	cl_assert(buf.asize == 0);

	/* empty buffer should be empty string */
65
	cl_assert_equal_s("", git_buf_cstr(&buf));
66
	cl_assert(buf.size == 0);
67
	/* cl_assert(buf.asize == 0); -- should not assume what git_buf does */
68 69 70 71 72 73 74 75 76

	/* free should set us back to the beginning */
	git_buf_free(&buf);
	cl_assert(buf.size == 0);
	cl_assert(buf.asize == 0);

	/* add letter */
	git_buf_putc(&buf, '+');
	cl_assert(git_buf_oom(&buf) == 0);
77
	cl_assert_equal_s("+", git_buf_cstr(&buf));
78 79 80 81

	/* add letter again */
	git_buf_putc(&buf, '+');
	cl_assert(git_buf_oom(&buf) == 0);
82
	cl_assert_equal_s("++", git_buf_cstr(&buf));
83 84 85 86 87 88

	/* let's try that a few times */
	for (i = 0; i < 16; ++i) {
		git_buf_putc(&buf, '+');
		cl_assert(git_buf_oom(&buf) == 0);
	}
89
	cl_assert_equal_s("++++++++++++++++++", git_buf_cstr(&buf));
90 91 92 93 94 95

	git_buf_free(&buf);

	/* add data */
	git_buf_put(&buf, "xo", 2);
	cl_assert(git_buf_oom(&buf) == 0);
96
	cl_assert_equal_s("xo", git_buf_cstr(&buf));
97 98 99 100

	/* add letter again */
	git_buf_put(&buf, "xo", 2);
	cl_assert(git_buf_oom(&buf) == 0);
101
	cl_assert_equal_s("xoxo", git_buf_cstr(&buf));
102 103 104 105 106 107

	/* let's try that a few times */
	for (i = 0; i < 16; ++i) {
		git_buf_put(&buf, "xo", 2);
		cl_assert(git_buf_oom(&buf) == 0);
	}
108
	cl_assert_equal_s("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo",
109 110 111 112 113 114 115
					   git_buf_cstr(&buf));

	git_buf_free(&buf);

	/* set to string */
	git_buf_sets(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
116
	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
117 118 119 120

	/* append string */
	git_buf_puts(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
121
	cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf));
122 123 124 125

	/* set to string again (should overwrite - not append) */
	git_buf_sets(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
126
	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
127 128 129

	/* test clear */
	git_buf_clear(&buf);
130
	cl_assert_equal_s("", git_buf_cstr(&buf));
131 132

	git_buf_free(&buf);
133 134 135 136 137

	/* test extracting data into buffer */
	git_buf_puts(&buf, REP4("0123456789"));
	cl_assert(git_buf_oom(&buf) == 0);

138
	git_buf_copy_cstr(data, sizeof(data), &buf);
139
	cl_assert_equal_s(REP4("0123456789"), data);
140
	git_buf_copy_cstr(data, 11, &buf);
141
	cl_assert_equal_s("0123456789", data);
142
	git_buf_copy_cstr(data, 3, &buf);
143
	cl_assert_equal_s("01", data);
144
	git_buf_copy_cstr(data, 1, &buf);
145
	cl_assert_equal_s("", data);
146

147
	git_buf_copy_cstr(data, sizeof(data), &buf);
148
	cl_assert_equal_s(REP4("0123456789"), data);
149 150 151 152

	git_buf_sets(&buf, REP256("x"));
	git_buf_copy_cstr(data, sizeof(data), &buf);
	/* since sizeof(data) == 128, only 127 bytes should be copied */
153
	cl_assert_equal_s(REP4(REP16("x")) REP16("x") REP16("x")
154
					   REP16("x") "xxxxxxxxxxxxxxx", data);
155 156 157

	git_buf_free(&buf);

158
	git_buf_copy_cstr(data, sizeof(data), &buf);
159
	cl_assert_equal_s("", data);
160 161 162 163 164 165 166 167 168 169
}

/* let's do some tests with larger buffers to push our limits */
void test_core_buffer__3(void)
{
	git_buf buf = GIT_BUF_INIT;

	/* set to string */
	git_buf_set(&buf, test_4096, 4096);
	cl_assert(git_buf_oom(&buf) == 0);
170
	cl_assert_equal_s(test_4096, git_buf_cstr(&buf));
171 172 173 174

	/* append string */
	git_buf_puts(&buf, test_4096);
	cl_assert(git_buf_oom(&buf) == 0);
175
	cl_assert_equal_s(test_8192, git_buf_cstr(&buf));
176 177 178 179

	/* set to string again (should overwrite - not append) */
	git_buf_set(&buf, test_4096, 4096);
	cl_assert(git_buf_oom(&buf) == 0);
180
	cl_assert_equal_s(test_4096, git_buf_cstr(&buf));
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

	git_buf_free(&buf);
}

/* let's try some producer/consumer tests */
void test_core_buffer__4(void)
{
	git_buf buf = GIT_BUF_INIT;
	int i;

	for (i = 0; i < 10; ++i) {
		git_buf_puts(&buf, "1234"); /* add 4 */
		cl_assert(git_buf_oom(&buf) == 0);
		git_buf_consume(&buf, buf.ptr + 2); /* eat the first two */
		cl_assert(strlen(git_buf_cstr(&buf)) == (size_t)((i + 1) * 2));
	}
	/* we have appended 1234 10x and removed the first 20 letters */
198
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
199 200

	git_buf_consume(&buf, NULL);
201
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
202 203

	git_buf_consume(&buf, "invalid pointer");
204
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
205 206

	git_buf_consume(&buf, buf.ptr);
207
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
208 209

	git_buf_consume(&buf, buf.ptr + 1);
210
	cl_assert_equal_s("2341234123412341234", git_buf_cstr(&buf));
211 212

	git_buf_consume(&buf, buf.ptr + buf.size);
213
	cl_assert_equal_s("", git_buf_cstr(&buf));
214 215 216 217 218 219 220 221 222 223

	git_buf_free(&buf);
}


static void
check_buf_append(
	const char* data_a,
	const char* data_b,
	const char* expected_data,
224 225
	size_t expected_size,
	size_t expected_asize)
226 227 228 229 230 231 232
{
	git_buf tgt = GIT_BUF_INIT;

	git_buf_sets(&tgt, data_a);
	cl_assert(git_buf_oom(&tgt) == 0);
	git_buf_puts(&tgt, data_b);
	cl_assert(git_buf_oom(&tgt) == 0);
233
	cl_assert_equal_s(expected_data, git_buf_cstr(&tgt));
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	cl_assert(tgt.size == expected_size);
	if (expected_asize > 0)
		cl_assert(tgt.asize == expected_asize);

	git_buf_free(&tgt);
}

static void
check_buf_append_abc(
	const char* buf_a,
	const char* buf_b,
	const char* buf_c,
	const char* expected_ab,
	const char* expected_abc,
	const char* expected_abca,
	const char* expected_abcab,
	const char* expected_abcabc)
{
	git_buf buf = GIT_BUF_INIT;

	git_buf_sets(&buf, buf_a);
	cl_assert(git_buf_oom(&buf) == 0);
256
	cl_assert_equal_s(buf_a, git_buf_cstr(&buf));
257 258 259

	git_buf_puts(&buf, buf_b);
	cl_assert(git_buf_oom(&buf) == 0);
260
	cl_assert_equal_s(expected_ab, git_buf_cstr(&buf));
261 262 263

	git_buf_puts(&buf, buf_c);
	cl_assert(git_buf_oom(&buf) == 0);
264
	cl_assert_equal_s(expected_abc, git_buf_cstr(&buf));
265 266 267

	git_buf_puts(&buf, buf_a);
	cl_assert(git_buf_oom(&buf) == 0);
268
	cl_assert_equal_s(expected_abca, git_buf_cstr(&buf));
269 270 271

	git_buf_puts(&buf, buf_b);
	cl_assert(git_buf_oom(&buf) == 0);
272
	cl_assert_equal_s(expected_abcab, git_buf_cstr(&buf));
273 274 275

	git_buf_puts(&buf, buf_c);
	cl_assert(git_buf_oom(&buf) == 0);
276
	cl_assert_equal_s(expected_abcabc, git_buf_cstr(&buf));
277 278 279 280 281 282 283 284

	git_buf_free(&buf);
}

/* more variations on append tests */
void test_core_buffer__5(void)
{
	check_buf_append("", "", "", 0, 8);
285 286
	check_buf_append("a", "", "a", 1, 8);
	check_buf_append("", "a", "a", 1, 8);
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	check_buf_append("", "a", "a", 1, 8);
	check_buf_append("a", "", "a", 1, 8);
	check_buf_append("a", "b", "ab", 2, 8);
	check_buf_append("", "abcdefgh", "abcdefgh", 8, 16);
	check_buf_append("abcdefgh", "", "abcdefgh", 8, 16);

	/* buffer with starting asize will grow to:
	 *  1 ->  2,  2 ->  3,  3 ->  5,  4 ->  6,  5 ->  8,  6 ->  9,
	 *  7 -> 11,  8 -> 12,  9 -> 14, 10 -> 15, 11 -> 17, 12 -> 18,
	 * 13 -> 20, 14 -> 21, 15 -> 23, 16 -> 24, 17 -> 26, 18 -> 27,
	 * 19 -> 29, 20 -> 30, 21 -> 32, 22 -> 33, 23 -> 35, 24 -> 36,
	 * ...
	 * follow sequence until value > target size,
	 * then round up to nearest multiple of 8.
	 */

	check_buf_append("abcdefgh", "/", "abcdefgh/", 9, 16);
304
	check_buf_append("abcdefgh", "ijklmno", "abcdefghijklmno", 15, 16);
305 306 307 308 309 310
	check_buf_append("abcdefgh", "ijklmnop", "abcdefghijklmnop", 16, 24);
	check_buf_append("0123456789", "0123456789",
					 "01234567890123456789", 20, 24);
	check_buf_append(REP16("x"), REP16("o"),
					 REP16("x") REP16("o"), 32, 40);

311 312
	check_buf_append(test_4096, "", test_4096, 4096, 4104);
	check_buf_append(test_4096, test_4096, test_8192, 8192, 9240);
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335

	/* check sequences of appends */
	check_buf_append_abc("a", "b", "c",
						 "ab", "abc", "abca", "abcab", "abcabc");
	check_buf_append_abc("a1", "b2", "c3",
						 "a1b2", "a1b2c3", "a1b2c3a1",
						 "a1b2c3a1b2", "a1b2c3a1b2c3");
	check_buf_append_abc("a1/", "b2/", "c3/",
						 "a1/b2/", "a1/b2/c3/", "a1/b2/c3/a1/",
						 "a1/b2/c3/a1/b2/", "a1/b2/c3/a1/b2/c3/");
}

/* test swap */
void test_core_buffer__6(void)
{
	git_buf a = GIT_BUF_INIT;
	git_buf b = GIT_BUF_INIT;

	git_buf_sets(&a, "foo");
	cl_assert(git_buf_oom(&a) == 0);
	git_buf_sets(&b, "bar");
	cl_assert(git_buf_oom(&b) == 0);

336 337
	cl_assert_equal_s("foo", git_buf_cstr(&a));
	cl_assert_equal_s("bar", git_buf_cstr(&b));
338 339 340

	git_buf_swap(&a, &b);

341 342
	cl_assert_equal_s("bar", git_buf_cstr(&a));
	cl_assert_equal_s("foo", git_buf_cstr(&b));
343 344 345 346 347 348

	git_buf_free(&a);
	git_buf_free(&b);
}


349
/* test detach/attach data */
350 351
void test_core_buffer__7(void)
{
352
	const char *fun = "This is fun";
353 354 355 356 357
	git_buf a = GIT_BUF_INIT;
	char *b = NULL;

	git_buf_sets(&a, "foo");
	cl_assert(git_buf_oom(&a) == 0);
358
	cl_assert_equal_s("foo", git_buf_cstr(&a));
359

360
	b = git_buf_detach(&a);
361

362 363
	cl_assert_equal_s("foo", b);
	cl_assert_equal_s("", a.ptr);
364 365
	git__free(b);

366
	b = git_buf_detach(&a);
367

368 369
	cl_assert_equal_s(NULL, b);
	cl_assert_equal_s("", a.ptr);
370 371

	git_buf_free(&a);
372 373 374 375

	b = git__strdup(fun);
	git_buf_attach(&a, b, 0);

376
	cl_assert_equal_s(fun, a.ptr);
377 378
	cl_assert(a.size == strlen(fun));
	cl_assert(a.asize == strlen(fun) + 1);
379 380 381 382 383 384

	git_buf_free(&a);

	b = git__strdup(fun);
	git_buf_attach(&a, b, strlen(fun) + 1);

385
	cl_assert_equal_s(fun, a.ptr);
386 387
	cl_assert(a.size == strlen(fun));
	cl_assert(a.asize == strlen(fun) + 1);
388 389

	git_buf_free(&a);
390 391 392 393
}


static void
394 395 396 397 398 399 400 401 402 403
check_joinbuf_2(
	const char *a,
	const char *b,
	const char *expected)
{
	char sep = '/';
	git_buf buf = GIT_BUF_INIT;

	git_buf_join(&buf, sep, a, b);
	cl_assert(git_buf_oom(&buf) == 0);
404
	cl_assert_equal_s(expected, git_buf_cstr(&buf));
405 406 407 408 409
	git_buf_free(&buf);
}

static void
check_joinbuf_n_2(
410 411 412 413 414 415 416 417 418 419
	const char *a,
	const char *b,
	const char *expected)
{
	char sep = '/';
	git_buf buf = GIT_BUF_INIT;

	git_buf_sets(&buf, a);
	cl_assert(git_buf_oom(&buf) == 0);

420
	git_buf_join_n(&buf, sep, 1, b);
421
	cl_assert(git_buf_oom(&buf) == 0);
422
	cl_assert_equal_s(expected, git_buf_cstr(&buf));
423 424 425 426 427

	git_buf_free(&buf);
}

static void
428
check_joinbuf_n_4(
429 430 431 432 433 434 435 436
	const char *a,
	const char *b,
	const char *c,
	const char *d,
	const char *expected)
{
	char sep = ';';
	git_buf buf = GIT_BUF_INIT;
437
	git_buf_join_n(&buf, sep, 4, a, b, c, d);
438
	cl_assert(git_buf_oom(&buf) == 0);
439
	cl_assert_equal_s(expected, git_buf_cstr(&buf));
440 441 442 443 444 445 446 447
	git_buf_free(&buf);
}

/* test join */
void test_core_buffer__8(void)
{
	git_buf a = GIT_BUF_INIT;

448
	git_buf_join_n(&a, '/', 1, "foo");
449
	cl_assert(git_buf_oom(&a) == 0);
450
	cl_assert_equal_s("foo", git_buf_cstr(&a));
451

452
	git_buf_join_n(&a, '/', 1, "bar");
453
	cl_assert(git_buf_oom(&a) == 0);
454
	cl_assert_equal_s("foo/bar", git_buf_cstr(&a));
455

456
	git_buf_join_n(&a, '/', 1, "baz");
457
	cl_assert(git_buf_oom(&a) == 0);
458
	cl_assert_equal_s("foo/bar/baz", git_buf_cstr(&a));
459 460 461

	git_buf_free(&a);

462 463 464
	check_joinbuf_2(NULL, "", "");
	check_joinbuf_2(NULL, "a", "a");
	check_joinbuf_2(NULL, "/a", "/a");
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
	check_joinbuf_2("", "", "");
	check_joinbuf_2("", "a", "a");
	check_joinbuf_2("", "/a", "/a");
	check_joinbuf_2("a", "", "a/");
	check_joinbuf_2("a", "/", "a/");
	check_joinbuf_2("a", "b", "a/b");
	check_joinbuf_2("/", "a", "/a");
	check_joinbuf_2("/", "", "/");
	check_joinbuf_2("/a", "/b", "/a/b");
	check_joinbuf_2("/a", "/b/", "/a/b/");
	check_joinbuf_2("/a/", "b/", "/a/b/");
	check_joinbuf_2("/a/", "/b/", "/a/b/");
	check_joinbuf_2("/a/", "//b/", "/a/b/");
	check_joinbuf_2("/abcd", "/defg", "/abcd/defg");
	check_joinbuf_2("/abcd", "/defg/", "/abcd/defg/");
	check_joinbuf_2("/abcd/", "defg/", "/abcd/defg/");
	check_joinbuf_2("/abcd/", "/defg/", "/abcd/defg/");

	check_joinbuf_n_2("", "", "");
	check_joinbuf_n_2("", "a", "a");
	check_joinbuf_n_2("", "/a", "/a");
	check_joinbuf_n_2("a", "", "a/");
	check_joinbuf_n_2("a", "/", "a/");
	check_joinbuf_n_2("a", "b", "a/b");
	check_joinbuf_n_2("/", "a", "/a");
	check_joinbuf_n_2("/", "", "/");
	check_joinbuf_n_2("/a", "/b", "/a/b");
	check_joinbuf_n_2("/a", "/b/", "/a/b/");
	check_joinbuf_n_2("/a/", "b/", "/a/b/");
	check_joinbuf_n_2("/a/", "/b/", "/a/b/");
	check_joinbuf_n_2("/abcd", "/defg", "/abcd/defg");
	check_joinbuf_n_2("/abcd", "/defg/", "/abcd/defg/");
	check_joinbuf_n_2("/abcd/", "defg/", "/abcd/defg/");
	check_joinbuf_n_2("/abcd/", "/defg/", "/abcd/defg/");

	check_joinbuf_n_4("", "", "", "", "");
	check_joinbuf_n_4("", "a", "", "", "a;");
	check_joinbuf_n_4("a", "", "", "", "a;");
	check_joinbuf_n_4("", "", "", "a", "a");
	check_joinbuf_n_4("a", "b", "", ";c;d;", "a;b;c;d;");
	check_joinbuf_n_4("a", "b", "", ";c;d", "a;b;c;d");
	check_joinbuf_n_4("abcd", "efgh", "ijkl", "mnop", "abcd;efgh;ijkl;mnop");
	check_joinbuf_n_4("abcd;", "efgh;", "ijkl;", "mnop;", "abcd;efgh;ijkl;mnop;");
	check_joinbuf_n_4(";abcd;", ";efgh;", ";ijkl;", ";mnop;", ";abcd;efgh;ijkl;mnop;");
509 510
}

511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
void test_core_buffer__9(void)
{
	git_buf buf = GIT_BUF_INIT;

	/* just some exhaustive tests of various separator placement */
	char *a[] = { "", "-", "a-", "-a", "-a-" };
	char *b[] = { "", "-", "b-", "-b", "-b-" };
	char sep[] = { 0, '-', '/' };
	char *expect_null[] = { "",    "-",     "a-",     "-a",     "-a-",
							"-",   "--",    "a--",    "-a-",    "-a--",
							"b-",  "-b-",   "a-b-",   "-ab-",   "-a-b-",
							"-b",  "--b",   "a--b",   "-a-b",   "-a--b",
							"-b-", "--b-",  "a--b-",  "-a-b-",  "-a--b-" };
	char *expect_dash[] = { "",    "-",     "a-",     "-a-",    "-a-",
							"-",   "-",     "a-",     "-a-",    "-a-",
							"b-",  "-b-",   "a-b-",   "-a-b-",  "-a-b-",
							"-b",  "-b",    "a-b",    "-a-b",   "-a-b",
							"-b-", "-b-",   "a-b-",   "-a-b-",  "-a-b-" };
	char *expect_slas[] = { "",    "-/",    "a-/",    "-a/",    "-a-/",
							"-",   "-/-",   "a-/-",   "-a/-",   "-a-/-",
							"b-",  "-/b-",  "a-/b-",  "-a/b-",  "-a-/b-",
							"-b",  "-/-b",  "a-/-b",  "-a/-b",  "-a-/-b",
							"-b-", "-/-b-", "a-/-b-", "-a/-b-", "-a-/-b-" };
	char **expect_values[] = { expect_null, expect_dash, expect_slas };
	char separator, **expect;
	unsigned int s, i, j;

	for (s = 0; s < sizeof(sep) / sizeof(char); ++s) {
		separator = sep[s];
		expect = expect_values[s];

		for (j = 0; j < sizeof(b) / sizeof(char*); ++j) {
			for (i = 0; i < sizeof(a) / sizeof(char*); ++i) {
				git_buf_join(&buf, separator, a[i], b[j]);
545
				cl_assert_equal_s(*expect, buf.ptr);
546 547 548 549 550 551 552
				expect++;
			}
		}
	}

	git_buf_free(&buf);
}
553 554 555 556 557 558

void test_core_buffer__10(void)
{
	git_buf a = GIT_BUF_INIT;

	cl_git_pass(git_buf_join_n(&a, '/', 1, "test"));
559
	cl_assert_equal_s(a.ptr, "test");
560
	cl_git_pass(git_buf_join_n(&a, '/', 1, "string"));
561
	cl_assert_equal_s(a.ptr, "test/string");
562 563
	git_buf_clear(&a);
	cl_git_pass(git_buf_join_n(&a, '/', 3, "test", "string", "join"));
564
	cl_assert_equal_s(a.ptr, "test/string/join");
565
	cl_git_pass(git_buf_join_n(&a, '/', 2, a.ptr, "more"));
566
	cl_assert_equal_s(a.ptr, "test/string/join/test/string/join/more");
567 568 569

	git_buf_free(&a);
}
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

void test_core_buffer__11(void)
{
	git_buf a = GIT_BUF_INIT;
	git_strarray t;
	char *t1[] = { "nothing", "in", "common" };
	char *t2[] = { "something", "something else", "some other" };
	char *t3[] = { "something", "some fun", "no fun" };
	char *t4[] = { "happy", "happier", "happiest" };
	char *t5[] = { "happiest", "happier", "happy" };
	char *t6[] = { "no", "nope", "" };
	char *t7[] = { "", "doesn't matter" };

	t.strings = t1;
	t.count = 3;
585
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
586 587 588 589
	cl_assert_equal_s(a.ptr, "");

	t.strings = t2;
	t.count = 3;
590
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
591 592 593 594
	cl_assert_equal_s(a.ptr, "some");

	t.strings = t3;
	t.count = 3;
595
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
596 597 598 599
	cl_assert_equal_s(a.ptr, "");

	t.strings = t4;
	t.count = 3;
600
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
601 602 603 604
	cl_assert_equal_s(a.ptr, "happ");

	t.strings = t5;
	t.count = 3;
605
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
606 607 608 609
	cl_assert_equal_s(a.ptr, "happ");

	t.strings = t6;
	t.count = 3;
610
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
611 612 613 614
	cl_assert_equal_s(a.ptr, "");

	t.strings = t7;
	t.count = 3;
615
	cl_git_pass(git_buf_text_common_prefix(&a, &t));
616 617 618 619
	cl_assert_equal_s(a.ptr, "");

	git_buf_free(&a);
}
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641

void test_core_buffer__rfind_variants(void)
{
	git_buf a = GIT_BUF_INIT;
	ssize_t len;

	cl_git_pass(git_buf_sets(&a, "/this/is/it/"));

	len = (ssize_t)git_buf_len(&a);

	cl_assert(git_buf_rfind(&a, '/') == len - 1);
	cl_assert(git_buf_rfind_next(&a, '/') == len - 4);

	cl_assert(git_buf_rfind(&a, 'i') == len - 3);
	cl_assert(git_buf_rfind_next(&a, 'i') == len - 3);

	cl_assert(git_buf_rfind(&a, 'h') == 2);
	cl_assert(git_buf_rfind_next(&a, 'h') == 2);

	cl_assert(git_buf_rfind(&a, 'q') == -1);
	cl_assert(git_buf_rfind_next(&a, 'q') == -1);

Russell Belfer committed
642
	git_buf_free(&a);
643 644 645 646 647 648 649
}

void test_core_buffer__puts_escaped(void)
{
	git_buf a = GIT_BUF_INIT;

	git_buf_clear(&a);
650
	cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "", ""));
651 652 653
	cl_assert_equal_s("this is a test", a.ptr);

	git_buf_clear(&a);
654
	cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "t", "\\"));
655 656 657
	cl_assert_equal_s("\\this is a \\tes\\t", a.ptr);

	git_buf_clear(&a);
658
	cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "i ", "__"));
659 660 661
	cl_assert_equal_s("th__is__ __is__ a__ test", a.ptr);

	git_buf_clear(&a);
662
	cl_git_pass(git_buf_text_puts_escape_regex(&a, "^match\\s*[A-Z]+.*"));
663 664 665 666
	cl_assert_equal_s("\\^match\\\\s\\*\\[A-Z\\]\\+\\.\\*", a.ptr);

	git_buf_free(&a);
}
667 668 669 670 671

static void assert_unescape(char *expected, char *to_unescape) {
	git_buf buf = GIT_BUF_INIT;

	cl_git_pass(git_buf_sets(&buf, to_unescape));
672
	git_buf_text_unescape(&buf);
673
	cl_assert_equal_s(expected, buf.ptr);
674
	cl_assert_equal_sz(strlen(expected), buf.size);
675 676 677 678 679 680 681 682 683 684 685 686

	git_buf_free(&buf);
}

void test_core_buffer__unescape(void)
{
	assert_unescape("Escaped\\", "Es\\ca\\ped\\");
	assert_unescape("Es\\caped\\", "Es\\\\ca\\ped\\\\");
	assert_unescape("\\", "\\");
	assert_unescape("\\", "\\\\");
	assert_unescape("", "");
}
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711

void test_core_buffer__base64(void)
{
	git_buf buf = GIT_BUF_INIT;

	/*     t  h  i  s
	 * 0x 74 68 69 73
     * 0b 01110100 01101000 01101001 01110011
	 * 0b 011101 000110 100001 101001 011100 110000
	 * 0x 1d 06 21 29 1c 30
	 *     d  G  h  p  c  w
	 */
	cl_git_pass(git_buf_put_base64(&buf, "this", 4));
	cl_assert_equal_s("dGhpcw==", buf.ptr);

	git_buf_clear(&buf);
	cl_git_pass(git_buf_put_base64(&buf, "this!", 5));
	cl_assert_equal_s("dGhpcyE=", buf.ptr);

	git_buf_clear(&buf);
	cl_git_pass(git_buf_put_base64(&buf, "this!\n", 6));
	cl_assert_equal_s("dGhpcyEK", buf.ptr);

	git_buf_free(&buf);
}
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734

void test_core_buffer__classify_with_utf8(void)
{
	char *data0 = "Simple text\n";
	size_t data0len = 12;
	char *data1 = "Is that UTF-8 data I see…\nYep!\n";
	size_t data1len = 31;
	char *data2 = "Internal NUL!!!\000\n\nI see you!\n";
	size_t data2len = 29;
	git_buf b;

	b.ptr = data0; b.size = b.asize = data0len;
	cl_assert(!git_buf_text_is_binary(&b));
	cl_assert(!git_buf_text_contains_nul(&b));

	b.ptr = data1; b.size = b.asize = data1len;
	cl_assert(git_buf_text_is_binary(&b));
	cl_assert(!git_buf_text_contains_nul(&b));

	b.ptr = data2; b.size = b.asize = data2len;
	cl_assert(git_buf_text_is_binary(&b));
	cl_assert(git_buf_text_contains_nul(&b));
}
735

736 737 738 739 740 741
#define SIMILARITY_TEST_DATA_1 \
	"test data\nright here\ninline\ntada\nneeds more data\nlots of data\n" \
	"is this enough?\nthere has to be enough data to fill the hash array!\n" \
	"Apparently 191 bytes is the minimum amount of data needed.\nHere goes!\n" \
	"Let's make sure we've got plenty to go with here.\n   smile   \n"

742 743
void test_core_buffer__similarity_metric(void)
{
744
	git_hashsig *a, *b;
745 746 747 748 749
	git_buf buf = GIT_BUF_INIT;
	int sim;

	/* in the first case, we compare data to itself and expect 100% match */

750
	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1));
751 752
	cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
	cl_git_pass(git_hashsig_create(&b, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
753

754
	cl_assert_equal_i(100, git_hashsig_compare(a, b));
755

756 757
	git_hashsig_free(a);
	git_hashsig_free(b);
758

759
	/* if we change just a single byte, how much does that change magnify? */
760

761
	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1));
762
	cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
763 764 765 766 767
	cl_git_pass(git_buf_sets(&buf,
		"Test data\nright here\ninline\ntada\nneeds more data\nlots of data\n"
		"is this enough?\nthere has to be enough data to fill the hash array!\n"
		"Apparently 191 bytes is the minimum amount of data needed.\nHere goes!\n"
		 "Let's make sure we've got plenty to go with here.\n   smile   \n"));
768
	cl_git_pass(git_hashsig_create(&b, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
769

770
	sim = git_hashsig_compare(a, b);
771

772
	cl_assert(95 < sim && sim < 100); /* expect >95% similarity */
773

774 775
	git_hashsig_free(a);
	git_hashsig_free(b);
776

777
	/* let's try comparing data to a superset of itself */
778

779
	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1));
780
	cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
781 782
	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1
		"and if I add some more, it should still be pretty similar, yes?\n"));
783
	cl_git_pass(git_hashsig_create(&b, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
784

785
	sim = git_hashsig_compare(a, b);
786

787
	cl_assert(70 < sim && sim < 80); /* expect in the 70-80% similarity range */
788

789 790 791 792 793 794
	git_hashsig_free(a);
	git_hashsig_free(b);

	/* what if we keep about half the original data and add half new */

	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1));
795
	cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
796 797 798 799 800
	cl_git_pass(git_buf_sets(&buf,
		"test data\nright here\ninline\ntada\nneeds more data\nlots of data\n"
		"is this enough?\nthere has to be enough data to fill the hash array!\n"
		"okay, that's half the original\nwhat else can we add?\nmore data\n"
		 "one more line will complete this\nshort\nlines\ndon't\nmatter\n"));
801
	cl_git_pass(git_hashsig_create(&b, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
802

803
	sim = git_hashsig_compare(a, b);
804

805
	cl_assert(40 < sim && sim < 60); /* expect in the 40-60% similarity range */
806

807 808
	git_hashsig_free(a);
	git_hashsig_free(b);
809 810 811

	/* lastly, let's check that we can hash file content as well */

812
	cl_git_pass(git_buf_sets(&buf, SIMILARITY_TEST_DATA_1));
813
	cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, GIT_HASHSIG_NORMAL));
814 815

	cl_git_pass(git_futils_mkdir("scratch", NULL, 0755, GIT_MKDIR_PATH));
816 817 818
	cl_git_mkfile("scratch/testdata", SIMILARITY_TEST_DATA_1);
	cl_git_pass(git_hashsig_create_fromfile(
		&b, "scratch/testdata", GIT_HASHSIG_NORMAL));
819

820
	cl_assert_equal_i(100, git_hashsig_compare(a, b));
821

822 823
	git_hashsig_free(a);
	git_hashsig_free(b);
824 825 826 827

	git_buf_free(&buf);
	git_futils_rmdir_r("scratch", NULL, GIT_RMDIR_REMOVE_FILES);
}
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882


void test_core_buffer__similarity_metric_whitespace(void)
{
	git_hashsig *a, *b;
	git_buf buf = GIT_BUF_INIT;
	int sim, i, j;
	git_hashsig_option_t opt;
	const char *tabbed =
		"	for (s = 0; s < sizeof(sep) / sizeof(char); ++s) {\n"
		"		separator = sep[s];\n"
		"		expect = expect_values[s];\n"
		"\n"
		"		for (j = 0; j < sizeof(b) / sizeof(char*); ++j) {\n"
		"			for (i = 0; i < sizeof(a) / sizeof(char*); ++i) {\n"
		"				git_buf_join(&buf, separator, a[i], b[j]);\n"
		"				cl_assert_equal_s(*expect, buf.ptr);\n"
		"				expect++;\n"
		"			}\n"
		"		}\n"
		"	}\n";
	const char *spaced =
		"   for (s = 0; s < sizeof(sep) / sizeof(char); ++s) {\n"
		"       separator = sep[s];\n"
		"       expect = expect_values[s];\n"
		"\n"
		"       for (j = 0; j < sizeof(b) / sizeof(char*); ++j) {\n"
		"           for (i = 0; i < sizeof(a) / sizeof(char*); ++i) {\n"
		"               git_buf_join(&buf, separator, a[i], b[j]);\n"
		"               cl_assert_equal_s(*expect, buf.ptr);\n"
		"               expect++;\n"
		"           }\n"
		"       }\n"
		"   }\n";
	const char *crlf_spaced2 =
		"  for (s = 0; s < sizeof(sep) / sizeof(char); ++s) {\r\n"
		"    separator = sep[s];\r\n"
		"    expect = expect_values[s];\r\n"
		"\r\n"
		"    for (j = 0; j < sizeof(b) / sizeof(char*); ++j) {\r\n"
		"      for (i = 0; i < sizeof(a) / sizeof(char*); ++i) {\r\n"
		"        git_buf_join(&buf, separator, a[i], b[j]);\r\n"
		"        cl_assert_equal_s(*expect, buf.ptr);\r\n"
		"        expect++;\r\n"
		"      }\r\n"
		"    }\r\n"
		"  }\r\n";
	const char *text[3] = { tabbed, spaced, crlf_spaced2 };

	/* let's try variations of our own code with whitespace changes */

	for (opt = GIT_HASHSIG_NORMAL; opt <= GIT_HASHSIG_SMART_WHITESPACE; ++opt) {
		for (i = 0; i < 3; ++i) {
			for (j = 0; j < 3; ++j) {
				cl_git_pass(git_buf_sets(&buf, text[i]));
883
				cl_git_pass(git_hashsig_create(&a, buf.ptr, buf.size, opt));
884 885

				cl_git_pass(git_buf_sets(&buf, text[j]));
886
				cl_git_pass(git_hashsig_create(&b, buf.ptr, buf.size, opt));
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906

				sim = git_hashsig_compare(a, b);

				if (opt == GIT_HASHSIG_NORMAL) {
					if (i == j)
						cl_assert_equal_i(100, sim);
					else
						cl_assert(sim < 30); /* expect pretty different */
				} else {
					cl_assert_equal_i(100, sim);
				}

				git_hashsig_free(a);
				git_hashsig_free(b);
			}
		}
	}

	git_buf_free(&buf);
}
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988

#define check_buf(expected,buf) do { \
	cl_assert_equal_s(expected, buf.ptr); \
	cl_assert_equal_sz(strlen(expected), buf.size); } while (0)

void test_core_buffer__lf_and_crlf_conversions(void)
{
	git_buf src = GIT_BUF_INIT, tgt = GIT_BUF_INIT;

	/* LF source */

	git_buf_sets(&src, "lf\nlf\nlf\nlf\n");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("lf\r\nlf\r\nlf\r\nlf\r\n", tgt);

	cl_assert_equal_i(GIT_ENOTFOUND, git_buf_text_crlf_to_lf(&tgt, &src));
	/* no conversion needed if all LFs already */

	git_buf_sets(&src, "\nlf\nlf\nlf\nlf\nlf");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("\r\nlf\r\nlf\r\nlf\r\nlf\r\nlf", tgt);

	cl_assert_equal_i(GIT_ENOTFOUND, git_buf_text_crlf_to_lf(&tgt, &src));
	/* no conversion needed if all LFs already */

	/* CRLF source */

	git_buf_sets(&src, "crlf\r\ncrlf\r\ncrlf\r\ncrlf\r\n");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("crlf\r\ncrlf\r\ncrlf\r\ncrlf\r\n", tgt);
	check_buf(src.ptr, tgt);

	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("crlf\ncrlf\ncrlf\ncrlf\n", tgt);

	git_buf_sets(&src, "\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf", tgt);
	check_buf(src.ptr, tgt);

	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("\ncrlf\ncrlf\ncrlf\ncrlf\ncrlf", tgt);

	/* CRLF in LF text */

	git_buf_sets(&src, "\nlf\nlf\ncrlf\r\nlf\nlf\ncrlf\r\n");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("\r\nlf\r\nlf\r\ncrlf\r\nlf\r\nlf\r\ncrlf\r\n", tgt);
	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("\nlf\nlf\ncrlf\nlf\nlf\ncrlf\n", tgt);

	/* LF in CRLF text */

	git_buf_sets(&src, "\ncrlf\r\ncrlf\r\nlf\ncrlf\r\ncrlf");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("\r\ncrlf\r\ncrlf\r\nlf\r\ncrlf\r\ncrlf", tgt);
	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("\ncrlf\ncrlf\nlf\ncrlf\ncrlf", tgt);

	/* bare CR test */

	git_buf_sets(&src, "\rcrlf\r\nlf\nlf\ncr\rcrlf\r\nlf\ncr\r");

	cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src));
	check_buf("\rcrlf\r\nlf\r\nlf\r\ncr\rcrlf\r\nlf\r\ncr\r", tgt);
	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("\rcrlf\nlf\nlf\ncr\rcrlf\nlf\ncr\r", tgt);

	git_buf_sets(&src, "\rcr\r");
	cl_assert_equal_i(GIT_ENOTFOUND, git_buf_text_lf_to_crlf(&tgt, &src));
	cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src));
	check_buf("\rcr\r", tgt);

	git_buf_free(&src);
	git_buf_free(&tgt);
}