/test/ruby/test_array.rb
Ruby | 3231 lines | 2712 code | 477 blank | 42 comment | 49 complexity | 915f1b674d3b594dfee8a6c4cd5ee3c5 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, AGPL-3.0
Large files files are truncated, but you can click here to view the full file
- # coding: US-ASCII
- # frozen_string_literal: false
- require 'test/unit'
- require "delegate"
- require "rbconfig/sizeof"
- class TestArray < Test::Unit::TestCase
- def setup
- @verbose = $VERBOSE
- $VERBOSE = nil
- @cls = Array
- end
- def teardown
- $VERBOSE = @verbose
- end
- def test_percent_i
- assert_equal([:foo, :bar], %i[foo bar])
- assert_equal([:"\"foo"], %i["foo])
- end
- def test_percent_I
- x = 10
- assert_equal([:foo, :b10], %I[foo b#{x}])
- assert_equal([:"\"foo10"], %I["foo#{x}])
- end
- def test_0_literal
- assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
- assert_equal([1, 2, 1, 2], [1, 2] * 2)
- assert_equal("1:2", [1, 2] * ":")
- assert_equal([1, 2].hash, [1, 2].hash)
- assert_equal([2,3], [1,2,3] & [2,3,4])
- assert_equal([1,2,3,4], [1,2,3] | [2,3,4])
- assert_equal([1,2,3] - [2,3], [1])
- x = [0, 1, 2, 3, 4, 5]
- assert_equal(2, x[2])
- assert_equal([1, 2, 3], x[1..3])
- assert_equal([1, 2, 3], x[1,3])
- assert_equal([3, 4, 5], x[3..])
- assert_equal([0, 1, 2], x[..2])
- assert_equal([0, 1], x[...2])
- x[0, 2] = 10
- assert_equal([10, 2, 3, 4, 5], x)
- x[0, 0] = -1
- assert_equal([-1, 10, 2, 3, 4, 5], x)
- x[-1, 1] = 20
- assert_equal(20, x[-1])
- assert_equal(20, x.pop)
- end
- def test_array_andor_0
- assert_equal([2], ([1,2,3]&[2,4,6]))
- assert_equal([1,2,3,4,6], ([1,2,3]|[2,4,6]))
- end
- def test_compact_0
- a = [nil, 1, nil, nil, 5, nil, nil]
- assert_equal [1, 5], a.compact
- assert_equal [nil, 1, nil, nil, 5, nil, nil], a
- a.compact!
- assert_equal [1, 5], a
- end
- def test_uniq_0
- x = [1, 1, 4, 2, 5, 4, 5, 1, 2]
- x.uniq!
- assert_equal([1, 4, 2, 5], x)
- end
- def test_empty_0
- assert_equal true, [].empty?
- assert_equal false, [1].empty?
- assert_equal false, [1, 1, 4, 2, 5, 4, 5, 1, 2].empty?
- end
- def test_sort_0
- x = ["it", "came", "to", "pass", "that", "..."]
- x = x.sort.join(" ")
- assert_equal("... came it pass that to", x)
- x = [2,5,3,1,7]
- x.sort!{|a,b| a<=>b} # sort with condition
- assert_equal([1,2,3,5,7], x)
- x.sort!{|a,b| b-a} # reverse sort
- assert_equal([7,5,3,2,1], x)
- end
- def test_split_0
- x = "The Book of Mormon"
- assert_equal(x.reverse, x.split(//).reverse!.join)
- assert_equal(x.reverse, x.reverse!)
- assert_equal("g:n:i:r:t:s: :e:t:y:b: :1", "1 byte string".split(//).reverse.join(":"))
- x = "a b c d"
- assert_equal(['a', 'b', 'c', 'd'], x.split)
- assert_equal(['a', 'b', 'c', 'd'], x.split(' '))
- end
- def test_misc_0
- assert(defined? "a".chomp, '"a".chomp is not defined')
- assert_equal(["a", "b", "c"], "abc".scan(/./))
- assert_equal([["1a"], ["2b"], ["3c"]], "1a2b3c".scan(/(\d.)/))
- # non-greedy match
- assert_equal([["a", "12"], ["b", "22"]], "a=12;b=22".scan(/(.*?)=(\d*);?/))
- x = [1]
- assert_equal('1:1:1:1:1', (x * 5).join(":"))
- assert_equal('1', (x * 1).join(":"))
- assert_equal('', (x * 0).join(":"))
- *x = *(1..7).to_a
- assert_equal(7, x.size)
- assert_equal([1, 2, 3, 4, 5, 6, 7], x)
- x = [1,2,3]
- x[1,0] = x
- assert_equal([1,1,2,3,2,3], x)
- x = [1,2,3]
- x[-1,0] = x
- assert_equal([1,2,1,2,3,3], x)
- x = [1,2,3]
- x.concat(x)
- assert_equal([1,2,3,1,2,3], x)
- x = [1,2,3]
- x.clear
- assert_equal([], x)
- x = [1,2,3]
- y = x.dup
- x << 4
- y << 5
- assert_equal([1,2,3,4], x)
- assert_equal([1,2,3,5], y)
- end
- def test_beg_end_0
- x = [1, 2, 3, 4, 5]
- assert_equal(1, x.first)
- assert_equal([1], x.first(1))
- assert_equal([1, 2, 3], x.first(3))
- assert_raise_with_message(ArgumentError, /0\.\.1/) {x.first(1, 2)}
- assert_equal(5, x.last)
- assert_equal([5], x.last(1))
- assert_equal([3, 4, 5], x.last(3))
- assert_raise_with_message(ArgumentError, /0\.\.1/) {x.last(1, 2)}
- assert_equal(1, x.shift)
- assert_equal([2, 3, 4], x.shift(3))
- assert_equal([5], x)
- assert_raise_with_message(ArgumentError, /0\.\.1/) {x.first(1, 2)}
- assert_equal([2, 3, 4, 5], x.unshift(2, 3, 4))
- assert_equal([1, 2, 3, 4, 5], x.unshift(1))
- assert_equal([1, 2, 3, 4, 5], x)
- assert_equal(5, x.pop)
- assert_equal([3, 4], x.pop(2))
- assert_equal([1, 2], x)
- assert_raise_with_message(ArgumentError, /0\.\.1/) {x.pop(1, 2)}
- assert_equal([1, 2, 3, 4], x.push(3, 4))
- assert_equal([1, 2, 3, 4, 5], x.push(5))
- assert_equal([1, 2, 3, 4, 5], x)
- end
- def test_find_all_0
- assert_respond_to([], :find_all)
- assert_respond_to([], :select) # Alias
- assert_respond_to([], :filter) # Alias
- assert_equal([], [].find_all{ |obj| obj == "foo"})
- x = ["foo", "bar", "baz", "baz", 1, 2, 3, 3, 4]
- assert_equal(["baz","baz"], x.find_all{ |obj| obj == "baz" })
- assert_equal([3,3], x.find_all{ |obj| obj == 3 })
- end
- def test_fill_0
- assert_equal([-1, -1, -1, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1))
- assert_equal([0, 1, 2, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, 3))
- assert_equal([0, 1, 2, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3, 2))
- assert_equal([0, 1, 2, -1, -1, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, 3, 5))
- assert_equal([0, 1, -1, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2, 2))
- assert_equal([0, 1, -1, -1, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, 2, 5))
- assert_equal([0, 1, 2, 3, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, -2, 1))
- assert_equal([0, 1, 2, 3, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, -2, 3))
- assert_equal([0, 1, 2, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3..4))
- assert_equal([0, 1, 2, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3...4))
- assert_equal([0, 1, -1, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2..-2))
- assert_equal([0, 1, -1, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2...-2))
- assert_equal([10, 11, 12, 13, 14, 15], [0, 1, 2, 3, 4, 5].fill{|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 15], [0, 1, 2, 3, 4, 5].fill(3){|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(3, 2){|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 15, 16, 17], [0, 1, 2, 3, 4, 5].fill(3, 5){|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(3..4){|i| i+10})
- assert_equal([0, 1, 2, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(3...4){|i| i+10})
- assert_equal([0, 1, 12, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(2..-2){|i| i+10})
- assert_equal([0, 1, 12, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(2...-2){|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 15], [0, 1, 2, 3, 4, 5].fill(3..){|i| i+10})
- assert_equal([0, 1, 2, 13, 14, 15], [0, 1, 2, 3, 4, 5].fill(3...){|i| i+10})
- end
- # From rubicon
- def test_00_new
- a = @cls.new()
- assert_instance_of(@cls, a)
- assert_equal(0, a.length)
- assert_nil(a[0])
- end
- def test_01_square_brackets
- a = @cls[ 5, 4, 3, 2, 1 ]
- assert_instance_of(@cls, a)
- assert_equal(5, a.length)
- 5.times { |i| assert_equal(5-i, a[i]) }
- assert_nil(a[6])
- end
- def test_AND # '&'
- assert_equal(@cls[1, 3], @cls[ 1, 1, 3, 5 ] & @cls[ 1, 2, 3 ])
- assert_equal(@cls[], @cls[ 1, 1, 3, 5 ] & @cls[ ])
- assert_equal(@cls[], @cls[ ] & @cls[ 1, 2, 3 ])
- assert_equal(@cls[], @cls[ 1, 2, 3 ] & @cls[ 4, 5, 6 ])
- end
- def test_AND_big_array # '&'
- assert_equal(@cls[1, 3], @cls[ 1, 1, 3, 5 ]*64 & @cls[ 1, 2, 3 ]*64)
- assert_equal(@cls[], @cls[ 1, 1, 3, 5 ]*64 & @cls[ ])
- assert_equal(@cls[], @cls[ ] & @cls[ 1, 2, 3 ]*64)
- assert_equal(@cls[], @cls[ 1, 2, 3 ]*64 & @cls[ 4, 5, 6 ]*64)
- end
- def test_intersection
- assert_equal(@cls[1, 2], @cls[1, 2, 3].intersection(@cls[1, 2]))
- assert_equal(@cls[ ], @cls[1].intersection(@cls[ ]))
- assert_equal(@cls[ ], @cls[ ].intersection(@cls[1]))
- assert_equal(@cls[1], @cls[1, 2, 3].intersection(@cls[1, 2], @cls[1]))
- assert_equal(@cls[ ], @cls[1, 2, 3].intersection(@cls[1, 2], @cls[3]))
- assert_equal(@cls[ ], @cls[1, 2, 3].intersection(@cls[4, 5, 6]))
- end
- def test_intersection_big_array
- assert_equal(@cls[1, 2], (@cls[1, 2, 3] * 64).intersection(@cls[1, 2] * 64))
- assert_equal(@cls[ ], (@cls[1] * 64).intersection(@cls[ ]))
- assert_equal(@cls[ ], @cls[ ].intersection(@cls[1] * 64))
- assert_equal(@cls[1], (@cls[1, 2, 3] * 64).intersection((@cls[1, 2] * 64), (@cls[1] * 64)))
- assert_equal(@cls[ ], (@cls[1, 2, 3] * 64).intersection(@cls[4, 5, 6] * 64))
- end
- def test_MUL # '*'
- assert_equal(@cls[], @cls[]*3)
- assert_equal(@cls[1, 1, 1], @cls[1]*3)
- assert_equal(@cls[1, 2, 1, 2, 1, 2], @cls[1, 2]*3)
- assert_equal(@cls[], @cls[1, 2, 3] * 0)
- assert_raise(ArgumentError) { @cls[1, 2]*(-3) }
- assert_equal('1-2-3-4-5', @cls[1, 2, 3, 4, 5] * '-')
- assert_equal('12345', @cls[1, 2, 3, 4, 5] * '')
- end
- def test_PLUS # '+'
- assert_equal(@cls[], @cls[] + @cls[])
- assert_equal(@cls[1], @cls[1] + @cls[])
- assert_equal(@cls[1], @cls[] + @cls[1])
- assert_equal(@cls[1, 1], @cls[1] + @cls[1])
- assert_equal(@cls['cat', 'dog', 1, 2, 3], %w(cat dog) + (1..3).to_a)
- end
- def test_MINUS # '-'
- assert_equal(@cls[], @cls[1] - @cls[1])
- assert_equal(@cls[1], @cls[1, 2, 3, 4, 5] - @cls[2, 3, 4, 5])
- assert_equal(@cls[1, 1, 1, 1], @cls[1, 2, 1, 3, 1, 4, 1, 5] - @cls[2, 3, 4, 5])
- assert_equal(@cls[1, 1], @cls[1, 2, 1] - @cls[2])
- assert_equal(@cls[1, 2, 3], @cls[1, 2, 3] - @cls[4, 5, 6])
- end
- def test_MINUS_big_array # '-'
- assert_equal(@cls[1]*64, @cls[1, 2, 3, 4, 5]*64 - @cls[2, 3, 4, 5]*64)
- assert_equal(@cls[1, 1, 1, 1]*64, @cls[1, 2, 1, 3, 1, 4, 1, 5]*64 - @cls[2, 3, 4, 5]*64)
- a = @cls[]
- 1000.times { a << 1 }
- assert_equal(1000, a.length)
- assert_equal(@cls[1] * 1000, a - @cls[2])
- end
- def test_difference
- assert_equal(@cls[], @cls[1].difference(@cls[1]))
- assert_equal(@cls[1], @cls[1, 2, 3, 4, 5].difference(@cls[2, 3, 4, 5]))
- assert_equal(@cls[1, 1], @cls[1, 2, 1].difference(@cls[2]))
- assert_equal(@cls[1, 1, 1, 1], @cls[1, 2, 1, 3, 1, 4, 1, 5].difference(@cls[2, 3, 4, 5]))
- assert_equal(@cls[], @cls[1, 2, 3, 4].difference(@cls[1], @cls[2], @cls[3], @cls[4]))
- a = [1]
- assert_equal(@cls[1], a.difference(@cls[2], @cls[2]))
- assert_equal(@cls[], a.difference(@cls[1]))
- assert_equal(@cls[1], a)
- end
- def test_difference_big_array
- assert_equal(@cls[1]*64, (@cls[1, 2, 3, 4, 5] * 64).difference(@cls[2, 3, 4] * 64, @cls[3, 5] * 64))
- assert_equal(@cls[1, 1, 1, 1]*64, (@cls[1, 2, 1, 3, 1, 4, 1, 5] * 64).difference(@cls[2, 3, 4, 5] * 64))
- a = @cls[1] * 1000
- assert_equal(@cls[1] * 1000, a.difference(@cls[2], @cls[2]))
- assert_equal(@cls[], a.difference(@cls[1]))
- assert_equal(@cls[1] * 1000, a)
- end
- def test_LSHIFT # '<<'
- a = @cls[]
- a << 1
- assert_equal(@cls[1], a)
- a << 2 << 3
- assert_equal(@cls[1, 2, 3], a)
- a << nil << 'cat'
- assert_equal(@cls[1, 2, 3, nil, 'cat'], a)
- a << a
- assert_equal(@cls[1, 2, 3, nil, 'cat', a], a)
- end
- def test_CMP # '<=>'
- assert_equal(0, @cls[] <=> @cls[])
- assert_equal(0, @cls[1] <=> @cls[1])
- assert_equal(0, @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3, 'cat'])
- assert_equal(-1, @cls[] <=> @cls[1])
- assert_equal(1, @cls[1] <=> @cls[])
- assert_equal(-1, @cls[1, 2, 3] <=> @cls[1, 2, 3, 'cat'])
- assert_equal(1, @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3])
- assert_equal(-1, @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3, 'dog'])
- assert_equal(1, @cls[1, 2, 3, 'dog'] <=> @cls[1, 2, 3, 'cat'])
- end
- def test_EQUAL # '=='
- assert_operator(@cls[], :==, @cls[])
- assert_operator(@cls[1], :==, @cls[1])
- assert_operator(@cls[1, 1, 2, 2], :==, @cls[1, 1, 2, 2])
- assert_operator(@cls[1.0, 1.0, 2.0, 2.0], :==, @cls[1, 1, 2, 2])
- end
- def test_VERY_EQUAL # '==='
- assert_operator(@cls[], :===, @cls[])
- assert_operator(@cls[1], :===, @cls[1])
- assert_operator(@cls[1, 1, 2, 2], :===, @cls[1, 1, 2, 2])
- assert_operator(@cls[1.0, 1.0, 2.0, 2.0], :===, @cls[1, 1, 2, 2])
- end
- def test_AREF # '[]'
- a = @cls[*(1..100).to_a]
- assert_equal(1, a[0])
- assert_equal(100, a[99])
- assert_nil(a[100])
- assert_equal(100, a[-1])
- assert_equal(99, a[-2])
- assert_equal(1, a[-100])
- assert_nil(a[-101])
- assert_nil(a[-101,0])
- assert_nil(a[-101,1])
- assert_nil(a[-101,-1])
- assert_nil(a[10,-1])
- assert_equal(@cls[1], a[0,1])
- assert_equal(@cls[100], a[99,1])
- assert_equal(@cls[], a[100,1])
- assert_equal(@cls[100], a[99,100])
- assert_equal(@cls[100], a[-1,1])
- assert_equal(@cls[99], a[-2,1])
- assert_equal(@cls[], a[-100,0])
- assert_equal(@cls[1], a[-100,1])
- assert_equal(@cls[10, 11, 12], a[9, 3])
- assert_equal(@cls[10, 11, 12], a[-91, 3])
- assert_equal(@cls[1], a[0..0])
- assert_equal(@cls[100], a[99..99])
- assert_equal(@cls[], a[100..100])
- assert_equal(@cls[100], a[99..200])
- assert_equal(@cls[100], a[-1..-1])
- assert_equal(@cls[99], a[-2..-2])
- assert_equal(@cls[10, 11, 12], a[9..11])
- assert_equal(@cls[98, 99, 100], a[97..])
- assert_equal(@cls[1, 2, 3], a[..2])
- assert_equal(@cls[1, 2], a[...2])
- assert_equal(@cls[10, 11, 12], a[-91..-89])
- assert_equal(@cls[98, 99, 100], a[-3..])
- assert_equal(@cls[1, 2, 3], a[..-98])
- assert_equal(@cls[1, 2], a[...-98])
- assert_nil(a[10, -3])
- assert_equal [], a[10..7]
- assert_raise(TypeError) {a['cat']}
- end
- def test_ASET # '[]='
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[0] = 0)
- assert_equal(@cls[0] + @cls[*(1..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[10,10] = 0)
- assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[-1] = 0)
- assert_equal(@cls[*(0..98).to_a] + @cls[0], a)
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[-10, 10] = 0)
- assert_equal(@cls[*(0..89).to_a] + @cls[0], a)
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[0,1000] = 0)
- assert_equal(@cls[0] , a)
- a = @cls[*(0..99).to_a]
- assert_equal(0, a[10..19] = 0)
- assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
- b = @cls[*%w( a b c )]
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[0,1] = b)
- assert_equal(b + @cls[*(1..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[10,10] = b)
- assert_equal(@cls[*(0..9).to_a] + b + @cls[*(20..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[-1, 1] = b)
- assert_equal(@cls[*(0..98).to_a] + b, a)
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[-10, 10] = b)
- assert_equal(@cls[*(0..89).to_a] + b, a)
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[0,1000] = b)
- assert_equal(b , a)
- a = @cls[*(0..99).to_a]
- assert_equal(b, a[10..19] = b)
- assert_equal(@cls[*(0..9).to_a] + b + @cls[*(20..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[0,1] = nil)
- assert_equal(@cls[nil] + @cls[*(1..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[10,10] = nil)
- assert_equal(@cls[*(0..9).to_a] + @cls[nil] + @cls[*(20..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[-1, 1] = nil)
- assert_equal(@cls[*(0..98).to_a] + @cls[nil], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[-10, 10] = nil)
- assert_equal(@cls[*(0..89).to_a] + @cls[nil], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[0,1000] = nil)
- assert_equal(@cls[nil] , a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[10..19] = nil)
- assert_equal(@cls[*(0..9).to_a] + @cls[nil] + @cls[*(20..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[10..] = nil)
- assert_equal(@cls[*(0..9).to_a] + @cls[nil], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[..10] = nil)
- assert_equal(@cls[nil] + @cls[*(11..99).to_a], a)
- a = @cls[*(0..99).to_a]
- assert_equal(nil, a[...10] = nil)
- assert_equal(@cls[nil] + @cls[*(10..99).to_a], a)
- a = @cls[1, 2, 3]
- a[1, 0] = a
- assert_equal([1, 1, 2, 3, 2, 3], a)
- a = @cls[1, 2, 3]
- a[-1, 0] = a
- assert_equal([1, 2, 1, 2, 3, 3], a)
- a = @cls[]
- a[5,0] = [5]
- assert_equal([nil, nil, nil, nil, nil, 5], a)
- a = @cls[1]
- a[1,0] = [2]
- assert_equal([1, 2], a)
- a = @cls[1]
- a[1,1] = [2]
- assert_equal([1, 2], a)
- end
- def test_append
- a = @cls[1, 2, 3]
- assert_equal(@cls[1, 2, 3, 4, 5], a.append(4, 5))
- assert_equal(@cls[1, 2, 3, 4, 5, nil], a.append(nil))
- a.append
- assert_equal @cls[1, 2, 3, 4, 5, nil], a
- a.append 6, 7
- assert_equal @cls[1, 2, 3, 4, 5, nil, 6, 7], a
- end
- def test_assoc
- a1 = @cls[*%w( cat feline )]
- a2 = @cls[*%w( dog canine )]
- a3 = @cls[*%w( mule asinine )]
- a = @cls[ a1, a2, a3 ]
- assert_equal(a1, a.assoc('cat'))
- assert_equal(a3, a.assoc('mule'))
- assert_equal(nil, a.assoc('asinine'))
- assert_equal(nil, a.assoc('wombat'))
- assert_equal(nil, a.assoc(1..2))
- end
- def test_at
- a = @cls[*(0..99).to_a]
- assert_equal(0, a.at(0))
- assert_equal(10, a.at(10))
- assert_equal(99, a.at(99))
- assert_equal(nil, a.at(100))
- assert_equal(99, a.at(-1))
- assert_equal(0, a.at(-100))
- assert_equal(nil, a.at(-101))
- assert_raise(TypeError) { a.at('cat') }
- end
- def test_clear
- a = @cls[1, 2, 3]
- b = a.clear
- assert_equal(@cls[], a)
- assert_equal(@cls[], b)
- assert_equal(a.__id__, b.__id__)
- end
- def test_clone
- for frozen in [ false, true ]
- a = @cls[*(0..99).to_a]
- a.freeze if frozen
- b = a.clone
- assert_equal(a, b)
- assert_not_equal(a.__id__, b.__id__)
- assert_equal(a.frozen?, b.frozen?)
- end
- end
- def test_collect
- a = @cls[ 1, 'cat', 1..1 ]
- assert_equal([ Integer, String, Range], a.collect {|e| e.class} )
- assert_equal([ 99, 99, 99], a.collect { 99 } )
- assert_equal([], @cls[].collect { 99 })
- assert_kind_of Enumerator, @cls[1, 2, 3].collect
- assert_raise(ArgumentError) {
- assert_equal([[1, 2, 3]], [[1, 2, 3]].collect(&->(a, b, c) {[a, b, c]}))
- }
- end
- # also update map!
- def test_collect!
- a = @cls[ 1, 'cat', 1..1 ]
- assert_equal([ Integer, String, Range], a.collect! {|e| e.class} )
- assert_equal([ Integer, String, Range], a)
- a = @cls[ 1, 'cat', 1..1 ]
- assert_equal([ 99, 99, 99], a.collect! { 99 } )
- assert_equal([ 99, 99, 99], a)
- a = @cls[ ]
- assert_equal([], a.collect! { 99 })
- assert_equal([], a)
- end
- def test_compact
- a = @cls[ 1, nil, nil, 2, 3, nil, 4 ]
- assert_equal(@cls[1, 2, 3, 4], a.compact)
- a = @cls[ nil, 1, nil, 2, 3, nil, 4 ]
- assert_equal(@cls[1, 2, 3, 4], a.compact)
- a = @cls[ 1, nil, nil, 2, 3, nil, 4, nil ]
- assert_equal(@cls[1, 2, 3, 4], a.compact)
- a = @cls[ 1, 2, 3, 4 ]
- assert_equal(@cls[1, 2, 3, 4], a.compact)
- end
- def test_compact!
- a = @cls[ 1, nil, nil, 2, 3, nil, 4 ]
- assert_equal(@cls[1, 2, 3, 4], a.compact!)
- assert_equal(@cls[1, 2, 3, 4], a)
- a = @cls[ nil, 1, nil, 2, 3, nil, 4 ]
- assert_equal(@cls[1, 2, 3, 4], a.compact!)
- assert_equal(@cls[1, 2, 3, 4], a)
- a = @cls[ 1, nil, nil, 2, 3, nil, 4, nil ]
- assert_equal(@cls[1, 2, 3, 4], a.compact!)
- assert_equal(@cls[1, 2, 3, 4], a)
- a = @cls[ 1, 2, 3, 4 ]
- assert_equal(nil, a.compact!)
- assert_equal(@cls[1, 2, 3, 4], a)
- end
- def test_concat
- assert_equal(@cls[1, 2, 3, 4], @cls[1, 2].concat(@cls[3, 4]))
- assert_equal(@cls[1, 2, 3, 4], @cls[].concat(@cls[1, 2, 3, 4]))
- assert_equal(@cls[1, 2, 3, 4], @cls[1].concat(@cls[2, 3], [4]))
- assert_equal(@cls[1, 2, 3, 4], @cls[1, 2, 3, 4].concat(@cls[]))
- assert_equal(@cls[1, 2, 3, 4], @cls[1, 2, 3, 4].concat())
- assert_equal(@cls[], @cls[].concat(@cls[]))
- assert_equal(@cls[@cls[1, 2], @cls[3, 4]], @cls[@cls[1, 2]].concat(@cls[@cls[3, 4]]))
- a = @cls[1, 2, 3]
- a.concat(a)
- assert_equal([1, 2, 3, 1, 2, 3], a)
- b = @cls[4, 5]
- b.concat(b, b)
- assert_equal([4, 5, 4, 5, 4, 5], b)
- assert_raise(TypeError) { [0].concat(:foo) }
- assert_raise(FrozenError) { [0].freeze.concat(:foo) }
- end
- def test_count
- a = @cls[1, 2, 3, 1, 2]
- assert_equal(5, a.count)
- assert_equal(2, a.count(1))
- assert_equal(3, a.count {|x| x % 2 == 1 })
- assert_equal(2, a.count(1) {|x| x % 2 == 1 })
- assert_raise(ArgumentError) { a.count(0, 1) }
- bug8654 = '[ruby-core:56072]'
- assert_in_out_err [], <<-EOS, ["0"], [], bug8654
- a1 = []
- a2 = Array.new(100) { |i| i }
- a2.count do |i|
- p i
- a2.replace(a1) if i == 0
- end
- EOS
- assert_in_out_err [], <<-EOS, ["[]", "0"], [], bug8654
- ARY = Array.new(100) { |i| i }
- class Integer
- alias old_equal ==
- def == other
- ARY.replace([]) if self.equal?(0)
- p ARY
- self.equal?(other)
- end
- end
- p ARY.count(42)
- EOS
- end
- def test_delete
- a = @cls[*('cab'..'cat').to_a]
- assert_equal('cap', a.delete('cap'))
- assert_equal(@cls[*('cab'..'cao').to_a] + @cls[*('caq'..'cat').to_a], a)
- a = @cls[*('cab'..'cat').to_a]
- assert_equal('cab', a.delete('cab'))
- assert_equal(@cls[*('cac'..'cat').to_a], a)
- a = @cls[*('cab'..'cat').to_a]
- assert_equal('cat', a.delete('cat'))
- assert_equal(@cls[*('cab'..'cas').to_a], a)
- a = @cls[*('cab'..'cat').to_a]
- assert_equal(nil, a.delete('cup'))
- assert_equal(@cls[*('cab'..'cat').to_a], a)
- a = @cls[*('cab'..'cat').to_a]
- assert_equal(99, a.delete('cup') { 99 } )
- assert_equal(@cls[*('cab'..'cat').to_a], a)
- o = Object.new
- def o.==(other); true; end
- o2 = Object.new
- def o2.==(other); true; end
- a = @cls[1, o, o2, 2]
- assert_equal(o2, a.delete(42))
- assert_equal([1, 2], a)
- end
- def test_delete_at
- a = @cls[*(1..5).to_a]
- assert_equal(3, a.delete_at(2))
- assert_equal(@cls[1, 2, 4, 5], a)
- a = @cls[*(1..5).to_a]
- assert_equal(4, a.delete_at(-2))
- assert_equal(@cls[1, 2, 3, 5], a)
- a = @cls[*(1..5).to_a]
- assert_equal(nil, a.delete_at(5))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[*(1..5).to_a]
- assert_equal(nil, a.delete_at(-6))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- end
- # also reject!
- def test_delete_if
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(a, a.delete_if { false })
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(a, a.delete_if { true })
- assert_equal(@cls[], a)
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(a, a.delete_if { |i| i > 3 })
- assert_equal(@cls[1, 2, 3], a)
- bug2545 = '[ruby-core:27366]'
- a = @cls[ 5, 6, 7, 8, 9, 10 ]
- assert_equal(9, a.delete_if {|i| break i if i > 8; i < 7})
- assert_equal(@cls[7, 8, 9, 10], a, bug2545)
- end
- def test_dup
- for frozen in [ false, true ]
- a = @cls[*(0..99).to_a]
- a.freeze if frozen
- b = a.dup
- assert_equal(a, b)
- assert_not_equal(a.__id__, b.__id__)
- assert_equal(false, b.frozen?)
- end
- end
- def test_each
- a = @cls[*%w( ant bat cat dog )]
- i = 0
- a.each { |e|
- assert_equal(a[i], e)
- i += 1
- }
- assert_equal(4, i)
- a = @cls[]
- i = 0
- a.each { |e|
- assert(false, "Never get here")
- i += 1
- }
- assert_equal(0, i)
- assert_equal(a, a.each {})
- end
- def test_each_index
- a = @cls[*%w( ant bat cat dog )]
- i = 0
- a.each_index { |ind|
- assert_equal(i, ind)
- i += 1
- }
- assert_equal(4, i)
- a = @cls[]
- i = 0
- a.each_index { |ind|
- assert(false, "Never get here")
- i += 1
- }
- assert_equal(0, i)
- assert_equal(a, a.each_index {})
- end
- def test_empty?
- assert_empty(@cls[])
- assert_not_empty(@cls[1])
- end
- def test_eql?
- assert_send([@cls[], :eql?, @cls[]])
- assert_send([@cls[1], :eql?, @cls[1]])
- assert_send([@cls[1, 1, 2, 2], :eql?, @cls[1, 1, 2, 2]])
- assert_not_send([@cls[1.0, 1.0, 2.0, 2.0], :eql?, @cls[1, 1, 2, 2]])
- end
- def test_fill
- assert_equal(@cls[], @cls[].fill(99))
- assert_equal(@cls[], @cls[].fill(99, 0))
- assert_equal(@cls[99], @cls[].fill(99, 0, 1))
- assert_equal(@cls[99], @cls[].fill(99, 0..0))
- assert_equal(@cls[99], @cls[1].fill(99))
- assert_equal(@cls[99], @cls[1].fill(99, 0))
- assert_equal(@cls[99], @cls[1].fill(99, 0, 1))
- assert_equal(@cls[99], @cls[1].fill(99, 0..0))
- assert_equal(@cls[99, 99], @cls[1, 2].fill(99))
- assert_equal(@cls[99, 99], @cls[1, 2].fill(99, 0))
- assert_equal(@cls[99, 99], @cls[1, 2].fill(99, nil))
- assert_equal(@cls[1, 99], @cls[1, 2].fill(99, 1, nil))
- assert_equal(@cls[99, 2], @cls[1, 2].fill(99, 0, 1))
- assert_equal(@cls[99, 2], @cls[1, 2].fill(99, 0..0))
- end
- def test_first
- assert_equal(3, @cls[3, 4, 5].first)
- assert_equal(nil, @cls[].first)
- end
- def test_flatten
- a1 = @cls[ 1, 2, 3]
- a2 = @cls[ 5, 6 ]
- a3 = @cls[ 4, a2 ]
- a4 = @cls[ a1, a3 ]
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a4.flatten)
- assert_equal(@cls[ a1, a3], a4)
- a5 = @cls[ a1, @cls[], a3 ]
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a5.flatten)
- assert_equal(@cls[1, 2, 3, 4, [5, 6]], a5.flatten(1))
- assert_equal(@cls[], @cls[].flatten)
- assert_equal(@cls[],
- @cls[@cls[@cls[@cls[],@cls[]],@cls[@cls[]],@cls[]],@cls[@cls[@cls[]]]].flatten)
- end
- def test_flatten_wrong_argument
- assert_raise(TypeError, "[ruby-dev:31197]") { [[]].flatten("") }
- end
- def test_flatten_level0
- a8 = @cls[[1, 2], 3]
- a9 = a8.flatten(0)
- assert_equal(a8, a9)
- assert_not_same(a8, a9)
- end
- def test_flatten_splat
- bug10748 = '[ruby-core:67637] [Bug #10748]'
- o = Object.new
- o.singleton_class.class_eval do
- define_method(:to_ary) do
- raise bug10748
- end
- end
- a = @cls[@cls[o]]
- assert_raise_with_message(RuntimeError, bug10748) {a.flatten}
- assert_nothing_raised(RuntimeError, bug10748) {a.flatten(1)}
- end
- def test_flattern_singleton_class
- bug12738 = '[ruby-dev:49781] [Bug #12738]'
- a = [[0]]
- class << a
- def m; end
- end
- assert_raise(NoMethodError, bug12738) { a.flatten.m }
- end
- def test_flatten!
- a1 = @cls[ 1, 2, 3]
- a2 = @cls[ 5, 6 ]
- a3 = @cls[ 4, a2 ]
- a4 = @cls[ a1, a3 ]
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a4.flatten!)
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a4)
- a5 = @cls[ a1, @cls[], a3 ]
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a5.flatten!)
- assert_nil(a5.flatten!(0), '[ruby-core:23382]')
- assert_equal(@cls[1, 2, 3, 4, 5, 6], a5)
- end
- def test_flatten_empty!
- assert_nil(@cls[].flatten!)
- assert_equal(@cls[],
- @cls[@cls[@cls[@cls[],@cls[]],@cls[@cls[]],@cls[]],@cls[@cls[@cls[]]]].flatten!)
- end
- def test_flatten_level0!
- assert_nil(@cls[].flatten!(0), '[ruby-core:23382]')
- end
- def test_flatten_splat!
- bug10748 = '[ruby-core:67637] [Bug #10748]'
- o = Object.new
- o.singleton_class.class_eval do
- define_method(:to_ary) do
- raise bug10748
- end
- end
- a = @cls[@cls[o]]
- assert_raise_with_message(RuntimeError, bug10748) {a.flatten!}
- assert_nothing_raised(RuntimeError, bug10748) {a.flatten!(1)}
- end
- def test_flattern_singleton_class!
- bug12738 = '[ruby-dev:49781] [Bug #12738]'
- a = [[0]]
- class << a
- def m; end
- end
- assert_nothing_raised(NameError, bug12738) { a.flatten!.m }
- end
- def test_flatten_with_callcc
- need_continuation
- o = Object.new
- def o.to_ary() callcc {|k| @cont = k; [1,2,3]} end
- begin
- assert_equal([10, 20, 1, 2, 3, 30, 1, 2, 3, 40], [10, 20, o, 30, o, 40].flatten)
- rescue => e
- else
- o.instance_eval {@cont}.call
- end
- assert_instance_of(RuntimeError, e, '[ruby-dev:34798]')
- assert_match(/reentered/, e.message, '[ruby-dev:34798]')
- end
- def test_flatten_respond_to_missing
- bug11465 = '[ruby-core:70460] [Bug #11465]'
- obj = Class.new do
- def respond_to_missing?(method, stuff)
- return false if method == :to_ary
- super
- end
- def method_missing(*args)
- super
- end
- end.new
- ex = nil
- trace = TracePoint.new(:raise) do |tp|
- ex = tp.raised_exception
- end
- trace.enable {[obj].flatten}
- assert_nil(ex, bug11465)
- end
- def test_permutation_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = [1,2,3]
- begin
- ary.permutation {
- callcc {|k| cont = k} unless cont
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e)
- assert_match(/reentered/, e.message)
- end
- def test_product_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = [1,2,3]
- begin
- ary.product {
- callcc {|k| cont = k} unless cont
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e)
- assert_match(/reentered/, e.message)
- end
- def test_combination_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = [1,2,3]
- begin
- ary.combination(2) {
- callcc {|k| cont = k} unless cont
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e)
- assert_match(/reentered/, e.message)
- end
- def test_repeated_permutation_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = [1,2,3]
- begin
- ary.repeated_permutation(2) {
- callcc {|k| cont = k} unless cont
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e)
- assert_match(/reentered/, e.message)
- end
- def test_repeated_combination_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = [1,2,3]
- begin
- ary.repeated_combination(2) {
- callcc {|k| cont = k} unless cont
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e)
- assert_match(/reentered/, e.message)
- end
- def test_hash
- a1 = @cls[ 'cat', 'dog' ]
- a2 = @cls[ 'cat', 'dog' ]
- a3 = @cls[ 'dog', 'cat' ]
- assert_equal(a1.hash, a2.hash)
- assert_not_equal(a1.hash, a3.hash)
- bug9231 = '[ruby-core:58993] [Bug #9231]'
- assert_not_equal(false.hash, @cls[].hash, bug9231)
- end
- def test_include?
- a = @cls[ 'cat', 99, /a/, @cls[ 1, 2, 3] ]
- assert_include(a, 'cat')
- assert_include(a, 99)
- assert_include(a, /a/)
- assert_include(a, [1,2,3])
- assert_not_include(a, 'ca')
- assert_not_include(a, [1,2])
- end
- def test_index
- a = @cls[ 'cat', 99, /a/, 99, @cls[ 1, 2, 3] ]
- assert_equal(0, a.index('cat'))
- assert_equal(1, a.index(99))
- assert_equal(4, a.index([1,2,3]))
- assert_nil(a.index('ca'))
- assert_nil(a.index([1,2]))
- assert_equal(1, a.index(99) {|x| x == 'cat' })
- end
- def test_values_at
- a = @cls[*('a'..'j').to_a]
- assert_equal(@cls['a', 'c', 'e'], a.values_at(0, 2, 4))
- assert_equal(@cls['j', 'h', 'f'], a.values_at(-1, -3, -5))
- assert_equal(@cls['h', nil, 'a'], a.values_at(-3, 99, 0))
- end
- def test_join
- $, = ""
- a = @cls[]
- assert_equal("", a.join)
- assert_equal("", a.join(','))
- assert_equal(Encoding::US_ASCII, a.join.encoding)
- $, = ""
- a = @cls[1, 2]
- assert_equal("12", a.join)
- assert_equal("12", a.join(nil))
- assert_equal("1,2", a.join(','))
- $, = ""
- a = @cls[1, 2, 3]
- assert_equal("123", a.join)
- assert_equal("123", a.join(nil))
- assert_equal("1,2,3", a.join(','))
- $, = ":"
- a = @cls[1, 2, 3]
- assert_equal("1:2:3", a.join)
- assert_equal("1:2:3", a.join(nil))
- assert_equal("1,2,3", a.join(','))
- $, = ""
- e = ''.force_encoding('EUC-JP')
- u = ''.force_encoding('UTF-8')
- assert_equal(Encoding::US_ASCII, [[]].join.encoding)
- assert_equal(Encoding::US_ASCII, [1, [u]].join.encoding)
- assert_equal(Encoding::UTF_8, [u, [e]].join.encoding)
- assert_equal(Encoding::UTF_8, [u, [1]].join.encoding)
- assert_equal(Encoding::UTF_8, [Struct.new(:to_str).new(u)].join.encoding)
- bug5379 = '[ruby-core:39776]'
- assert_equal(Encoding::US_ASCII, [[], u, nil].join.encoding, bug5379)
- assert_equal(Encoding::UTF_8, [[], "\u3042", nil].join.encoding, bug5379)
- ensure
- $, = nil
- end
- def test_last
- assert_equal(nil, @cls[].last)
- assert_equal(1, @cls[1].last)
- assert_equal(99, @cls[*(3..99).to_a].last)
- end
- def test_length
- assert_equal(0, @cls[].length)
- assert_equal(1, @cls[1].length)
- assert_equal(2, @cls[1, nil].length)
- assert_equal(2, @cls[nil, 1].length)
- assert_equal(234, @cls[*(0..233).to_a].length)
- end
- # also update collect!
- def test_map!
- a = @cls[ 1, 'cat', 1..1 ]
- assert_equal(@cls[ Integer, String, Range], a.map! {|e| e.class} )
- assert_equal(@cls[ Integer, String, Range], a)
- a = @cls[ 1, 'cat', 1..1 ]
- assert_equal(@cls[ 99, 99, 99], a.map! { 99 } )
- assert_equal(@cls[ 99, 99, 99], a)
- a = @cls[ ]
- assert_equal(@cls[], a.map! { 99 })
- assert_equal(@cls[], a)
- end
- def test_pack
- a = @cls[*%w( cat wombat x yy)]
- assert_equal("catwomx yy ", a.pack("A3A3A3A3"))
- assert_equal("cat", a.pack("A*"))
- assert_equal("cwx yy ", a.pack("A3@1A3@2A3A3"))
- assert_equal("catwomx\000\000yy\000", a.pack("a3a3a3a3"))
- assert_equal("cat", a.pack("a*"))
- assert_equal("ca", a.pack("a2"))
- assert_equal("cat\000\000", a.pack("a5"))
- assert_equal("\x61", @cls["01100001"].pack("B8"))
- assert_equal("\x61", @cls["01100001"].pack("B*"))
- assert_equal("\x61", @cls["0110000100110111"].pack("B8"))
- assert_equal("\x61\x37", @cls["0110000100110111"].pack("B16"))
- assert_equal("\x61\x37", @cls["01100001", "00110111"].pack("B8B8"))
- assert_equal("\x60", @cls["01100001"].pack("B4"))
- assert_equal("\x40", @cls["01100001"].pack("B2"))
- assert_equal("\x86", @cls["01100001"].pack("b8"))
- assert_equal("\x86", @cls["01100001"].pack("b*"))
- assert_equal("\x86", @cls["0110000100110111"].pack("b8"))
- assert_equal("\x86\xec", @cls["0110000100110111"].pack("b16"))
- assert_equal("\x86\xec", @cls["01100001", "00110111"].pack("b8b8"))
- assert_equal("\x06", @cls["01100001"].pack("b4"))
- assert_equal("\x02", @cls["01100001"].pack("b2"))
- assert_equal("ABC", @cls[ 65, 66, 67 ].pack("C3"))
- assert_equal("\377BC", @cls[ -1, 66, 67 ].pack("C*"))
- assert_equal("ABC", @cls[ 65, 66, 67 ].pack("c3"))
- assert_equal("\377BC", @cls[ -1, 66, 67 ].pack("c*"))
- assert_equal("AB\n\x10", @cls["4142", "0a", "12"].pack("H4H2H1"))
- assert_equal("AB\n\x02", @cls["1424", "a0", "21"].pack("h4h2h1"))
- assert_equal("abc=02def=\ncat=\n=01=\n",
- @cls["abc\002def", "cat", "\001"].pack("M9M3M4"))
- assert_equal("aGVsbG8K\n", @cls["hello\n"].pack("m"))
- assert_equal(",:&5L;&\\*:&5L;&\\*\n", @cls["hello\nhello\n"].pack("u"))
- assert_equal("\u{a9 42 2260}", @cls[0xa9, 0x42, 0x2260].pack("U*"))
- format = "c2x5CCxsdils_l_a6";
- # Need the expression in here to force ary[5] to be numeric. This avoids
- # test2 failing because ary2 goes str->numeric->str and ary does not.
- ary = [1, -100, 127, 128, 32767, 987.654321098/100.0,
- 12345, 123456, -32767, -123456, "abcdef"]
- x = ary.pack(format)
- ary2 = x.unpack(format)
- assert_equal(ary.length, ary2.length)
- assert_equal(ary.join(':'), ary2.join(':'))
- assert_not_nil(x =~ /def/)
- =begin
- skipping "Not tested:
- D,d & double-precision float, native format\\
- E & double-precision float, little-endian byte order\\
- e & single-precision float, little-endian byte order\\
- F,f & single-precision float, native format\\
- G & double-precision float, network (big-endian) byte order\\
- g & single-precision float, network (big-endian) byte order\\
- I & unsigned integer\\
- i & integer\\
- L & unsigned long\\
- l & long\\
- N & long, network (big-endian) byte order\\
- n & short, network (big-endian) byte-order\\
- P & pointer to a structure (fixed-length string)\\
- p & pointer to a null-terminated string\\
- S & unsigned short\\
- s & short\\
- V & long, little-endian byte order\\
- v & short, little-endian byte order\\
- X & back up a byte\\
- x & null byte\\
- Z & ASCII string (null padded, count is width)\\
- "
- =end
- end
- def test_pop
- a = @cls[ 'cat', 'dog' ]
- assert_equal('dog', a.pop)
- assert_equal(@cls['cat'], a)
- assert_equal('cat', a.pop)
- assert_equal(@cls[], a)
- assert_nil(a.pop)
- assert_equal(@cls[], a)
- end
- def test_prepend
- a = @cls[]
- assert_equal(@cls['cat'], a.prepend('cat'))
- assert_equal(@cls['dog', 'cat'], a.prepend('dog'))
- assert_equal(@cls[nil, 'dog', 'cat'], a.prepend(nil))
- assert_equal(@cls[@cls[1,2], nil, 'dog', 'cat'], a.prepend(@cls[1, 2]))
- end
- def test_push
- a = @cls[1, 2, 3]
- assert_equal(@cls[1, 2, 3, 4, 5], a.push(4, 5))
- assert_equal(@cls[1, 2, 3, 4, 5, nil], a.push(nil))
- a.push
- assert_equal @cls[1, 2, 3, 4, 5, nil], a
- a.push 6, 7
- assert_equal @cls[1, 2, 3, 4, 5, nil, 6, 7], a
- end
- def test_rassoc
- a1 = @cls[*%w( cat feline )]
- a2 = @cls[*%w( dog canine )]
- a3 = @cls[*%w( mule asinine )]
- a = @cls[ a1, a2, a3 ]
- assert_equal(a1, a.rassoc('feline'))
- assert_equal(a3, a.rassoc('asinine'))
- assert_equal(nil, a.rassoc('dog'))
- assert_equal(nil, a.rassoc('mule'))
- assert_equal(nil, a.rassoc(1..2))
- end
- # also delete_if
- def test_reject!
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(nil, a.reject! { false })
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(a, a.reject! { true })
- assert_equal(@cls[], a)
- a = @cls[ 1, 2, 3, 4, 5 ]
- assert_equal(a, a.reject! { |i| i > 3 })
- assert_equal(@cls[1, 2, 3], a)
- bug2545 = '[ruby-core:27366]'
- a = @cls[ 5, 6, 7, 8, 9, 10 ]
- assert_equal(9, a.reject! {|i| break i if i > 8; i < 7})
- assert_equal(@cls[7, 8, 9, 10], a, bug2545)
- end
- def test_shared_array_reject!
- c = []
- b = [1, 2, 3, 4]
- 3.times do
- a = b.dup
- c << a.dup
- begin
- a.reject! do |x|
- case x
- when 2 then true
- when 3 then raise StandardError, 'Oops'
- else false
- end
- end
- rescue StandardError
- end
- c << a.dup
- end
- bug90781 = '[ruby-core:90781]'
- assert_equal [[1, 2, 3, 4],
- [1, 3, 4],
- [1, 2, 3, 4],
- [1, 3, 4],
- [1, 2, 3, 4],
- [1, 3, 4]], c, bug90781
- end
- def test_iseq_shared_array_reject!
- c = []
- 3.times do
- a = [1, 2, 3, 4]
- c << a.dup
- begin
- a.reject! do |x|
- case x
- when 2 then true
- when 3 then raise StandardError, 'Oops'
- else false
- end
- end
- rescue StandardError
- end
- c << a.dup
- end
- bug90781 = '[ruby-core:90781]'
- assert_equal [[1, 2, 3, 4],
- [1, 3, 4],
- [1, 2, 3, 4],
- [1, 3, 4],
- [1, 2, 3, 4],
- [1, 3, 4]], c, bug90781
- end
- def test_replace
- a = @cls[ 1, 2, 3]
- a_id = a.__id__
- assert_equal(@cls[4, 5, 6], a.replace(@cls[4, 5, 6]))
- assert_equal(@cls[4, 5, 6], a)
- assert_equal(a_id, a.__id__)
- assert_equal(@cls[], a.replace(@cls[]))
- fa = a.dup.freeze
- assert_nothing_raised(RuntimeError) { a.replace(a) }
- assert_raise(FrozenError) { fa.replace(fa) }
- assert_raise(ArgumentError) { fa.replace() }
- assert_raise(TypeError) { a.replace(42) }
- assert_raise(FrozenError) { fa.replace(42) }
- end
- def test_reverse
- a = @cls[*%w( dog cat bee ant )]
- assert_equal(@cls[*%w(ant bee cat dog)], a.reverse)
- assert_equal(@cls[*%w(dog cat bee ant)], a)
- assert_equal(@cls[], @cls[].reverse)
- end
- def test_reverse!
- a = @cls[*%w( dog cat bee ant )]
- assert_equal(@cls[*%w(ant bee cat dog)], a.reverse!)
- assert_equal(@cls[*%w(ant bee cat dog)], a)
- assert_equal @cls[], @cls[].reverse!
- end
- def test_reverse_each
- a = @cls[*%w( dog cat bee ant )]
- i = a.length
- a.reverse_each { |e|
- i -= 1
- assert_equal(a[i], e)
- }
- assert_equal(0, i)
- a = @cls[]
- i = 0
- a.reverse_each { |e|
- i += 1
- assert(false, "Never get here")
- }
- assert_equal(0, i)
- end
- def test_rindex
- a = @cls[ 'cat', 99, /a/, 99, [ 1, 2, 3] ]
- assert_equal(0, a.rindex('cat'))
- assert_equal(3, a.rindex(99))
- assert_equal(4, a.rindex([1,2,3]))
- assert_nil(a.rindex('ca'))
- assert_nil(a.rindex([1,2]))
- assert_equal(3, a.rindex(99) {|x| x == [1,2,3] })
- bug15951 = "[Bug #15951]"
- o2 = Object.new
- def o2.==(other)
- other.replace([]) if Array === other
- false
- end
- a = Array.new(10)
- a.fill(o2)
- assert_nil(a.rindex(a), bug15951)
- end
- def test_shift
- a = @cls[ 'cat', 'dog' ]
- assert_equal('cat', a.shift)
- assert_equal(@cls['dog'], a)
- assert_equal('dog', a.shift)
- assert_equal(@cls[], a)
- assert_nil(a.shift)
- assert_equal(@cls[], a)
- end
- def test_size
- assert_equal(0, @cls[].size)
- assert_equal(1, @cls[1].size)
- assert_equal(100, @cls[*(0..99).to_a].size)
- end
- def test_slice
- a = @cls[*(1..100).to_a]
- assert_equal(1, a.slice(0))
- assert_equal(100, a.slice(99))
- assert_nil(a.slice(100))
- assert_equal(100, a.slice(-1))
- assert_equal(99, a.slice(-2))
- assert_equal(1, a.slice(-100))
- assert_nil(a.slice(-101))
- assert_equal(@cls[1], a.slice(0,1))
- assert_equal(@cls[100], a.slice(99,1))
- assert_equal(@cls[], a.slice(100,1))
- assert_equal(@cls[100], a.slice(99,100))
- assert_equal(@cls[100], a.slice(-1,1))
- assert_equal(@cls[99], a.slice(-2,1))
- assert_equal(@cls[10, 11, 12], a.slice(9, 3))
- assert_equal(@cls[10, 11, 12], a.slice(-91, 3))
- assert_nil(a.slice(-101, 2))
- assert_equal(@cls[1], a.slice(0..0))
- assert_equal(@cls[100], a.slice(99..99))
- assert_equal(@cls[], a.slice(100..100))
- assert_equal(@cls[100], a.slice(99..200))
- assert_equal(@cls[100], a.slice(-1..-1))
- assert_equal(@cls[99], a.slice(-2..-2))
- assert_equal(@cls[10, 11, 12], a.slice(9..11))
- assert_equal(@cls[98, 99, 100], a.slice(97..))
- assert_equal(@cls[10, 11, 12], a.slice(-91..-89))
- assert_equal(@cls[10, 11, 12], a.slice(-91..-89))
- assert_nil(a.slice(-101..-1))
- assert_nil(a.slice(-101..))
- assert_nil(a.slice(10, -3))
- assert_equal @cls[], a.slice(10..7)
- end
- def test_slice!
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(3, a.slice!(2))
- assert_equal(@cls[1, 2, 4, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(4, a.slice!(-2))
- assert_equal(@cls[1, 2, 3, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(@cls[3,4], a.slice!(2,2))
- assert_equal(@cls[1, 2, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(@cls[4,5], a.slice!(-2,2))
- assert_equal(@cls[1, 2, 3], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(@cls[3,4], a.slice!(2..3))
- assert_equal(@cls[1, 2, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(nil, a.slice!(20))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(nil, a.slice!(-6))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(nil, a.slice!(-6..4))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- a = @cls[1, 2, 3, 4, 5]
- assert_equal(nil, a.slice!(-6,2))
- assert_equal(@cls[1, 2, 3, 4, 5], a)
- assert_equal("[2, 3]", [1,2,3].slice!(1,10000).inspect, "moved from btest/knownbug")
- assert_raise(ArgumentError) { @cls[1].slice! }
- assert_raise(ArgumentError) { @cls[1].slice!(0, 0, 0) }
- end
- def test_sort
- a = @cls[ 4, 1, 2, 3 ]
- assert_equal(@cls[1, 2, 3, 4], a.sort)
- assert_equal(@cls[4, 1, 2, 3], a)
- assert_equal(@cls[4, 3, 2, 1], a.sort { |x, y| y <=> x} )
- assert_equal(@cls[4, 1, 2, 3], a)
- assert_equal(@cls[1, 2, 3, 4], a.sort { |x, y| (x - y) * (2**100) })
- a.fill(1)
- assert_equal(@cls[1, 1, 1, 1], a.sort)
- assert_equal(@cls[], @cls[].sort)
- end
- def test_sort!
- a = @cls[ 4, 1, 2, 3 ]
- assert_equal(@cls[1, 2, 3, 4], a.sort!)
- assert_equal(@cls[1, 2, 3, 4], a)
- assert_equal(@cls[4, 3, 2, 1], a.sort! { |x, y| y <=> x} )
- assert_equal(@cls[4, 3, 2, 1], a)
- a.fill(1)
- assert_equal(@cls[1, 1, 1, 1], a.sort!)
- assert_equal(@cls[1], @cls[1].sort!)
- assert_equal(@cls[], @cls[].sort!)
- a = @cls[4, 3, 2, 1]
- a.sort! {|m, n| a.replace([9, 8, 7, 6]); m <=> n }
- assert_equal([1, 2, 3, 4], a)
- a = @cls[4, 3, 2, 1]
- a.sort! {|m, n| a.replace([9, 8, 7]); m <=> n }
- assert_equal([1, 2, 3, 4], a)
- end
- def test_sort_with_callcc
- need_continuation
- n = 1000
- cont = nil
- ary = (1..100).to_a
- begin
- ary.sort! {|a,b|
- callcc {|k| cont = k} unless cont
- assert_equal(100, ary.size, '[ruby-core:16679]')
- a <=> b
- }
- rescue => e
- end
- n -= 1
- cont.call if 0 < n
- assert_instance_of(RuntimeError, e, '[ruby-core:16679]')
- assert_match(/reentered/, e.message, '[ruby-core:16679]')
- end
- def test_sort_with_replace
- bug = '[ruby-core:34732]'
- assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}", timeout: 30)
- bug = "#{bug}"
- begin;
- xary = (1..100).to_a
- 100.times do
- ary = (1..100).to_a
- ary.sort! {|a,b| ary.replace(xary); a <=> b}
- GC.start
- assert_equal(xary, ary, '[ruby-dev:34732]')
- end
- assert_nothing_raised(SystemStackError, bug) do
- assert_equal(:ok, Array.new(100_000, nil).permutation {break :ok})
- end
- end;
- end
- def test_sort_bang_with_freeze
- ary = []
- o1 = Object.new
- o1.singleton_class.class_eval {
- define_method(:<=>) {|v|
- ary.freeze
- 1
- }
- }
- o2 = o1.clone
- ary << o1 << o2
- orig = ary.dup
- assert_raise(FrozenError, "frozen during comparison") {ary.sort!}
- assert_equal(orig, ary, "must not be modified once frozen")
- end
- def test_short_heap_array_sort_bang_memory_leak
- bug11332 = '[ruby-dev:49166] [Bug #11332]'
- assert_no_memory_leak([], <<-PREP, <<-TEST, bug11332, limit: 1.3, timeout: 60)
- def t; ary = [*1..5]; ary.pop(2); ary.sort!; end
- 1.times {t}
- PREP
- 500000.times {t}
- TEST
- end
- def test_to_a
- a = @cls[ 1, 2, 3 ]
- a_id = a.__id__
- assert_equal(a, a.to_a)
- assert_equal(a_id, a.to_a.__id__)
- end
- def test_to_ary
- a = [ 1, 2, 3 ]
- b = @cls[*a]
- a_id = a.__id__
- assert_equal(a, b.to_ary)
- if (@cls == Array)
- assert_equal(a_id, a.to_ary.__id__)
- end
- o = Object.new
- def o.to_ary
- [4, 5]
- end
- assert_equal([1, 2, 3, 4, 5], a.concat(o))
- o = Object.new
- def o.to_ary
- foo_bar()
- end
- assert_raise_with_message(NoMethodError, /foo_bar/) {a.concat(o)}
- end
- def test_to_s
- $, = ""
- a = @cls[]
- assert_equal("[]", a.to_s)
- $, = ""
- a = @cls[1, 2]
- assert_equal("[1, 2]", a.to_s)
- $, = ""
- a = @cls[1, 2, 3]
- assert_equal("[1, 2, 3]", a.to_s)
- $, = ":"
- a = @cls[1, 2, 3]
- assert_equal("[1, 2, 3]", a.to_s)
- ensure
- $, = nil
- end
- StubToH = [
- [:key, :value],
- Object.new.tap do |kvp|
- def kvp.to_ary
- [:obtained, :via_to_ary]
- end
- end,
- ]
- def test_to_h
- array = StubToH
- assert_equal({key: :value, obtained: :via_to_ary}, array.to_h)
- e = assert_raise(TypeError) {
- [[:first_one, :ok], :not_ok].to_h
- }
- assert_equal "wrong element type Symbol at 1 (expected array)", e.message
- array = [eval("class C\u{1f5ff}; self; end").new]
- assert_raise_with_message(TypeError, /C\u{1f5ff}/) {array.to_h}
- e = assert_raise(ArgumentError) {
- [[:first_one, :ok], [1, 2], [:not_ok]].to_h
- }
- assert_equal "wrong array length at 2 (expected 2, was 1)", e.message
- end
- def test_to_h_block
- array = StubToH
- assert_equal({"key" => "value", "obtained" => "via_to_ary"},
- array.to_h {|k, v| [k.to_s, v.to_s]})
- assert_equal({first_one: :ok, not_ok: :ng},
- [[:first_one, :ok], :not_ok].to_h {|k, v| [k, v || :ng]})
- e = assert_raise(TypeError) {
- [[:first_one, :ok], :not_ok].to_h {|k, v| v ? [k, v] : k}
- }
- assert_equal "wrong element type Symbol at 1 (expected array)", e.message
- array = [1]
- k = eval("class C\u{1f5ff}; self; end").new
- assert_raise_with_message(TypeError, /C\u{1f5ff}/) {array.to_h {k}}
- e = assert_raise(ArgumentError) {
- [[:first_one, :ok], [1, 2], [:not_ok]].to_h {|kv| kv}
- }
- assert_equal "wrong array length at 2 (expected 2, was 1)", e.message
- end
- def test_min
- assert_equal(1, [1, 2, 3, 1, 2].min)
- assert_equal(3, [1, 2, 3, 1, 2].min {|a,b| b <=> a })
- cond = ->((a, ia), (b, ib)) { (b <=> a).nonzero? or ia <=> ib }
- assert_equal([3, 2], [1, 2, 3, 1, 2].each_with_index.min(&cond))
- ary = %w(albatross dog horse)
- assert_equal("albatross", ary.min)
- assert_equal("dog", ary.min {|a,b| a.length <=> b.length })
- assert_equal(1, [3,2,1].min)
- assert_equal(%w[albatross dog], ary.min(2))
- assert_equal(%w[dog horse],
- ary.min(2) {|a,b| a.length <=> b.length })
- assert_equal([13, 14], [20, 32, 32, 21, 30, 25, 29, 13, 14].min(2))
- assert_equal([2, 4, 6, 7], [2, 4, 8, 6, 7].min(4))
- class << (obj = Object.new)
- def <=>(x) 1 <=> x end
- def coerce(x) [x, 1] end
- end
- assert_same(obj, [obj, 1.0].min)
- end
- def test_max
- assert_equal(3, [1, 2, 3, 1, 2].max)
- assert_equal(1, [1, 2, 3, 1, 2].max {|a,b| b <=> a })
- cond = ->((a, ia), (b, ib)) { (b <=> a).nonzero? or ia <=>…
Large files files are truncated, but you can click here to view the full file