自学教程：C++ svn_string_create函数代码示例

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

svn_error_t *svn_repos_get_commit_editor4(const svn_delta_editor_t **editor,                             void **edit_baton,                             svn_repos_t *repos,                             svn_fs_txn_t *txn,                             const char *repos_url,                             const char *base_path,                             const char *user,                             const char *log_msg,                             svn_commit_callback2_t callback,                             void *callback_baton,                             svn_repos_authz_callback_t authz_callback,                             void *authz_baton,                             apr_pool_t *pool){  apr_hash_t *revprop_table = apr_hash_make(pool);  if (user)    apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR,                 APR_HASH_KEY_STRING,                 svn_string_create(user, pool));  if (log_msg)    apr_hash_set(revprop_table, SVN_PROP_REVISION_LOG,                 APR_HASH_KEY_STRING,                 svn_string_create(log_msg, pool));  return svn_repos_get_commit_editor5(editor, edit_baton, repos, txn,                                      repos_url, base_path, revprop_table,                                      callback, callback_baton,                                      authz_callback, authz_baton, pool);}

static dav_error *db_store(dav_db *db,         const dav_prop_name *name,         const apr_xml_elem *elem,         dav_namespace_map *mapping){  const svn_string_t *const *old_propval_p;  const svn_string_t *old_propval;  const svn_string_t *propval;  svn_boolean_t absent;  apr_pool_t *pool = db->p;  dav_error *derr;  /* SVN sends property values as a big blob of bytes. Thus, there should be     no child elements of the property-name element. That also means that     the entire contents of the blob is located in elem->first_cdata. The     dav_xml_get_cdata() will figure it all out for us, but (normally) it     should be awfully fast and not need to copy any data. */  propval = svn_string_create    (dav_xml_get_cdata(elem, pool, 0 /* strip_white */), pool);  derr = decode_property_value(&propval, &absent, propval, elem, pool);  if (derr)    return derr;  if (absent && ! elem->first_child)    /* ### better error check */    return dav_svn__new_error(pool, HTTP_INTERNAL_SERVER_ERROR, 0,                              apr_psprintf(pool,                                           "'%s' cannot be specified on the "                                           "value without specifying an "                                           "expectation",                                           SVN_DAV__OLD_VALUE__ABSENT));  /* ### namespace check? */  if (elem->first_child && !strcmp(elem->first_child->name, SVN_DAV__OLD_VALUE))    {      const char *propname;      get_repos_propname(db, name, &propname);      /* Parse OLD_PROPVAL. */      old_propval = svn_string_create(dav_xml_get_cdata(elem->first_child, pool,                                                        0 /* strip_white */),                                      pool);      derr = decode_property_value(&old_propval, &absent,                                   old_propval, elem->first_child, pool);      if (derr)        return derr;      old_propval_p = (const svn_string_t *const *) &old_propval;    }  else    old_propval_p = NULL;  return save_value(db, name, old_propval_p, propval);}

  /**   * set property in @a path no matter whether local or   * repository   *   * @param path   * @param revision   * @param propName   * @param propValue   * @param recurse   * @param revprop   * @return PropertiesList   */  svn_revnum_t  Client::revpropset(const char *propName,                     const char *propValue,                     const Path &path,                     const Revision &revision,                     bool force)  {    Pool pool;    const svn_string_t * propval    = svn_string_create((const char *) propValue, pool);    svn_revnum_t revnum;    svn_error_t * error =      svn_client_revprop_set(propName,                             propval,                             path.c_str(),                             revision.revision(),                             &revnum,                             force,                             *m_context,                             pool);    if (error != nullptr)      throw ClientException(error);    return revnum;  }

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

/* Implementation of svn_auth__password_get_t that decrypts   the incoming password using the Windows CryptoAPI and verifies its   validity. */static svn_error_t *windows_ssl_client_cert_pw_decrypter(svn_boolean_t *done,                                     const char **out,                                     apr_hash_t *creds,                                     const char *realmstring,                                     const char *username,                                     apr_hash_t *parameters,                                     svn_boolean_t non_interactive,                                     apr_pool_t *pool){  const svn_string_t *orig;  const char *in;  SVN_ERR(svn_auth__ssl_client_cert_pw_get(done, &in, creds, realmstring,                                           username, parameters,                                           non_interactive, pool));  if (!*done)    return SVN_NO_ERROR;  orig = svn_base64_decode_string(svn_string_create(in, pool), pool);  orig = decrypt_data(orig, pool);  if (orig)    {      *out = orig->data;      *done = TRUE;    }  else    {      *done = FALSE;    }  return SVN_NO_ERROR;}

static intl_propset (lua_State *L) {	const char *path = luaL_checkstring (L, 1);	const char *propname = luaL_checkstring (L, 2);	const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);		apr_pool_t *pool;	svn_error_t *err;	svn_client_ctx_t *ctx;	init_function (&ctx, &pool, L);	path = svn_path_canonicalize (path, pool);	const char *propname_utf8;	err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);	IF_ERROR_RETURN (err, pool, L);	if (propval != NULL) {		svn_string_t *sstring = svn_string_create (propval, pool);		err = svn_client_propset2 (propname_utf8, sstring, path, TRUE, FALSE, ctx, pool);	} else {		err = svn_client_propset2 (propname_utf8, NULL, path, TRUE, FALSE, ctx, pool);	}	IF_ERROR_RETURN (err, pool, L);		svn_pool_destroy (pool);	return 0;}

apr_hash_t *hashOfStringsFromDistOfStrings( Py::Object arg, SvnPool &pool ){    Py::Dict dict( arg );    apr_hash_t *hash = apr_hash_make( pool );    std::string type_error_message;    try    {        Py::List all_keys( dict.keys() );        for( Py::List::size_type i=0; i<all_keys.length(); i++ )        {            type_error_message = "expecting string key in dict";            Py::Bytes key( asUtf8Bytes( all_keys[i] ) );            type_error_message = "expecting string value in dict";            Py::Bytes value( asUtf8Bytes( dict[ key ] ) );            char *hash_key = apr_pstrdup( pool, key.as_std_string().c_str() );            svn_string_t *hash_value = svn_string_create( value.as_std_string().c_str(), pool );            apr_hash_set( hash, hash_key, APR_HASH_KEY_STRING, hash_value );        }    }    catch( Py::TypeError & )    {        throw Py::TypeError( type_error_message );    }    return hash;}

static svn_error_t *ssl_server_trust_file_save_credentials(svn_boolean_t *saved,                                       void *credentials,                                       void *provider_baton,                                       apr_hash_t *parameters,                                       const char *realmstring,                                       apr_pool_t *pool){  svn_auth_cred_ssl_server_trust_t *creds = credentials;  const svn_auth_ssl_server_cert_info_t *cert_info;  apr_hash_t *creds_hash = NULL;  const char *config_dir;  if (! creds->may_save)    return SVN_NO_ERROR;  config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);  cert_info = svn_hash_gets(parameters, SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO);  creds_hash = apr_hash_make(pool);  svn_hash_sets(creds_hash, SVN_CONFIG_AUTHN_ASCII_CERT_KEY,                svn_string_create(cert_info->ascii_cert, pool));  svn_hash_sets(creds_hash, SVN_CONFIG_AUTHN_FAILURES_KEY,                svn_string_createf(pool, "%lu",                                   (unsigned long)creds->accepted_failures));  SVN_ERR(svn_config_write_auth_data(creds_hash,                                     SVN_AUTH_CRED_SSL_SERVER_TRUST,                                     realmstring,                                     config_dir,                                     pool));  *saved = TRUE;  return SVN_NO_ERROR;}

/* Send a property named NAME with value VAL in an element named ELEM_NAME.   Quote NAME and base64-encode VAL if necessary. */static svn_error_t *send_prop(struct file_rev_baton *frb,          const char *elem_name,          const char *name,          const svn_string_t *val,          apr_pool_t *pool){  name = apr_xml_quote_string(pool, name, 1);  if (svn_xml_is_xml_safe(val->data, val->len))    {      svn_stringbuf_t *tmp = NULL;      svn_xml_escape_cdata_string(&tmp, val, pool);      val = svn_string_create(tmp->data, pool);      SVN_ERR(dav_svn__brigade_printf(frb->bb, frb->output,                                      "<S:%s name=/"%s/">%s</S:%s>" DEBUG_CR,                                      elem_name, name, val->data, elem_name));    }  else    {      val = svn_base64_encode_string2(val, TRUE, pool);      SVN_ERR(dav_svn__brigade_printf(frb->bb, frb->output,                                      "<S:%s name=/"%s/" encoding=/"base64/">"                                      "%s</S:%s>" DEBUG_CR,                                      elem_name, name, val->data, elem_name));    }  return SVN_NO_ERROR;}

const apr_hash_t *RevpropTable::hash(const SVN::Pool &pool){  if (m_revprops.size() == 0)    return NULL;  apr_hash_t *revprop_table = apr_hash_make(pool.getPool());  std::map<std::string, std::string>::const_iterator it;  for (it = m_revprops.begin(); it != m_revprops.end(); ++it)    {      const char *propname = apr_pstrdup(pool.getPool(), it->first.c_str());      if (!svn_prop_name_is_valid(propname))        {          const char *msg = apr_psprintf(pool.getPool(),                                         "Invalid property name: '%s'",                                         propname);          JNIUtil::throwNativeException(JAVA_PACKAGE "/ClientException", msg,                                        NULL, SVN_ERR_CLIENT_PROPERTY_NAME);          return NULL;        }      svn_string_t *propval = svn_string_create(it->second.c_str(),                                                pool.getPool());      apr_hash_set(revprop_table, propname, APR_HASH_KEY_STRING, propval);    }  return revprop_table;}

/* Helper for svn_repos_dump_fs.   Write a revision record of REV in FS to writable STREAM, using POOL. */static svn_error_t *write_revision_record(svn_stream_t *stream,                      svn_fs_t *fs,                      svn_revnum_t rev,                      apr_pool_t *pool){  apr_size_t len;  apr_hash_t *props;  svn_stringbuf_t *encoded_prophash;  apr_time_t timetemp;  svn_string_t *datevalue;  svn_stream_t *propstream;  /* Read the revision props even if we're aren't going to dump     them for verification purposes */  SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, pool));  /* Run revision date properties through the time conversion to     canonicalize them. */  /* ### Remove this when it is no longer needed for sure. */  datevalue = apr_hash_get(props, SVN_PROP_REVISION_DATE,                           APR_HASH_KEY_STRING);  if (datevalue)    {      SVN_ERR(svn_time_from_cstring(&timetemp, datevalue->data, pool));      datevalue = svn_string_create(svn_time_to_cstring(timetemp, pool),                                    pool);      apr_hash_set(props, SVN_PROP_REVISION_DATE, APR_HASH_KEY_STRING,                   datevalue);    }  encoded_prophash = svn_stringbuf_create_ensure(0, pool);  propstream = svn_stream_from_stringbuf(encoded_prophash, pool);  SVN_ERR(svn_hash_write2(props, propstream, "PROPS-END", pool));  SVN_ERR(svn_stream_close(propstream));  /* ### someday write a revision-content-checksum */  SVN_ERR(svn_stream_printf(stream, pool,                            SVN_REPOS_DUMPFILE_REVISION_NUMBER                            ": %ld/n", rev));  SVN_ERR(svn_stream_printf(stream, pool,                            SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH                            ": %" APR_SIZE_T_FMT "/n",                            encoded_prophash->len));  /* Write out a regular Content-length header for the benefit of     non-Subversion RFC-822 parsers. */  SVN_ERR(svn_stream_printf(stream, pool,                            SVN_REPOS_DUMPFILE_CONTENT_LENGTH                            ": %" APR_SIZE_T_FMT "/n/n",                            encoded_prophash->len));  len = encoded_prophash->len;  SVN_ERR(svn_stream_write(stream, encoded_prophash->data, &len));  len = 1;  return svn_stream_write(stream, "/n", &len);}

/* retrieve ssl server CA failure overrides (if any) from servers   config */static svn_error_t *ssl_server_trust_file_first_credentials(void **credentials,                                        void **iter_baton,                                        void *provider_baton,                                        apr_hash_t *parameters,                                        const char *realmstring,                                        apr_pool_t *pool){  apr_uint32_t *failures = svn_hash_gets(parameters,                                         SVN_AUTH_PARAM_SSL_SERVER_FAILURES);  const svn_auth_ssl_server_cert_info_t *cert_info =    svn_hash_gets(parameters, SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO);  apr_hash_t *creds_hash = NULL;  const char *config_dir;  svn_error_t *error = SVN_NO_ERROR;  *credentials = NULL;  *iter_baton = NULL;  /* Check if this is a permanently accepted certificate */  config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);  error =    svn_config_read_auth_data(&creds_hash, SVN_AUTH_CRED_SSL_SERVER_TRUST,                              realmstring, config_dir, pool);  svn_error_clear(error);  if (! error && creds_hash)    {      svn_string_t *trusted_cert, *this_cert, *failstr;      apr_uint32_t last_failures = 0;      trusted_cert = svn_hash_gets(creds_hash, SVN_CONFIG_AUTHN_ASCII_CERT_KEY);      this_cert = svn_string_create(cert_info->ascii_cert, pool);      failstr = svn_hash_gets(creds_hash, SVN_CONFIG_AUTHN_FAILURES_KEY);      if (failstr)        SVN_ERR(svn_cstring_atoui(&last_failures, failstr->data));      /* If the cert is trusted and there are no new failures, we       * accept it by clearing all failures. */      if (trusted_cert &&          svn_string_compare(this_cert, trusted_cert) &&          (*failures & ~last_failures) == 0)        {          *failures = 0;        }    }  /* If all failures are cleared now, we return the creds */  if (! *failures)    {      svn_auth_cred_ssl_server_trust_t *creds =        apr_pcalloc(pool, sizeof(*creds));      creds->may_save = FALSE; /* No need to save it again... */      *credentials = creds;    }  return SVN_NO_ERROR;}

svn_error_t *svn_repos_fs_begin_txn_for_commit(svn_fs_txn_t **txn_p,                                  svn_repos_t *repos,                                  svn_revnum_t rev,                                  const char *author,                                  const char *log_msg,                                  apr_pool_t *pool){    apr_hash_t *revprop_table = apr_hash_make(pool);    if (author)        svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,                      svn_string_create(author, pool));    if (log_msg)        svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,                      svn_string_create(log_msg, pool));    return svn_repos_fs_begin_txn_for_commit2(txn_p, repos, rev, revprop_table,            pool);}

/* For one auto-props config entry (NAME, VALUE), if the filename pattern   NAME matches BATON->filename case insensitively then add the properties   listed in VALUE into BATON->properties.   BATON must point to an auto_props_baton_t.*/static svn_boolean_tauto_props_enumerator(const char *name,                      const char *value,                      void *baton,                      apr_pool_t *pool){  auto_props_baton_t *autoprops = baton;  char *property;  char *last_token;  /* nothing to do here without a value */  if (strlen(value) == 0)    return TRUE;  /* check if filename matches and return if it doesn't */  if (apr_fnmatch(name, autoprops->filename, APR_FNM_CASE_BLIND) == APR_FNM_NOMATCH)    return TRUE;  /* parse the value (we dup it first to effectively lose the     'const', and to avoid messing up the original value) */  property = apr_pstrdup(autoprops->pool, value);  property = apr_strtok(property, ";", &last_token);  while (property)    {      int len;      const char *this_value;      char *equal_sign = strchr(property, '=');      if (equal_sign)        {          *equal_sign = '/0';          equal_sign++;          trim_string(&equal_sign);          this_value = equal_sign;        }      else        {          this_value = "";        }      trim_string(&property);      len = strlen(property);      if (len > 0)        {          svn_string_t *propval = svn_string_create(this_value,                                                    autoprops->pool);          apr_hash_set(autoprops->properties, property, len, propval);          if (strcmp(property, SVN_PROP_MIME_TYPE) == 0)            autoprops->mimetype = this_value;          else if (strcmp(property, SVN_PROP_EXECUTABLE) == 0)            autoprops->have_executable = TRUE;        }      property = apr_strtok(NULL, ";", &last_token);    }  return TRUE;}

svn_error_t *svn_ra_neon__get_activity_collection(const svn_string_t **activity_coll,                                     svn_ra_neon__session_t *ras,                                     apr_pool_t *pool){  if (! ras->act_coll)    SVN_ERR(svn_ra_neon__exchange_capabilities(ras, pool));  *activity_coll = svn_string_create(ras->act_coll, pool);  return SVN_NO_ERROR;}

static intl_revprop_set (lua_State *L) {	apr_pool_t *pool;	svn_error_t *err;	svn_client_ctx_t *ctx;	svn_opt_revision_t revision;   	svn_revnum_t rev;			const char *url = luaL_checkstring (L, 1);	const char *propname = luaL_checkstring (L, 2);	const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);	const char *propname_utf8 = NULL;	int itable = 5;	svn_boolean_t force = FALSE;	if (lua_gettop (L) < 4 || lua_isnil (L, 4)) {		revision.kind = get_revision_kind (url);	} else {		revision.kind = svn_opt_revision_number;		revision.value.number = lua_tointeger (L, 4);	}	if (lua_gettop (L) >= itable && lua_istable (L, itable)) {		lua_getfield (L, itable, "force");		if (lua_isboolean (L, -1)) {			force = lua_toboolean (L, -1);		}	} 	init_function (&ctx, &pool, L);	url = svn_path_canonicalize (url, pool);	err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);	IF_ERROR_RETURN (err, pool, L);	if (propval != NULL) {		svn_string_t *sstring = svn_string_create (propval, pool);		if (svn_prop_needs_translation (propname_utf8)) {			err = svn_subst_translate_string (&sstring, sstring, APR_LOCALE_CHARSET, pool);			IF_ERROR_RETURN (err, pool, L);		}			err = svn_client_revprop_set (propname_utf8, sstring, url, &revision, &rev, force, ctx, pool);	} else {		err = svn_client_revprop_set (propname_utf8, NULL, url, &revision, &rev, force, ctx, pool);	}	IF_ERROR_RETURN (err, pool, L);		svn_pool_destroy (pool);	return 0;}

static svn_error_t *test_invalid_bom(apr_pool_t *pool){  svn_config_t *cfg;  svn_error_t *err;  svn_string_t *cfg_string;  svn_stream_t *stream;  cfg_string = svn_string_create("/xEF", pool);  stream = svn_stream_from_string(cfg_string, pool);  err = svn_config_parse(&cfg, stream, TRUE, TRUE, pool);  SVN_TEST_ASSERT_ERROR(err, SVN_ERR_MALFORMED_FILE);  cfg_string = svn_string_create("/xEF/xBB", pool);  stream = svn_stream_from_string(cfg_string, pool);  err = svn_config_parse(&cfg, stream, TRUE, TRUE, pool);  SVN_TEST_ASSERT_ERROR(err, SVN_ERR_MALFORMED_FILE);  return SVN_NO_ERROR;}

static svn_error_t *get_node_props(apr_hash_t **props,               svn_ra_local__session_baton_t *sess,               svn_fs_root_t *root,               const char *path,               apr_pool_t *pool){  svn_revnum_t cmt_rev;  const char *cmt_date, *cmt_author;  /* Create a hash with props attached to the fs node. */  SVN_ERR(svn_fs_node_proplist(props, root, path, pool));  /* Now add some non-tweakable metadata to the hash as well... */  /* The so-called 'entryprops' with info about CR & friends. */  SVN_ERR(svn_repos_get_committed_info(&cmt_rev, &cmt_date,                                       &cmt_author, root, path, pool));  apr_hash_set(*props,               SVN_PROP_ENTRY_COMMITTED_REV,               APR_HASH_KEY_STRING,               svn_string_createf(pool, "%ld", cmt_rev));  apr_hash_set(*props,               SVN_PROP_ENTRY_COMMITTED_DATE,               APR_HASH_KEY_STRING,               cmt_date ? svn_string_create(cmt_date, pool) : NULL);  apr_hash_set(*props,               SVN_PROP_ENTRY_LAST_AUTHOR,               APR_HASH_KEY_STRING,               cmt_author ? svn_string_create(cmt_author, pool) : NULL);  apr_hash_set(*props,               SVN_PROP_ENTRY_UUID,               APR_HASH_KEY_STRING,               svn_string_create(sess->uuid, pool));  /* We have no 'wcprops' in ra_local, but might someday. */  return SVN_NO_ERROR;}

/* This implements the svn_auth__password_set_t interface.   Store PASSPHRASE in CREDS; ignore other parameters. */svn_boolean_tsvn_auth__ssl_client_cert_pw_set(apr_hash_t *creds,                                 const char *realmstring,                                 const char *username,                                 const char *passphrase,                                 apr_hash_t *parameters,                                 svn_boolean_t non_interactive,                                 apr_pool_t *pool){  apr_hash_set(creds, AUTHN_PASSPHRASE_KEY, APR_HASH_KEY_STRING,               svn_string_create(passphrase, pool));  return TRUE;}

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

/* Get a lock comment, allocate it in POOL and store it in *COMMENT. */static svn_error_t *get_comment(const char **comment, svn_client_ctx_t *ctx,            svn_cl__opt_state_t *opt_state, apr_pool_t *pool){  svn_string_t *comment_string;  if (opt_state->filedata)    {      /* Get it from the -F argument. */      if (strlen(opt_state->filedata->data) < opt_state->filedata->len)        {          /* A message containing a zero byte can't be represented as a C             string. */          return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL,                                  _("Lock comment contains a zero byte"));        }      comment_string = svn_string_create(opt_state->filedata->data, pool);    }  else if (opt_state->message)    {      /* Get if from the -m option. */      comment_string = svn_string_create(opt_state->message, pool);    }  else    {      *comment = NULL;      return SVN_NO_ERROR;    }  /* Translate to UTF8/LF. */  SVN_ERR(svn_subst_translate_string2(&comment_string, NULL, NULL,                                      comment_string, opt_state->encoding,                                      FALSE, pool, pool));  *comment = comment_string->data;  return SVN_NO_ERROR;}

dav_error *dav_svn__create_txn(dav_svn_repos *repos,                    const char **ptxn_name,                    apr_hash_t *revprops,                    apr_pool_t *pool){  svn_revnum_t rev;  svn_fs_txn_t *txn;  svn_error_t *serr;  if (! revprops)    {      revprops = apr_hash_make(pool);    }  if (repos->username)    {      svn_hash_sets(revprops,                    SVN_PROP_REVISION_AUTHOR,                    svn_string_create(repos->username, pool));    }  serr = dav_svn__get_youngest_rev(&rev, repos, pool);  if (serr != NULL)    {      return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,                                  "could not determine youngest revision",                                  repos->pool);    }  serr = svn_repos_fs_begin_txn_for_commit2(&txn, repos->repos, rev,                                            revprops, repos->pool);  if (serr != NULL)    {      return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,                                  "could not begin a transaction",                                  repos->pool);    }  serr = svn_fs_txn_name(ptxn_name, txn, pool);  if (serr != NULL)    {      return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,                                  "could not fetch transaction name",                                  repos->pool);    }  return NULL;}

static svn_error_t *test_ignore_bom(apr_pool_t *pool){  svn_config_t *cfg;  svn_string_t *cfg_string = svn_string_create("/xEF/xBB/xBF[s1]/nfoo=bar/n",                                               pool);  svn_stream_t *stream = svn_stream_from_string(cfg_string, pool);  SVN_ERR(svn_config_parse(&cfg, stream, TRUE, TRUE, pool));  if (! svn_config_has_section(cfg, "s1"))    return fail(pool, "failed to find section s1");  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;}

/* This implements the svn_auth__password_set_t interface.   Store PASSPHRASE in CREDS; ignore other parameters. */svn_error_t *svn_auth__ssl_client_cert_pw_set(svn_boolean_t *done,                                 apr_hash_t *creds,                                 const char *realmstring,                                 const char *username,                                 const char *passphrase,                                 apr_hash_t *parameters,                                 svn_boolean_t non_interactive,                                 apr_pool_t *pool){  svn_hash_sets(creds, AUTHN_PASSPHRASE_KEY,                svn_string_create(passphrase, pool));  *done = TRUE;  return SVN_NO_ERROR;}

svn_error_t *svn_opt_parse_revprop(apr_hash_t **revprop_table_p, const char *revprop_spec,                      apr_pool_t *pool){  const char *sep, *propname;  svn_string_t *propval;  if (! *revprop_spec)    return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,                            _("Revision property pair is empty"));  if (! *revprop_table_p)    *revprop_table_p = apr_hash_make(pool);  sep = strchr(revprop_spec, '=');  if (sep)    {      propname = apr_pstrndup(pool, revprop_spec, sep - revprop_spec);      SVN_ERR(svn_utf_cstring_to_utf8(&propname, propname, pool));      propval = svn_string_create(sep + 1, pool);    }  else    {      SVN_ERR(svn_utf_cstring_to_utf8(&propname, revprop_spec, pool));      propval = svn_string_create("", pool);    }  if (!svn_prop_name_is_valid(propname))    return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,                             _("'%s' is not a valid Subversion property name"),                             propname);  apr_hash_set(*revprop_table_p, propname, APR_HASH_KEY_STRING, propval);  return SVN_NO_ERROR;}

svn_error_t *svn_rdump__normalize_prop(const char *name,                          const svn_string_t **value,                          apr_pool_t *result_pool){  if (svn_prop_needs_translation(name))    {      const char *cstring;      SVN_ERR(svn_subst_translate_cstring2((*value)->data, &cstring,                                           "/n", TRUE,                                           NULL, FALSE,                                           result_pool));      *value = svn_string_create(cstring, result_pool);    }  return SVN_NO_ERROR;}

svn_error_t *sbox_wc_propset(svn_test__sandbox_t *b,           const char *name,           const char *value,           const char *path){  svn_client_ctx_t *ctx;  apr_array_header_t *paths = apr_array_make(b->pool, 1,                                             sizeof(const char *));  svn_string_t *pval = value ? svn_string_create(value, b->pool) : NULL;  SVN_ERR(svn_client_create_context2(&ctx, NULL, b->pool));  ctx->wc_ctx = b->wc_ctx;  APR_ARRAY_PUSH(paths, const char *) = sbox_wc_path(b, path);  return svn_client_propset_local(name, pval, paths, svn_depth_empty,                                  TRUE /* skip_checks */,                                  NULL, ctx, b->pool);}