require 'test/unit'

require 'facet/array/%5B%5D%3D'
require 'facet/array/%5B%5D'
require 'facet/array/at_rand'
require 'facet/array/body'
require 'facet/array/combinations'
require 'facet/array/delete_values'
require 'facet/array/delete_values_at'
require 'facet/array/each_combination'
require 'facet/array/each_unique_pair'
require 'facet/array/first%21'
require 'facet/array/first%3D'
require 'facet/array/foot'
#require 'facet/array/get'
require 'facet/array/head'
require 'facet/array/last%21'
require 'facet/array/last%3D'
require 'facet/array/last_index'
require 'facet/array/middle'
require 'facet/array/permute'
require 'facet/array/pos'
require 'facet/array/pull'
require 'facet/array/range'
require 'facet/array/rotate%21'
require 'facet/array/rotate'
require 'facet/array/select%21'
require 'facet/array/shuffle%21'
require 'facet/array/shuffle'
require 'facet/array/tail'
require 'facet/array/thru'
require 'facet/array/to_b'
require 'facet/array/to_h'
require 'facet/array/top'


class TC_Array < Test::Unit::TestCase

  # index-op, i.e. []
  #--
  # Inline test.
  #++  
  def test_index_op
    a = ['a','b','c','d','e','f']
    assert_equal( ['b','f'], a[[1,-1]] )
    #assert_equal( ['a','c','e'], a[0,2,4] )
  end

  # at_rand
  
  def test_at_rand!
    a = ['a','b','c']
    assert_equal( 1, a.at_rand.length )
    assert_equal( 3, a.length )
    a = ['a','b','c']
    assert_equal( 1, a.at_rand!(1).length )
    assert_equal( 2, a.length )
    a = ['a','b','c']
    assert_equal( 2, a.at_rand!(2).length )
    assert_equal( 1, a.length )
    a = ['a','b','c']
    assert_equal( 3, a.pick(3).length )
    assert_equal( 0, a.length )
    a = ['a','b','c']
    assert_equal( 3, a.pick(4).length )
    assert_equal( 0, a.length )
  end

  def test_at_rand
    a = [1,2,3,4,5]
    20.times{ assert_nothing_raised{ a.at_rand } }
    20.times{ assert( a.include?( a.at_rand ) ) }
    a = [1,2,3,4,5]
    20.times{ assert_nothing_raised{ a.at_rand(1) } }
    assert_equal( 3, a.at_rand(3).length )
  end
  
  # body
    
  def test_body
    a = [1,2,3,4,5]
    assert_equal( [1,2,3,4], a.body )
  end

  # combinations
  
  def test_combinations
    a = [1,2]
    b = [3,4]
    r = Array.combinations(a,b)
    assert_equal( [[1,3],[1,4],[2,3],[2,4]], r )
  end
  
  def test_each_combination
    r = []
    a = [1,2,3,4]
    a.each_combination(2){ |a,b| r << [a,b] }
    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
  end
  
  def test_each_unique_pair
    r = []
    a = [1,2,3,4]
    a.each_unique_pair{ |a,b| r << [a,b] }
    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
  end
  
  # delete_values
  #--
  # Inline test.
  #++
  def test_delete_values
    a = [1,2,3,4]
    assert_equal( [1,2], a.delete_values(1,2) )
    assert_equal( [3,4], a )
  end
  
  def test_delete_values_at
    a = [1,2,3,4]
    assert_equal( [2,3], a.delete_values_at(1,2) )
    assert_equal( [1,4], a )
    a = [1,2,3,4]
    assert_equal( [1,2,3], a.delete_values_at(0..2) )
    assert_equal( [4], a )
  end
  
  # first
  
  def test_first_eq
    a = [1,2]
    a.first = 0
    assert_equal( [0,2], a )
  end

  def test_first!
    a = [1,2,3]
    assert_equal( 1, a.first! )
    assert_equal( [2,3], a )
  end

  # foot
  
  def test_foot
    a = [1,2,3,4,5]
    assert_equal( [5], a.foot )
  end

  # get
  
  #def test_get
  #  assert_equal( [3,4,5], [1,2,3,4,5,6,7,8,9].get(2,3) )
  #  assert_equal( [1], [1,2,3,4,5,6,7,8,9].get(0,1) )
  #end
  
  # head
  
  def test_head
    a = [1,2,3,4,5]
    assert_equal( [1], a.head )
  end
  
  # last
  
  def test_last_eq
    a = [1,2]
    a.last = 3
    assert_equal( [1,3], a )
  end
  
  def test_last!
    a = [1,2,3]
    assert_equal( 3, a.last! )
    assert_equal( [1,2], a )
  end

  # last_index

  def test_last_index
    assert_equal( [1,2,3,4,5].last_index, 4 )
  end

  # middle
  
  def test_middle
    a = [1,2,3,4,5]
    b = [1,2,3,4,5,6]  
    assert_equal( 3, a.middle )
    assert_equal( 4, b.middle )
    assert_equal( 4, a.middle(1) )
    assert_equal( 5, b.middle(1) )
    assert_equal( 6, b.middle(2) )
    assert_equal( 3, b.middle(-1) )
  end 
  
  # pos

  def test_pos
    a = [1,2,3,4,5]
    assert_equal( a.pos(1), 0 )
    assert_equal( a.pos(-1), 4 )
  end

  # pull
  
  def test_pull
    a = [1,2,3,4,5]
    assert_equal( 1, a.pull )
    assert_equal( [2,3,4,5], a )
  end
    
  # range
  
  def test_range
    a = [1,2,3,4,5]
    b = [1,2,3,4,5,6]
    assert_equal( (0..4), a.range )
    assert_equal( (0..5), b.range )
    assert_equal( (1..3), a.range(2,4) )
    assert_equal( (1..2), b.range(2,3) )
    assert_equal( (3..1), b.range(4,2) )
  end
  
  # select!
  
  def test_select!
    a = [1,2,3,4,5,6,7,8,9,10]
    a.select!{ |e| e % 2 == 0 }
    assert_equal( [2,4,6,8,10], a)
  end
  
  # shuffle
  
  def test_shuffle
    a = [1,2,3,4,5]
    100.times{ assert_nothing_raised{ a.shuffle } }
  end
  
  # tail

  def test_tail
    a = [1,2,3,4,5]
    assert_equal( [2,3,4,5], a.tail )
  end
  
  # to_b
  
  def test_to_b
    a = []
    assert_equal( false, a.to_b )
  end

  # to_h
  
  def to_h
    a = [[1,2],[3,4],[5,6]]
    assert_equal( { 1=>2, 3=>4, 5=>6 }, a.to_h )
    k = [1,3,5]
    v = [2,4,6]
    assert_equal( { 1=>2, 3=>4, 5=>6 }, k.to_h(v) )
  end

  # top
  
  def test_top
    a = [2,3,4,5]
    assert_equal( [1,2,3,4,5], a.top(1) )
  end
  
end