/* Tests to parse non-valid git diffs. */ static svn_error_t * test_bad_git_diff_headers(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_patch_t *patch; svn_diff_hunk_t *hunk; SVN_ERR(create_patch_file(&patch_file, bad_git_diff_header, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota.copied"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_copied); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'iota'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'iota'." NL "some more bytes to 'iota'" NL, pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * short_string_table_body(svn_boolean_t do_load_store, apr_pool_t *pool) { apr_size_t indexes[STRING_COUNT] = { 0 }; string_table_builder_t *builder; string_table_t *table; int i; builder = svn_fs_x__string_table_builder_create(pool); for (i = 0; i < STRING_COUNT; ++i) indexes[i] = svn_fs_x__string_table_builder_add(builder, basic_strings[i], 0); table = svn_fs_x__string_table_create(builder, pool); if (do_load_store) SVN_ERR(store_and_load_table(&table, pool)); SVN_TEST_ASSERT(indexes[2] == indexes[6]); for (i = 0; i < STRING_COUNT; ++i) { apr_size_t len; const char *string = svn_fs_x__string_table_get(table, indexes[i], &len, pool); SVN_TEST_STRING_ASSERT(string, basic_strings[i]); SVN_TEST_ASSERT(len == strlen(string)); SVN_TEST_ASSERT(len == strlen(basic_strings[i])); } SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, STRING_COUNT, NULL, pool), ""); return SVN_NO_ERROR; }
static svn_error_t * test_svn_subst_translate_string2(apr_pool_t *pool) { static const struct translate_string2_data_t tests[] = { /* No reencoding, no translation of line endings */ { "abcdefz", "abcdefz", FALSE, FALSE }, /* No reencoding, translation of line endings */ { " \r\n\r\n \r\n \r\n", " \n\n \n \n", FALSE, TRUE }, /* Reencoding, no translation of line endings */ { "\xc7\xa9\xf4\xdf", "\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f", TRUE, FALSE }, /* Reencoding, translation of line endings */ { "\xc7\xa9\xf4\xdf\r\n", "\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f\n", TRUE, TRUE }, { NULL, NULL, FALSE, FALSE } }; const struct translate_string2_data_t *t; for (t = tests; t->source != NULL; t++) { svn_string_t *source_string = svn_string_create(t->source, pool); svn_string_t *new_value = NULL; svn_boolean_t translated_line_endings = ! t->translated_line_endings; svn_boolean_t translated_to_utf8; SVN_ERR(svn_subst_translate_string2(&new_value, NULL, &translated_line_endings, source_string, "ISO-8859-1", FALSE, pool, pool)); SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str); SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings); new_value = NULL; translated_to_utf8 = ! t->translated_to_utf8; translated_line_endings = ! t->translated_line_endings; SVN_ERR(svn_subst_translate_string2(&new_value, &translated_to_utf8, &translated_line_endings, source_string, "ISO-8859-1", FALSE, pool, pool)); SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str); SVN_TEST_ASSERT(translated_to_utf8 == t->translated_to_utf8); SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings); } /* Test that when REPAIR is FALSE, SVN_ERR_IO_INCONSISTENT_EOL is returned. */ { svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool); svn_string_t *new_value = NULL; svn_error_t *err = svn_subst_translate_string2(&new_value, NULL, NULL, source_string, "ISO-8859-1", FALSE, pool, pool); SVN_TEST_ASSERT_ERROR(err, SVN_ERR_IO_INCONSISTENT_EOL); } return SVN_NO_ERROR; }
static svn_error_t * test_expand(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file, *val; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); /* Get expanded "g" which requires expanding "c". */ svn_config_get(cfg, &val, "section1", "g", NULL); /* Get expanded "c". */ svn_config_get(cfg, &val, "section1", "c", NULL); /* With pool debugging enabled this ensures that the expanded value of "c" was not created in a temporary pool when expanding "g". */ SVN_TEST_STRING_ASSERT(val, "bar"); /* Get expanded "j" and "k" which have cyclic definitions. * They must return empty values. */ svn_config_get(cfg, &val, "section1", "j", NULL); SVN_TEST_STRING_ASSERT(val, ""); svn_config_get(cfg, &val, "section1", "k", NULL); SVN_TEST_STRING_ASSERT(val, ""); /* Get expanded "l" which depends on a cyclic definition. * So, it also considered "undefined" and will be normalized to "". */ svn_config_get(cfg, &val, "section1", "l", NULL); SVN_TEST_STRING_ASSERT(val, ""); return SVN_NO_ERROR; }
static svn_error_t * test_parse_property_and_text_diff(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_patch_t *patch; svn_prop_patch_t *prop_patch; svn_diff_hunk_t *hunk; apr_array_header_t *hunks; SVN_ERR(create_patch_file(&patch_file, property_and_text_unidiff, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota"); SVN_TEST_ASSERT(patch->hunks->nelts == 1); SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 1); /* Check contents of text hunk */ hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'iota'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'iota'." NL "some more bytes to 'iota'" NL, pool)); /* Check the added property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_add", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "", pool)); SVN_ERR(check_content(hunk, FALSE, "value" NL, pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_svn_subst_translate_cstring2(apr_pool_t *pool) { static const struct translate_cstring2_data_t tests[] = { /* Test the unusual case where EOL_STR is an empty string. */ { " \r \n\r\n \n\n\n", "", TRUE, " " }, /* Test the unusual case where EOL_STR is not a standard EOL string. */ { " \r \n\r\n \n\n\n", "z", TRUE, " z zz zzz" }, { " \n \n ", "buzz", FALSE, " buzz buzz " }, { " \r\n \n", "buzz", TRUE , " buzz buzz"}, { NULL, NULL, FALSE, NULL } }; const struct translate_cstring2_data_t *t; for (t = tests; t->source != NULL; t++) { const char *result = NULL; SVN_ERR(svn_subst_translate_cstring2(t->source, &result, t->eol_str, t->repair, NULL, FALSE, pool)); SVN_TEST_STRING_ASSERT(result, t->expected_str); } return SVN_NO_ERROR; }
static svn_error_t * test_stream_base64(apr_pool_t *pool) { svn_stream_t *stream; svn_stringbuf_t *actual = svn_stringbuf_create_empty(pool); svn_stringbuf_t *expected = svn_stringbuf_create_empty(pool); int i; static const char *strings[] = { "fairly boring test data... blah blah", "A", "abc", "012345679", NULL }; stream = svn_stream_from_stringbuf(actual, pool); stream = svn_base64_decode(stream, pool); stream = svn_base64_encode(stream, pool); for (i = 0; strings[i]; i++) { apr_size_t len = strlen(strings[i]); svn_stringbuf_appendbytes(expected, strings[i], len); SVN_ERR(svn_stream_write(stream, strings[i], &len)); } SVN_ERR(svn_stream_close(stream)); SVN_TEST_STRING_ASSERT(actual->data, expected->data); return SVN_NO_ERROR; }
/* Check that reading a line from HUNK equals what's inside EXPECTED. * If ORIGINAL is TRUE, read the original hunk text; else, read the * modified hunk text. */ static svn_error_t * check_content(svn_diff_hunk_t *hunk, svn_boolean_t original, const char *expected, apr_pool_t *pool) { svn_stream_t *exp; svn_stringbuf_t *exp_buf; svn_stringbuf_t *hunk_buf; svn_boolean_t exp_eof; svn_boolean_t hunk_eof; exp = svn_stream_from_string(svn_string_create(expected, pool), pool); while (TRUE) { SVN_ERR(svn_stream_readline(exp, &exp_buf, NL, &exp_eof, pool)); if (original) SVN_ERR(svn_diff_hunk_readline_original_text(hunk, &hunk_buf, NULL, &hunk_eof, pool, pool)); else SVN_ERR(svn_diff_hunk_readline_modified_text(hunk, &hunk_buf, NULL, &hunk_eof, pool, pool)); SVN_TEST_ASSERT(exp_eof == hunk_eof); if (exp_eof) break; SVN_TEST_STRING_ASSERT(exp_buf->data, hunk_buf->data); } if (!hunk_eof) SVN_TEST_ASSERT(hunk_buf->len == 0); return SVN_NO_ERROR; }
static svn_error_t * test_parse_unidiff_lacking_trailing_eol(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_boolean_t reverse; svn_boolean_t ignore_whitespace; int i; apr_pool_t *iterpool; reverse = FALSE; ignore_whitespace = FALSE; iterpool = svn_pool_create(pool); for (i = 0; i < 2; i++) { svn_patch_t *patch; svn_diff_hunk_t *hunk; svn_pool_clear(iterpool); SVN_ERR(create_patch_file(&patch_file, unidiff_lacking_trailing_eol, pool)); /* We have one patch with one hunk. Parse it. */ SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, reverse, ignore_whitespace, iterpool, iterpool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "A/C/gamma"); SVN_TEST_STRING_ASSERT(patch->new_filename, "A/C/gamma"); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, ! reverse, "This is the file 'gamma'." NL, pool)); SVN_ERR(check_content(hunk, reverse, "This is the file 'gamma'." NL "some more bytes to 'gamma'", pool)); reverse = !reverse; SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); } svn_pool_destroy(iterpool); return SVN_NO_ERROR; }
static svn_error_t * test_svn_subst_build_keywords3(apr_pool_t *pool) { /* Test expansion of custom keywords. */ struct keywords_tests_data { const char *keyword_name; const char *keywords_string; const char *expanded_keyword; const char *rev; const char *url; const char *repos_root_url; /* Can't test date since expanded value depends on local clock. */ const char *author; } tests[] = { {"FOO", "FOO=%P%_%a%_%b%_%%", "trunk/foo.txt stsp foo.txt %", "1234", "http://svn.example.com/repos/trunk/foo.txt", "http://svn.example.com/repos", "stsp"}, {"FOO", "FOO=author%_=%_%a", "author = stsp", "1234", "http://svn.example.com/repos/trunk/foo.txt", "http://svn.example.com/repos", "stsp"}, {"MyKeyword", "MyKeyword=%r%_%u%_%_%a", "4567 http://svn.example.com/svn/branches/myfile jrandom", "4567", "http://svn.example.com/svn/branches/myfile", "http://svn.example.com/svn", "jrandom"}, {"FreeBSD", "FreeBSD=%H", "head/README 222812 joel", /* date is not expanded in this test */ "222812", "http://svn.freebsd.org/base/head/README", "http://svn.freebsd.org/base", "joel"}, {"FreeBSD", "FreeBSD=%I", "README 222812 joel", /* date is not expanded in this test */ "222812", "http://svn.freebsd.org/base/head/README", "http://svn.freebsd.org/base", "joel"}, { NULL, NULL, NULL, NULL, NULL, NULL, NULL} }; const struct keywords_tests_data *t; for (t = tests; t->keyword_name != NULL; t++) { apr_hash_t *kw; svn_string_t *expanded_keyword; SVN_ERR(svn_subst_build_keywords3(&kw, t->keywords_string, t->rev, t->url, t->repos_root_url, 0 /* date */, t->author, pool)); expanded_keyword = svn_hash_gets(kw, t->keyword_name); SVN_TEST_ASSERT(expanded_keyword != NULL); SVN_TEST_STRING_ASSERT(expanded_keyword->data, t->expanded_keyword); } return SVN_NO_ERROR; }
static svn_error_t * create_empty_table_body(svn_boolean_t do_load_store, apr_pool_t *pool) { string_table_builder_t *builder = svn_fs_x__string_table_builder_create(pool); string_table_t *table = svn_fs_x__string_table_create(builder, pool); SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), ""); if (do_load_store) SVN_ERR(store_and_load_table(&table, pool)); SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), ""); return SVN_NO_ERROR; }
static svn_error_t * test_stringbuf_from_stream(apr_pool_t *pool) { const char *test_cases[] = { "", "x", "this string is longer than the default 64 minimum block size used" "by the function under test", NULL }; const char **test_case; for (test_case = test_cases; *test_case; ++test_case) { svn_stringbuf_t *result1, *result2, *result3, *result4; svn_stringbuf_t *original = svn_stringbuf_create(*test_case, pool); svn_stream_t *stream1 = svn_stream_from_stringbuf(original, pool); svn_stream_t *stream2 = svn_stream_from_stringbuf(original, pool); SVN_ERR(svn_stringbuf_from_stream(&result1, stream1, 0, pool)); SVN_ERR(svn_stringbuf_from_stream(&result2, stream1, 0, pool)); SVN_ERR(svn_stringbuf_from_stream(&result3, stream2, original->len, pool)); SVN_ERR(svn_stringbuf_from_stream(&result4, stream2, original->len, pool)); /* C-string contents must match */ SVN_TEST_STRING_ASSERT(result1->data, original->data); SVN_TEST_STRING_ASSERT(result2->data, ""); SVN_TEST_STRING_ASSERT(result3->data, original->data); SVN_TEST_STRING_ASSERT(result4->data, ""); /* assumed length must match */ SVN_TEST_ASSERT(result1->len == original->len); SVN_TEST_ASSERT(result2->len == 0); SVN_TEST_ASSERT(result3->len == original->len); SVN_TEST_ASSERT(result4->len == 0); } return SVN_NO_ERROR; }
static svn_error_t * test_git_diffs_with_spaces_diff(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_patch_t *patch; SVN_ERR(create_patch_file(&patch_file, path_with_spaces_unidiff, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "path 1"); SVN_TEST_STRING_ASSERT(patch->new_filename, "path 1"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_added); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "path one 1"); SVN_TEST_STRING_ASSERT(patch->new_filename, "path one 1"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_added); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "dir/ b/path"); SVN_TEST_STRING_ASSERT(patch->new_filename, "dir/ b/path"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_added); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, " b/path 1"); SVN_TEST_STRING_ASSERT(patch->new_filename, " b/path 1"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_added); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_serialization(apr_pool_t *pool) { svn_stringbuf_t *original_content; svn_stringbuf_t *written_content; svn_config_t *cfg; const struct { const char *section; const char *option; const char *value; } test_data[] = { { "my section", "value1", "some" }, { "my section", "value2", "something" }, { "another Section", "value1", "one" }, { "another Section", "value2", "two" }, { "another Section", "value 3", "more" }, }; int i; /* Format the original with the same formatting that the writer will use. */ original_content = svn_stringbuf_create("\n[my section]\n" "value1=some\n" "value2=%(value1)sthing\n" "\n[another Section]\n" "value1=one\n" "value2=two\n" "value 3=more\n", pool); written_content = svn_stringbuf_create_empty(pool); SVN_ERR(svn_config_parse(&cfg, svn_stream_from_stringbuf(original_content, pool), TRUE, TRUE, pool)); SVN_ERR(svn_config__write(svn_stream_from_stringbuf(written_content, pool), cfg, pool)); SVN_ERR(svn_config_parse(&cfg, svn_stream_from_stringbuf(written_content, pool), TRUE, TRUE, pool)); /* The serialized and re-parsed config must have the expected contents. */ for (i = 0; i < sizeof(test_data) / sizeof(test_data[0]); ++i) { const char *val; svn_config_get(cfg, &val, test_data[i].section, test_data[i].option, NULL); SVN_TEST_STRING_ASSERT(val, test_data[i].value); } return SVN_NO_ERROR; }
static svn_error_t * test_stream_seek_stringbuf(apr_pool_t *pool) { svn_stream_t *stream; svn_stringbuf_t *stringbuf; char buf[4]; apr_size_t len; svn_stream_mark_t *mark; stringbuf = svn_stringbuf_create("OneTwo", pool); stream = svn_stream_from_stringbuf(stringbuf, pool); len = 3; SVN_ERR(svn_stream_read_full(stream, buf, &len)); buf[3] = '\0'; SVN_TEST_STRING_ASSERT(buf, "One"); SVN_ERR(svn_stream_mark(stream, &mark, pool)); len = 3; SVN_ERR(svn_stream_read_full(stream, buf, &len)); buf[3] = '\0'; SVN_TEST_STRING_ASSERT(buf, "Two"); SVN_ERR(svn_stream_seek(stream, mark)); len = 3; SVN_ERR(svn_stream_read_full(stream, buf, &len)); buf[3] = '\0'; SVN_TEST_STRING_ASSERT(buf, "Two"); /* Go back to the begin of last word and try to skip some of it */ SVN_ERR(svn_stream_seek(stream, mark)); SVN_ERR(svn_stream_skip(stream, 2)); /* The remaining line should be empty */ len = 3; SVN_ERR(svn_stream_read_full(stream, buf, &len)); buf[len] = '\0'; SVN_TEST_ASSERT(len == 1); SVN_TEST_STRING_ASSERT(buf, "o"); SVN_ERR(svn_stream_close(stream)); return SVN_NO_ERROR; }
static svn_error_t * test_compress_lz4_empty(apr_pool_t *pool) { svn_stringbuf_t *compressed = svn_stringbuf_create_empty(pool); svn_stringbuf_t *decompressed = svn_stringbuf_create_empty(pool); SVN_ERR(svn__compress_lz4("", 0, compressed)); SVN_ERR(svn__decompress_lz4(compressed->data, compressed->len, decompressed, 100)); SVN_TEST_STRING_ASSERT(decompressed->data, ""); return SVN_NO_ERROR; }
static svn_error_t * test_one_long_keyword(const char *keyword, const char *expected, apr_pool_t *pool) { svn_string_t *src_string; svn_stream_t *src_stream, *dst_stream; svn_stringbuf_t *dst_stringbuf, *src_stringbuf; apr_hash_t *keywords = apr_hash_make(pool); svn_string_t *expanded = svn_string_create("abcdefg", pool); svn_hash_sets(keywords, keyword, expanded); /* Expand */ src_string = svn_string_createf(pool, "$%s$", keyword); src_stream = svn_stream_from_string(src_string, pool); dst_stringbuf = svn_stringbuf_create_empty(pool); dst_stream = svn_stream_from_stringbuf(dst_stringbuf, pool); dst_stream = svn_subst_stream_translated(dst_stream, NULL, FALSE, keywords, TRUE, pool); SVN_ERR(svn_stream_copy3(src_stream, dst_stream, NULL, NULL, pool)); SVN_TEST_STRING_ASSERT(dst_stringbuf->data, expected); /* Unexpand */ src_stringbuf = dst_stringbuf; src_stream = svn_stream_from_stringbuf(src_stringbuf, pool); dst_stringbuf = svn_stringbuf_create_empty(pool); dst_stream = svn_stream_from_stringbuf(dst_stringbuf, pool); dst_stream = svn_subst_stream_translated(dst_stream, NULL, FALSE, keywords, FALSE, pool); SVN_ERR(svn_stream_copy3(src_stream, dst_stream, NULL, NULL, pool)); SVN_TEST_STRING_ASSERT(dst_stringbuf->data, src_string->data); return SVN_NO_ERROR; }
static svn_error_t * test_repairing_svn_subst_translate_string2(apr_pool_t *pool) { { svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool); svn_string_t *new_value = NULL; SVN_ERR(svn_subst_translate_string2(&new_value, NULL, NULL, source_string, "ISO-8859-1", TRUE, pool, pool)); SVN_TEST_ASSERT(new_value != NULL); SVN_TEST_ASSERT(new_value->data != NULL); SVN_TEST_STRING_ASSERT(new_value->data, " \n \n \n "); } return SVN_NO_ERROR; }
static svn_error_t * test_compress_lz4(apr_pool_t *pool) { const char input[] = "aaaabbbbccccaaaaccccbbbbaaaabbbb" "aaaabbbbccccaaaaccccbbbbaaaabbbb" "aaaabbbbccccaaaaccccbbbbaaaabbbb"; svn_stringbuf_t *compressed = svn_stringbuf_create_empty(pool); svn_stringbuf_t *decompressed = svn_stringbuf_create_empty(pool); SVN_ERR(svn__compress_lz4(input, sizeof(input), compressed)); SVN_ERR(svn__decompress_lz4(compressed->data, compressed->len, decompressed, 100)); SVN_TEST_STRING_ASSERT(decompressed->data, input); return SVN_NO_ERROR; }
static svn_error_t * test_decompress_lz4(apr_pool_t *pool) { const char input[] = "\x61\xc0\x61\x61\x61\x61\x62\x62\x62\x62\x63\x63\x63\x63\x0c\x00\x00\x08" "\x00\x00\x10\x00\x00\x0c\x00\x08\x08\x00\x00\x18\x00\x00\x14\x00\x00\x08" "\x00\x08\x18\x00\x00\x14\x00\x00\x10\x00\x00\x18\x00\x00\x0c\x00\x00\x08" "\x00\x00\x10\x00\x90\x61\x61\x61\x61\x62\x62\x62\x62"; svn_stringbuf_t *decompressed = svn_stringbuf_create_empty(pool); SVN_ERR(svn__decompress_lz4(input, sizeof(input), decompressed, 100)); SVN_TEST_STRING_ASSERT(decompressed->data, "aaaabbbbccccaaaaccccbbbbaaaabbbb" "aaaabbbbccccaaaaccccbbbbaaaabbbb" "aaaabbbbccccaaaaccccbbbbaaaabbbb"); return SVN_NO_ERROR; }
static svn_error_t * many_strings_table_body(svn_boolean_t do_load_store, apr_pool_t *pool) { /* cause multiple sub-tables (6 to be exact) to be created */ enum { COUNT = 100 }; svn_stringbuf_t *strings[COUNT] = { 0 }; apr_size_t indexes[COUNT] = { 0 }; string_table_builder_t *builder; string_table_t *table; int i; builder = svn_fs_x__string_table_builder_create(pool); for (i = 0; i < COUNT; ++i) { strings[i] = generate_string(APR_UINT64_C(0x1234567876543210) * (i + 1), (i * i) % 23000, pool); indexes[i] = svn_fs_x__string_table_builder_add(builder, strings[i]->data, strings[i]->len); } table = svn_fs_x__string_table_create(builder, pool); if (do_load_store) SVN_ERR(store_and_load_table(&table, pool)); for (i = 0; i < COUNT; ++i) { apr_size_t len; const char *string = svn_fs_x__string_table_get(table, indexes[i], &len, pool); SVN_TEST_STRING_ASSERT(string, strings[i]->data); SVN_TEST_ASSERT(len == strlen(string)); SVN_TEST_ASSERT(len == strings[i]->len); } return SVN_NO_ERROR; }
/* The body of the svn_subst_translate_string2_null_encoding test. It should only be called by test_svn_subst_translate_string2_null_encoding(), as this code assumes that the process locale has been changed to a locale that uses either CP-1252 or ISO-8859-1 for the default narrow string encoding. */ static svn_error_t * test_svn_subst_translate_string2_null_encoding_helper(apr_pool_t *pool) { { svn_string_t *new_value = NULL; svn_boolean_t translated_to_utf8 = FALSE; svn_boolean_t translated_line_endings = TRUE; /* The 'AE' ligature, which is 0xc6 in both ISO-8859-1 and Windows-1252 */ svn_string_t *source_string = svn_string_create("\xc6", pool); SVN_ERR(svn_subst_translate_string2(&new_value, &translated_to_utf8, &translated_line_endings, source_string, NULL, FALSE, pool, pool)); SVN_TEST_STRING_ASSERT(new_value->data, "\xc3\x86"); SVN_TEST_ASSERT(translated_to_utf8); SVN_TEST_ASSERT(!translated_line_endings); } return SVN_NO_ERROR; }
static svn_error_t * test_svn_subst_truncated_keywords(apr_pool_t *pool) { svn_string_t *src_string = svn_string_create("$Qq: " "01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567" " $", pool); svn_stream_t *src_stream = svn_stream_from_string(src_string, pool); svn_stringbuf_t *dst_stringbuf = svn_stringbuf_create_empty(pool); svn_stream_t *dst_stream = svn_stream_from_stringbuf(dst_stringbuf, pool); apr_hash_t *keywords = apr_hash_make(pool); svn_string_t *expanded = svn_string_create("01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567" "xxxxxxxxxx", pool); /* The source is already at the maximum length. */ SVN_TEST_ASSERT(src_string->len == SVN_KEYWORD_MAX_LEN); svn_hash_sets(keywords, "Qq", expanded); dst_stream = svn_subst_stream_translated(dst_stream, NULL, FALSE, keywords, TRUE, pool); SVN_ERR(svn_stream_copy3(src_stream, dst_stream, NULL, NULL, pool)); /* The expanded value would make the keyword longer than the maximum allowed so it must be truncated; the remaining part of the expanded value is the same as the source. */ SVN_TEST_STRING_ASSERT(dst_stringbuf->data, src_string->data); return SVN_NO_ERROR; }
static svn_error_t * test_expand(const svn_test_opts_t *opts, apr_pool_t *pool) { svn_config_t *cfg; const char *cfg_file, *val; SVN_ERR(get_config_file_path(&cfg_file, opts, pool)); SVN_ERR(svn_config_read3(&cfg, cfg_file, TRUE, TRUE, FALSE, pool)); /* Get expanded "g" which requires expanding "c". */ svn_config_get(cfg, &val, "section1", "g", NULL); /* Get expanded "c". */ svn_config_get(cfg, &val, "section1", "c", NULL); /* With pool debugging enabled this ensures that the expanded value of "c" was not created in a temporary pool when expanding "g". */ SVN_TEST_STRING_ASSERT(val, "bar"); return SVN_NO_ERROR; }
static svn_error_t * test_parse_git_tree_and_text_diff(apr_pool_t *pool) { /* ### Should we check for reversed diffs? */ svn_patch_file_t *patch_file; svn_patch_t *patch; svn_diff_hunk_t *hunk; SVN_ERR(create_patch_file(&patch_file, git_tree_and_text_unidiff, pool)); /* Parse a copied file with text modifications. */ SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota.copied"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_copied); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'iota'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'iota'." NL "some more bytes to 'iota'" NL, pool)); /* Parse a moved file with text modifications. */ SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "A/mu"); SVN_TEST_STRING_ASSERT(patch->new_filename, "A/mu.moved"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_moved); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'mu'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'mu'." NL "some more bytes to 'mu'" NL, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "/dev/null"); SVN_TEST_STRING_ASSERT(patch->new_filename, "new"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_added); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "", pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'new'." NL, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "A/B/lambda"); SVN_TEST_STRING_ASSERT(patch->new_filename, "/dev/null"); SVN_TEST_ASSERT(patch->operation == svn_diff_op_deleted); SVN_TEST_ASSERT(patch->hunks->nelts == 1); hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'lambda'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "", pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_stream_seek_translated(apr_pool_t *pool) { svn_stream_t *stream, *translated_stream; svn_stringbuf_t *stringbuf; char buf[44]; /* strlen("One$MyKeyword: my keyword was expanded $Two") + \0 */ apr_size_t len; svn_stream_mark_t *mark; apr_hash_t *keywords; svn_string_t *keyword_val; keywords = apr_hash_make(pool); keyword_val = svn_string_create("my keyword was expanded", pool); apr_hash_set(keywords, "MyKeyword", APR_HASH_KEY_STRING, keyword_val); stringbuf = svn_stringbuf_create("One$MyKeyword$Two", pool); stream = svn_stream_from_stringbuf(stringbuf, pool); translated_stream = svn_subst_stream_translated(stream, APR_EOL_STR, FALSE, keywords, TRUE, pool); /* Seek from outside of keyword to inside of keyword. */ len = 25; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 25); buf[25] = '\0'; SVN_TEST_STRING_ASSERT(buf, "One$MyKeyword: my keyword"); SVN_ERR(svn_stream_mark(translated_stream, &mark, pool)); SVN_ERR(svn_stream_reset(translated_stream)); SVN_ERR(svn_stream_seek(translated_stream, mark)); len = 4; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 4); buf[4] = '\0'; SVN_TEST_STRING_ASSERT(buf, " was"); SVN_ERR(svn_stream_seek(translated_stream, mark)); SVN_ERR(svn_stream_skip(translated_stream, 2)); len = 2; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 2); buf[len] = '\0'; SVN_TEST_STRING_ASSERT(buf, "as"); /* Seek from inside of keyword to inside of keyword. */ SVN_ERR(svn_stream_mark(translated_stream, &mark, pool)); len = 9; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 9); buf[9] = '\0'; SVN_TEST_STRING_ASSERT(buf, " expanded"); SVN_ERR(svn_stream_seek(translated_stream, mark)); len = 9; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 9); buf[9] = '\0'; SVN_TEST_STRING_ASSERT(buf, " expanded"); SVN_ERR(svn_stream_seek(translated_stream, mark)); SVN_ERR(svn_stream_skip(translated_stream, 6)); len = 3; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 3); buf[len] = '\0'; SVN_TEST_STRING_ASSERT(buf, "ded"); /* Seek from inside of keyword to outside of keyword. */ SVN_ERR(svn_stream_mark(translated_stream, &mark, pool)); len = 4; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 4); buf[4] = '\0'; SVN_TEST_STRING_ASSERT(buf, " $Tw"); SVN_ERR(svn_stream_seek(translated_stream, mark)); len = 4; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 4); buf[4] = '\0'; SVN_TEST_STRING_ASSERT(buf, " $Tw"); SVN_ERR(svn_stream_seek(translated_stream, mark)); SVN_ERR(svn_stream_skip(translated_stream, 2)); len = 2; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 2); buf[len] = '\0'; SVN_TEST_STRING_ASSERT(buf, "Tw"); /* Seek from outside of keyword to outside of keyword. */ SVN_ERR(svn_stream_mark(translated_stream, &mark, pool)); len = 1; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 1); buf[1] = '\0'; SVN_TEST_STRING_ASSERT(buf, "o"); SVN_ERR(svn_stream_seek(translated_stream, mark)); len = 1; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 1); buf[1] = '\0'; SVN_TEST_STRING_ASSERT(buf, "o"); SVN_ERR(svn_stream_seek(translated_stream, mark)); SVN_ERR(svn_stream_skip(translated_stream, 2)); len = 1; SVN_ERR(svn_stream_read_full(translated_stream, buf, &len)); SVN_TEST_ASSERT(len == 0); buf[len] = '\0'; SVN_TEST_STRING_ASSERT(buf, ""); SVN_ERR(svn_stream_close(stream)); return SVN_NO_ERROR; }
/* Tests to parse a diff with three property changes, one is added, one is * modified and one is deleted. */ static svn_error_t * test_parse_property_diff(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_patch_t *patch; svn_prop_patch_t *prop_patch; svn_diff_hunk_t *hunk; apr_array_header_t *hunks; SVN_ERR(create_patch_file(&patch_file, property_unidiff, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota"); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 3); /* Check the deleted property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_del", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_deleted); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "value" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "", pool)); /* Check the added property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_add", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(!strcmp("prop_add", prop_patch->name)); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "", pool)); SVN_ERR(check_content(hunk, FALSE, "value" NL, pool)); /* Check the modified property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_mod", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_modified); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 2); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "value" NL "context" NL "context" NL "context" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "new value" NL "context" NL "context" NL "context" NL, pool)); hunk = APR_ARRAY_IDX(hunks, 1 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "context" NL "context" NL "context" NL "value" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "context" NL "context" NL "context" NL "new value" NL, pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_parse_diff_symbols_in_prop_unidiff(apr_pool_t *pool) { svn_patch_t *patch; svn_patch_file_t *patch_file; svn_prop_patch_t *prop_patch; svn_diff_hunk_t *hunk; apr_array_header_t *hunks; SVN_ERR(create_patch_file(&patch_file, diff_symbols_in_prop_unidiff, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota"); SVN_TEST_ASSERT(patch->hunks->nelts == 0); SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 3); /* Check the added property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_add", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "", pool)); SVN_ERR(check_content(hunk, FALSE, "Added: bogus_prop" NL "## -0,0 +20 ##" NL "@@ -1,2 +0,0 @@" NL, pool)); /* Check the deleted property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_del", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_deleted); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "--- iota" NL "+++ iota" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "", pool)); /* Check the modified property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_mod", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_modified); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 2); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "## -1,2 +1,2 ##" NL "## -1,5 -0,0 ##" NL "@@ -1,5 -0,0 @@" NL "Modified: prop_mod" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "## -1,3 +1,3 ##" NL "## -1,5 -0,0 ##" NL "@@ -1,5 -0,0 @@" NL "Modified: prop_mod" NL, pool)); hunk = APR_ARRAY_IDX(hunks, 1 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "context" NL "context" NL "context" NL "## -0,0 +1 ##" NL, pool)); SVN_ERR(check_content(hunk, FALSE, "context" NL "context" NL "context" NL "## -1,2 +1,4 ##" NL, pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_stubs(apr_pool_t *pool) { svn_wc__db_t *db; const char *local_abspath; const char *local_relpath; svn_wc_adm_access_t *adm_access; svn_wc_adm_access_t *subdir_access; const svn_wc_entry_t *stub_entry; const svn_wc_entry_t *entry; const svn_wc_entry_t *test_entry; apr_hash_t *entries; #undef WC_NAME #define WC_NAME "test_stubs" SVN_ERR(create_open(&db, &local_abspath, WC_NAME, pool)); /* The "M" entry is a subdir. Let's ensure we can reach its stub, and the actual contents. */ local_relpath = svn_dirent_join_many(pool, "fake-wc", WC_NAME, "M", NULL); SVN_ERR(svn_wc_adm_open3(&adm_access, NULL /* associated */, svn_dirent_join("fake-wc", WC_NAME, pool), FALSE /* write_lock */, 0 /* levels_to_lock */, NULL /* cancel_func */, NULL /* cancel_baton */, pool)); /* Ensure we get the stub. NOTE: do this before we have associated the subdir baton with ADM_ACCESS. */ SVN_ERR(svn_wc_entry(&stub_entry, local_relpath, adm_access, TRUE, pool)); SVN_TEST_STRING_ASSERT(stub_entry->name, "M"); SVN_ERR(svn_wc_adm_open3(&subdir_access, adm_access, local_relpath, FALSE /* write_lock */, 0 /* levels_to_lock */, NULL /* cancel_func */, NULL /* cancel_baton */, pool)); /* Ensure we get the real entry. */ SVN_ERR(svn_wc_entry(&entry, local_relpath, subdir_access, TRUE, pool)); SVN_TEST_STRING_ASSERT(entry->name, ""); /* Ensure that we get the SAME entry, even using the parent baton. */ SVN_ERR(svn_wc_entry(&test_entry, local_relpath, adm_access, TRUE, pool)); SVN_TEST_ASSERT(test_entry == entry); /* Ensure we get the stub when reading entries with ADM_ACCESS. */ SVN_ERR(svn_wc_entries_read(&entries, adm_access, TRUE /* show_hidden */, pool)); SVN_TEST_ASSERT(stub_entry == apr_hash_get(entries, "M", APR_HASH_KEY_STRING)); /* Ensure we get the real entry when reading entries with SUBDIR_ACCESS. */ SVN_ERR(svn_wc_entries_read(&entries, subdir_access, TRUE /* show_hidden */, pool)); SVN_TEST_ASSERT(entry == apr_hash_get(entries, "", APR_HASH_KEY_STRING)); return SVN_NO_ERROR; }