testdynimicbaseindex.rb

二叉树详细源码

require 'dynimic_base_index'
require 'test/unit'

class TestDynimicBaseIndex < Test::Unit::TestCase
  def test_base_index
     a = ['a','b','c','d','e']
     assert_equal(0, a.base_index)
     a.base_index = 1
     assert_equal(1, a.base_index)
   end
   
   def test_index_reader_operator()
       a = ['a','b','c','d','e']
       
       assert_equal(0, a.base_index)
       assert_equal('a', a[0])
       assert_equal(['b','c','d'], a[1,3])
       assert_equal(['b','c','d','e'], a[1..4])
       assert_equal('e', a[-1])
       
       a.base_index = 1
       assert_equal(1, a.base_index)
       assert_equal('a', a[1])
       assert_equal(['a','b','c'], a[1,3])
       assert_equal(['a','b','c','d'], a[1..4])
       assert_equal('e', a[0])
       assert_equal(nil, a[6])
       assert_equal([], a[6,1])
       assert_equal([], a[6..10])
       assert_equal(nil, a[7,1])
     end
     
     def test_index_writer_operator()
       a = ['a','b','c','d','e']
       a.base_index = 1
       a[1] = 'Y'
       assert_equal(['Y','b','c','d','e'], a)
       
       b = ['a','b','c','d','e']
       b.base_index = 1
       b[1,3] = ['Y','Z']
       assert_equal(['Y','Z','d','e'], b)
       
       c = ['a','b','c','d','e']
       c.base_index = 1
       c[1,3] = 'Y'
       assert_equal(['Y','d','e'], c)
       
       d = ['a','b','c','d','e']
       d.base_index = 1
       d[1..3] = 'Y'
       assert_equal(['Y','d','e'], d)
       
       e = ['a','b','c','d','e']
       e.base_index = 1
       e[1..3] = ['Y', 'Z']
       assert_equal(['Y','Z','d','e'], e)
     end
     
     def test_at()
       a = ['a','b','c','d','e']
       assert_equal('a', a.at(0))
       a.base_index = 1
       assert_equal('a', a.at(1))
     end
     
     def test_delete_at()
       a = ['a','b','c','d','e']
       a.base_index = 1
       assert_equal('a', a.delete_at(1))
       assert_equal(['b','c','d','e'], a)
     end
     
     def test_each_index()
       a = ['a','b','c','d','e']
       expected_indexes = [1,2,3,4,5]
       actual_indexes = Array.new
       
       a.base_index = 1
       
       a.each_index do |i|
         actual_indexes << i
       end
       
       assert_equal(expected_indexes, actual_indexes)
     end
     
     def test_fetch()
       a = [ 11, 22, 33, 44 ]
       a.base_index = 1
       
       assert_equal(11, a.fetch(1))
       assert_equal(44, a.fetch(0))
       assert_equal(121, a.fetch(1) { |value| value**2 } )
       
       assert_equal('cat', a.fetch(5, 'cat'))
     end
     
     def test_fill()
       a = [ "a", "b", "c", "d" ]
       a.base_index = 1
       
       assert_equal(["x","x","x","x"], a.fill("x"))
       assert_equal(["x","y","y","y"], a.fill("y", 2))
       assert_equal(["x","z","z","y"], a.fill("z", 2, 2))
       assert_equal(["x","a","a","a"], a.fill("a", 2..4))
       
       a = [ "a", "b", "c", "d" ]
       a.base_index = 1
       assert_equal([1,4,9,16], a.fill { |i| i*i })
       assert_equal([1,8,18,32], a.fill(2) { |i| a[i]*2 })
       assert_equal([1,4,9,32], a.fill(2,2) { |i| a[i]/2 })
       assert_equal([1,4,6,8], a.fill(2..4) { |i| i*2 })       
     end
     
     def test_index()
       a = [ "a", "b", "c", "d" ]
       a.base_index = 1
       assert_equal(2, a.index('b'))
       assert_equal(nil, a.index('x'))
     end
     
     def test_insert()
       a = [11,22,33]
       a.base_index = 1
       assert_equal([11,22,33], a.insert(2))
       assert_equal([11,'a',22,33], a.insert(2, 'a'))
       assert_equal([11,['!','@'],'a',22,33], a.insert(2, ['!','@']))
       assert_equal([11,'Q','S',['!','@'],'a',22,33], a.insert(2, 'Q','S'))
     end
     
     def test_rindex()
       a = [ "a", "b", "b", "b", "c" ]
       a.base_index = 1
       
       assert_equal(4, a.rindex("b"))
       assert_equal(nil, a.rindex("z"))
     end
     
     def test_slice()
       a = ['a','b','c','d','e']
       a.base_index = 1
       assert_equal(1, a.base_index)
       assert_equal('a', a.slice(1))
       assert_equal(['a','b','c'], a.slice(1,3))
       assert_equal(['a','b','c','d'], a.slice(1..4))
       assert_equal('e', a.slice(0))
       assert_equal(nil, a.slice(6))
       assert_equal([], a.slice(6,1))
       assert_equal([], a.slice(6..10))
       assert_equal(nil, a.slice(7,1))
     end
     
     def test_slice!()
       a = ['a','b','c']
       a.base_index = 1
       
       assert_equal('b', a.slice!(2))
       assert_equal(['a','c'], a)
       assert_equal(nil, a.slice!(100))
       assert_equal(['a','c'], a)
     end
     
     def test_indexes()
       a = [11,22,33,44,55,66,77,88]
       a.base_index = 1
       
       assert_equal([11], a.indexes(1))
       assert_equal([11,33], a.indexes(1,3))
       assert_equal([11,11], a.indexes(1,1))
       assert_equal([11,33,11], a.indexes(1,3,1))
       assert_equal([[11,22,33],[22,33,44],77], a.indexes(1..3,2..4,7))
       assert_equal([[11,22]], a.indexes(1...3))
       assert_equal([[]], a.indexes(2..1))
       assert_equal([], a.indexes())
       assert_equal([nil,nil], a.indexes(99,97))
     end
     
     def test_indices()
       a = [11,22,33,44,55,66,77,88]
       a.base_index = 1
       
       assert_equal([11], a.indices(1))
       assert_equal([11,33], a.indices(1,3))
       assert_equal([11,11], a.indices(1,1))
       assert_equal([11,33,11], a.indices(1,3,1))
       assert_equal([[11,22,33],[22,33,44],77], a.indices(1..3,2..4,7))
       assert_equal([[11,22]], a.indices(1...3))
       assert_equal([[]], a.indices(2..1))
       assert_equal([], a.indices())
       assert_equal([nil,nil], a.indices(99,97))
     end
     
     def test_values_at()
       a = [11,22,33,44,55,66,77,88]
       a.base_index = 1
       
       assert_equal([11], a.values_at(1))
       assert_equal([11,33], a.values_at(1,3))
       assert_equal([11,11], a.values_at(1,1))
       assert_equal([11,33,11], a.values_at(1,3,1))
       assert_equal([11,22,33,22,33,44,77], a.values_at(1..3,2..4,7))
       assert_equal([11,22], a.values_at(1...3))
       assert_equal([], a.values_at(2..1))
       assert_equal([], a.values_at())
       assert_equal([nil,nil], a.values_at(99,97))
     end
     
     
end