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

data/subversion/test/test-unit-ext/long-display-for-emacs.rb

@@ -0,0 +1,25 @@
+require 'test/unit/failure'
+require 'test/unit/error'
+
+module Test
+  module Unit
+    BACKTRACE_INFO_RE = /.+:\d+:in `.+?'/
+    class Failure
+      alias_method :original_long_display, :long_display
+      def long_display
+        extract_backtraces_re =
+          /^    \[(#{BACKTRACE_INFO_RE}(?:\n     #{BACKTRACE_INFO_RE})+)\]:$/
+        original_long_display.gsub(extract_backtraces_re) do |backtraces|
+          $1.gsub(/^     (#{BACKTRACE_INFO_RE})/, '\1') + ':'
+        end
+      end
+    end
+
+    class Error
+      alias_method :original_long_display, :long_display
+      def long_display
+        original_long_display.gsub(/^    (#{BACKTRACE_INFO_RE})/, '\1')
+      end
+    end
+  end
+end

data/subversion/test/test-unit-ext/priority.rb

@@ -0,0 +1,176 @@
+require "test/unit"
+
+require "fileutils"
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        def inherited(sub)
+          super
+          sub.instance_variable_set("@priority_initialized", true)
+          sub.instance_variable_set("@priority_table", {})
+          sub.priority :normal
+        end
+
+        def include(*args)
+          args.reverse_each do |mod|
+            super(mod)
+            next unless defined?(@priority_initialized)
+            mod.instance_methods(false).each do |name|
+              set_priority(name)
+            end
+          end
+        end
+
+        def method_added(name)
+          set_priority(name) if defined?(@priority_initialized)
+        end
+
+        def priority(name, *tests)
+          singleton_class = (class << self; self; end)
+          priority_check_method = priority_check_method_name(name)
+          unless singleton_class.private_method_defined?(priority_check_method)
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          if tests.empty?
+            @current_priority = name
+          else
+            tests.each do |test|
+              set_priority(test, name)
+            end
+          end
+        end
+
+        def need_to_run?(test_name)
+          normalized_test_name = normalize_test_name(test_name)
+          priority = @priority_table[normalized_test_name]
+          return true unless priority
+          __send__(priority_check_method_name(priority), test_name)
+        end
+
+        private
+        def priority_check_method_name(priority_name)
+          "run_priority_#{priority_name}?"
+        end
+
+        def normalize_test_name(test_name)
+          "test_#{test_name.to_s.sub(/^test_/, '')}"
+        end
+
+        def set_priority(name, priority=@current_priority)
+          @priority_table[normalize_test_name(name)] = priority
+        end
+
+        def run_priority_must?(test_name)
+          true
+        end
+
+        def run_priority_important?(test_name)
+          rand > 0.1
+        end
+
+        def run_priority_high?(test_name)
+          rand > 0.3
+        end
+
+        def run_priority_normal?(test_name)
+          rand > 0.5
+        end
+
+        def run_priority_low?(test_name)
+          rand > 0.75
+        end
+
+        def run_priority_never?(test_name)
+          false
+        end
+      end
+
+      def need_to_run?
+        !previous_test_success? or self.class.need_to_run?(@method_name)
+      end
+
+      alias_method :original_run, :run
+      def run(result, &block)
+        original_run(result, &block)
+      ensure
+        if passed?
+          FileUtils.touch(passed_file)
+        else
+          FileUtils.rm_f(passed_file)
+        end
+      end
+
+      private
+      def previous_test_success?
+        File.exist?(passed_file)
+      end
+
+      def result_dir
+        dir = File.join(File.dirname($0), ".test-result",
+                        self.class.name, escaped_method_name)
+        dir = File.expand_path(dir)
+        FileUtils.mkdir_p(dir)
+        dir
+      end
+
+      def passed_file
+        File.join(result_dir, "passed")
+      end
+
+      def escaped_method_name
+        @method_name.to_s.gsub(/[!?]$/) do |matched|
+          case matched
+          when "!"
+            ".destructive"
+          when "?"
+            ".predicate"
+          end
+        end
+      end
+    end
+
+    class TestSuite
+      @@priority_mode = false
+
+      class << self
+        def priority_mode=(bool)
+          @@priority_mode = bool
+        end
+      end
+
+      alias_method :original_run, :run
+      def run(*args, &block)
+        priority_mode = @@priority_mode
+        if priority_mode
+          @original_tests = @tests
+          apply_priority
+        end
+        original_run(*args, &block)
+      ensure
+        @tests = @original_tests if priority_mode
+      end
+
+      def apply_priority
+        @tests = @tests.reject {|test| !test.need_to_run?}
+      end
+
+      def need_to_run?
+        apply_priority
+        !@tests.empty?
+      end
+    end
+
+    class AutoRunner
+      alias_method :original_options, :options
+      def options
+        opts = original_options
+        opts.on("--[no-]priority", "use priority mode") do |bool|
+          TestSuite.priority_mode = bool
+        end
+        opts
+      end
+    end
+  end
+end

data/subversion/test/test_client.rb

@@ -0,0 +1,2457 @@
+require "my-assertions"
+require "util"
+
+require "svn/core"
+require "svn/client"
+
+class SvnClientTest < Test::Unit::TestCase
+  include SvnTestUtil
+
+  def setup
+    setup_basic(true)
+  end
+
+  def teardown
+    teardown_basic
+  end
+
+  def test_version
+    assert_equal(Svn::Core.subr_version, Svn::Client.version)
+  end
+
+  def test_add_not_recurse
+    log = "sample log"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, dir)
+    uri = "#{@repos_uri}/#{dir}/#{dir}"
+
+    make_context(log) do |ctx|
+      FileUtils.mkdir(dir_path)
+      FileUtils.mkdir(path)
+      ctx.add(dir_path, false)
+      ctx.commit(@wc_path)
+
+      assert_raise(Svn::Error::FS_NOT_FOUND) do
+        ctx.cat(uri)
+      end
+    end
+  end
+
+  def test_add_recurse
+    log = "sample log"
+    file = "hello.txt"
+    src = "Hello"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    uri = "#{@repos_uri}/#{dir}/#{file}"
+
+    make_context(log) do |ctx|
+      FileUtils.mkdir(dir_path)
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(dir_path)
+      ctx.commit(@wc_path)
+
+      assert_equal(src, ctx.cat(uri))
+    end
+  end
+
+  def test_add_force
+    log = "sample log"
+    file = "hello.txt"
+    src = "Hello"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    uri = "#{@repos_uri}/#{dir}/#{file}"
+
+    make_context(log) do |ctx|
+      FileUtils.mkdir(dir_path)
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(dir_path, false)
+      ctx.commit(@wc_path)
+
+      assert_raise(Svn::Error::ENTRY_EXISTS) do
+        ctx.add(dir_path, true, false)
+      end
+
+      ctx.add(dir_path, true, true)
+      ctx.commit(@wc_path)
+      assert_equal(src, ctx.cat(uri))
+    end
+  end
+
+  def test_add_no_ignore
+    log = "sample log"
+    file = "hello.txt"
+    src = "Hello"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    uri = "#{@repos_uri}/#{dir}/#{file}"
+
+    make_context(log) do |ctx|
+      FileUtils.mkdir(dir_path)
+      ctx.add(dir_path, false)
+      ctx.propset(Svn::Core::PROP_IGNORE, file, dir_path)
+      ctx.commit(@wc_path)
+
+      File.open(path, "w") {|f| f.print(src)}
+
+      ctx.add(dir_path, true, true, false)
+      ctx.commit(@wc_path)
+      assert_raise(Svn::Error::FS_NOT_FOUND) do
+        ctx.cat(uri)
+      end
+
+      ctx.add(dir_path, true, true, true)
+      ctx.commit(@wc_path)
+      assert_equal(src, ctx.cat(uri))
+    end
+  end
+
+  def test_mkdir
+    log = "sample log"
+    dir = "dir"
+    deep_dir = ["d", "e", "e", "p"]
+    dir2 = "dir2"
+    dir_uri = "#{@repos_uri}/#{dir}"
+    deep_dir_uri = "#{@repos_uri}/#{deep_dir.join('/')}"
+    dir2_uri = "#{@repos_uri}/#{dir2}"
+    dir_path = File.join(@wc_path, dir)
+    deep_dir_path = File.join(@wc_path, *deep_dir)
+    dir2_path = File.join(@wc_path, dir2)
+
+    make_context(log) do |ctx|
+
+      assert(!File.exist?(dir_path))
+      ctx.mkdir(dir_path)
+      assert(File.exist?(dir_path))
+      assert_raises(Svn::Error::EntryExists) do
+        ctx.add(dir_path)
+      end
+      old_rev = ctx.commit(@wc_path).revision
+
+      new_rev = ctx.mkdir(dir2_uri).revision
+      assert_equal(old_rev + 1, new_rev)
+      assert_raises(Svn::Error::FsAlreadyExists) do
+        ctx.mkdir(dir2_uri)
+      end
+      assert(!File.exist?(dir2_path))
+      ctx.update(@wc_path)
+      assert(File.exist?(dir2_path))
+
+      assert_raises(Svn::Error::SvnError) do
+        ctx.mkdir(deep_dir_path)
+      end
+    end
+  end
+
+  def assert_mkdir_with_multiple_paths
+    log = "sample log"
+    dir = "dir"
+    dir2 = "dir2"
+    dirs = [dir, dir2]
+    dirs_path = dirs.collect {|d| Pathname.new(@wc_path) + d}
+    dirs_full_path = dirs_path.collect {|path| path.expand_path}
+
+    make_context(log) do |ctx|
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+
+      assert_equal([false, false], dirs_path.collect {|path| path.exist?})
+      yield(ctx, dirs_path.collect {|path| path.to_s})
+      assert_equal(dirs_path.collect {|path| path.to_s}.sort,
+                   infos.collect{|path, notify| path}.sort)
+      assert_equal([true] * dirs_path.size,
+                   infos.collect{|path, notify| notify.add?})
+      assert_equal([true, true], dirs_path.collect {|path| path.exist?})
+
+      infos.clear
+      ctx.commit(@wc_path)
+      assert_equal(dirs_full_path.collect {|path| path.to_s}.sort,
+                   infos.collect{|path, notify| path}.sort)
+      assert_equal([true] * dirs_path.size,
+                   infos.collect{|path, notify| notify.commit_added?})
+    end
+  end
+
+  def test_mkdir_with_multiple_paths
+    assert_mkdir_with_multiple_paths do |ctx, dirs|
+      ctx.mkdir(*dirs)
+    end
+  end
+
+  def test_mkdir_with_multiple_paths_as_array
+    assert_mkdir_with_multiple_paths do |ctx, dirs|
+      ctx.mkdir(dirs)
+    end
+  end
+
+  def test_mkdir_p
+    log = "sample log"
+    dir = "parent"
+    child_dir = "parent/child"
+    dir_path = Pathname.new(@wc_path) + dir
+    child_dir_path = dir_path + "child"
+    full_paths = [dir_path, child_dir_path].collect {|path| path.expand_path}
+
+    make_context(log) do |ctx|
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+
+      assert_equal([false, false], [dir_path.exist?, child_dir_path.exist?])
+      ctx.mkdir_p(child_dir_path.to_s)
+      assert_equal(full_paths.collect {|path| path.to_s}.sort,
+                   infos.collect{|path, notify| path}.sort)
+      assert_equal([true, true],
+                   infos.collect{|path, notify| notify.add?})
+      assert_equal([true, true], [dir_path.exist?, child_dir_path.exist?])
+
+      infos.clear
+      ctx.commit(@wc_path)
+      assert_equal(full_paths.collect {|path| path.to_s}.sort,
+                   infos.collect{|path, notify| path}.sort)
+      assert_equal([true, true],
+                   infos.collect{|path, notify| notify.commit_added?})
+    end
+  end
+
+  def test_delete
+    log = "sample log"
+    src = "sample source\n"
+    file = "file.txt"
+    dir = "dir"
+    path = File.join(@wc_path, file)
+    dir_path = File.join(@wc_path, dir)
+
+    make_context(log) do |ctx|
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.mkdir(dir_path)
+      ctx.commit(@wc_path)
+
+      ctx.delete([path, dir_path])
+      ctx.commit(@wc_path)
+      assert(!File.exist?(path))
+      assert(!File.exist?(dir_path))
+
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      File.open(path, "w") {|f| f.print(src * 2)}
+      assert_raises(Svn::Error::ClientModified) do
+        ctx.delete(path)
+      end
+      assert_nothing_raised do
+        ctx.delete(path, true)
+        ctx.commit(@wc_path)
+      end
+      assert(!File.exist?(path))
+    end
+  end
+
+  def test_delete_alias
+    log = "sample log"
+    src = "sample source\n"
+    file = "file.txt"
+    dir = "dir"
+    path = File.join(@wc_path, file)
+    dir_path = File.join(@wc_path, dir)
+
+    make_context(log) do |ctx|
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.mkdir(dir_path)
+      ctx.commit(@wc_path)
+
+      ctx.rm([path, dir_path])
+      ctx.commit(@wc_path)
+      assert(!File.exist?(path))
+      assert(!File.exist?(dir_path))
+
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      File.open(path, "w") {|f| f.print(src * 2)}
+      assert_raises(Svn::Error::ClientModified) do
+        ctx.rm(path)
+      end
+      assert_nothing_raised do
+        ctx.rm_f(path)
+        ctx.commit(@wc_path)
+      end
+      assert(!File.exist?(path))
+
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.mkdir(dir_path)
+      ctx.commit(@wc_path)
+
+      ctx.rm_f(path, dir_path)
+      ctx.commit(@wc_path)
+      assert(!File.exist?(path))
+      assert(!File.exist?(dir_path))
+    end
+  end
+
+  def test_import
+    src = "source\n"
+    log = "sample log"
+    deep_dir = File.join(%w(a b c d e))
+    file = "sample.txt"
+    deep_dir_path = File.join(@wc_path, deep_dir)
+    path = File.join(deep_dir_path, file)
+    tmp_deep_dir_path = File.join(@tmp_path, deep_dir)
+    tmp_path = File.join(tmp_deep_dir_path, file)
+
+    make_context(log) do |ctx|
+
+      FileUtils.mkdir_p(tmp_deep_dir_path)
+      File.open(tmp_path, "w") {|f| f.print(src)}
+
+      ctx.import(@tmp_path, @repos_uri)
+
+      ctx.up(@wc_path)
+      assert_equal(src, File.open(path){|f| f.read})
+    end
+  end
+
+  def test_import_custom_revprops
+    src = "source\n"
+    log = "sample log"
+    deep_dir = File.join(%w(a b c d e))
+    file = "sample.txt"
+    deep_dir_path = File.join(@wc_path, deep_dir)
+    path = File.join(deep_dir_path, file)
+    tmp_deep_dir_path = File.join(@tmp_path, deep_dir)
+    tmp_path = File.join(tmp_deep_dir_path, file)
+
+    make_context(log) do |ctx|
+
+      FileUtils.mkdir_p(tmp_deep_dir_path)
+      File.open(tmp_path, "w") {|f| f.print(src)}
+
+      new_rev = ctx.import(@tmp_path, @repos_uri, true, false,
+                           {"custom-prop" => "some-value"}).revision
+      assert_equal(["some-value", new_rev],
+                   ctx.revprop_get("custom-prop", @repos_uri, new_rev))
+
+      ctx.up(@wc_path)
+      assert_equal(src, File.open(path){|f| f.read})
+    end
+  end
+
+  def test_commit
+    log = "sample log"
+    dir1 = "dir1"
+    dir2 = "dir2"
+    dir1_path = File.join(@wc_path, dir1)
+    dir2_path = File.join(dir1_path, dir2)
+
+    make_context(log) do |ctx|
+      assert_equal(Svn::Core::INVALID_REVNUM,ctx.commit(@wc_path).revision)
+      ctx.mkdir(dir1_path)
+      assert_equal(0, youngest_rev)
+      assert_equal(1, ctx.commit(@wc_path).revision)
+      ctx.mkdir(dir2_path)
+      assert_equal(Svn::Core::INVALID_REVNUM,ctx.commit(@wc_path, false).revision)
+      assert_equal(2, ctx.ci(@wc_path).revision)
+    end
+  end
+
+  def test_status
+    log = "sample log"
+    file1 = "sample1.txt"
+    file2 = "sample2.txt"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(dir_path, file2)
+
+    make_context(log) do |ctx|
+      File.open(path1, "w") {}
+      ctx.add(path1)
+      rev1 = ctx.commit(@wc_path).revision
+
+
+      ctx.mkdir(dir_path)
+      File.open(path2, "w") {}
+
+      infos = []
+      rev = ctx.status(@wc_path) do |path, status|
+        infos << [path, status]
+      end
+
+      assert_equal(youngest_rev, rev)
+      assert_equal([dir_path, path2].sort,
+                   infos.collect{|path, status| path}.sort)
+      dir_status = infos.assoc(dir_path).last
+      assert(dir_status.text_added?)
+      assert(dir_status.entry.dir?)
+      assert(dir_status.entry.add?)
+      path2_status = infos.assoc(path2).last
+      assert(!path2_status.text_added?)
+      assert_nil(path2_status.entry)
+
+
+      infos = []
+      rev = ctx.st(@wc_path, rev1, true, true) do |path, status|
+        infos << [path, status]
+      end
+
+      assert_equal(rev1, rev)
+      assert_equal([@wc_path, dir_path, path1, path2].sort,
+                   infos.collect{|path, status| path}.sort)
+      wc_status = infos.assoc(@wc_path).last
+      assert(wc_status.text_normal?)
+      assert(wc_status.entry.dir?)
+      assert(wc_status.entry.normal?)
+      dir_status = infos.assoc(dir_path).last
+      assert(dir_status.text_added?)
+      assert(dir_status.entry.dir?)
+      assert(dir_status.entry.add?)
+      path1_status = infos.assoc(path1).last
+      assert(path1_status.text_normal?)
+      assert(path1_status.entry.file?)
+      assert(path1_status.entry.normal?)
+      path2_status = infos.assoc(path2).last
+      assert(!path2_status.text_added?)
+      assert_nil(path2_status.entry)
+
+
+      ctx.prop_set(Svn::Core::PROP_IGNORE, file2, dir_path)
+
+      infos = []
+      rev = ctx.status(@wc_path, nil, true, true, true, false) do |path, status|
+        infos << [path, status]
+      end
+
+      assert_equal(rev1, rev)
+      assert_equal([@wc_path, dir_path, path1].sort,
+                   infos.collect{|path, status| path}.sort)
+
+
+      infos = []
+      rev = ctx.status(@wc_path, nil, true, true, true, true) do |path, status|
+        infos << [path, status]
+      end
+
+      assert_equal(rev1, rev)
+      assert_equal([@wc_path, dir_path, path1, path2].sort,
+                   infos.collect{|path, status| path}.sort)
+      end
+  end
+
+  def test_status_with_depth
+    setup_greek_tree
+
+    log = "sample log"
+      make_context(log) do |ctx|
+
+      # make everything out-of-date
+      ctx.prop_set('propname', 'propvalue', @greek.path(:b), :infinity)
+
+      recurse_and_depth_choices.each do |rd|
+        ctx.status(@greek.path(:mu), nil, rd) do |path, status|
+          assert_equal @greek.uri(:mu), status.url
+        end
+      end
+
+      expected_statuses_by_depth = {
+        true => [:beta, :b, :lambda, :e, :f, :alpha],
+        false => [:b, :lambda, :e, :f],
+        'empty' => [:b],
+        'files' => [:b, :lambda],
+        'immediates' => [:b, :lambda, :e, :f],
+        'infinity' => [:beta, :b, :lambda, :e, :f, :alpha],
+      }
+
+      recurse_and_depth_choices.each do |rd|
+        urls = []
+        ctx.status(@greek.path(:b), nil, rd) do |path, status|
+          urls << status.url
+        end
+        assert_equal(expected_statuses_by_depth[rd].map{|s| @greek.uri(s)}.sort,
+                     urls.sort,
+                     "depth '#{rd}")
+      end
+    end
+  end
+
+  def test_checkout
+    log = "sample log"
+    file = "hello.txt"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    content = "Hello"
+
+    make_context(log) do |ctx|
+      ctx.mkdir(dir_path)
+      File.open(path, "w"){|f| f.print(content)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      FileUtils.rm_rf(@wc_path)
+      ctx.checkout(@repos_uri, @wc_path)
+      assert(File.exist?(path))
+
+      FileUtils.rm_rf(@wc_path)
+      ctx.co(@repos_uri, @wc_path, nil, nil, false)
+      assert(!File.exist?(path))
+    end
+  end
+
+  def test_update
+    log = "sample log"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+    content = "Hello"
+    File.open(path, "w"){|f| f.print(content)}
+
+    make_context(log) do |ctx|
+
+      assert_nothing_raised do
+        ctx.update(File.join(@wc_path, "non-exist"), youngest_rev)
+      end
+
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+
+      FileUtils.rm(path)
+      assert(!File.exist?(path))
+      assert_equal(commit_info.revision,
+                   ctx.update(path, commit_info.revision))
+      assert_equal(content, File.read(path))
+
+      FileUtils.rm(path)
+      assert(!File.exist?(path))
+      assert_equal([commit_info.revision],
+                   ctx.update([path], commit_info.revision))
+      assert_equal(content, File.read(path))
+
+      assert_raise(Svn::Error::FS_NO_SUCH_REVISION) do
+        begin
+          ctx.update(path, commit_info.revision + 1)
+        ensure
+          ctx.cleanup(@wc_path)
+        end
+      end
+      assert_nothing_raised do
+        ctx.update(path + "non-exist", commit_info.revision)
+      end
+    end
+  end
+
+  def test_revert
+    log = "sample log"
+    file1 = "hello1.txt"
+    file2 = "hello2.txt"
+    file3 = "hello3.txt"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(@wc_path, file2)
+    path3 = File.join(dir_path, file3)
+    content = "Hello"
+
+    make_context(log) do |ctx|
+      File.open(path1, "w"){|f| f.print(content)}
+      File.open(path2, "w"){|f| f.print(content)}
+      ctx.add(path1)
+      ctx.add(path2)
+      ctx.mkdir(dir_path)
+      File.open(path3, "w"){|f| f.print(content)}
+      ctx.add(path3)
+      commit_info = ctx.commit(@wc_path)
+
+      File.open(path1, "w"){}
+      assert_equal("", File.open(path1){|f| f.read})
+
+      ctx.revert(path1)
+      assert_equal(content, File.open(path1){|f| f.read})
+
+      File.open(path1, "w"){}
+      File.open(path2, "w"){}
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      ctx.revert([path1, path2])
+      assert_equal(content, File.open(path1){|f| f.read})
+      assert_equal(content, File.open(path2){|f| f.read})
+
+      File.open(path1, "w"){}
+      File.open(path2, "w"){}
+      File.open(path3, "w"){}
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      assert_equal("", File.open(path3){|f| f.read})
+      ctx.revert(@wc_path)
+      assert_equal(content, File.open(path1){|f| f.read})
+      assert_equal(content, File.open(path2){|f| f.read})
+      assert_equal(content, File.open(path3){|f| f.read})
+
+      File.open(path1, "w"){}
+      File.open(path2, "w"){}
+      File.open(path3, "w"){}
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      assert_equal("", File.open(path3){|f| f.read})
+      ctx.revert(@wc_path, false)
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      assert_equal("", File.open(path3){|f| f.read})
+
+      File.open(path1, "w"){}
+      File.open(path2, "w"){}
+      File.open(path3, "w"){}
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      assert_equal("", File.open(path3){|f| f.read})
+      ctx.revert(dir_path)
+      assert_equal("", File.open(path1){|f| f.read})
+      assert_equal("", File.open(path2){|f| f.read})
+      assert_equal(content, File.open(path3){|f| f.read})
+    end
+  end
+
+  def test_log
+    log1 = "sample log1"
+    log2 = "sample log2"
+    log3 = "sample log3"
+    src1 = "source1\n"
+    src2 = "source2\n"
+    src3 = "source3\n"
+    file1 = "sample1.txt"
+    file2 = "sample2.txt"
+    file3 = "sample3.txt"
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(@wc_path, file2)
+    path3 = File.join(@wc_path, file3)
+    abs_path1 = File.join('', file1)
+    abs_path2 = File.join('', file2)
+    abs_path3 = File.join('', file3)
+
+    rev1 = make_context(log1) do |ctx|
+      File.open(path1, "w") {|f| f.print(src1)}
+      ctx.add(path1)
+      rev1 = ctx.ci(@wc_path).revision
+    end
+
+    rev2 = make_context(log2) do |ctx|
+      ctx.cp(path1, path2)
+      rev2 = ctx.ci(@wc_path).revision
+    end
+
+    make_context(log3) do |ctx|
+      ctx.cp(path1, path3)
+      File.open(path1, "w") {|f| f.print(src2)}
+      File.open(path3, "w") {|f| f.print(src3)}
+      rev3 = ctx.ci(@wc_path).revision
+
+      changed_paths_lists = {}
+      revs = {}
+      messages = {}
+      keys = [@wc_path, path1, path2, path3]
+      keys.each do |key|
+        revs[key] = []
+        changed_paths_lists[key] = []
+        messages[key] = []
+        args = [key, 1, "HEAD", 0, true, nil]
+        ctx.log(*args) do |changed_paths, rev, author, date, message|
+          revs[key] << rev
+          changed_paths_lists[key] << changed_paths
+          messages[key] << message
+        end
+      end
+      changed_paths_list = changed_paths_lists[@wc_path]
+
+      assert_equal([rev1, rev2, rev3], revs[@wc_path])
+      assert_equal([rev1, rev3], revs[path1])
+      assert_equal([rev1, rev2], revs[path2])
+      assert_equal([rev1, rev3], revs[path3])
+      assert_equal([log1, log2, log3], messages[@wc_path])
+
+      expected = [[abs_path1], [abs_path2], [abs_path1, abs_path3]]
+      actual = changed_paths_list.collect {|changed_paths| changed_paths.keys}
+      assert_nested_sorted_array(expected, actual)
+
+      assert_equal('A', changed_paths_list[0][abs_path1].action)
+      assert_false(changed_paths_list[0][abs_path1].copied?)
+      assert_equal('A', changed_paths_list[1][abs_path2].action)
+      assert_true(changed_paths_list[1][abs_path2].copied?)
+      assert_equal(abs_path1, changed_paths_list[1][abs_path2].copyfrom_path)
+      assert_equal(rev1, changed_paths_list[1][abs_path2].copyfrom_rev)
+      assert_equal('M', changed_paths_list[2][abs_path1].action)
+      assert_equal('A', changed_paths_list[2][abs_path3].action)
+    end
+  end
+
+  def test_log_message
+    log = "sample log"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+    FileUtils.touch(path)
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev = commit_info.revision
+
+      assert_equal(log, ctx.log_message(path, rev))
+    end
+  end
+
+  def test_blame
+    log = "sample log"
+    file = "hello.txt"
+    srcs = %w(first second third)
+    infos = []
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+
+      File.open(path, "w") {|f| f.puts(srcs[0])}
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      infos << [0, commit_info.revision, @author, commit_info.date, srcs[0]]
+
+      File.open(path, "a") {|f| f.puts(srcs[1])}
+      commit_info = ctx.commit(@wc_path)
+      infos << [1, commit_info.revision, @author, commit_info.date, srcs[1]]
+
+      File.open(path, "a") {|f| f.puts(srcs[2])}
+      commit_info = ctx.commit(@wc_path)
+      infos << [2, commit_info.revision, @author, commit_info.date, srcs[2]]
+
+      result = []
+      ctx.blame(path) do |line_no, revision, author, date, line|
+        result << [line_no, revision, author, date, line]
+      end
+      assert_equal(infos, result)
+
+
+      ctx.prop_set(Svn::Core::PROP_MIME_TYPE, "image/DUMMY", path)
+      ctx.commit(@wc_path)
+
+      assert_raise(Svn::Error::CLIENT_IS_BINARY_FILE) do
+        ctx.ann(path) {}
+      end
+    end
+  end
+
+  def test_diff
+    log = "sample log"
+    before = "before\n"
+    after = "after\n"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+
+    File.open(path, "w") {|f| f.print(before)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev1 = commit_info.revision
+
+      File.open(path, "w") {|f| f.print(after)}
+
+      out_file = Tempfile.new("svn")
+      err_file = Tempfile.new("svn")
+      ctx.diff([], path, rev1, path, "WORKING", out_file.path, err_file.path)
+      out_file.open
+      assert_match(/-#{before}\+#{after}\z/, out_file.read)
+
+      commit_info = ctx.commit(@wc_path)
+      rev2 = commit_info.revision
+      out_file = Tempfile.new("svn")
+      ctx.diff([], path, rev1, path, rev2, out_file.path, err_file.path)
+      out_file.open
+      assert_match(/-#{before}\+#{after}\z/, out_file.read)
+    end
+  end
+
+  def test_diff_peg
+    log = "sample log"
+    before = "before\n"
+    after = "after\n"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+
+    File.open(path, "w") {|f| f.print(before)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev1 = commit_info.revision
+
+      File.open(path, "w") {|f| f.print(after)}
+
+      out_file = Tempfile.new("svn")
+      err_file = Tempfile.new("svn")
+      ctx.diff_peg([], path, rev1, "WORKING", out_file.path, err_file.path)
+      out_file.open
+      assert_match(/-#{before}\+#{after}\z/, out_file.read)
+
+      commit_info = ctx.commit(@wc_path)
+      rev2 = commit_info.revision
+      out_file = Tempfile.new("svn")
+      ctx.diff_peg([], path, rev1, rev2, out_file.path, err_file.path)
+      out_file.open
+      assert_match(/-#{before}\+#{after}\z/, out_file.read)
+    end
+  end
+
+  def test_diff_summarize
+    log = "sample log"
+    before = "before\n"
+    after = "after\n"
+    file = "hello.txt"
+    path = File.join(@wc_path, file)
+
+    File.open(path, "w") {|f| f.print(before)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev1 = commit_info.revision
+
+      File.open(path, "w") {|f| f.print(after)}
+
+      commit_info = ctx.commit(@wc_path)
+      rev2 = commit_info.revision
+
+      diffs = []
+      ctx.diff_summarize(@wc_path, rev1, @wc_path, rev2) do |diff|
+        diffs << diff
+      end
+      assert_equal([file], diffs.collect {|d| d.path})
+      kinds = diffs.collect do |d|
+        [d.kind_normal?, d.kind_added?, d.kind_modified?, d.kind_deleted?]
+      end
+      assert_equal([[false, false, true, false]], kinds)
+      assert_equal([false], diffs.collect {|d| d.prop_changed?})
+      node_kinds = diffs.collect do |d|
+        [d.node_kind_none?, d.node_kind_file?,
+         d.node_kind_dir?, d.node_kind_unknown?]
+      end
+      assert_equal([[false, true, false, false]], node_kinds)
+    end
+  end
+
+  def test_diff_summarize_peg
+    log = "sample log"
+    before = "before\n"
+    after = "after\n"
+    before_file = "before.txt"
+    after_file = "after.txt"
+    moved_file = "moved.txt"
+    before_path = File.join(@wc_path, before_file)
+    after_path = File.join(@wc_path, after_file)
+    moved_path = File.join(@wc_path, moved_file)
+
+    File.open(before_path, "w") {|f| f.print(before)}
+
+    make_context(log) do |ctx|
+      ctx.add(before_path)
+      commit_info = ctx.commit(@wc_path)
+      rev1 = commit_info.revision
+
+      ctx.mv(before_path, after_path)
+      commit_info = ctx.commit(@wc_path)
+      rev2 = commit_info.revision
+
+      File.open(after_path, "w") {|f| f.print(after)}
+      commit_info = ctx.commit(@wc_path)
+      rev3 = commit_info.revision
+
+      File.open(after_path, "w") {|f| f.print(before)}
+      commit_info = ctx.commit(@wc_path)
+      rev4 = commit_info.revision
+
+      ctx.mv(after_path, moved_path)
+      commit_info = ctx.commit(@wc_path)
+      rev5 = commit_info.revision
+
+      diffs = []
+      ctx.diff_summarize_peg(@repos_uri, rev3, rev4, rev3) do |diff|
+        diffs << diff
+      end
+      assert_equal([after_file], diffs.collect {|d| d.path})
+      kinds = diffs.collect do |d|
+        [d.kind_normal?, d.kind_added?, d.kind_modified?, d.kind_deleted?]
+      end
+      assert_equal([[false, false, true, false]], kinds)
+      assert_equal([false], diffs.collect {|d| d.prop_changed?})
+      node_kinds = diffs.collect do |d|
+        [d.node_kind_none?, d.node_kind_file?,
+         d.node_kind_dir?, d.node_kind_unknown?]
+      end
+      assert_equal([[false, true, false, false]], node_kinds)
+    end
+  end
+
+  def assert_changed(ctx, path)
+    statuses = []
+    ctx.status(path) do |_, status|
+      statuses << status
+    end
+    assert_not_equal([], statuses)
+  end
+
+  def assert_not_changed(ctx, path)
+    statuses = []
+    ctx.status(path) do |_, status|
+      statuses << status
+    end
+    assert_equal([], statuses)
+  end
+
+  def assert_merge
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample\n"
+    trunk = File.join(@wc_path, "trunk")
+    branch = File.join(@wc_path, "branch")
+    branch_relative_uri = "/branch"
+    branch_uri = "#{@repos_uri}#{branch_relative_uri}"
+    trunk_path = File.join(trunk, file)
+    trunk_path_uri = "#{@repos_uri}/trunk/#{file}"
+    branch_path = File.join(branch, file)
+    branch_path_relative_uri = "#{branch_relative_uri}/#{file}"
+    branch_path_uri = "#{@repos_uri}#{branch_path_relative_uri}"
+
+    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
+
+      merged_entries = []
+      ctx.log_merged(trunk, nil, branch_uri, nil) do |entry|
+        merged_entries << entry
+      end
+      assert_equal_log_entries([], merged_entries)
+      assert_nil(ctx.merged(trunk))
+
+      merged_entries = []
+      yield(ctx, branch, rev1, rev2, trunk)
+      ctx.log_merged(trunk, nil, branch_uri, nil) do |entry|
+        merged_entries << entry
+      end
+      assert_equal_log_entries([
+                                [
+                                 {branch_path_relative_uri => ["M", nil, -1]},
+                                 rev2,
+                                 {
+                                   "svn:author" => @author,
+                                   "svn:log" => log,
+                                 },
+                                 false,
+                                ]
+                               ],
+                               merged_entries)
+      mergeinfo = ctx.merged(trunk)
+      assert_not_nil(mergeinfo)
+      assert_equal([branch_uri], mergeinfo.keys)
+      ranges = mergeinfo[branch_uri].collect {|range| range.to_a}
+      assert_equal([[1, 2, true]], ranges)
+
+      rev3 = ctx.commit(@wc_path).revision
+
+      assert_equal(normalize_line_break(src), ctx.cat(trunk_path, rev3))
+
+      ctx.rm(branch_path)
+      rev4 = ctx.commit(@wc_path).revision
+
+      yield(ctx, branch, rev3, rev4, trunk)
+      assert(!File.exist?(trunk_path))
+
+      merged_entries = []
+      ctx.log_merged(trunk, rev4, branch_uri, rev4) do |entry|
+        merged_entries << entry
+      end
+      assert_equal_log_entries([
+                                [
+                                 {branch_path_relative_uri => ["D", nil, -1]},
+                                 rev4,
+                                 {
+                                   "svn:author" => @author,
+                                   "svn:log" => log,
+                                 },
+                                 false,
+                                ]
+                               ] * 2, merged_entries)
+
+      ctx.propdel("svn:mergeinfo", trunk)
+      merged_entries = []
+      ctx.log_merged(trunk, rev4, branch_uri, rev4) do |entry|
+        merged_entries << entry
+      end
+      assert_equal_log_entries([], merged_entries)
+
+      ctx.revert(trunk)
+      File.open(trunk_path, "a") {|f| f.print(src)}
+      yield(ctx, branch, rev3, rev4, trunk)
+      ctx.revert(trunk, false)
+      ctx.resolve(:path=>trunk_path,
+                  :conflict_choice=>Svn::Wc::CONFLICT_CHOOSE_MERGED)
+      rev5 = ctx.commit(@wc_path).revision
+      assert(File.exist?(trunk_path))
+      ctx.up(@wc_path)
+
+      yield(ctx, branch, rev3, rev4, trunk, nil, false, true)
+      assert_changed(ctx, trunk)
+
+      ctx.propdel("svn:mergeinfo", trunk)
+      rev6 = ctx.commit(@wc_path).revision
+
+      yield(ctx, branch, rev3, rev4, trunk, nil, false, true, true)
+      assert_not_changed(ctx, trunk)
+
+      yield(ctx, branch, rev3, rev4, trunk, nil, false, true)
+      assert_changed(ctx, trunk)
+    end
+  end
+
+  def test_merge
+    assert_merge do |ctx, from, from_rev1, from_rev2, to, *rest|
+      ctx.merge(from, from_rev1, from, from_rev2, to, *rest)
+    end
+  end
+
+  def test_merge_peg
+    assert_merge do |ctx, from, from_rev1, from_rev2, to, *rest|
+      ctx.merge_peg(from, from_rev1, from_rev2, to, nil, *rest)
+    end
+  end
+
+  def test_cleanup
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample\n"
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      rev = ctx.commit(@wc_path).revision
+
+      ctx.up(@wc_path, rev - 1)
+      File.open(path, "w") {|f| f.print(src)}
+
+      assert_raise(Svn::Error::WC_OBSTRUCTED_UPDATE) do
+        ctx.up(@wc_path, rev)
+      end
+
+      Svn::Wc::AdmAccess.open(nil, @wc_path, true, -1) do |access|
+        assert_raise(Svn::Error::WC_LOCKED) do
+          ctx.commit(@wc_path)
+        end
+      end
+
+      ctx.set_cancel_func do
+        raise Svn::Error::CANCELLED
+      end
+      Svn::Wc::AdmAccess.open(nil, @wc_path, true, -1) do |access|
+        assert_raise(Svn::Error::CANCELLED) do
+          ctx.cleanup(@wc_path)
+        end
+        assert_raise(Svn::Error::WC_LOCKED) do
+          ctx.commit(@wc_path)
+        end
+      end
+
+      ctx.set_cancel_func(nil)
+      access = Svn::Wc::AdmAccess.open(nil, @wc_path, true, -1)
+      assert_nothing_raised do
+        ctx.cleanup(@wc_path)
+      end
+      assert_nothing_raised do
+        ctx.commit(@wc_path)
+      end
+      assert_raises(Svn::Error::SvnError) do
+        access.close
+      end
+    end
+  end
+
+  def test_relocate
+    log = "sample log"
+    file = "sample.txt"
+    src = "sample\n"
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      assert_nothing_raised do
+        ctx.cat(path)
+      end
+
+      ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+        cred.username = @author
+        cred.password = @password
+        cred.may_save = true
+      end
+      ctx.relocate(@wc_path, @repos_uri, @repos_svnserve_uri)
+
+      make_context(log) do |ctx|
+        assert_raises(Svn::Error::AuthnNoProvider) do
+          ctx.cat(path)
+        end
+      end
+    end
+  end
+
+  def test_resolved
+    log = "sample log"
+    file = "sample.txt"
+    dir = "dir"
+    src1 = "before\n"
+    src2 = "after\n"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+
+    make_context(log) do |ctx|
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {}
+      ctx.add(path)
+      rev1 = ctx.ci(@wc_path).revision
+
+      File.open(path, "w") {|f| f.print(src1)}
+      rev2 = ctx.ci(@wc_path).revision
+
+      ctx.up(@wc_path, rev1)
+
+      File.open(path, "w") {|f| f.print(src2)}
+      ctx.up(@wc_path)
+
+      assert_raises(Svn::Error::WcFoundConflict) do
+        ctx.ci(@wc_path)
+      end
+
+      ctx.resolved(dir_path, false)
+      assert_raises(Svn::Error::WcFoundConflict) do
+        ctx.ci(@wc_path)
+      end
+
+      ctx.resolved(dir_path)
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(rev2 + 1, info.revision)
+    end
+  end
+
+  def test_copy
+    log = "sample log"
+    src = "source\n"
+    file1 = "sample1.txt"
+    file2 = "sample2.txt"
+    path1 = Pathname.new(@wc_path) + file1
+    path2 = Pathname.new(@wc_path) + file2
+    full_path2 = path2.expand_path
+
+    make_context(log) do |ctx|
+      File.open(path1, "w") {|f| f.print(src)}
+      ctx.add(path1.to_s)
+
+      ctx.ci(@wc_path)
+
+      ctx.cp(path1.to_s, path2.to_s)
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+      ctx.ci(@wc_path)
+
+      assert_equal([full_path2.to_s].sort,
+                   infos.collect{|path, notify| path}.sort)
+      path2_notify = infos.assoc(full_path2.to_s)[1]
+      assert(path2_notify.commit_added?)
+      assert_equal(File.open(path1) {|f| f.read},
+                   File.open(path2) {|f| f.read})
+    end
+  end
+
+  def test_move
+    log = "sample log"
+    src = "source\n"
+    file1 = "sample1.txt"
+    file2 = "sample2.txt"
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(@wc_path, file2)
+
+    make_context(log) do |ctx|
+      File.open(path1, "w") {|f| f.print(src)}
+      ctx.add(path1)
+
+      ctx.ci(@wc_path)
+
+      ctx.mv(path1, path2)
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+      ctx.ci(@wc_path)
+
+      assert_equal([path1, path2].sort.collect{|p|File.expand_path(p)},
+                   infos.collect{|path, notify| path}.sort)
+      path1_notify = infos.assoc(File.expand_path(path1))[1]
+      assert(path1_notify.commit_deleted?)
+      path2_notify = infos.assoc(File.expand_path(path2))[1]
+      assert(path2_notify.commit_added?)
+      assert_equal(src, File.open(path2) {|f| f.read})
+    end
+  end
+
+  def test_move_force
+    log = "sample log"
+    src1 = "source1\n"
+    src2 = "source2\n"
+    file1 = "sample1.txt"
+    file2 = "sample2.txt"
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(@wc_path, file2)
+
+    make_context(log) do |ctx|
+      File.open(path1, "w") {|f| f.print(src1)}
+      ctx.add(path1)
+      ctx.ci(@wc_path)
+
+      File.open(path1, "w") {|f| f.print(src2)}
+      assert_nothing_raised do
+        ctx.mv(path1, path2)
+      end
+      ctx.revert([path1, path2])
+      FileUtils.rm(path2)
+
+      File.open(path1, "w") {|f| f.print(src2)}
+      assert_nothing_raised do
+        ctx.mv_f(path1, path2)
+      end
+
+      notifies = []
+      ctx.set_notify_func do |notify|
+        notifies << notify
+      end
+      ctx.ci(@wc_path)
+
+      paths = notifies.collect do |notify|
+        notify.path
+      end
+      assert_equal([path1, path2, path2].sort.collect{|p|File.expand_path(p)},
+                   paths.sort)
+
+      deleted_paths = notifies.find_all do |notify|
+        notify.commit_deleted?
+      end.collect do |notify|
+        notify.path
+      end
+      assert_equal([path1].sort.collect{|p|File.expand_path(p)},
+                   deleted_paths.sort)
+
+      added_paths = notifies.find_all do |notify|
+        notify.commit_added?
+      end.collect do |notify|
+        notify.path
+      end
+      assert_equal([path2].sort.collect{|p|File.expand_path(p)},
+                   added_paths.sort)
+
+      postfix_txdelta_paths = notifies.find_all do |notify|
+        notify.commit_postfix_txdelta?
+      end.collect do |notify|
+        notify.path
+      end
+      assert_equal([path2].sort.collect{|p|File.expand_path(p)},
+                   postfix_txdelta_paths.sort)
+
+      assert_equal(src2, File.open(path2) {|f| f.read})
+    end
+  end
+
+  def test_prop
+    log = "sample log"
+    dir = "dir"
+    file = "sample.txt"
+    dir_path = File.join(@wc_path, dir)
+    dir_uri = "#{@repos_uri}/#{dir}"
+    path = File.join(dir_path, file)
+    uri = "#{dir_uri}/#{file}"
+    prop_name = "sample-prop"
+    prop_value = "sample value"
+    invalid_mime_type_prop_value = "image"
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {}
+      ctx.add(path)
+
+      ctx.commit(@wc_path)
+
+      assert_equal({}, ctx.prop_get(prop_name, path))
+      ctx.prop_set(prop_name, prop_value, path)
+      ctx.commit(@wc_path)
+      assert_equal({uri => prop_value}, ctx.pget(prop_name, path))
+
+      ctx.prop_del(prop_name, path)
+      ctx.commit(@wc_path)
+      assert_equal({}, ctx.pg(prop_name, path))
+
+      ctx.ps(prop_name, prop_value, path)
+      ctx.commit(@wc_path)
+      assert_equal({uri => prop_value}, ctx.pg(prop_name, path))
+
+      ctx.ps(prop_name, nil, path)
+      ctx.commit(@wc_path)
+      assert_equal({}, ctx.pg(prop_name, path))
+
+      ctx.up(@wc_path)
+      ctx.ps(prop_name, prop_value, dir_path)
+      ctx.ci(@wc_path)
+      assert_equal({
+                     dir_uri => prop_value,
+                     uri => prop_value,
+                   },
+                   ctx.pg(prop_name, dir_path))
+
+      ctx.up(@wc_path)
+      ctx.pdel(prop_name, dir_path, false)
+      ctx.ci(@wc_path)
+      assert_equal({uri => prop_value}, ctx.pg(prop_name, dir_path))
+
+      ctx.up(@wc_path)
+      ctx.pd(prop_name, dir_path)
+      ctx.ci(@wc_path)
+      assert_equal({}, ctx.pg(prop_name, dir_path))
+
+      ctx.up(@wc_path)
+      ctx.ps(prop_name, prop_value, dir_path, false)
+      ctx.ci(@wc_path)
+      assert_equal({dir_uri => prop_value}, ctx.pg(prop_name, dir_path))
+
+      assert_raises(Svn::Error::BadMimeType) do
+        ctx.ps(Svn::Core::PROP_MIME_TYPE,
+               invalid_mime_type_prop_value,
+               path)
+      end
+      ctx.cleanup(@wc_path)
+
+      assert_nothing_raised do
+        ctx.ps(Svn::Core::PROP_MIME_TYPE,
+               invalid_mime_type_prop_value,
+               path, false, true)
+      end
+      ctx.commit(@wc_path)
+      assert_equal({uri => invalid_mime_type_prop_value},
+                   ctx.pg(Svn::Core::PROP_MIME_TYPE, path))
+    end
+  end
+
+  def test_prop_list
+    log = "sample log"
+    dir = "dir"
+    file = "sample.txt"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    dir_uri = "#{@repos_uri}/#{dir}"
+    uri = "#{dir_uri}/#{file}"
+    name1 = "name1"
+    name2 = "name2"
+    value1 = "value1"
+    value2 = "value2"
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {}
+      ctx.add(path)
+
+      ctx.ci(@wc_path)
+
+      assert_equal([], ctx.prop_list(path))
+
+      ctx.ps(name1, value1, path)
+      ctx.ci(@wc_path)
+      assert_equal([uri], ctx.prop_list(path).collect{|item| item.node_name})
+      assert_equal([{name1 => value1}],
+                   ctx.plist(path).collect{|item| item.prop_hash})
+      assert_equal([value1], ctx.pl(path).collect{|item| item[name1]})
+
+      ctx.up(@wc_path)
+      ctx.ps(name2, value2, dir_path)
+      ctx.ci(@wc_path)
+      assert_equal([uri, dir_uri].sort,
+                   ctx.prop_list(dir_path).collect{|item| item.name})
+      prop_list = ctx.plist(dir_path).collect{|item| [item.name, item.props]}
+      props = prop_list.assoc(uri)[1]
+      dir_props = prop_list.assoc(dir_uri)[1]
+      assert_equal({name1 => value1, name2 => value2}, props)
+      assert_equal({name2 => value2}, dir_props)
+    end
+  end
+
+  def recurse_and_depth_choices
+    [false, true, 'empty', 'files', 'immediates', 'infinity']
+  end
+
+  def test_file_prop
+    setup_greek_tree
+
+    log = "sample log"
+    make_context(log) do |ctx|
+
+      # when no props set, everything is empty
+      recurse_and_depth_choices.each do |rd|
+        assert_equal([],
+                     ctx.prop_list(@greek.path(:mu), nil, nil, rd),
+                     "prop_list with Depth '#{rd}'")
+      end
+
+      recurse_and_depth_choices.each do |rd|
+        assert_equal({},
+                     ctx.prop_get(rd.to_s, @greek.path(:mu), nil, nil, rd),
+                     "prop_get with Depth '#{rd}'")
+      end
+
+      # set some props
+      recurse_and_depth_choices.each do |rd|
+        ctx.prop_set(rd.to_s, rd.to_s, @greek.path(:mu), rd)
+      end
+      ctx.commit(@greek.path(:mu))
+
+      # get the props
+      recurse_and_depth_choices.each do |rd|
+        assert_equal({@greek.uri(:mu) => rd.to_s},
+                     ctx.prop_get(rd.to_s, @greek.path(:mu), nil, nil, rd),
+                     "prop_get with Depth '#{rd}'")
+      end
+
+      prop_hash = {}
+      recurse_and_depth_choices.each {|rd| prop_hash[rd.to_s] = rd.to_s}
+
+      # list the props
+      recurse_and_depth_choices.each do |rd|
+        props = ctx.prop_list(@greek.path(:mu), nil, nil, rd)
+        assert_equal([@greek.uri(:mu)],
+                     props.collect {|item| item.node_name},
+                     "prop_list (node_name) with Depth '#{rd}'")
+
+        props = ctx.plist(@greek.path(:mu), nil, nil, rd)
+        assert_equal([prop_hash],
+                     props.collect {|item| item.prop_hash},
+                     "prop_list (prop_hash) with Depth '#{rd}'")
+
+        recurse_and_depth_choices.each do |rd1|
+          props = ctx.plist(@greek.path(:mu), nil, nil, rd)
+          assert_equal([rd1.to_s],
+                       props.collect {|item| item[rd1.to_s]},
+                       "prop_list (#{rd1.to_s}]) with Depth '#{rd}'")
+        end
+      end
+    end
+  end
+
+  def test_dir_prop
+    setup_greek_tree
+
+    log = "sample log"
+    make_context(log) do |ctx|
+
+      # when no props set, everything is empty
+      recurse_and_depth_choices.each do |rd|
+        assert_equal([],
+                     ctx.prop_list(@greek.path(:b), nil, nil, rd),
+                     "prop_list with Depth '#{rd}'")
+      end
+
+      recurse_and_depth_choices.each do |rd|
+        assert_equal({},
+                     ctx.prop_get(rd.to_s, @greek.path(:b), nil, nil, rd),
+                     "prop_get with Depth '#{rd}'")
+      end
+
+      # set some props with various depths
+      recurse_and_depth_choices.each do |rd|
+        ctx.prop_set(rd.to_s, rd.to_s, @greek.path(:b), rd)
+      end
+      ctx.commit(@greek.path(:b))
+
+      expected_props = {
+        true => [:beta, :b, :lambda, :e, :f, :alpha],
+        false => [:b],
+        'empty' => [:b],
+        'files' => [:b, :lambda],
+        'immediates' => [:b, :lambda, :e, :f],
+        'infinity' => [:beta, :b, :lambda, :e, :f, :alpha],
+      }
+
+      paths = [:b, :e, :alpha, :beta, :f, :lambda]
+
+      # how are the props set?
+      recurse_and_depth_choices.each do |rd|
+        paths.each do |path|
+          if expected_props[rd].include?(path)
+            expected = {@greek.uri(path) => rd.to_s}
+          else
+            expected = {}
+          end
+          assert_equal(expected,
+                       ctx.prop_get(rd.to_s, @greek.path(path), nil, nil, false),
+                       "prop_get #{@greek.resolve(path)} with Depth '#{rd}'")
+        end
+      end
+
+      recurse_and_depth_choices.each do |rd_for_prop|
+        recurse_and_depth_choices.each do |rd_for_depth|
+          expected = {}
+          expected_paths = expected_props[rd_for_depth]
+          expected_paths &= expected_props[rd_for_prop]
+          expected_paths.each do |path|
+            expected[@greek.uri(path)] = rd_for_prop.to_s
+          end
+
+          assert_equal(expected,
+                       ctx.prop_get(rd_for_prop.to_s, @greek.path(:b),
+                                    nil, nil, rd_for_depth),
+                       "prop_get '#{rd_for_prop}' with Depth '#{rd_for_depth}'")
+
+        end
+      end
+
+      recurse_and_depth_choices.each do |rd|
+        props = ctx.prop_list(@greek.path(:b), nil, nil, rd)
+        assert_equal(expected_props[rd].collect {|path| @greek.uri(path)}.sort,
+                     props.collect {|item| item.node_name}.sort,
+                     "prop_list (node_name) with Depth '#{rd}'")
+        end
+    end
+  end
+
+  def test_cat
+    log = "sample log"
+    src1 = "source1\n"
+    src2 = "source2\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+
+    File.open(path, "w") {|f| f.print(src1)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      commit_info = ctx.commit(@wc_path)
+      rev1 = commit_info.revision
+
+      assert_equal(normalize_line_break(src1), ctx.cat(path, rev1))
+      assert_equal(normalize_line_break(src1), ctx.cat(path))
+
+      File.open(path, "w") {|f| f.print(src2)}
+
+      commit_info = ctx.commit(@wc_path)
+      rev2 = commit_info.revision
+
+      assert_equal(normalize_line_break(src1), ctx.cat(path, rev1))
+      assert_equal(normalize_line_break(src2), ctx.cat(path, rev2))
+      assert_equal(normalize_line_break(src2), ctx.cat(path))
+    end
+  end
+
+  def test_lock
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    absolute_path = File.expand_path(path)
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+      ctx.lock(path)
+
+      assert_equal([absolute_path], infos.collect{|_path, notify| _path})
+      file_notify = infos.assoc(absolute_path)[1]
+      assert(file_notify.locked?)
+    end
+  end
+
+  def test_unlock
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    absolute_path = File.expand_path(path)
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      ctx.lock(path)
+
+      infos = []
+      ctx.set_notify_func do |notify|
+        infos << [notify.path, notify]
+      end
+      ctx.unlock(path)
+
+      assert_equal([absolute_path], infos.collect{|_path, notify| _path})
+      file_notify = infos.assoc(absolute_path)[1]
+      assert(file_notify.unlocked?)
+    end
+  end
+
+  def test_info
+    log = "sample log"
+    make_context(log) do |ctx|
+      repos_base = File.basename(@repos_path)
+
+      infos = []
+      ctx.info(@wc_path) do |path, info|
+        infos << [path, info]
+      end
+      assert_equal([repos_base],
+                   infos.collect{|path, info| path})
+      top_info = infos.assoc(repos_base)[1]
+      assert_equal(@repos_uri, top_info.url)
+    end
+  end
+
+  def test_info_with_depth
+    setup_greek_tree
+
+    log = "sample log"
+    make_context(log) do |ctx|
+
+      recurse_and_depth_choices.each do |rd|
+        ctx.info(@greek.path(:mu),nil,nil,rd) do |path, info|
+          assert_equal @greek.uri(:mu), info.URL
+        end
+      end
+
+      expected_info_by_depth = {
+        true => [:beta, :b, :lambda, :e, :f, :alpha],
+        false => [:b],
+        'empty' => [:b],
+        'files' => [:b, :lambda],
+        'immediates' => [:b, :lambda, :e, :f],
+        'infinity' => [:beta, :b, :lambda, :e, :f, :alpha],
+      }
+
+      recurse_and_depth_choices.each do |rd|
+        urls = []
+        ctx.info(@greek.path(:b),nil,nil,rd) do |path, info|
+          urls << info.URL
+        end
+        assert_equal expected_info_by_depth[rd].map{|s| @greek.uri(s)}.sort,
+                     urls.sort,
+                     "depth '#{rd}"
+      end
+    end
+  end
+
+  def test_url_from_path
+    log = "sample log"
+    make_context(log) do |ctx|
+      assert_equal(@repos_uri, ctx.url_from_path(@wc_path))
+      assert_equal(@repos_uri, Svn::Client.url_from_path(@wc_path))
+    end
+  end
+
+  def test_uuid
+    log = "sample log"
+    make_context(log) do |ctx|
+      Svn::Wc::AdmAccess.open(nil, @wc_path, false, 0) do |adm|
+        assert_equal(ctx.uuid_from_url(@repos_uri),
+                     ctx.uuid_from_path(@wc_path, adm))
+      end
+    end
+  end
+
+  def test_open_ra_session
+    log = "sample log"
+    make_context(log) do |ctx|
+      assert_instance_of(Svn::Ra::Session, ctx.open_ra_session(@repos_uri))
+    end
+  end
+
+  def test_revprop
+    log = "sample log"
+    new_log = "new sample log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      info = ctx.commit(@wc_path)
+
+      assert_equal([
+                     {
+                       Svn::Core::PROP_REVISION_AUTHOR => @author,
+                       Svn::Core::PROP_REVISION_DATE => info.date,
+                       Svn::Core::PROP_REVISION_LOG => log,
+                     },
+                     info.revision
+                   ],
+                   ctx.revprop_list(@repos_uri, info.revision))
+
+      assert_equal([log, info.revision],
+                   ctx.revprop_get(Svn::Core::PROP_REVISION_LOG,
+                                   @repos_uri, info.revision))
+      assert_equal(log,
+                   ctx.revprop(Svn::Core::PROP_REVISION_LOG,
+                               @repos_uri, info.revision))
+
+      assert_equal(info.revision,
+                   ctx.revprop_set(Svn::Core::PROP_REVISION_LOG, new_log,
+                                   @repos_uri, info.revision))
+      assert_equal([new_log, info.revision],
+                   ctx.rpget(Svn::Core::PROP_REVISION_LOG,
+                             @repos_uri, info.revision))
+      assert_equal(new_log,
+                   ctx.rp(Svn::Core::PROP_REVISION_LOG,
+                          @repos_uri, info.revision))
+      assert_equal([
+                     {
+                       Svn::Core::PROP_REVISION_AUTHOR => @author,
+                       Svn::Core::PROP_REVISION_DATE => info.date,
+                       Svn::Core::PROP_REVISION_LOG => new_log,
+                     },
+                     info.revision
+                   ],
+                   ctx.rplist(@repos_uri, info.revision))
+
+      assert_equal(info.revision,
+                   ctx.revprop_del(Svn::Core::PROP_REVISION_LOG,
+                                   @repos_uri, info.revision))
+      assert_equal([nil, info.revision],
+                   ctx.rpg(Svn::Core::PROP_REVISION_LOG,
+                           @repos_uri, info.revision))
+      assert_equal(nil,
+                   ctx.rp(Svn::Core::PROP_REVISION_LOG,
+                          @repos_uri, info.revision))
+
+      assert_equal(info.revision,
+                   ctx.rpset(Svn::Core::PROP_REVISION_LOG, new_log,
+                             @repos_uri, info.revision))
+      assert_equal(new_log,
+                   ctx.rp(Svn::Core::PROP_REVISION_LOG,
+                          @repos_uri, info.revision))
+      assert_equal(info.revision,
+                   ctx.rps(Svn::Core::PROP_REVISION_LOG, nil,
+                           @repos_uri, info.revision))
+      assert_equal(nil,
+                   ctx.rp(Svn::Core::PROP_REVISION_LOG,
+                          @repos_uri, info.revision))
+
+      assert_equal([
+                     {
+                       Svn::Core::PROP_REVISION_AUTHOR => @author,
+                       Svn::Core::PROP_REVISION_DATE => info.date,
+                     },
+                     info.revision
+                   ],
+                   ctx.rpl(@repos_uri, info.revision))
+    end
+  end
+
+  def test_export
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    dir = "sample"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+    tmp_base_path = File.join(@tmp_path, "tmp")
+    tmp_dir_path = File.join(tmp_base_path, dir)
+    tmp_path = File.join(tmp_dir_path, file)
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      rev = ctx.ci(@wc_path).revision
+
+      assert_equal(rev, ctx.export(@repos_uri, tmp_base_path))
+      assert_equal(src, File.open(tmp_path) {|f| f.read})
+    end
+  end
+
+  def test_ls
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    dir = "sample"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      rev = ctx.ci(@wc_path).revision
+
+      dirents, locks = ctx.ls(@wc_path, rev)
+      assert_equal([dir, file].sort, dirents.keys.sort)
+      dir_dirent = dirents[dir]
+      assert(dir_dirent.directory?)
+      file_dirent = dirents[file]
+      assert(file_dirent.file?)
+    end
+  end
+
+  def test_list
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    dir = "sample"
+    prop_name = "sample-prop"
+    prop_value = "sample value"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.prop_set(prop_name, prop_value, path)
+      rev = ctx.ci(@wc_path).revision
+
+      entries = []
+      ctx.list(@wc_path, rev) do |path, dirent, lock, abs_path|
+        entries << [path, dirent, lock, abs_path]
+      end
+      paths = entries.collect do |path, dirent, lock, abs_path|
+        [path, abs_path]
+      end
+      assert_equal([["", "/"], [dir, "/"], [file, "/"]].sort, paths.sort)
+      entries.each do |path, dirent, lock, abs_path|
+        case path
+        when dir, ""
+          assert(dirent.directory?)
+          assert_false(dirent.have_props?)
+        when file
+          assert(dirent.file?)
+          assert_true(dirent.have_props?)
+        else
+          flunk
+        end
+      end
+    end
+  end
+
+  def test_list_with_depth
+    setup_greek_tree
+
+    log = "sample log"
+    make_context(log) do |ctx|
+
+      expected_lists_by_depth = {
+        true => [:beta, :b, :lambda, :e, :f, :alpha],
+        false => [:b, :lambda, :e, :f],
+        'empty' => [:b],
+        'files' => [:b, :lambda],
+        'immediates' => [:b, :lambda, :e, :f],
+        'infinity' => [:beta, :b, :lambda, :e, :f, :alpha],
+      }
+
+      recurse_and_depth_choices.each do |rd|
+        paths = []
+        ctx.list(@greek.path(:b), 'head' ,nil, rd) do |path, dirent, lock, abs_path|
+          paths << (path.empty? ? abs_path : File.join(abs_path, path))
+        end
+        assert_equal(expected_lists_by_depth[rd].map{|s| "/#{@greek.resolve(s)}"}.sort,
+                     paths.sort,
+                     "depth '#{rd}")
+      end
+    end
+  end
+
+  def test_switch
+    log = "sample log"
+    trunk_src = "trunk source\n"
+    tag_src = "tag source\n"
+    file = "sample.txt"
+    file = "sample.txt"
+    trunk_dir = "trunk"
+    tag_dir = "tags"
+    tag_name = "0.0.1"
+    trunk_repos_uri = "#{@repos_uri}/#{trunk_dir}"
+    tag_repos_uri = "#{@repos_uri}/#{tag_dir}/#{tag_name}"
+    trunk_dir_path = File.join(@wc_path, trunk_dir)
+    tag_dir_path = File.join(@wc_path, tag_dir)
+    tag_name_dir_path = File.join(@wc_path, tag_dir, tag_name)
+    trunk_path = File.join(trunk_dir_path, file)
+    tag_path = File.join(tag_name_dir_path, file)
+    path = File.join(@wc_path, file)
+
+    make_context(log) do |ctx|
+
+      ctx.mkdir(trunk_dir_path)
+      File.open(trunk_path, "w") {|f| f.print(trunk_src)}
+      ctx.add(trunk_path)
+      trunk_rev = ctx.commit(@wc_path).revision
+
+      ctx.mkdir(tag_dir_path, tag_name_dir_path)
+      File.open(tag_path, "w") {|f| f.print(tag_src)}
+      ctx.add(tag_path)
+      tag_rev = ctx.commit(@wc_path).revision
+
+      assert_equal(youngest_rev, ctx.switch(@wc_path, trunk_repos_uri))
+      assert_equal(normalize_line_break(trunk_src), ctx.cat(path))
+
+      assert_equal(youngest_rev, ctx.switch(@wc_path, tag_repos_uri))
+      assert_equal(normalize_line_break(tag_src), ctx.cat(path))
+
+
+      notify_info = []
+      ctx.set_notify_func do |notify|
+        notify_info << [notify.path, notify.action]
+      end
+
+      assert_equal(trunk_rev, ctx.switch(@wc_path, trunk_repos_uri, trunk_rev))
+      assert_equal(normalize_line_break(trunk_src), ctx.cat(path))
+      assert_equal([
+                     [path, Svn::Wc::NOTIFY_UPDATE_UPDATE],
+                     [@wc_path, Svn::Wc::NOTIFY_UPDATE_UPDATE],
+                     [@wc_path, Svn::Wc::NOTIFY_UPDATE_COMPLETED],
+                   ],
+                   notify_info)
+
+      notify_info.clear
+      assert_equal(tag_rev, ctx.switch(@wc_path, tag_repos_uri, tag_rev))
+      assert_equal(normalize_line_break(tag_src), ctx.cat(path))
+      assert_equal([
+                     [path, Svn::Wc::NOTIFY_UPDATE_UPDATE],
+                     [@wc_path, Svn::Wc::NOTIFY_UPDATE_UPDATE],
+                     [@wc_path, Svn::Wc::NOTIFY_UPDATE_COMPLETED],
+                   ],
+                   notify_info)
+    end
+  end
+
+  def test_authentication
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    svnserve_uri = "#{@repos_svnserve_uri}/#{file}"
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      ctx.add(path)
+      ctx.commit(@wc_path)
+    end
+
+    Svn::Client::Context.new do |ctx|
+      assert_raises(Svn::Error::AuthnNoProvider) do
+        ctx.cat(svnserve_uri)
+      end
+
+      ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+        cred.username = "wrong-#{@author}"
+        cred.password = @password
+        cred.may_save = false
+      end
+      assert_raises(Svn::Error::RaNotAuthorized) do
+        ctx.cat(svnserve_uri)
+      end
+
+      ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+        cred.username = @author
+        cred.password = "wrong-#{@password}"
+        cred.may_save = false
+      end
+      assert_raises(Svn::Error::RaNotAuthorized) do
+        ctx.cat(svnserve_uri)
+      end
+
+      ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+        cred.username = @author
+        cred.password = @password
+        cred.may_save = false
+      end
+      assert_equal(normalize_line_break(src), ctx.cat(svnserve_uri))
+    end
+  end
+
+  def assert_simple_provider(method)
+    log = "sample log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    svnserve_uri = "#{@repos_svnserve_uri}/#{file}"
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      setup_auth_baton(ctx.auth_baton)
+      ctx.add(path)
+      ctx.commit(@wc_path)
+    end
+
+    ctx = Svn::Client::Context.new
+    setup_auth_baton(ctx.auth_baton)
+    ctx.send(method)
+    assert_raises(Svn::Error::RaNotAuthorized) do
+      ctx.cat(svnserve_uri)
+    end
+
+    ctx = Svn::Client::Context.new
+    setup_auth_baton(ctx.auth_baton)
+    ctx.send(method)
+    ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+      cred.username = @author
+      cred.password = @password
+    end
+    assert_equal(normalize_line_break(src), ctx.cat(svnserve_uri))
+  end
+
+  def test_simple_provider
+    assert_simple_provider(:add_simple_provider)
+  end
+
+  if Svn::Core.respond_to?(:auth_get_windows_simple_provider)
+    def test_windows_simple_provider
+      assert_simple_provider(:add_windows_simple_provider)
+    end
+  end
+
+  if Svn::Core.respond_to?(:auth_get_keychain_simple_provider)
+    def test_keychain_simple_provider
+      assert_simple_provider(:add_keychain_simple_provider)
+    end
+  end
+
+  def test_username_provider
+    log = "sample log"
+    new_log = "sample new log"
+    src = "source\n"
+    file = "sample.txt"
+    path = File.join(@wc_path, file)
+    repos_uri = "#{@repos_uri}/#{file}"
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    info_revision = make_context(log) do |ctx|
+      ctx.add(path)
+      info = ctx.commit(@wc_path)
+      info.revision
+    end
+
+    Svn::Client::Context.new do |ctx|
+      setup_auth_baton(ctx.auth_baton)
+      ctx.auth_baton[Svn::Core::AUTH_PARAM_DEFAULT_USERNAME] = @author
+      ctx.add_username_provider
+      assert_nothing_raised do
+        ctx.revprop_set(Svn::Core::PROP_REVISION_LOG, new_log,
+                        repos_uri, info_revision)
+      end
+    end
+
+    Svn::Client::Context.new do |ctx|
+      setup_auth_baton(ctx.auth_baton)
+      ctx.auth_baton[Svn::Core::AUTH_PARAM_DEFAULT_USERNAME] = "#{@author}-NG"
+      ctx.add_username_provider
+      assert_raise(Svn::Error::REPOS_HOOK_FAILURE) do
+        ctx.revprop_set(Svn::Core::PROP_REVISION_LOG, new_log,
+                        repos_uri, info_revision)
+      end
+    end
+
+    Svn::Client::Context.new do |ctx|
+      setup_auth_baton(ctx.auth_baton)
+      ctx.auth_baton[Svn::Core::AUTH_PARAM_DEFAULT_USERNAME] = nil
+      ctx.add_username_prompt_provider(0) do |cred, realm, may_save|
+      end
+      assert_raise(Svn::Error::REPOS_HOOK_FAILURE) do
+        ctx.revprop_set(Svn::Core::PROP_REVISION_LOG, new_log,
+                        repos_uri, info_revision)
+      end
+    end
+
+    Svn::Client::Context.new do |ctx|
+      setup_auth_baton(ctx.auth_baton)
+      ctx.auth_baton[Svn::Core::AUTH_PARAM_DEFAULT_USERNAME] = nil
+      ctx.add_username_prompt_provider(0) do |cred, realm, may_save|
+        cred.username = @author
+      end
+      assert_nothing_raised do
+        ctx.revprop_set(Svn::Core::PROP_REVISION_LOG, new_log,
+                        repos_uri, info_revision)
+      end
+    end
+  end
+
+  def test_add_providers
+    Svn::Client::Context.new do |ctx|
+      assert_nothing_raised do
+        ctx.add_ssl_client_cert_file_provider
+        ctx.add_ssl_client_cert_pw_file_provider
+        ctx.add_ssl_server_trust_file_provider
+        if Svn::Core.respond_to?(:auth_get_windows_ssl_server_trust_provider)
+          ctx.add_windows_ssl_server_trust_provider
+        end
+      end
+    end
+  end
+
+  def test_commit_item
+    assert_raise(NoMethodError) do
+      Svn::Client::CommitItem.new
+    end
+
+    assert_raise(NoMethodError) do
+      Svn::Client::CommitItem2.new
+    end
+
+    item = Svn::Client::CommitItem3.new
+    assert_kind_of(Svn::Client::CommitItem3, item)
+
+    url = "xxx"
+    item.url = url
+    assert_equal(url, item.dup.url)
+  end
+
+  def test_log_msg_func_commit_items
+    log = "sample log"
+    file = "file"
+    file2 = "file2"
+    src = "source"
+    path = File.join(@wc_path, file)
+    repos_uri2 = "#{@repos_uri}/#{file2}"
+
+    File.open(path, "w") {|f| f.print(src)}
+
+    make_context(log) do |ctx|
+      items = nil
+      ctx.set_log_msg_func do |items|
+        [true, log]
+      end
+
+      ctx.add(path)
+      ctx.prop_set(Svn::Core::PROP_MIME_TYPE, "text/plain", path)
+      ctx.commit(@wc_path)
+      assert_equal([[]], items.collect {|item| item.wcprop_changes})
+      assert_equal([[]], items.collect {|item| item.incoming_prop_changes})
+      assert_equal([nil], items.collect {|item| item.outgoing_prop_changes})
+
+      items = nil
+      ctx.cp(path, repos_uri2)
+      assert_equal([nil], items.collect {|item| item.wcprop_changes})
+      assert_equal([nil], items.collect {|item| item.incoming_prop_changes})
+      assert_equal([nil], items.collect {|item| item.outgoing_prop_changes})
+    end
+  end
+
+  def test_log_msg_func_cancel
+    log = "sample log"
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+
+    make_context(log) do |ctx|
+      ctx.set_log_msg_func do |items|
+        raise Svn::Error::Cancelled
+      end
+      ctx.mkdir(dir_path)
+      assert_raise(Svn::Error::Cancelled) do
+        ctx.commit(@wc_path)
+      end
+    end
+  end
+
+  def test_set_config
+    log = "sample log"
+    make_context(log) do |ctx|
+      options = {
+        "groups" => {"collabnet" => "svn.collab.net"},
+        "collabnet" => {
+          "http-proxy-host" => "proxy",
+          "http-proxy-port" => "8080",
+        },
+      }
+      servers_config_file = File.join(@config_path,
+                                      Svn::Core::CONFIG_CATEGORY_SERVERS)
+      File.open(servers_config_file, "w") do |file|
+        options.each do |section, values|
+          file.puts("[#{section}]")
+          values.each do |key, value|
+            file.puts("#{key} = #{value}")
+          end
+        end
+      end
+      config = Svn::Core::Config.config(@config_path)
+      assert_nil(ctx.config)
+      assert_equal(options, config[Svn::Core::CONFIG_CATEGORY_SERVERS].to_hash)
+      ctx.config = config
+      assert_equal(options,
+                   ctx.config[Svn::Core::CONFIG_CATEGORY_SERVERS].to_hash)
+    end
+  end
+
+  def test_context_mimetypes_map
+    Svn::Client::Context.new do |context|
+      assert_nil(context.mimetypes_map)
+      context.mimetypes_map = {"txt" => "text/plain"}
+      assert_equal({"txt" => "text/plain"}, context.mimetypes_map)
+    end
+  end
+
+  def assert_changelists
+    log = "sample log"
+    file1 = "hello1.txt"
+    file2 = "hello2.txt"
+    src = "Hello"
+    changelist1 = "XXX"
+    changelist2 = "YYY"
+    path1 = File.join(@wc_path, file1)
+    path2 = File.join(@wc_path, file2)
+
+    make_context(log) do |ctx|
+      File.open(path1, "w") {|f| f.print(src)}
+      File.open(path2, "w") {|f| f.print(src)}
+      ctx.add(path1)
+      ctx.add(path2)
+      ctx.commit(@wc_path)
+
+      assert_equal({}, yield(ctx, changelist1))
+      assert_equal({nil=>[@wc_path,path1,path2]}, yield(ctx, nil))
+      assert_equal({}, yield(ctx, []))
+      assert_equal({}, yield(ctx, [changelist1]))
+      assert_equal({}, yield(ctx, [changelist2]))
+      ctx.add_to_changelist(changelist1, path1)
+      assert_equal({changelist1=>[path1]}, yield(ctx, changelist1))
+      assert_equal({changelist1=>[path1],nil=>[@wc_path,path2]}, yield(ctx, nil))
+      assert_equal({}, yield(ctx, []))
+      assert_equal({changelist1=>[path1]}, yield(ctx, [changelist1]))
+      assert_equal({}, yield(ctx, [changelist2]))
+
+      assert_equal({}, yield(ctx, changelist2))
+      ctx.add_to_changelist(changelist2, [path1, path2])
+      assert_equal({changelist2=>[path1, path2]}, yield(ctx, changelist2))
+      assert_equal({}, yield(ctx, changelist1))
+
+      ctx.add_to_changelist(changelist1, [path1, path2])
+      assert_equal({changelist1=>[path1, path2]}, yield(ctx, changelist1))
+      assert_equal({}, yield(ctx, changelist2))
+
+      ctx.remove_from_changelists(changelist1, path1)
+      assert_equal({changelist1=>[path2]}, yield(ctx, changelist1))
+      ctx.remove_from_changelists(changelist1, [path2])
+      assert_equal({}, yield(ctx, changelist1))
+
+      ctx.add_to_changelist(changelist1, path1)
+      ctx.add_to_changelist(changelist2, path2)
+      assert_equal({changelist1=>[path1]}, yield(ctx, changelist1))
+      assert_equal({changelist2=>[path2]}, yield(ctx, changelist2))
+
+      assert_equal({changelist1=>[path1]}, yield(ctx, changelist1))
+      assert_equal({changelist2=>[path2]}, yield(ctx, changelist2))
+      assert_equal({changelist1=>[path1]}, yield(ctx, [changelist1]))
+      assert_equal({changelist2=>[path2]}, yield(ctx, [changelist2]))
+      assert_equal({changelist1=>[path1],changelist2=>[path2],nil=>[@wc_path]}, yield(ctx, nil))
+      assert_equal({}, yield(ctx, []))
+      assert_equal({changelist1=>[path1],changelist2=>[path2]},
+                   yield(ctx, [changelist1,changelist2]))
+
+      ctx.remove_from_changelists(nil, [path1, path2])
+      assert_equal({}, yield(ctx, changelist1))
+      assert_equal({}, yield(ctx, changelist2))
+    end
+  end
+
+  def test_changelists_get_without_block
+    assert_changelists do |ctx, changelist_name|
+      ctx.changelists(changelist_name, @wc_path)
+    end
+  end
+
+  def test_changelists_get_with_block
+    assert_changelists do |ctx, changelist_name|
+      changelists = Hash.new{|h,k| h[k]=[]}
+      ctx.changelists(changelist_name, @wc_path) do |path,cl_name|
+        changelists[cl_name] << path
+      end
+      changelists
+    end
+  end
+
+  def test_set_revision_by_date
+    log = "sample log"
+    file = "hello.txt"
+    src = "Hello"
+    src_after = "Hello World"
+    path = File.join(@wc_path, file)
+    uri = "#{@repos_uri}/#{file}"
+
+    make_context(log) do |ctx|
+      File.open(path, "w") {|f| f.print(src)}
+      ctx.add(path)
+      ctx.commit(@wc_path)
+
+      first_commit_time = Time.now
+      sleep(1)
+
+      File.open(path, "w") {|f| f.print(src_after)}
+      ctx.commit(@wc_path)
+
+      assert_equal(src, ctx.cat(uri, first_commit_time))
+    end
+  end
+
+  def assert_resolve(choice)
+    log = "sample log"
+    file = "sample.txt"
+    srcs = ["before\n","after\n"]
+    dir = "dir"
+    dir_path = File.join(@wc_path, dir)
+    path = File.join(dir_path, file)
+
+    make_context(log) do |ctx|
+      ctx.mkdir(dir_path)
+      File.open(path, "w") {}
+      ctx.add(path)
+      rev1 = ctx.ci(@wc_path).revision
+
+      File.open(path, "w") {|f| f.print(srcs[0])}
+      rev2 = ctx.ci(@wc_path).revision
+
+      ctx.up(@wc_path, rev1)
+
+      File.open(path, "w") {|f| f.print(srcs[1])}
+      ctx.up(@wc_path)
+
+      assert_raises(Svn::Error::WcFoundConflict) do
+        ctx.ci(@wc_path)
+      end
+
+      ctx.resolve(:path=>dir_path, :depth=>:empty, :conflict_choice=>choice)
+      assert_raises(Svn::Error::WcFoundConflict) do
+        ctx.ci(@wc_path)
+      end
+
+      ctx.resolve(:path=>dir_path, :depth=>:infinite, :conflict_choice=>choice)
+      yield ctx, path
+    end
+  end
+
+  def test_resolve_base
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_BASE) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(3, info.revision)
+
+      assert_equal("", File.read(path))
+    end
+  end
+
+  def test_resolve_theirs_full
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_THEIRS_FULL) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(-1, info.revision)
+
+      assert_equal("before\n", File.read(path))
+    end
+  end
+
+  def test_resolve_mine_full
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_MINE_FULL) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(3, info.revision)
+
+      assert_equal("after\n", File.read(path))
+    end
+  end
+
+  def test_resolve_theirs_conflict
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_THEIRS_FULL) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(-1, info.revision)
+
+      assert_equal("before\n", File.read(path))
+    end
+  end
+
+  def test_resolve_mine_conflict
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_MINE_FULL) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(3, info.revision)
+
+      assert_equal("after\n", File.read(path))
+    end
+  end
+
+  def test_resolve_merged
+    assert_resolve(Svn::Wc::CONFLICT_CHOOSE_MERGED) do |ctx,path|
+      info = nil
+      assert_nothing_raised do
+        info = ctx.ci(@wc_path)
+      end
+      assert_not_nil(info)
+      assert_equal(3, info.revision)
+
+      assert_equal("<<<<<<< .mine\nafter\n=======\nbefore\n>>>>>>> .r2\n",
+                   File.read(path))
+    end
+  end
+end