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

#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);
22
	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
23 24 25

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

	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);
38
	cl_assert_equal_s("shoop da 23 ", git_buf_cstr(&buf));
39 40 41

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

	git_buf_free(&buf);
}

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

	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 */
62
	cl_assert_equal_s("", git_buf_cstr(&buf));
63
	cl_assert(buf.size == 0);
64
	/* cl_assert(buf.asize == 0); -- should not assume what git_buf does */
65 66 67 68 69 70 71 72 73

	/* 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);
74
	cl_assert_equal_s("+", git_buf_cstr(&buf));
75 76 77 78

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

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

	git_buf_free(&buf);

	/* add data */
	git_buf_put(&buf, "xo", 2);
	cl_assert(git_buf_oom(&buf) == 0);
93
	cl_assert_equal_s("xo", git_buf_cstr(&buf));
94 95 96 97

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

	/* 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);
	}
105
	cl_assert_equal_s("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo",
106 107 108 109 110 111 112
					   git_buf_cstr(&buf));

	git_buf_free(&buf);

	/* set to string */
	git_buf_sets(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
113
	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
114 115 116 117

	/* append string */
	git_buf_puts(&buf, test_string);
	cl_assert(git_buf_oom(&buf) == 0);
118
	cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf));
119 120 121 122

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

	/* test clear */
	git_buf_clear(&buf);
127
	cl_assert_equal_s("", git_buf_cstr(&buf));
128 129

	git_buf_free(&buf);
130 131 132 133 134

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

135
	git_buf_copy_cstr(data, sizeof(data), &buf);
136
	cl_assert_equal_s(REP4("0123456789"), data);
137
	git_buf_copy_cstr(data, 11, &buf);
138
	cl_assert_equal_s("0123456789", data);
139
	git_buf_copy_cstr(data, 3, &buf);
140
	cl_assert_equal_s("01", data);
141
	git_buf_copy_cstr(data, 1, &buf);
142
	cl_assert_equal_s("", data);
143

144
	git_buf_copy_cstr(data, sizeof(data), &buf);
145
	cl_assert_equal_s(REP4("0123456789"), data);
146 147 148 149

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

	git_buf_free(&buf);

155
	git_buf_copy_cstr(data, sizeof(data), &buf);
156
	cl_assert_equal_s("", data);
157 158 159 160 161 162 163 164 165 166
}

/* 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);
167
	cl_assert_equal_s(test_4096, git_buf_cstr(&buf));
168 169 170 171

	/* append string */
	git_buf_puts(&buf, test_4096);
	cl_assert(git_buf_oom(&buf) == 0);
172
	cl_assert_equal_s(test_8192, git_buf_cstr(&buf));
173 174 175 176

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

	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 */
195
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
196 197

	git_buf_consume(&buf, NULL);
198
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
199 200

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

	git_buf_consume(&buf, buf.ptr);
204
	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
205 206

	git_buf_consume(&buf, buf.ptr + 1);
207
	cl_assert_equal_s("2341234123412341234", git_buf_cstr(&buf));
208 209

	git_buf_consume(&buf, buf.ptr + buf.size);
210
	cl_assert_equal_s("", git_buf_cstr(&buf));
211 212 213 214 215 216 217 218 219 220

	git_buf_free(&buf);
}


static void
check_buf_append(
	const char* data_a,
	const char* data_b,
	const char* expected_data,
221 222
	size_t expected_size,
	size_t expected_asize)
223 224 225 226 227 228 229
{
	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);
230
	cl_assert_equal_s(expected_data, git_buf_cstr(&tgt));
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
	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);
253
	cl_assert_equal_s(buf_a, git_buf_cstr(&buf));
254 255 256

	git_buf_puts(&buf, buf_b);
	cl_assert(git_buf_oom(&buf) == 0);
257
	cl_assert_equal_s(expected_ab, git_buf_cstr(&buf));
258 259 260

	git_buf_puts(&buf, buf_c);
	cl_assert(git_buf_oom(&buf) == 0);
261
	cl_assert_equal_s(expected_abc, git_buf_cstr(&buf));
262 263 264

	git_buf_puts(&buf, buf_a);
	cl_assert(git_buf_oom(&buf) == 0);
265
	cl_assert_equal_s(expected_abca, git_buf_cstr(&buf));
266 267 268

	git_buf_puts(&buf, buf_b);
	cl_assert(git_buf_oom(&buf) == 0);
269
	cl_assert_equal_s(expected_abcab, git_buf_cstr(&buf));
270 271 272

	git_buf_puts(&buf, buf_c);
	cl_assert(git_buf_oom(&buf) == 0);
273
	cl_assert_equal_s(expected_abcabc, git_buf_cstr(&buf));
274 275 276 277 278 279 280 281

	git_buf_free(&buf);
}

/* more variations on append tests */
void test_core_buffer__5(void)
{
	check_buf_append("", "", "", 0, 8);
282 283
	check_buf_append("a", "", "a", 1, 8);
	check_buf_append("", "a", "a", 1, 8);
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
	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);
301
	check_buf_append("abcdefgh", "ijklmno", "abcdefghijklmno", 15, 16);
302 303 304 305 306 307
	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);

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

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

333 334
	cl_assert_equal_s("foo", git_buf_cstr(&a));
	cl_assert_equal_s("bar", git_buf_cstr(&b));
335 336 337

	git_buf_swap(&a, &b);

338 339
	cl_assert_equal_s("bar", git_buf_cstr(&a));
	cl_assert_equal_s("foo", git_buf_cstr(&b));
340 341 342 343 344 345

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


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

	git_buf_sets(&a, "foo");
	cl_assert(git_buf_oom(&a) == 0);
355
	cl_assert_equal_s("foo", git_buf_cstr(&a));
356

357
	b = git_buf_detach(&a);
358

359 360
	cl_assert_equal_s("foo", b);
	cl_assert_equal_s("", a.ptr);
361 362
	git__free(b);

363
	b = git_buf_detach(&a);
364

365 366
	cl_assert_equal_s(NULL, b);
	cl_assert_equal_s("", a.ptr);
367 368

	git_buf_free(&a);
369 370 371 372

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

373
	cl_assert_equal_s(fun, a.ptr);
374 375
	cl_assert(a.size == strlen(fun));
	cl_assert(a.asize == strlen(fun) + 1);
376 377 378 379 380 381

	git_buf_free(&a);

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

382
	cl_assert_equal_s(fun, a.ptr);
383 384
	cl_assert(a.size == strlen(fun));
	cl_assert(a.asize == strlen(fun) + 1);
385 386

	git_buf_free(&a);
387 388 389 390
}


static void
391 392 393 394 395 396 397 398 399 400
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);
401
	cl_assert_equal_s(expected, git_buf_cstr(&buf));
402 403 404 405 406
	git_buf_free(&buf);
}

static void
check_joinbuf_n_2(
407 408 409 410 411 412 413 414 415 416
	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);

417
	git_buf_join_n(&buf, sep, 1, b);
418
	cl_assert(git_buf_oom(&buf) == 0);
419
	cl_assert_equal_s(expected, git_buf_cstr(&buf));
420 421 422 423 424

	git_buf_free(&buf);
}

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

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

445
	git_buf_join_n(&a, '/', 1, "foo");
446
	cl_assert(git_buf_oom(&a) == 0);
447
	cl_assert_equal_s("foo", git_buf_cstr(&a));
448

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

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

	git_buf_free(&a);

459 460 461 462 463 464 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
	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;");
503 504
}

505 506 507 508 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
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]);
539
				cl_assert_equal_s(*expect, buf.ptr);
540 541 542 543 544 545 546
				expect++;
			}
		}
	}

	git_buf_free(&buf);
}
547 548 549 550 551 552

void test_core_buffer__10(void)
{
	git_buf a = GIT_BUF_INIT;

	cl_git_pass(git_buf_join_n(&a, '/', 1, "test"));
553
	cl_assert_equal_s(a.ptr, "test");
554
	cl_git_pass(git_buf_join_n(&a, '/', 1, "string"));
555
	cl_assert_equal_s(a.ptr, "test/string");
556 557
	git_buf_clear(&a);
	cl_git_pass(git_buf_join_n(&a, '/', 3, "test", "string", "join"));
558
	cl_assert_equal_s(a.ptr, "test/string/join");
559
	cl_git_pass(git_buf_join_n(&a, '/', 2, a.ptr, "more"));
560
	cl_assert_equal_s(a.ptr, "test/string/join/test/string/join/more");
561 562 563

	git_buf_free(&a);
}
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613

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;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "");

	t.strings = t2;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "some");

	t.strings = t3;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "");

	t.strings = t4;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "happ");

	t.strings = t5;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "happ");

	t.strings = t6;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "");

	t.strings = t7;
	t.count = 3;
	cl_git_pass(git_buf_common_prefix(&a, &t));
	cl_assert_equal_s(a.ptr, "");

	git_buf_free(&a);
}