view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/ruby/test/test_core.rb  view on Meta::CPAN

#    "License"); you may not use this file except in compliance
#    with the License.  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing,
#    software distributed under the License is distributed on an
#    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#    KIND, either express or implied.  See the License for the
#    specific language governing permissions and limitations
#    under the License.
# ====================================================================

require "my-assertions"
require "util"

require "stringio"

require "svn/core"
require "svn/repos"

class SvnCoreTest < Test::Unit::TestCase
  include SvnTestUtil

  def setup
    setup_default_variables
    @config_file = File.join(@config_path, Svn::Core::CONFIG_CATEGORY_CONFIG)
    @servers_file = File.join(@config_path, Svn::Core::CONFIG_CATEGORY_SERVERS)
    setup_repository(@repos_path)
    setup_config
    setup_tmp
  end

  def teardown
    teardown_repository(@repos_path)
    teardown_config
    teardown_tmp
  end

  def test_binary_mime_type?
    assert(Svn::Core.binary_mime_type?("image/png"))
    assert(!Svn::Core.binary_mime_type?("text/plain"))
  end

  def test_time
    now = Time.now.gmtime
    str = now.strftime("%Y-%m-%dT%H:%M:%S.") + "#{now.usec}Z"

    if RUBY_VERSION > '1.9'
      # ruby 1.9 Time comparison gets into the nano-seconds, strftime
      # shaves these off. So we can compare epoch time instead
      assert_equal(now.to_i, Time.from_svn_format(str).gmtime.to_i)
    else
      assert_equal(now, Time.from_svn_format(str).gmtime)
    end

    apr_time = now.to_i * 1000000 + now.usec
    assert_equal(apr_time, now.to_apr_time)
  end

  def test_not_new_auth_provider_object
    assert_raise(NoMethodError) do
      Svn::Core::AuthProviderObject.new
    end
  end

  def test_version_to_x
    major = 1
    minor = 2
    patch = 3
    tag = "-dev"
    ver = Svn::Core::Version.new(major, minor, patch, tag)

    assert_equal("#{major}.#{minor}.#{patch}#{tag}", ver.to_s)
    assert_equal([major, minor, patch, tag], ver.to_a)
  end

  def test_version_valid?
    assert_true(Svn::Core::Version.new(1, 2, 3, "-devel").valid?)
    assert_true(Svn::Core::Version.new(nil, nil, nil, "").valid?)
    assert_true(Svn::Core::Version.new.valid?)
  end

  def test_version_equal
    major = 1
    minor = 2
    patch = 3
    tag = ""
    ver1 = Svn::Core::Version.new(major, minor, patch, tag)
    ver2 = Svn::Core::Version.new(major, minor, patch, tag)
    ver3 = Svn::Core::Version.new
    assert_equal(ver1, ver2)
    assert_not_equal(ver1, ver3)
  end

  def test_version_compatible?
    major = 1
    minor = 2
    patch = 3

    my_tag = "-devel"
    lib_tag = "-devel"
    ver1 = Svn::Core::Version.new(major, minor, patch, my_tag)
    ver2 = Svn::Core::Version.new(major, minor, patch, lib_tag)
    ver3 = Svn::Core::Version.new(major, minor, patch, lib_tag + "x")
    assert_true(ver1.compatible?(ver2))
    assert_false(ver1.compatible?(ver3))

    my_tag = "-devel"
    lib_tag = ""
    ver1 = Svn::Core::Version.new(major, minor, patch, my_tag)
    ver2 = Svn::Core::Version.new(major, minor, patch, lib_tag)
    ver3 = Svn::Core::Version.new(major, minor, patch - 1, lib_tag)
    assert_false(ver1.compatible?(ver2))
    assert_true(ver1.compatible?(ver3))

    tag = ""
    ver1 = Svn::Core::Version.new(major, minor, patch, tag)
    ver2 = Svn::Core::Version.new(major, minor, patch, tag)
    ver3 = Svn::Core::Version.new(major, minor, patch - 1, tag)
    ver4 = Svn::Core::Version.new(major, minor + 1, patch, tag)
    ver5 = Svn::Core::Version.new(major, minor - 1, patch, tag)
    assert_true(ver1.compatible?(ver2))
    assert_true(ver1.compatible?(ver3))
    assert_true(ver1.compatible?(ver4))
    assert_false(ver1.compatible?(ver5))
  end

  def test_version
    vers = [Svn::Core::VER_MAJOR, Svn::Core::VER_MINOR, Svn::Core::VER_PATCH]
    ver_num = vers.collect {|ver| ver.to_s}.join(".")
    assert_equal(ver_num, Svn::Core::VER_NUM)
    assert_equal("#{ver_num}#{Svn::Core::VER_NUMTAG}", Svn::Core::VER_NUMBER)
    assert_equal("#{Svn::Core::VER_NUMBER}#{Svn::Core::VER_TAG}", Svn::Core::VERSION)
  end

  def test_auth_parameter
    key = "key"
    value = "value"
    auth = Svn::Core::AuthBaton.new
    assert_nil(auth[key])
    auth[key] = value
    assert_equal(value, auth[key])

    assert_raise(TypeError) do
      auth[key] = 1
    end
  end

  def test_pool_GC
    gc_disable do
      made_number_of_pool = 100
      pools = []

src/subversion/subversion/bindings/swig/ruby/test/test_core.rb  view on Meta::CPAN

    assert_equal({}, Svn::Core::MergeInfo.parse(""))

    input = "/trunk: 5,7-9,10,11,13,14"
    result = Svn::Core::MergeInfo.parse(input)
    assert_equal(["/trunk"], result.keys)
    assert_equal([[4, 5, true], [6, 11, true], [12, 14, true]],
                 result["/trunk"].collect {|range| range.to_a})

    input = "/trunk: 5*,7-9,10,11,13,14"
    result = Svn::Core::MergeInfo.parse(input)
    assert_equal(["/trunk"], result.keys)
    assert_equal([[4, 5, false], [6, 11, true], [12, 14, true]],
                 result["/trunk"].collect {|range| range.to_a})
  end

  def test_mergeinfo_diff
    input1 = "/trunk: 5,7-9,10,11,13,14"
    input2 = "/trunk: 5,6,7-9,10,11"

    info1 = Svn::Core::MergeInfo.parse(input1)
    info2 = Svn::Core::MergeInfo.parse(input2)
    result = info1.diff(info2)
    deleted, added = result
    assert_equal(["/trunk"], deleted.keys)
    assert_equal(["/trunk"], added.keys)
    assert_equal([[12, 14, true]],
                 deleted["/trunk"].collect {|range| range.to_a})
    assert_equal([[5, 6, true]],
                 added["/trunk"].collect {|range| range.to_a})
  end

  def test_mergeinfo_merge
    info = Svn::Core::MergeInfo.parse("/trunk: 5,7-9")
    assert_equal(["/trunk"], info.keys)
    assert_equal([[4, 5, true], [6, 9, true]],
                 info["/trunk"].collect {|range| range.to_a})

    changes = Svn::Core::MergeInfo.parse("/trunk: 6-13")
    merged = info.merge(changes)
    assert_equal(["/trunk"], merged.keys)
    assert_equal([[4, 13, true]],
                 merged["/trunk"].collect {|range| range.to_a})
  end

  def test_mergeinfo_remove
    info = Svn::Core::MergeInfo.parse("/trunk: 5-13")
    assert_equal(["/trunk"], info.keys)
    assert_equal([[4, 13, true]],
                 info["/trunk"].collect {|range| range.to_a})

    eraser = Svn::Core::MergeInfo.parse("/trunk: 7,9-11")
    removed = info.remove(eraser)
    assert_equal(["/trunk"], removed.keys)
    assert_equal([[4, 6, true], [7, 8, true], [11, 13, true]],
                 removed["/trunk"].collect {|range| range.to_a})
  end

  def test_mergeinfo_to_s
    info = Svn::Core::MergeInfo.parse("/trunk: 5,7,9-13")
    assert_equal("/trunk:5,7,9-13", info.to_s)
    assert_not_equal(info.to_s, info.inspect)

    info = Svn::Core::MergeInfo.parse("/trunk: 5*,7,9-13")
    assert_equal("/trunk:5*,7,9-13", info.to_s)
    assert_not_equal(info.to_s, info.inspect)
  end

  def test_mergeinfo_sort
    info = Svn::Core::MergeInfo.parse("/trunk: 5,7,9-13")

    info["/trunk"] = info["/trunk"].reverse
    assert_equal(["/trunk"], info.keys)
    assert_equal([[13, 8, true], [7, 6, true], [5, 4, true]],
                 info["/trunk"].collect {|range| range.to_a})

    sorted_info = info.sort
    assert_equal(["/trunk"], sorted_info.keys)
    assert_equal([[5, 4, true], [7, 6, true], [13, 8, true]],
                 sorted_info["/trunk"].collect {|range| range.to_a})
  end

  def test_range_list_diff
    range_list1 = Svn::Core::RangeList.new([4, 5, true], [9, 13, true])
    range_list2 = Svn::Core::RangeList.new([7, 11, true])

    deleted, added = range_list1.diff(range_list2)
    assert_equal([[7, 9, true]], added.collect {|range| range.to_a})
    assert_equal([[4, 5, true], [11, 13, true]],
                 deleted.collect {|range| range.to_a})
  end

  def test_range_list_merge
    range_list1 = Svn::Core::RangeList.new([4, 5, true],
                                           [7, 8, true], [9, 13, true])
    range_list2 = Svn::Core::RangeList.new([5, 9, true])

    merged = range_list1.merge(range_list2)
    assert_equal([[4, 13, true]], merged.collect {|range| range.to_a})
  end

  def test_range_list_remove
    range_list1 = Svn::Core::RangeList.new([4, 5, true],
                                           [7, 8, true], [10, 13, true])
    range_list2 = Svn::Core::RangeList.new([4, 9, true])

    removed = range_list1.remove(range_list2)
    assert_equal([[10, 13, true]], removed.collect {|range| range.to_a})
  end

  def test_range_list_intersect
    range_list1 = Svn::Core::RangeList.new([4, 9, true])
    range_list2 = Svn::Core::RangeList.new([4, 5, true],
                                           [7, 8, true], [9, 13, true])

    intersected = range_list1.intersect(range_list2)
    assert_equal([[4, 5, true], [7, 8, true]],
                 intersected.collect {|range| range.to_a})
  end

  def test_range_list_reverse
    range_list = Svn::Core::RangeList.new([4, 5, true],
                                          [7, 8, true], [10, 13, true])

    reversed = range_list.reverse
    assert_equal([[13, 10, true], [8, 7, true], [5, 4, true]],
                 reversed.collect {|range| range.to_a})
  end

  def test_range_list_to_s
    range_list = Svn::Core::RangeList.new([4, 6, true],
                                          [6, 8, true], [9, 13, true])
    expectation = "5-6,7-8,10-13"
    assert_equal(expectation, range_list.to_s)
    assert_not_equal(expectation, range_list.inspect)
  end

  def test_mergerange_equality
    mergerange1 = Svn::Core::MergeRange.new(1,2,true)
    mergerange2 = Svn::Core::MergeRange.new(1,2,true)
    mergerange3 = Svn::Core::MergeRange.new(1,2,false)
    mergerange4 = Svn::Core::MergeRange.new(1,4,true)

    assert_equal(mergerange1, mergerange2)
    assert_not_equal(mergerange1, mergerange3)
    assert_not_equal(mergerange1, mergerange4)
  end

  private
  def used_pool
    pool = Svn::Core::Pool.new
    now = Time.now.gmtime
    Svn::Core.time_to_human_cstring(now.to_apr_time, pool)
    pool
  end
end