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;
}