static svn_error_t *
test6(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "dup two strings, then compare";
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(phrase_1, pool);
b = svn_stringbuf_create(phrase_2, pool);
c = svn_stringbuf_dup(a, pool);
/* Test that length, data, and null-termination are correct. */
if ((svn_stringbuf_compare(a, c)) && (! svn_stringbuf_compare(b, c)))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
static svn_error_t *
test_stringbuf_unequal(const char* str1,
const char* str2,
svn_boolean_t msg_only,
apr_pool_t *pool)
{
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(str1, pool);
b = svn_stringbuf_create(str2, pool);
if (svn_stringbuf_compare(a, b))
return fail(pool, "test failed");
else
return SVN_NO_ERROR;
}
static svn_error_t *
read_packed_fs(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_fs_t *fs;
svn_stream_t *rstream;
svn_stringbuf_t *rstring;
svn_revnum_t i;
*msg = "read from a packed FSFS filesystem";
if (msg_only)
return SVN_NO_ERROR;
/* Bail (with success) on known-untestable scenarios */
if ((strcmp(opts->fs_type, "fsfs") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
SVN_ERR(create_packed_filesystem(REPO_NAME, opts, 11, 5, pool));
SVN_ERR(svn_fs_open(&fs, REPO_NAME, NULL, pool));
for (i = 1; i < 12; i++)
{
svn_fs_root_t *rev_root;
svn_stringbuf_t *sb;
SVN_ERR(svn_fs_revision_root(&rev_root, fs, i, pool));
SVN_ERR(svn_fs_file_contents(&rstream, rev_root, "iota", pool));
SVN_ERR(svn_test__stream_to_string(&rstring, rstream, pool));
if (i == 1)
sb = svn_stringbuf_create("This is the file 'iota'.\n", pool);
else
sb = svn_stringbuf_create(get_rev_contents(i, pool), pool);
if (! svn_stringbuf_compare(rstring, sb))
return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,
"Bad data in revision %ld.", i);
}
return SVN_NO_ERROR;
}
static svn_error_t *
test_stream_tee(apr_pool_t *pool)
{
svn_stringbuf_t *test_bytes = generate_test_bytes(100, pool);
svn_stringbuf_t *output_buf1 = svn_stringbuf_create_empty(pool);
svn_stringbuf_t *output_buf2 = svn_stringbuf_create_empty(pool);
svn_stream_t *source_stream = svn_stream_from_stringbuf(test_bytes, pool);
svn_stream_t *output_stream1 = svn_stream_from_stringbuf(output_buf1, pool);
svn_stream_t *output_stream2 = svn_stream_from_stringbuf(output_buf2, pool);
svn_stream_t *tee_stream;
tee_stream = svn_stream_tee(output_stream1, output_stream2, pool);
SVN_ERR(svn_stream_copy3(source_stream, tee_stream, NULL, NULL, pool));
if (!svn_stringbuf_compare(output_buf1, output_buf2))
return svn_error_create(SVN_ERR_TEST_FAILED, NULL,
"Duplicated streams did not match.");
return SVN_NO_ERROR;
}
static svn_error_t *
test21(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "check that whitespace will be stripped correctly";
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(" \ttest\t\t \t ", pool);
b = svn_stringbuf_create("test", pool);
svn_stringbuf_strip_whitespace(a);
if (svn_stringbuf_compare(a, b) == TRUE)
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
static svn_error_t *
test5(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "append bytes, then compare two strings";
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(phrase_1, pool);
svn_stringbuf_appendbytes(a, "new bytes to append", 9);
/* Test that length, data, and null-termination are correct. */
if (svn_stringbuf_compare
(a, svn_stringbuf_create("hello, new bytes", pool)))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
static svn_error_t *
test_stream_from_string(apr_pool_t *pool)
{
int i;
apr_pool_t *subpool = svn_pool_create(pool);
#define NUM_TEST_STRINGS 4
#define TEST_BUF_SIZE 10
static const char * const strings[NUM_TEST_STRINGS] = {
/* 0 */
"",
/* 1 */
"This is a string.",
/* 2 */
"This is, by comparison to the previous string, a much longer string.",
/* 3 */
"And if you thought that last string was long, you just wait until "
"I'm finished here. I mean, how can a string really claim to be long "
"when it fits on a single line of 80-columns? Give me a break. "
"Now, I'm not saying that I'm the longest string out there--far from "
"it--but I feel that it is safe to assume that I'm far longer than my "
"peers. And that demands some amount of respect, wouldn't you say?"
};
/* Test svn_stream_from_stringbuf() as a readable stream. */
for (i = 0; i < NUM_TEST_STRINGS; i++)
{
svn_stream_t *stream;
char buffer[TEST_BUF_SIZE];
svn_stringbuf_t *inbuf, *outbuf;
apr_size_t len;
inbuf = svn_stringbuf_create(strings[i], subpool);
outbuf = svn_stringbuf_create_empty(subpool);
stream = svn_stream_from_stringbuf(inbuf, subpool);
len = TEST_BUF_SIZE;
while (len == TEST_BUF_SIZE)
{
/* Read a chunk ... */
SVN_ERR(svn_stream_read_full(stream, buffer, &len));
/* ... and append the chunk to the stringbuf. */
svn_stringbuf_appendbytes(outbuf, buffer, len);
}
if (! svn_stringbuf_compare(inbuf, outbuf))
return svn_error_create(SVN_ERR_TEST_FAILED, NULL,
"Got unexpected result.");
svn_pool_clear(subpool);
}
/* Test svn_stream_from_stringbuf() as a writable stream. */
for (i = 0; i < NUM_TEST_STRINGS; i++)
{
svn_stream_t *stream;
svn_stringbuf_t *inbuf, *outbuf;
apr_size_t amt_read, len;
inbuf = svn_stringbuf_create(strings[i], subpool);
outbuf = svn_stringbuf_create_empty(subpool);
stream = svn_stream_from_stringbuf(outbuf, subpool);
amt_read = 0;
while (amt_read < inbuf->len)
{
/* Write a chunk ... */
len = TEST_BUF_SIZE < (inbuf->len - amt_read)
? TEST_BUF_SIZE
: inbuf->len - amt_read;
SVN_ERR(svn_stream_write(stream, inbuf->data + amt_read, &len));
amt_read += len;
}
if (! svn_stringbuf_compare(inbuf, outbuf))
return svn_error_create(SVN_ERR_TEST_FAILED, NULL,
"Got unexpected result.");
svn_pool_clear(subpool);
}
#undef NUM_TEST_STRINGS
#undef TEST_BUF_SIZE
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
static svn_error_t *
test_stream_compressed(apr_pool_t *pool)
{
#define NUM_TEST_STRINGS 5
#define TEST_BUF_SIZE 10
#define GENERATED_SIZE 20000
int i;
svn_stringbuf_t *bufs[NUM_TEST_STRINGS];
apr_pool_t *subpool = svn_pool_create(pool);
static const char * const strings[NUM_TEST_STRINGS - 1] = {
/* 0 */
"",
/* 1 */
"This is a string.",
/* 2 */
"This is, by comparison to the previous string, a much longer string.",
/* 3 */
"And if you thought that last string was long, you just wait until "
"I'm finished here. I mean, how can a string really claim to be long "
"when it fits on a single line of 80-columns? Give me a break. "
"Now, I'm not saying that I'm the longest string out there--far from "
"it--but I feel that it is safe to assume that I'm far longer than my "
"peers. And that demands some amount of respect, wouldn't you say?"
};
for (i = 0; i < (NUM_TEST_STRINGS - 1); i++)
bufs[i] = svn_stringbuf_create(strings[i], pool);
/* the last buffer is for the generated data */
bufs[NUM_TEST_STRINGS - 1] = generate_test_bytes(GENERATED_SIZE, pool);
for (i = 0; i < NUM_TEST_STRINGS; i++)
{
svn_stream_t *stream;
svn_stringbuf_t *origbuf, *inbuf, *outbuf;
char buf[TEST_BUF_SIZE];
apr_size_t len;
origbuf = bufs[i];
inbuf = svn_stringbuf_create_empty(subpool);
outbuf = svn_stringbuf_create_empty(subpool);
stream = svn_stream_compressed(svn_stream_from_stringbuf(outbuf,
subpool),
subpool);
len = origbuf->len;
SVN_ERR(svn_stream_write(stream, origbuf->data, &len));
SVN_ERR(svn_stream_close(stream));
stream = svn_stream_compressed(svn_stream_from_stringbuf(outbuf,
subpool),
subpool);
len = TEST_BUF_SIZE;
while (len >= TEST_BUF_SIZE)
{
len = TEST_BUF_SIZE;
SVN_ERR(svn_stream_read_full(stream, buf, &len));
if (len > 0)
svn_stringbuf_appendbytes(inbuf, buf, len);
}
if (! svn_stringbuf_compare(inbuf, origbuf))
return svn_error_create(SVN_ERR_TEST_FAILED, NULL,
"Got unexpected result.");
SVN_ERR(svn_stream_close(stream));
svn_pool_clear(subpool);
}
#undef NUM_TEST_STRINGS
#undef TEST_BUF_SIZE
#undef GENERATED_SIZE
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
