subversion 1.6.6-x86-mswin32-60 → 1.6.11-x86-mswin32-60

data/subversion/test/test_info.rb

@@ -0,0 +1,331 @@
+require "util"
+
+require "svn/info"
+
+class SvnInfoTest < Test::Unit::TestCase
+  include SvnTestUtil
+
+  def setup
+    setup_basic
+  end
+
+  def teardown
+    teardown_basic
+  end
+
+  def test_info
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+    log = "test commit\nnew line"
+    FileUtils.touch(path)
+
+    commit_info = make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit([@wc_path])
+    end
+
+    info = make_info(commit_info.revision)
+    assert_equal(@author, info.author)
+    assert_equal(commit_info.date, info.date)
+    assert_equal(commit_info.revision, info.revision)
+    assert_equal(log, info.log)
+  end
+
+  def test_dirs_changed
+    dir = "new_dir"
+    file = "new.txt"
+    dir_path = File.join(@wc_path, dir)
+    file_path = File.join(dir_path, file)
+    log = "added dir"
+
+    commit_info = make_context(log) do |ctx|
+      ctx.mkdir(dir_path)
+      FileUtils.touch(file_path)
+      ctx.add(file_path)
+      commit_info = ctx.commit(@wc_path)
+    end
+
+    info = make_info(commit_info.revision)
+    assert_equal(["/", "#{dir}/"], info.changed_dirs)
+    assert_equal(commit_info.revision, info.revision)
+    assert_equal(log, info.log)
+  end
+
+  def test_changed
+    dir = "changed_dir"
+    tmp_dir = "changed_tmp_dir"
+    dir_path = File.join(@wc_path, dir)
+    tmp_dir_path = File.join(@wc_path, tmp_dir)
+    dir_svn_path = dir
+    tmp_dir_svn_path = tmp_dir
+
+    file1 = "changed1.txt"
+    file2 = "changed2.txt"
+    file3 = "changed3.txt"
+    file4 = "changed4.txt"
+    file5 = "changed5.txt"
+    file1_path = File.join(@wc_path, file1)
+    file2_path = File.join(dir_path, file2)
+    file3_path = File.join(@wc_path, file3)
+    file4_path = File.join(dir_path, file4)
+    file5_path = File.join(@wc_path, file5)
+    file1_svn_path = file1
+    file2_svn_path = [dir_svn_path, file2].join("/")
+    file3_svn_path = file3
+    file4_svn_path = [dir_svn_path, file4].join("/")
+    file5_svn_path = file5
+
+    file6 = "changed6.txt"
+    file7 = "changed7.txt"
+    file8 = "changed8.txt"
+    file9 = "changed9.txt"
+    file6_path = File.join(dir_path, file6)
+    file7_path = File.join(@wc_path, file7)
+    file8_path = File.join(dir_path, file8)
+    file9_path = File.join(dir_path, file9)
+    file6_svn_path = [dir_svn_path, file6].join("/")
+    file7_svn_path = file7
+    file8_svn_path = [dir_svn_path, file8].join("/")
+    file9_svn_path = [dir_svn_path, file9].join("/")
+
+    first_rev = nil
+
+    log = "added 2 dirs\nanded 5 files"
+    make_context(log) do |ctx|
+
+      ctx.mkdir([dir_path, tmp_dir_path])
+      FileUtils.touch(file1_path)
+      FileUtils.touch(file2_path)
+      FileUtils.touch(file3_path)
+      FileUtils.touch(file4_path)
+      FileUtils.touch(file5_path)
+      ctx.add(file1_path)
+      ctx.add(file2_path)
+      ctx.add(file3_path)
+      ctx.add(file4_path)
+      ctx.add(file5_path)
+
+      commit_info = ctx.commit(@wc_path)
+      first_rev = commit_info.revision
+
+      info = make_info(commit_info.revision)
+      assert_equal([].sort, info.updated_dirs)
+      assert_equal([].sort, info.deleted_dirs)
+      assert_equal(["#{dir_svn_path}/", "#{tmp_dir_svn_path}/"].sort,
+                   info.added_dirs)
+
+      File.open(file1_path, "w") {|f| f.puts "changed"}
+      File.open(file2_path, "w") {|f| f.puts "changed"}
+      File.open(file3_path, "w") {|f| f.puts "changed"}
+    end
+
+    log = "changed 3 files\ndeleted 2 files\nadded 3 files"
+    make_context(log) do |ctx|
+      ctx.rm_f([file4_path, file5_path])
+      FileUtils.touch(file6_path)
+      FileUtils.touch(file7_path)
+      FileUtils.touch(file8_path)
+      ctx.add(file6_path)
+      ctx.add(file7_path)
+      ctx.add(file8_path)
+      ctx.cp(file1_path, file9_path)
+      ctx.rm(tmp_dir_path)
+
+      commit_info = ctx.commit(@wc_path)
+      second_rev = commit_info.revision
+
+      info = make_info(commit_info.revision)
+      assert_equal([file1_svn_path, file2_svn_path, file3_svn_path].sort,
+                   info.updated_files)
+      assert_equal([file4_svn_path, file5_svn_path].sort,
+                   info.deleted_files)
+      assert_equal([file6_svn_path, file7_svn_path, file8_svn_path].sort,
+                   info.added_files)
+      assert_equal([].sort, info.updated_dirs)
+      assert_equal([
+                     [file9_svn_path, file1_svn_path, first_rev]
+                   ].sort_by{|x| x[0]},
+                   info.copied_files)
+      assert_equal([], info.copied_dirs)
+      assert_equal(["#{tmp_dir_svn_path}/"].sort, info.deleted_dirs)
+      assert_equal([].sort, info.added_dirs)
+    end
+  end
+
+  def test_diff
+    log = "diff"
+    make_context(log) do |ctx|
+
+      file1 = "diff1.txt"
+      file2 = "diff2.txt"
+      file3 = "diff3.txt"
+      file1_path = File.join(@wc_path, "diff1.txt")
+      file2_path = File.join(@wc_path, "diff2.txt")
+      file3_path = File.join(@wc_path, "diff3.txt")
+      file1_prop_key = "AAA"
+      file1_prop_value = "BBB"
+      FileUtils.touch(file1_path)
+      File.open(file2_path, "w") {|f| f.puts "changed"}
+      FileUtils.touch(file3_path)
+
+      ctx.add(file1_path)
+      ctx.add(file2_path)
+      ctx.add(file3_path)
+      ctx.propset(file1_prop_key, file1_prop_value, file1_path)
+
+      ctx.commit(@wc_path)
+
+      file4 = "diff4.txt"
+      file5 = "diff5.txt"
+      file4_path = File.join(@wc_path, file4)
+      file5_path = File.join(@wc_path, file5)
+      file4_prop_key = "XXX"
+      file4_prop_value = "YYY"
+      File.open(file1_path, "w") {|f| f.puts "changed"}
+      File.open(file2_path, "wb") {|f| f.puts "removed\nadded"}
+      FileUtils.touch(file4_path)
+      ctx.add(file4_path)
+      ctx.propdel(file1_prop_key, file1_path)
+      ctx.propset(file4_prop_key, file4_prop_value, file4_path)
+      ctx.cp(file3_path, file5_path)
+
+      commit_info = ctx.commit(@wc_path)
+
+      info = make_info(commit_info.revision)
+      keys = info.diffs.keys.sort
+      file5_key = keys.last
+      assert_equal(4, info.diffs.size)
+      assert_equal([file1, file2, file4].sort, keys[0..-2])
+      assert_match(/\A#{file5}/, file5_key)
+      assert(info.diffs[file1].has_key?(:modified))
+      assert(info.diffs[file1].has_key?(:property_changed))
+      assert(info.diffs[file2].has_key?(:modified))
+      assert(info.diffs[file4].has_key?(:added))
+      assert(info.diffs[file4].has_key?(:property_changed))
+      assert(info.diffs[file5_key].has_key?(:copied))
+      assert_equal(1, info.diffs[file1][:modified].added_line)
+      assert_equal(0, info.diffs[file1][:modified].deleted_line)
+      assert_equal(2, info.diffs[file2][:modified].added_line)
+      assert_equal(1, info.diffs[file2][:modified].deleted_line)
+      assert_equal(0, info.diffs[file4][:added].added_line)
+      assert_equal(0, info.diffs[file4][:added].deleted_line)
+      assert_equal(0, info.diffs[file5_key][:copied].added_line)
+      assert_equal(0, info.diffs[file5_key][:copied].deleted_line)
+      assert_equal("Name: #{file1_prop_key}\n   - #{file1_prop_value}\n",
+                   info.diffs[file1][:property_changed].body)
+      assert_equal("Name: #{file4_prop_key}\n   + #{file4_prop_value}\n",
+                   info.diffs[file4][:property_changed].body)
+      assert_equal(commit_info.revision, info.revision)
+      assert_equal(log, info.log)
+    end
+  end
+
+  def test_diff_path
+    log = "diff path"
+    make_context(log) do |ctx|
+
+      parent_dir = "parent_dir"
+      child_dir = "child_dir"
+      parent_dir_path = File.join(@wc_path, parent_dir)
+      child_dir_path = File.join(parent_dir_path, child_dir)
+      parent_dir_svn_path = parent_dir
+      child_dir_svn_path = [parent_dir, child_dir].join("/")
+
+      ctx.mkdir([parent_dir_path, child_dir_path])
+
+      file1 = "diff1.txt"
+      file2 = "diff2.txt"
+      file1_path = File.join(@wc_path, file1)
+      file2_path = File.join(child_dir_path, file2)
+      file1_svn_path = file1
+      file2_svn_path = [child_dir_svn_path, file2].join("/")
+      File.open(file1_path, "w") {|f| f.puts "new"}
+      File.open(file2_path, "w") {|f| f.puts "deep"}
+      ctx.add(file1_path)
+      ctx.add(file2_path)
+
+      commit_info = ctx.commit(@wc_path)
+
+      info = make_info(commit_info.revision)
+      assert_equal(2, info.diffs.size)
+      assert(info.diffs.has_key?(file1_svn_path))
+      assert(info.diffs.has_key?(file2_svn_path))
+      assert(info.diffs[file1_svn_path].has_key?(:added))
+      assert(info.diffs[file2_svn_path].has_key?(:added))
+      assert_equal(1, info.diffs[file1_svn_path][:added].added_line)
+      assert_equal(0, info.diffs[file1_svn_path][:added].deleted_line)
+      assert_equal(1, info.diffs[file2_svn_path][:added].added_line)
+      assert_equal(0, info.diffs[file2_svn_path][:added].deleted_line)
+
+
+      file3 = "diff3.txt"
+      file4 = "diff4.txt"
+      file3_path = File.join(parent_dir_path, file3)
+      file4_path = File.join(child_dir_path, file4)
+      file3_svn_path = [parent_dir_svn_path, file3].join("/")
+      file4_svn_path = [child_dir_svn_path, file4].join("/")
+
+      ctx.mv(file2_path, file3_path)
+      ctx.mv(file1_path, file4_path)
+
+      commit_info = ctx.commit(@wc_path)
+
+      info = make_info(commit_info.revision)
+      assert_equal([
+                     file1_svn_path,
+                     file2_svn_path,
+                     file3_svn_path,
+                     file4_svn_path,
+                   ].sort,
+                   info.diffs.keys.sort)
+      assert(info.diffs[file1_svn_path].has_key?(:deleted))
+      assert(info.diffs[file2_svn_path].has_key?(:deleted))
+      assert(info.diffs[file3_svn_path].has_key?(:copied))
+      assert(info.diffs[file4_svn_path].has_key?(:copied))
+    end
+  end
+
+  def test_sha256
+    log = "sha256"
+    make_context(log) do |ctx|
+
+      file1 = "diff1.txt"
+      file2 = "diff2.txt"
+      file3 = "diff3.txt"
+      file1_path = File.join(@wc_path, "diff1.txt")
+      file2_path = File.join(@wc_path, "diff2.txt")
+      file3_path = File.join(@wc_path, "diff3.txt")
+      file1_content = file1
+      file2_content = file2
+      file3_content = file3
+      all_content = [file1, file2, file3].sort.join("")
+      File.open(file1_path, "w") {|f| f.print file1_content}
+      File.open(file2_path, "w") {|f| f.print file2_content}
+      File.open(file3_path, "w") {|f| f.print file3_content}
+
+      ctx.add(file1_path)
+      ctx.add(file2_path)
+      ctx.add(file3_path)
+
+      commit_info = ctx.commit(@wc_path)
+
+      info = make_info(commit_info.revision)
+      assert_equal(3, info.sha256.size)
+      assert_equal(Digest::SHA256.hexdigest(file1_content),
+                   info.sha256[file1][:sha256])
+      assert_equal(Digest::SHA256.hexdigest(file2_content),
+                   info.sha256[file2][:sha256])
+      assert_equal(Digest::SHA256.hexdigest(file3_content),
+                   info.sha256[file3][:sha256])
+      assert_equal(Digest::SHA256.hexdigest(all_content),
+                   info.entire_sha256)
+      assert_equal(commit_info.revision, info.revision)
+      assert_equal(log, info.log)
+    end
+  end
+
+  def make_info(rev=nil)
+    Svn::Info.new(@repos_path, rev || @fs.youngest_rev)
+  end
+
+end

data/subversion/test/test_ra.rb

@@ -0,0 +1,436 @@
+require "util"
+
+require "svn/ra"
+
+class SvnRaTest < Test::Unit::TestCase
+  include SvnTestUtil
+
+  def setup
+    setup_basic
+  end
+
+  def teardown
+    teardown_basic
+  end
+
+  def test_version
+    assert_equal(Svn::Core.subr_version, Svn::Ra.version)
+  end
+
+  def test_uuid
+    Svn::Ra::Session.open(@repos_uri) do |session|
+      assert_equal(File.read(File.join(@repos_path, "db", "uuid")).strip,
+                   session.uuid)
+    end
+  end
+
+  def test_open_without_callback
+    assert_nothing_raised do
+      Svn::Ra::Session.open(@repos_uri).close
+    end
+  end
+
+  def test_session
+    log = "sample log"
+    log2 = "sample log2"
+    file = "sample.txt"
+    src = "sample source"
+    path = File.join(@wc_path, file)
+
+    session = nil
+    rev1 = nil
+    path_props = nil
+
+    make_context(log) do |ctx0|
+      config = {}
+      path_props = {"my-prop" => "value"}
+      callbacks = Svn::Ra::Callbacks.new(ctx0.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config,callbacks) do |session|
+
+        assert_equal(youngest_rev, session.latest_revnum)
+        assert_equal(@repos_uri, session.repos_root)
+
+        File.open(path, "w") {|f| f.print(src)}
+        ctx0.add(path)
+        info = ctx0.ci(@wc_path)
+        rev1 = info.revision
+
+        assert_equal(info.revision, session.dated_revision(info.date))
+        content, props = session.file(file, info.revision)
+        assert_equal(src, content)
+        assert_equal([
+                       Svn::Core::PROP_ENTRY_COMMITTED_DATE,
+                       Svn::Core::PROP_ENTRY_UUID,
+                       Svn::Core::PROP_ENTRY_LAST_AUTHOR,
+                       Svn::Core::PROP_ENTRY_COMMITTED_REV,
+                     ].sort,
+                     props.keys.sort)
+        entries, props = session.dir("", info.revision)
+        assert_equal([file], entries.keys)
+        assert(entries[file].file?)
+        assert_equal([
+                       Svn::Core::PROP_ENTRY_COMMITTED_DATE,
+                       Svn::Core::PROP_ENTRY_UUID,
+                       Svn::Core::PROP_ENTRY_LAST_AUTHOR,
+                       Svn::Core::PROP_ENTRY_COMMITTED_REV,
+                     ].sort,
+                     props.keys.sort)
+
+        entries, props = session.dir("", info.revision, Svn::Core::DIRENT_KIND)
+        assert_equal(Svn::Core::NODE_FILE, entries[file].kind)
+        entries, props = session.dir("", info.revision, 0)
+        assert_equal(Svn::Core::NODE_NONE, entries[file].kind)
+
+        make_context(log2) do |ctx|
+          File.open(path, "w") {|f| f.print(src * 2)}
+          path_props.each do |key, value|
+            ctx.prop_set(key, value, path)
+          end
+          info = ctx.ci(@wc_path)
+          rev2 = info.revision
+
+          logs = []
+          receiver = Proc.new do |changed_paths, revision, author, date, message|
+            logs << [revision, message]
+          end
+          session.log([file], rev1, rev2, rev2 - rev1 + 1, &receiver)
+          assert_equal([
+                         [rev1, log],
+                         [rev2, log2],
+                       ].sort_by {|rev, log| rev},
+                       logs.sort_by {|rev, log| rev})
+
+          assert_equal(Svn::Core::NODE_FILE, session.check_path(file))
+          assert_equal(Svn::Core::NODE_FILE, session.stat(file).kind)
+
+          assert_equal({
+                         rev1 => "/#{file}",
+                         rev2 => "/#{file}",
+                       },
+                       session.locations(file, [rev1, rev2]))
+
+          infos = []
+          session.file_revs(file, rev1, rev2) do |_path, rev, rev_props, prop_diffs|
+            hashed_prop_diffs = {}
+            prop_diffs.each do |prop|
+              hashed_prop_diffs[prop.name] = prop.value
+            end
+            infos << [rev, _path, hashed_prop_diffs]
+          end
+          assert_equal([
+                         [rev1, "/#{file}", {}],
+                         [rev2, "/#{file}", path_props],
+                       ],
+                       infos)
+
+          infos = []
+          session.file_revs2(file, rev1, rev2) do |_path, rev, rev_props, prop_diffs|
+            infos << [rev, _path, prop_diffs]
+          end
+          assert_equal([
+                         [rev1, "/#{file}", {}],
+                         [rev2, "/#{file}", path_props],
+                       ],
+                       infos)
+
+          assert_equal({}, session.get_locks(""))
+          locks = []
+          session.lock({file => rev2}) do |_path, do_lock, lock, ra_err|
+            locks << [_path, do_lock, lock, ra_err]
+          end
+          assert_equal([file],
+                       locks.collect{|_path, *rest| _path}.sort)
+          lock = locks.assoc(file)[2]
+          assert_equal(["/#{file}"],
+                       session.get_locks("").collect{|_path, *rest| _path})
+          assert_equal(lock.token, session.get_lock(file).token)
+          assert_equal([lock.token],
+                       session.get_locks(file).values.collect{|l| l.token})
+          session.unlock({file => lock.token})
+          assert_equal({}, session.get_locks(file))
+        end
+      end
+    end
+  end
+
+  def assert_property_access
+    log = "sample log"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    make_context(log) do |ctx|
+      config = {}
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+
+        FileUtils.touch(path)
+        ctx.add(path)
+        info = ctx.commit(@wc_path)
+
+        assert_equal(@author, yield(session, :get, Svn::Core::PROP_REVISION_AUTHOR))
+        assert_equal(log, yield(session, :get, Svn::Core::PROP_REVISION_LOG))
+        assert_equal([
+                       Svn::Core::PROP_REVISION_AUTHOR,
+                       Svn::Core::PROP_REVISION_DATE,
+                       Svn::Core::PROP_REVISION_LOG,
+                     ].sort,
+                     yield(session, :list).keys.sort)
+        yield(session, :set, Svn::Core::PROP_REVISION_LOG, nil)
+        assert_nil(yield(session, :get ,Svn::Core::PROP_REVISION_LOG))
+        assert_equal([
+                       Svn::Core::PROP_REVISION_AUTHOR,
+                       Svn::Core::PROP_REVISION_DATE,
+                     ].sort,
+                     yield(session, :list).keys.sort)
+      end
+    end
+  end
+
+  def test_prop
+    assert_property_access do |session, action, *args|
+      case action
+      when :get
+        key, = args
+        session[key]
+      when :set
+        key, value = args
+        session[key] = value
+      when :list
+        session.properties
+      end
+    end
+  end
+
+  def test_prop_with_no_ruby_way
+    assert_property_access do |session, action, *args|
+      case action
+      when :get
+        key, = args
+        session.prop(key)
+      when :set
+        key, value = args
+        session.set_prop(key, value)
+      when :list
+        session.proplist
+      end
+    end
+  end
+
+  def test_callback
+    log = "sample log"
+    file = "sample.txt"
+    src1 = "sample source1"
+    src2 = "sample source2"
+    path = File.join(@wc_path, file)
+    path_in_repos = "/#{file}"
+    make_context(log) do |ctx|
+      config = {}
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+
+        File.open(path, "w") {|f| f.print(src1)}
+        ctx.add(path)
+        rev1 = ctx.ci(@wc_path).revision
+
+        File.open(path, "w") {|f| f.print(src2)}
+        rev2 = ctx.ci(@wc_path).revision
+
+        ctx.up(@wc_path)
+
+        editor, editor_baton = session.commit_editor(log) {}
+        reporter = session.update(rev2, "", editor, editor_baton)
+        reporter.abort_report
+
+        editor, editor_baton = session.commit_editor(log) {}
+        reporter = session.update2(rev2, "", editor)
+        reporter.abort_report
+      end
+    end
+  end
+
+  def test_diff
+    log = "sample log"
+    file = "sample.txt"
+    src1 = "a\nb\nc\nd\ne\n"
+    src2 = "a\nb\nC\nd\ne\n"
+    path = File.join(@wc_path, file)
+    path_in_repos = "/#{file}"
+    make_context(log) do |ctx|
+      config = {}
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+
+        File.open(path, "w") {|f| f.print(src1)}
+        ctx.add(path)
+        rev1 = ctx.ci(@wc_path).revision
+
+        File.open(path, "w") {|f| f.print(src2)}
+        rev2 = ctx.ci(@wc_path).revision
+
+        ctx.up(@wc_path)
+
+        editor = Svn::Delta::BaseEditor.new # dummy
+        reporter = session.diff(rev2, "", @repos_uri, editor)
+        reporter.set_path("", rev1, false, nil)
+        reporter.finish_report
+      end
+    end
+  end
+
+  def test_commit_editor
+    log = "sample log"
+    dir_uri = "/test"
+    config = {}
+    make_context(log) do |ctx|
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+        actual_info = nil
+        actual_date = nil
+
+        expected_info = [1, @author]
+        start_time = Time.now
+        gc_disable do
+          editor, baton = session.commit_editor(log) do |rev, date, author|
+            actual_info = [rev, author]
+            actual_date = date
+          end
+          editor.baton = baton
+
+          root = editor.open_root(-1)
+          editor.add_directory(dir_uri, root, nil, -1)
+          gc_enable do
+            GC.start
+            editor.close_edit
+          end
+          assert_equal(expected_info, actual_info)
+          assert_operator(start_time..(Time.now), :include?, actual_date)
+        end
+      end
+    end
+  end
+
+  def test_commit_editor2
+    log = "sample log"
+    dir_uri = "/test"
+    config = {}
+    make_context(log) do |ctx|
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+        actual_info = nil
+        actual_date = nil
+
+        expected_info = [1, @author]
+        start_time = Time.now
+        gc_disable do
+          editor = session.commit_editor2(log) do |info|
+            actual_info = [info.revision, info.author]
+            actual_date = info.date
+          end
+
+          root = editor.open_root(-1)
+          editor.add_directory(dir_uri, root, nil, -1)
+          gc_enable do
+            GC.start
+            editor.close_edit
+          end
+          assert_equal(expected_info, actual_info)
+          assert_operator(start_time..(Time.now), :include?, actual_date)
+        end
+      end
+    end
+  end
+
+  def test_reparent
+    log = "sample log"
+    dir = "dir"
+    deep_dir = "deep"
+    dir_path = File.join(@wc_path, dir)
+    deep_dir_path = File.join(dir_path, deep_dir)
+    config = {}
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      ctx.ci(@wc_path)
+
+      ctx.mkdir(deep_dir_path)
+      ctx.ci(@wc_path)
+
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+
+        entries, props = session.dir(dir, nil)
+        assert_equal([deep_dir], entries.keys)
+        assert_raise(Svn::Error::FS_NOT_FOUND) do
+          session.dir(deep_dir)
+        end
+
+        session.reparent("#{@repos_uri}/#{dir}")
+        assert_raise(Svn::Error::FS_NOT_FOUND) do
+          session.dir(dir)
+        end
+        entries, props = session.dir(deep_dir)
+        assert_equal([], entries.keys)
+
+        assert_raise(Svn::Error::RA_ILLEGAL_URL) do
+          session.reparent("file:///tmp/xxx")
+        end
+      end
+    end
+  end
+
+  def test_mergeinfo
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample\n"
+    config = {}
+    trunk = File.join(@wc_path, "trunk")
+    branch = File.join(@wc_path, "branch")
+    trunk_path = File.join(trunk, file)
+    branch_path = File.join(branch, file)
+    session_relative_trunk_path = "trunk"
+    repository_branch_path = "/branch"
+
+    make_context(log) do |ctx|
+      ctx.mkdir(trunk, branch)
+      File.open(trunk_path, "w") {}
+      File.open(branch_path, "w") {}
+      ctx.add(trunk_path)
+      ctx.add(branch_path)
+      rev1 = ctx.commit(@wc_path).revision
+
+      File.open(branch_path, "w") {|f| f.print(src)}
+      rev2 = ctx.commit(@wc_path).revision
+
+      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
+      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|
+
+        assert_nil(session.mergeinfo(session_relative_trunk_path))
+        ctx.merge(branch, rev1, branch, rev2, trunk)
+        assert_nil(session.mergeinfo(session_relative_trunk_path))
+
+        rev3 = ctx.commit(@wc_path).revision
+        mergeinfo = session.mergeinfo(session_relative_trunk_path)
+        assert_equal([session_relative_trunk_path], mergeinfo.keys)
+        trunk_mergeinfo = mergeinfo[session_relative_trunk_path]
+        assert_equal([repository_branch_path], trunk_mergeinfo.keys)
+        assert_equal([[1, 2, true]],
+                     trunk_mergeinfo[repository_branch_path].collect {|range|
+                        range.to_a})
+
+        ctx.rm(branch_path)
+        rev4 = ctx.commit(@wc_path).revision
+
+        ctx.merge(branch, rev3, branch, rev4, trunk)
+        assert(!File.exist?(trunk_path))
+        rev5 = ctx.commit(@wc_path).revision
+
+        mergeinfo = session.mergeinfo(session_relative_trunk_path, rev5)
+        assert_equal([session_relative_trunk_path], mergeinfo.keys)
+        trunk_mergeinfo = mergeinfo[session_relative_trunk_path]
+        assert_equal([repository_branch_path], trunk_mergeinfo.keys)
+        assert_equal([[1, 2, true], [3, 4, true]],
+                     trunk_mergeinfo[repository_branch_path].collect {|range|
+                        range.to_a})
+      end
+    end
+  end
+end