static void do_one_diff(apr_file_t *source_file, apr_file_t *target_file, int *count, apr_off_t *len, int quiet, apr_pool_t *pool, const char *tag, FILE* stream) { svn_txdelta_stream_t *delta_stream = NULL; svn_txdelta_window_t *delta_window = NULL; apr_pool_t *fpool = svn_pool_create(pool); apr_pool_t *wpool = svn_pool_create(pool); *count = 0; *len = 0; svn_txdelta(&delta_stream, svn_stream_from_aprfile(source_file, fpool), svn_stream_from_aprfile(target_file, fpool), fpool); do { svn_error_t *err; err = svn_txdelta_next_window(&delta_window, delta_stream, wpool); if (err) svn_handle_error2(err, stderr, TRUE, "vdelta-test: "); if (delta_window != NULL) { *len += print_delta_window(delta_window, tag, quiet, stream); svn_pool_clear(wpool); ++*count; } } while (delta_window != NULL); fprintf(stream, "%s: (LENGTH %" APR_OFF_T_FMT " +%d)\n", tag, *len, *count); svn_pool_destroy(fpool); svn_pool_destroy(wpool); }
svn_error_t *svn_txdelta_send_txstream(svn_txdelta_stream_t *txstream, svn_txdelta_window_handler_t handler, void *handler_baton, apr_pool_t *pool) { svn_txdelta_window_t *window; /* create a pool just for the windows */ apr_pool_t *wpool = svn_pool_create(pool); do { /* free the window (if any) */ svn_pool_clear(wpool); /* read in a single delta window */ SVN_ERR(svn_txdelta_next_window(&window, txstream, wpool)); /* shove it at the handler */ SVN_ERR((*handler)(window, handler_baton)); } while (window != NULL); svn_pool_destroy(wpool); return SVN_NO_ERROR; }
int main(int argc, char **argv) { apr_file_t *source_file_A = NULL; apr_file_t *target_file_A = NULL; int count_A = 0; apr_off_t len_A = 0; apr_file_t *source_file_B = NULL; apr_file_t *target_file_B = NULL; int count_B = 0; apr_off_t len_B = 0; apr_pool_t *pool; int quiet = 0; if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'q') { quiet = 1; --argc; ++argv; } apr_initialize(); pool = svn_pool_create(NULL); if (argc == 2) { target_file_A = open_binary_read(argv[1], pool); } else if (argc == 3) { source_file_A = open_binary_read(argv[1], pool); target_file_A = open_binary_read(argv[2], pool); } else if (argc == 4) { source_file_A = open_binary_read(argv[1], pool); target_file_A = open_binary_read(argv[2], pool); source_file_B = open_binary_read(argv[2], pool); target_file_B = open_binary_read(argv[3], pool); } else { fprintf(stderr, "Usage: vdelta-test [-q] <target>\n" " or: vdelta-test [-q] <source> <target>\n" " or: vdelta-test [-q] <source> <intermediate> <target>\n"); exit(1); } do_one_diff(source_file_A, target_file_A, &count_A, &len_A, quiet, pool, "A ", stdout); if (source_file_B) { apr_pool_t *fpool = svn_pool_create(pool); apr_pool_t *wpool = svn_pool_create(pool); svn_txdelta_stream_t *stream_A = NULL; svn_txdelta_stream_t *stream_B = NULL; svn_txdelta_window_t *window_A = NULL; svn_txdelta_window_t *window_B = NULL; svn_txdelta_window_t *window_AB = NULL; int count_AB = 0; apr_off_t len_AB = 0; putc('\n', stdout); do_one_diff(source_file_B, target_file_B, &count_B, &len_B, quiet, pool, "B ", stdout); putc('\n', stdout); { apr_off_t offset = 0; apr_file_seek(source_file_A, APR_SET, &offset); apr_file_seek(target_file_A, APR_SET, &offset); apr_file_seek(source_file_B, APR_SET, &offset); apr_file_seek(target_file_B, APR_SET, &offset); } svn_txdelta(&stream_A, svn_stream_from_aprfile(source_file_A, fpool), svn_stream_from_aprfile(target_file_A, fpool), fpool); svn_txdelta(&stream_B, svn_stream_from_aprfile(source_file_B, fpool), svn_stream_from_aprfile(target_file_B, fpool), fpool); for (count_AB = 0; count_AB < count_B; ++count_AB) { svn_error_t *err; err = svn_txdelta_next_window(&window_A, stream_A, wpool); if (err) svn_handle_error2(err, stderr, TRUE, "vdelta-test: "); err = svn_txdelta_next_window(&window_B, stream_B, wpool); if (err) svn_handle_error2(err, stderr, TRUE, "vdelta-test: "); /* Note: It's not possible that window_B is null, we already counted the number of windows in the second delta. */ assert(window_A != NULL || window_B->src_ops == 0); if (window_B->src_ops == 0) { window_AB = window_B; window_AB->sview_len = 0; } else window_AB = svn_txdelta_compose_windows(window_A, window_B, wpool); len_AB += print_delta_window(window_AB, "AB", quiet, stdout); svn_pool_clear(wpool); } fprintf(stdout, "AB: (LENGTH %" APR_OFF_T_FMT " +%d)\n", len_AB, count_AB); } if (source_file_A) apr_file_close(source_file_A); if (target_file_A) apr_file_close(target_file_A); if (source_file_B) apr_file_close(source_file_B); if (target_file_B) apr_file_close(source_file_B); svn_pool_destroy(pool); apr_terminate(); exit(0); }
/* (Note: *LAST_SEED is an output parameter.) */ static svn_error_t * do_random_combine_test(const char **msg, svn_boolean_t msg_only, apr_pool_t *pool, apr_uint32_t *last_seed) { static char msg_buff[256]; apr_uint32_t seed, bytes_range, maxlen; int i, iterations, dump_files, print_windows; const char *random_bytes; /* Initialize parameters and print out the seed in case we dump core or something. */ init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows, &random_bytes, &bytes_range, pool); sprintf(msg_buff, "random combine delta test, seed = %lu", (unsigned long) seed); *msg = msg_buff; if (msg_only) return SVN_NO_ERROR; else printf("SEED: %s\n", msg_buff); for (i = 0; i < iterations; i++) { /* Generate source and target for the delta and its application. */ apr_uint32_t subseed_base = svn_test_rand((*last_seed = seed, &seed)); apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *middle = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed, random_bytes, bytes_range, dump_files, pool); apr_file_t *source_copy = copy_tempfile(source, pool); apr_file_t *middle_copy = copy_tempfile(middle, pool); apr_file_t *target_regen = open_tempfile(NULL, pool); svn_txdelta_stream_t *txdelta_stream_A; svn_txdelta_stream_t *txdelta_stream_B; svn_txdelta_window_handler_t handler; svn_stream_t *stream; void *handler_baton; /* Set up a four-stage pipeline: create two deltas, combine them and convert the result to svndiff format, parse that back into delta format, and apply it to a copy of the source file to see if we get the same target back. */ apr_pool_t *delta_pool = svn_pool_create(pool); /* Make stage 4: apply the text delta. */ svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool), svn_stream_from_aprfile(target_regen, delta_pool), NULL, NULL, delta_pool, &handler, &handler_baton); /* Make stage 3: reparse the text delta. */ stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE, delta_pool); /* Make stage 2: encode the text delta in svndiff format. */ svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1, delta_pool); /* Make stage 1: create the text deltas. */ svn_txdelta(&txdelta_stream_A, svn_stream_from_aprfile(source, delta_pool), svn_stream_from_aprfile(middle, delta_pool), delta_pool); svn_txdelta(&txdelta_stream_B, svn_stream_from_aprfile(middle_copy, delta_pool), svn_stream_from_aprfile(target, delta_pool), delta_pool); { svn_txdelta_window_t *window_A; svn_txdelta_window_t *window_B; svn_txdelta_window_t *composite; apr_pool_t *wpool = svn_pool_create(delta_pool); do { SVN_ERR(svn_txdelta_next_window(&window_A, txdelta_stream_A, wpool)); if (print_windows) delta_window_print(window_A, "A ", stdout); SVN_ERR(svn_txdelta_next_window(&window_B, txdelta_stream_B, wpool)); if (print_windows) delta_window_print(window_B, "B ", stdout); if (!window_B) break; assert(window_A != NULL || window_B->src_ops == 0); if (window_B->src_ops == 0) { composite = window_B; composite->sview_len = 0; } else composite = svn_txdelta_compose_windows(window_A, window_B, wpool); if (print_windows) delta_window_print(composite, "AB", stdout); /* The source view length should not be 0 if there are source copy ops in the window. */ if (composite && composite->sview_len == 0 && composite->src_ops > 0) return svn_error_create (SVN_ERR_FS_GENERAL, NULL, "combined delta window is inconsistent"); SVN_ERR(handler(composite, handler_baton)); svn_pool_clear(wpool); } while (composite != NULL); svn_pool_destroy(wpool); } svn_pool_destroy(delta_pool); SVN_ERR(compare_files(target, target_regen, dump_files)); apr_file_close(source); apr_file_close(middle); apr_file_close(target); apr_file_close(source_copy); apr_file_close(middle_copy); apr_file_close(target_regen); } return SVN_NO_ERROR; }
static svn_error_t * stream_window_test(const char **msg, svn_boolean_t msg_only, svn_test_opts_t *opts, apr_pool_t *pool) { /* Note: put these in data segment, not the stack */ static char source[109001]; static char target[109001]; int i; char *p = &source[9]; svn_checksum_t *expected; svn_checksum_t *actual; svn_string_t source_str; svn_string_t target_str; svn_stream_t *source_stream; svn_stream_t *target_stream; svn_txdelta_stream_t *txstream; *msg = "txdelta stream and windows test"; if (msg_only) return SVN_NO_ERROR; memcpy(source, "a\nb\nc\nd\ne", 9); for (i = 100; i--; ) *p++ = '\n'; for (i = 999; i--; p += 109) memcpy(p, source, 109); source[109000] = '\0'; memcpy(target, source, 109001); for (i = 1000; i--; ) target[i*109 + 4] = 'X'; SVN_ERR(svn_checksum(&expected, svn_checksum_md5, target, 109000, pool)); /* f6fd44565e14c6e44b35292719deb77e */ printf("expected: %s\n", svn_checksum_to_cstring(expected, pool)); source_str.data = source; source_str.len = 109000; source_stream = svn_stream_from_string(&source_str, pool); target_str.data = target; target_str.len = 109000; target_stream = svn_stream_from_string(&target_str, pool); svn_txdelta(&txstream, source_stream, target_stream, pool); while (1) { svn_txdelta_window_t *window; SVN_ERR(svn_txdelta_next_window(&window, txstream, pool)); if (window == NULL) break; /* ### examine the window */ } actual = svn_checksum__from_digest(svn_txdelta_md5_digest(txstream), svn_checksum_md5, pool);; printf(" actual: %s\n", svn_checksum_to_cstring(actual, pool)); if (!svn_checksum_match(expected, actual)) { return svn_error_create(SVN_ERR_TEST_FAILED, NULL, "Checksums did not match."); } return SVN_NO_ERROR; }