static svn_error_t *
unparse_implicit_length(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "unparse implicit-length atoms";
if (msg_only)
return SVN_NO_ERROR;
/* Unparse and check every single-byte implicit-length atom. */
{
int byte;
for (byte = 0; byte < 256; byte++)
if (skel_is_name( (apr_byte_t)byte))
{
svn_stringbuf_t *str = get_empty_string(pool);
char buf = (char)byte;
svn_skel_t *skel = build_atom(1, &buf, pool);
str = svn_skel__unparse(skel, pool);
if (! (str
&& str->len == 1
&& str->data[0] == (char)byte))
return fail(pool, "incorrectly unparsed single-byte "
"implicit-length atom");
}
}
return SVN_NO_ERROR;
}
/* Set DBT to the unparsed form of SKEL; allocate memory from POOL. */
DBT *
svn_fs_base__skel_to_dbt(DBT *dbt,
svn_skel_t *skel,
apr_pool_t *pool)
{
svn_stringbuf_t *unparsed_skel = svn_skel__unparse(skel, pool);
svn_fs_base__set_dbt(dbt, unparsed_skel->data, unparsed_skel->len);
return dbt;
}
svn_error_t *
svn_sqlite__bind_properties(svn_sqlite__stmt_t *stmt,
int slot,
const apr_hash_t *props,
apr_pool_t *scratch_pool)
{
svn_skel_t *skel;
svn_stringbuf_t *properties;
if (props == NULL)
return svn_error_trace(svn_sqlite__bind_blob(stmt, slot, NULL, 0));
SVN_ERR(svn_skel__unparse_proplist(&skel, props, scratch_pool));
properties = svn_skel__unparse(skel, scratch_pool);
return svn_error_trace(svn_sqlite__bind_blob(stmt,
slot,
properties->data,
properties->len));
}
svn_error_t *
svn_wc__deserialize_conflict(const svn_wc_conflict_description2_t **conflict,
const svn_skel_t *skel,
const char *dir_path,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *victim_basename;
const char *victim_abspath;
svn_node_kind_t node_kind;
svn_wc_operation_t operation;
svn_wc_conflict_action_t action;
svn_wc_conflict_reason_t reason;
const svn_wc_conflict_version_t *src_left_version;
const svn_wc_conflict_version_t *src_right_version;
int n;
svn_wc_conflict_description2_t *new_conflict;
if (!is_valid_conflict_skel(skel))
return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL,
_("Invalid conflict info '%s' in tree conflict "
"description"),
skel ? svn_skel__unparse(skel, scratch_pool)->data
: "(null)");
/* victim basename */
victim_basename = apr_pstrmemdup(scratch_pool,
skel->children->next->data,
skel->children->next->len);
if (victim_basename[0] == '\0')
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Empty 'victim' field in tree conflict "
"description"));
/* node_kind */
SVN_ERR(read_enum_field(&n, node_kind_map, skel->children->next->next));
node_kind = (svn_node_kind_t)n;
if (node_kind != svn_node_file && node_kind != svn_node_dir)
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Invalid 'node_kind' field in tree conflict description"));
/* operation */
SVN_ERR(read_enum_field(&n, svn_wc__operation_map,
skel->children->next->next->next));
operation = (svn_wc_operation_t)n;
SVN_ERR(svn_dirent_get_absolute(&victim_abspath,
svn_dirent_join(dir_path, victim_basename, scratch_pool),
scratch_pool));
/* action */
SVN_ERR(read_enum_field(&n, svn_wc__conflict_action_map,
skel->children->next->next->next->next));
action = n;
/* reason */
SVN_ERR(read_enum_field(&n, svn_wc__conflict_reason_map,
skel->children->next->next->next->next->next));
reason = n;
/* Let's just make it a bit easier on ourself here... */
skel = skel->children->next->next->next->next->next->next;
/* src_left_version */
SVN_ERR(read_node_version_info(&src_left_version, skel,
result_pool, scratch_pool));
/* src_right_version */
SVN_ERR(read_node_version_info(&src_right_version, skel->next,
result_pool, scratch_pool));
new_conflict = svn_wc_conflict_description_create_tree2(victim_abspath,
node_kind, operation, src_left_version, src_right_version,
result_pool);
new_conflict->action = action;
new_conflict->reason = reason;
*conflict = new_conflict;
return SVN_NO_ERROR;
}
static svn_error_t *
read_rep(const svn_test_opts_t *opts,
apr_pool_t *pool)
{
struct rep_args new_args;
struct rep_args args;
struct rep_args read_args;
svn_stringbuf_t *skel_data;
svn_fs_t *fs;
const char *rep = "((fulltext 0 ) kfogel31337)";
const char *new_rep_before = "((fulltext 0 ) a83t2Z0)";
/* This test also tests the introduction of checksums into skels that
didn't have them. */
/* Get writeable strings. */
char *rep_after = apr_pstrdup
(pool, "((fulltext 0 (md5 16 XXXXXXXXXXXXXXXX)) kfogel31337");
char *new_rep_after = apr_pstrdup
(pool, "((fulltext 0 (md5 16 XXXXXXXXXXXXXXXX)) a83t2Z0");
size_t rep_after_len = strlen(rep_after);
size_t new_rep_after_len = strlen(new_rep_after);
/* Replace the fake fake checksums with the real fake checksums.
And someday, when checksums are actually calculated, we can
replace the real fake checksums with real real checksums. */
{
char *p;
for (p = rep_after; *p; p++)
if (*p == 'X')
*p = '\0';
for (p = new_rep_after; *p; p++)
if (*p == 'X')
*p = '\0';
}
/* Create a new fs and repos */
SVN_ERR(svn_test__create_bdb_fs
(&fs, "test-repo-read-rep", opts,
pool));
/* Set up transaction baton */
new_args.fs = fs;
new_args.skel = svn_skel__parse(new_rep_before, strlen(new_rep_before),
pool);
new_args.key = NULL;
/* Write new rep to reps table. */
SVN_ERR(svn_fs_base__retry_txn(new_args.fs, txn_body_write_new_rep,
&new_args, FALSE, pool));
/* Make sure we got a valid key. */
if (new_args.key == NULL)
return svn_error_create(SVN_ERR_FS_GENERAL, NULL,
"error writing new representation");
/* Read the new rep back from the reps table. */
read_args.fs = new_args.fs;
read_args.skel = NULL;
read_args.key = new_args.key;
SVN_ERR(svn_fs_base__retry_txn(new_args.fs, txn_body_read_rep, &read_args,
FALSE, pool));
/* Make sure the skel matches. */
if (! read_args.skel)
return svn_error_create(SVN_ERR_FS_GENERAL, NULL,
"error reading new representation");
skel_data = svn_skel__unparse(read_args.skel, pool);
if (memcmp(skel_data->data, new_rep_after, new_rep_after_len) != 0)
return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,
"representation corrupted (first check)");
/* Set up transaction baton for re-writing reps. */
args.fs = new_args.fs;
args.skel = svn_skel__parse(rep, strlen(rep), pool);
args.key = new_args.key;
/* Overwrite first rep in reps table. */
SVN_ERR(svn_fs_base__retry_txn(new_args.fs, txn_body_write_rep, &args,
FALSE, pool));
/* Read the new rep back from the reps table (using the same FS and
key as the first read...let's make sure this thing didn't get
written to the wrong place). */
read_args.skel = NULL;
SVN_ERR(svn_fs_base__retry_txn(new_args.fs, txn_body_read_rep, &read_args,
FALSE, pool));
/* Make sure the skel matches. */
if (! read_args.skel)
return svn_error_create(SVN_ERR_FS_GENERAL, NULL,
"error reading new representation");
skel_data = svn_skel__unparse(read_args.skel, pool);
if (memcmp(skel_data->data, rep_after, rep_after_len) != 0)
return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,
"representation corrupted (second check)");
return SVN_NO_ERROR;
}
static svn_error_t *
unparse_list(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "unparse lists";
if (msg_only)
return SVN_NO_ERROR;
/* Make a list of all the single-byte implicit-length atoms. */
{
svn_stringbuf_t *str = get_empty_string(pool);
int byte;
svn_skel_t *list = empty(pool);
svn_skel_t *reparsed, *elt;
for (byte = 0; byte < 256; byte++)
if (skel_is_name( (apr_byte_t)byte))
{
char buf = byte;
add(build_atom(1, &buf, pool), list);
}
/* Unparse that, parse it again, and see if we got the same thing
back. */
str = svn_skel__unparse(list, pool);
reparsed = svn_skel__parse(str->data, str->len, pool);
if (! reparsed || reparsed->is_atom)
return fail(pool, "result is syntactically misformed, or not a list");
if (! skel_equal(list, reparsed))
return fail(pool, "unparsing and parsing didn't preserve contents");
elt = reparsed->children;
for (byte = 255; byte >= 0; byte--)
if (skel_is_name( (apr_byte_t)byte))
{
if (! (elt
&& elt->is_atom
&& elt->len == 1
&& elt->data[0] == byte))
return fail(pool, "bad element");
/* Verify that each element's data falls within the string. */
if (elt->data < str->data
|| elt->data + elt->len > str->data + str->len)
return fail(pool, "bad element");
elt = elt->next;
}
/* We should have reached the end of the list at this point. */
if (elt)
return fail(pool, "list too long");
}
/* Make a list of lists. */
{
svn_stringbuf_t *str = get_empty_string(pool);
svn_skel_t *top = empty(pool);
svn_skel_t *reparsed;
int i;
for (i = 0; i < 10; i++)
{
svn_skel_t *middle = empty(pool);
int j;
for (j = 0; j < 10; j++)
{
char buf[10];
apr_size_t k;
int val;
/* Make some interesting atom, containing lots of binary
characters. */
val = i * 10 + j;
for (k = 0; k < sizeof(buf); k++)
{
buf[k] = val;
val += j;
}
add(build_atom(sizeof(buf), buf, pool), middle);
}
add(middle, top);
}
str = svn_skel__unparse(top, pool);
reparsed = svn_skel__parse(str->data, str->len, pool);
if (! skel_equal(top, reparsed))
return fail(pool, "failed to reparse list of lists");
}
return SVN_NO_ERROR;
}