/*
 * Regression tests for mtcc code in the libsvn_client library.
 *
 * ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

#include "svn_pools.h"
#include "svn_props.h"
#include "svn_client.h"
#include "private/svn_client_mtcc.h"

#include "../svn_test.h"
#include "../svn_test_fs.h"

/* Baton for verify_commit_callback*/
struct verify_commit_baton
{
  const svn_commit_info_t *commit_info;
  apr_pool_t *result_pool;
};

/* Commit result collector for verify_mtcc_commit */
static svn_error_t *
verify_commit_callback(const svn_commit_info_t *commit_info,
                       void *baton,
                       apr_pool_t *pool)
{
  struct verify_commit_baton *vcb = baton;

  vcb->commit_info = svn_commit_info_dup(commit_info, vcb->result_pool);
  return SVN_NO_ERROR;
}

/* Create a stream from a c string */
static svn_stream_t *
cstr_stream(const char *data, apr_pool_t *result_pool)
{
  return svn_stream_from_string(svn_string_create(data, result_pool),
                                result_pool);
}

static svn_error_t *
verify_mtcc_commit(svn_client__mtcc_t *mtcc,
                   svn_revnum_t expected_rev,
                   apr_pool_t *pool)
{
  struct verify_commit_baton vcb;
  vcb.commit_info = NULL;
  vcb.result_pool = pool;

  SVN_ERR(svn_client__mtcc_commit(NULL, verify_commit_callback, &vcb, mtcc, pool));

  SVN_TEST_ASSERT(vcb.commit_info != NULL);
  SVN_TEST_ASSERT(vcb.commit_info->revision == expected_rev);

  return SVN_NO_ERROR;
}


/* Constructs a greek tree as revision 1 in the repository at repos_url */
static svn_error_t *
make_greek_tree(const char *repos_url,
                apr_pool_t *scratch_pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  apr_pool_t *subpool;
  int i;

  subpool = svn_pool_create(scratch_pool);

  SVN_ERR(svn_client_create_context2(&ctx, NULL, subpool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, subpool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 0, ctx, subpool, subpool));

  for (i = 0; svn_test__greek_tree_nodes[i].path; i++)
    {
      if (svn_test__greek_tree_nodes[i].contents)
        {
          SVN_ERR(svn_client__mtcc_add_add_file(
                                svn_test__greek_tree_nodes[i].path,
                                cstr_stream(
                                        svn_test__greek_tree_nodes[i].contents,
                                        subpool),
                                NULL /* src_checksum */,
                                mtcc, subpool));
        }
      else
        {
          SVN_ERR(svn_client__mtcc_add_mkdir(
                                svn_test__greek_tree_nodes[i].path,
                                mtcc, subpool));
        }
    }

  SVN_ERR(verify_mtcc_commit(mtcc, 1, subpool));

  svn_pool_clear(subpool);
  return SVN_NO_ERROR;
}

static svn_error_t *
test_mkdir(const svn_test_opts_t *opts,
           apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-mkdir",
                                  opts, pool, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 0, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_mkdir("branches", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("trunk", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("branches/1.x", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("tags", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("tags/1.0", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("tags/1.1", mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 1, pool));

  return SVN_NO_ERROR;
}

static svn_error_t *
test_mkgreek(const svn_test_opts_t *opts,
             apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-mkgreek",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_copy("A", 1, "greek_A", mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));

  return SVN_NO_ERROR;
}

static svn_error_t *
test_swap(const svn_test_opts_t *opts,
          apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-swap",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_move("A/B", "B", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_move("A/D", "A/B", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_copy("A/B", 1, "A/D", mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));

  return SVN_NO_ERROR;
}

static svn_error_t *
test_propset(const svn_test_opts_t *opts,
             apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-propset",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_propset("iota", "key",
                                       svn_string_create("val", pool), FALSE,
                                       mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_propset("A", "A-key",
                                       svn_string_create("val-A", pool), FALSE,
                                       mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_propset("A/B", "B-key",
                                       svn_string_create("val-B", pool), FALSE,
                                       mtcc, pool));

  /* The repository ignores propdeletes of properties that aren't there,
     so this just works */
  SVN_ERR(svn_client__mtcc_add_propset("A/D", "D-key", NULL, FALSE,
                                       mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 2, ctx, pool, pool));
  SVN_TEST_ASSERT_ERROR(
      svn_client__mtcc_add_propset("A", SVN_PROP_MIME_TYPE,
                                   svn_string_create("text/plain", pool),
                                   FALSE, mtcc, pool),
      SVN_ERR_ILLEGAL_TARGET);

  SVN_TEST_ASSERT_ERROR(
      svn_client__mtcc_add_propset("iota", SVN_PROP_IGNORE,
                                   svn_string_create("iota", pool),
                                   FALSE, mtcc, pool),
      SVN_ERR_ILLEGAL_TARGET);

  SVN_ERR(svn_client__mtcc_add_propset("iota", SVN_PROP_EOL_STYLE,
                                       svn_string_create("LF", pool),
                                       FALSE, mtcc, pool));

  SVN_ERR(svn_client__mtcc_add_add_file("ok", cstr_stream("line\nline\n", pool),
                                        NULL, mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_add_file("bad", cstr_stream("line\nno\r\n", pool),
                                        NULL, mtcc, pool));

  SVN_ERR(svn_client__mtcc_add_propset("ok", SVN_PROP_EOL_STYLE,
                                       svn_string_create("LF", pool),
                                       FALSE, mtcc, pool));

  SVN_TEST_ASSERT_ERROR(
          svn_client__mtcc_add_propset("bad", SVN_PROP_EOL_STYLE,
                                       svn_string_create("LF", pool),
                                       FALSE, mtcc, pool),
          SVN_ERR_ILLEGAL_TARGET);

  SVN_ERR(verify_mtcc_commit(mtcc, 3, pool));

  return SVN_NO_ERROR;
}

static svn_error_t *
test_update_files(const svn_test_opts_t *opts,
             apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-update-files",
                                  opts, pool, pool));
  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  /* Update iota with knowledge of the old data */
  SVN_ERR(svn_client__mtcc_add_update_file(svn_test__greek_tree_nodes[0].path,
                                           cstr_stream("new-iota", pool),
                                           NULL,
                                           cstr_stream(
                                             svn_test__greek_tree_nodes[0]
                                                         .contents,
                                             pool),
                                           NULL,
                                           mtcc, pool));

  SVN_ERR(svn_client__mtcc_add_update_file("A/mu",
                                           cstr_stream("new-MU", pool),
                                           NULL,
                                           NULL, NULL,
                                           mtcc, pool));

  /* Set a property on the same node */
  SVN_ERR(svn_client__mtcc_add_propset("A/mu", "mu-key",
                                       svn_string_create("mu-A", pool), FALSE,
                                       mtcc, pool));
  /* And some other node */
  SVN_ERR(svn_client__mtcc_add_propset("A/B", "B-key",
                                       svn_string_create("val-B", pool), FALSE,
                                       mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));
  return SVN_NO_ERROR;
}

static svn_error_t *
test_overwrite(const svn_test_opts_t *opts,
               apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-overwrite",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_copy("A", 1, "AA", mtcc, pool));

  SVN_TEST_ASSERT_ERROR(svn_client__mtcc_add_mkdir("AA/B", mtcc, pool),
                        SVN_ERR_FS_ALREADY_EXISTS);

  SVN_TEST_ASSERT_ERROR(svn_client__mtcc_add_mkdir("AA/D/H/chi", mtcc, pool),
                        SVN_ERR_FS_ALREADY_EXISTS);

  SVN_ERR(svn_client__mtcc_add_mkdir("AA/BB", mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));
  return SVN_NO_ERROR;
}

static svn_error_t *
test_anchoring(const svn_test_opts_t *opts,
               apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-anchoring",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  /* Update a file as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "iota",
                                                              pool),
                                  1, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_update_file("",
                                           cstr_stream("new-iota", pool),
                                           NULL, NULL, NULL,
                                           mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_propset("", "key",
                                       svn_string_create("value", pool),
                                       FALSE, mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));

  /* Add a directory as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "BB",
                                                              pool),
                                  2, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("", mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 3, pool));

  /* Add a file as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "new",
                                                              pool),
                                  3, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_add_file("", cstr_stream("new", pool), NULL,
                                        mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 4, pool));

  /* Delete as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "new",
                                                              pool),
                                  4, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_delete("", mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 5, pool));

  /* Propset file as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "A/mu",
                                                              pool),
                                  5, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_propset("", "key",
                                       svn_string_create("val", pool),
                                       FALSE, mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 6, pool));

  /* Propset dir as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc,
                                  svn_path_url_add_component2(repos_url, "A",
                                                              pool),
                                  6, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_propset("", "key",
                                       svn_string_create("val", pool),
                                       FALSE, mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 7, pool));

  /* Propset reposroot as root operation */
  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 7, ctx, pool, pool));
  SVN_ERR(svn_client__mtcc_add_propset("", "key",
                                       svn_string_create("val", pool),
                                       FALSE, mtcc, pool));
  SVN_ERR(verify_mtcc_commit(mtcc, 8, pool));

  return SVN_NO_ERROR;
}

static svn_error_t *
test_replace_tree(const svn_test_opts_t *opts,
                  apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  const char *repos_url;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-replace_tree",
                                  opts, pool, pool));

  SVN_ERR(make_greek_tree(repos_url, pool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, pool, pool));

  SVN_ERR(svn_client__mtcc_add_delete("A", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_delete("iota", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A/B", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A/B/C", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("M", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("M/N", mtcc, pool));
  SVN_ERR(svn_client__mtcc_add_mkdir("M/N/O", mtcc, pool));

  SVN_ERR(verify_mtcc_commit(mtcc, 2, pool));

  return SVN_NO_ERROR;
}

/* Baton for handle_rev */
struct handle_rev_baton
{
  svn_revnum_t last;
  svn_boolean_t up;
  svn_boolean_t first;

  /* Per revision handler */
  svn_txdelta_window_handler_t inner_handler;
  void *inner_baton;

  /* Swapped between revisions to reconstruct data */
  svn_stringbuf_t *cur;
  svn_stringbuf_t *prev;

  /* Pool for some test stuff */
  apr_pool_t *pool;
};

/* Implement svn_txdelta_window_handler_t */
static svn_error_t *
handle_rev_delta(svn_txdelta_window_t *window,
                 void * baton)
{
  struct handle_rev_baton *hrb = baton;

  SVN_ERR(hrb->inner_handler(window, hrb->inner_baton));

  if (!window)
    {
      int expected_rev;
      const char *expected;

      /* Some revisions don't update the revision body */
      switch (hrb->last)
        {
          case 5:
            expected_rev = 4;
            break;
          case 7: /* Not reported */
          case 8:
            expected_rev = 6;
            break;
          default:
            expected_rev = (int)hrb->last;
        }

      expected = apr_psprintf(hrb->pool, "revision-%d", expected_rev);

      SVN_TEST_STRING_ASSERT(hrb->cur->data, expected);
    }

  return SVN_NO_ERROR;
}

/* Helper for test_file_revs_both_ways */
static svn_error_t *
handle_rev(void *baton,
           const char *path,
           svn_revnum_t rev,
           apr_hash_t *rev_props,
           svn_boolean_t result_of_merge,
           svn_txdelta_window_handler_t *delta_handler,
           void **delta_baton,
           apr_array_header_t *prop_diffs,
           apr_pool_t *pool)
{
  struct handle_rev_baton *hrb = baton;
  svn_revnum_t expected_rev = hrb->up ? (hrb->last + 1) : (hrb->last - 1);

  if (expected_rev == 7)
    expected_rev = hrb->up ? 8 : 6;

  SVN_TEST_ASSERT(rev == expected_rev);
  SVN_TEST_ASSERT(apr_hash_count(rev_props) >= 3);
  SVN_TEST_STRING_ASSERT(path, (rev < 5) ? "/iota" : "/mu");

  if (!hrb->first
      && (rev == (hrb->up ? 5 : 4) || rev == (hrb->up ? 8 : 6)))
    SVN_TEST_ASSERT(delta_handler == NULL);
  else
    SVN_TEST_ASSERT(delta_handler != NULL);

  if (delta_handler)
    {
      svn_stringbuf_t *tmp;

      *delta_handler = handle_rev_delta;
      *delta_baton = hrb;

      /* Swap string buffers, to use previous as original */
      tmp = hrb->prev;
      hrb->prev = hrb->cur;
      hrb->cur = tmp;

      svn_stringbuf_setempty(hrb->cur);

      svn_txdelta_apply(svn_stream_from_stringbuf(hrb->prev, pool),
                        svn_stream_from_stringbuf(hrb->cur, pool),
                        NULL, NULL, pool,
                        &hrb->inner_handler,
                        &hrb->inner_baton);
    }

  hrb->last = rev;
  hrb->first = FALSE;

  return SVN_NO_ERROR;
}

static svn_error_t *
test_file_revs_both_ways(const svn_test_opts_t *opts,
                         apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  apr_pool_t *subpool = svn_pool_create(pool);
  const char *repos_url;
  svn_ra_session_t *ra;
  struct handle_rev_baton hrb;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-file-revs",
                                  opts, pool, subpool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 0, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_add_file("iota",
                                        cstr_stream("revision-1", subpool),
                                        NULL /* src_checksum */,
                                        mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 1, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 1, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_update_file("iota",
                                           cstr_stream("revision-2", subpool),
                                           NULL /* src_checksum */, NULL, NULL,
                                           mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 2, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 2, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_update_file("iota",
                                           cstr_stream("revision-3", subpool),
                                           NULL /* src_checksum */, NULL, NULL,
                                           mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 3, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 3, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_update_file("iota",
                                           cstr_stream("revision-4", subpool),
                                           NULL /* src_checksum */, NULL, NULL,
                                           mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 4, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 4, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_move("iota", "mu", mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 5, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 5, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_update_file("mu",
                                           cstr_stream("revision-6", subpool),
                                           NULL /* src_checksum */, NULL, NULL,
                                           mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 6, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 6, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_delete("mu", mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 7, subpool));
  svn_pool_clear(subpool);

  SVN_ERR(svn_client_open_ra_session2(&ra, repos_url, NULL, ctx, pool, subpool));

  hrb.prev = svn_stringbuf_create("", pool);
  hrb.cur = svn_stringbuf_create("", pool);
  hrb.pool = pool;

  svn_pool_clear(subpool);
  hrb.up = FALSE;
  hrb.last = 5;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "iota", 4, 1, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 1);

  svn_pool_clear(subpool);
  hrb.up = TRUE;
  hrb.last = 0;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "iota", 1, 4, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 4);

  svn_pool_clear(subpool);
  hrb.up = FALSE;
  hrb.last = 7;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "mu", 6, 1, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 1);

  svn_pool_clear(subpool);
  hrb.up = TRUE;
  hrb.last = 0;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "mu", 1, 6, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 6);

  /* Ressurect mu */
  svn_pool_clear(subpool);
  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 7, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_copy("mu", 6, "mu", mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 8, subpool));

  svn_pool_clear(subpool);
  hrb.up = TRUE;
  hrb.last = 0;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "mu", 1, SVN_INVALID_REVNUM, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 8);

  svn_pool_clear(subpool);
  hrb.up = FALSE;
  hrb.last = 9;
  hrb.first = TRUE;
  svn_stringbuf_setempty(hrb.prev);
  svn_stringbuf_setempty(hrb.cur);
  SVN_ERR(svn_ra_get_file_revs2(ra, "mu", SVN_INVALID_REVNUM, 1, FALSE,
                                handle_rev, &hrb,
                                subpool));
  SVN_TEST_ASSERT(hrb.last == 1);

  return SVN_NO_ERROR;
}

static svn_error_t *
test_iprops_path_format(const svn_test_opts_t *opts,
                        apr_pool_t *pool)
{
  svn_client__mtcc_t *mtcc;
  svn_client_ctx_t *ctx;
  apr_pool_t *subpool = svn_pool_create(pool);
  const char *repos_url;
  svn_ra_session_t *ra;

  SVN_ERR(svn_test__create_repos2(NULL, &repos_url, NULL, "mtcc-iprops-paths",
                                  opts, pool, subpool));

  SVN_ERR(svn_client_create_context2(&ctx, NULL, pool));
  SVN_ERR(svn_test__init_auth_baton(&ctx->auth_baton, pool));

  SVN_ERR(svn_client__mtcc_create(&mtcc, repos_url, 0, ctx, subpool, subpool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A", mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A/B", mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A/B/C", mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_mkdir("A/B/C/D", mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_propset("", "on-root",
                                       svn_string_create("ROOT", subpool),
                                       FALSE, mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_propset("A/B", "on-B",
                                       svn_string_create("BBBB", subpool),
                                       FALSE, mtcc, subpool));
  SVN_ERR(svn_client__mtcc_add_propset("A/B/C", "Z",
                                       svn_string_create("Z", subpool),
                                       FALSE, mtcc, subpool));
  SVN_ERR(verify_mtcc_commit(mtcc, 1, subpool));
  svn_pool_clear(subpool);

  {
    apr_array_header_t *iprops;
    svn_prop_inherited_item_t *ip;

    SVN_ERR(svn_client_open_ra_session2(&ra, repos_url, NULL, ctx,
                                        pool, subpool));

    SVN_ERR(svn_ra_get_inherited_props(ra, &iprops, "A/B/C/D", 1,
                                       subpool, subpool));

    SVN_TEST_ASSERT(iprops != NULL);
    SVN_TEST_INT_ASSERT(iprops->nelts, 3);

    ip = APR_ARRAY_IDX(iprops, 0, svn_prop_inherited_item_t *);
    SVN_TEST_STRING_ASSERT(ip->path_or_url, "");

    ip = APR_ARRAY_IDX(iprops, 1, svn_prop_inherited_item_t *);
    SVN_TEST_STRING_ASSERT(ip->path_or_url, "A/B");

    ip = APR_ARRAY_IDX(iprops, 2, svn_prop_inherited_item_t *);
    SVN_TEST_STRING_ASSERT(ip->path_or_url, "A/B/C");
  }

  return SVN_NO_ERROR;
}

/* ========================================================================== */


static int max_threads = 3;

static struct svn_test_descriptor_t test_funcs[] =
  {
    SVN_TEST_NULL,
    SVN_TEST_OPTS_PASS(test_mkdir,
                       "test mtcc mkdir"),
    SVN_TEST_OPTS_PASS(test_mkgreek,
                       "test making greek tree"),
    SVN_TEST_OPTS_PASS(test_swap,
                       "swapping some trees"),
    SVN_TEST_OPTS_PASS(test_propset,
                       "test propset and propdel"),
    SVN_TEST_OPTS_PASS(test_update_files,
                       "test update files"),
    SVN_TEST_OPTS_PASS(test_overwrite,
                       "test overwrite"),
    SVN_TEST_OPTS_PASS(test_anchoring,
                       "test mtcc anchoring for root operations"),
    SVN_TEST_OPTS_PASS(test_replace_tree,
                       "test mtcc replace tree"),
    SVN_TEST_OPTS_PASS(test_file_revs_both_ways,
                       "test ra_get_file_revs2 both ways"),
    SVN_TEST_OPTS_PASS(test_iprops_path_format,
                       "test iprops url format"),
    SVN_TEST_NULL
  };

SVN_TEST_MAIN
