nano 0.8.1

data/test/array/tc_array.rb

@@ -0,0 +1,324 @@
+
+require 'test/unit'
+
+require 'nano/array/%5B%5D'
+require 'nano/array/%5B%5D%3D'
+require 'nano/array/at_rand'
+require 'nano/array/at_rand%21'
+require 'nano/array/bulk'
+require 'nano/array/delete_values_at'
+require 'nano/array/delete_values'
+require 'nano/array/first%21'
+require 'nano/array/first%3D'
+require 'nano/array/foot'
+require 'nano/array/head'
+require 'nano/array/last%21'
+require 'nano/array/last%3D'
+require 'nano/array/last_index'
+require 'nano/array/middle'
+require 'nano/array/mid'
+require 'nano/array/pick%21'
+require 'nano/array/pick'
+require 'nano/array/slap'
+require 'nano/array/pos'
+#require 'nano/array/pull'
+require 'nano/array/rand_index'
+require 'nano/array/rand_subset'
+require 'nano/array/range'
+require 'nano/array/rotate'
+require 'nano/array/rotate%21'
+require 'nano/array/select%21'
+require 'nano/array/shuffle'
+require 'nano/array/shuffle%21'
+require 'nano/array/store'
+require 'nano/array/tail'
+require 'nano/array/thru'
+require 'nano/array/to_b'
+require 'nano/array/to_h'
+
+class TC_Array < Test::Unit::TestCase
+
+  # []
+
+  def test_index_op
+    a = ['a','b','c','d','e','f']
+    assert_equal( ['b','f'], a[[1,-1]] )
+  end
+
+  # []=
+
+  def test_index_op_eq
+    a = ['a','o','z']
+    a[[0,2]] = ['A','Z']
+    assert_equal( ['A','o','Z'], a )
+    a[[0,-1]] = ['W','Y']
+    assert_equal( ['W','o','Y'], a )
+  end
+
+  # at_rand
+
+  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 ) ) }
+  end
+
+  # at_rand!
+
+  def test_at_rand!
+    a = ['a','b','c']
+    assert_equal( 1, a.at_rand!.length )
+    assert_equal( 2, a.length )
+  end
+
+  # bulk
+
+  def test_bulk
+    a = [1,2,3,4,5]
+    assert_equal( [1,2,3,4], a.bulk )
+  end
+
+  # delete_values
+
+  def test_delete_values
+    a = [1,2,3,4]
+    assert_equal( [1,2], a.delete_values(1,2) )
+    assert_equal( [3,4], a )
+  end
+
+  # delete_values_at
+
+  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
+
+  # first!
+
+  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
+
+  # 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
+
+  # last!
+
+  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
+
+  # mid
+
+  def test_mid
+    a = [1,2,3,4,5]
+    b = [1,2,3,4,5,6]
+    assert_equal( 3, a.mid )
+    assert_equal( 4, b.mid )
+    assert_equal( 4, a.mid(1) )
+    assert_equal( 5, b.mid(1) )
+    assert_equal( 6, b.mid(2) )
+    assert_equal( 3, b.mid(-1) )
+  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( [3,4], b.middle )
+  end
+
+  # pick
+
+  def test_pick
+    a = ['a','b','c']
+    assert_equal( 3, a.pick(3).length )
+    assert_equal( 3, a.length )
+    a = ['a','b','c']
+    assert_equal( 3, a.pick(4).length )
+    assert_equal( 3, a.length )
+  end
+
+  # pick!
+
+  def test_pick
+    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
+
+  # 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
+
+  # rand_index
+
+  def test_rand_index
+    10.times {
+      i = [1,2,3].rand_index
+      assert( 0..2.include?(i) )
+    }
+  end
+
+  # rand_subset
+
+  def test_rand_index
+    10.times {
+      a = [1,2,3,4].rand_subset
+      assert( a.size <= 4 )
+    }
+  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
+
+  # rotate
+
+  def test_rotate
+    a = [1,2,3]
+    assert_equal( [3,1,2], a.rotate, 'clockwise' )
+    assert_equal( [2,3,1], a.rotate(-1), 'counter-clockwise' )
+  end
+
+  # rotate!
+
+  def test_rotate!
+    a = [1,2,3]
+    a.rotate!
+    assert_equal( [3,1,2], a, 'clockwise' )
+    a.rotate!(-1)
+    assert_equal( [1,2,3], a, 'counter-clockwise' )
+  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]
+    b = a.shuffle
+    assert_equal( a, b.sort )
+  end
+
+  # shuffle!
+
+  def test_shuffle
+    a = [1,2,3,4,5]
+    b = a.dup
+    b.shuffle!
+    assert_equal( a, b.sort )
+  end
+
+  # slap
+
+  def test_slap
+    a = [2,3]
+    assert_equal( [1,2,3], a.slap(1) )
+    assert_equal( [4,1,2,3], a.slap(4) )
+  end
+
+  # tail
+
+  def test_tail
+    a = [1,2,3,4,5]
+    assert_equal( [2,3,4,5], a.tail )
+  end
+
+  # thru
+
+  def test_thru
+    assert_equal( [2,3,4], [0,1,2,3,4,5].thru(2,4) )
+    assert_equal( [0,1], [0,1,2,3,4,5].thru(0,1) )
+  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
+
+end

data/test/binding/tc_binding.rb

@@ -0,0 +1,108 @@
+
+require 'test/unit'
+
+require 'nano/binding/%5B%5D'
+require 'nano/binding/%5B%5D%3D'
+require 'nano/binding/called'
+require 'nano/binding/caller'
+require 'nano/binding/defined%3F'
+require 'nano/binding/eval'
+require 'nano/binding/local_variables'
+require 'nano/binding/method_name'
+require 'nano/binding/self'
+require 'nano/binding/__DIR__'
+require 'nano/binding/__FILE__'
+require 'nano/binding/__LINE__'
+
+
+class TC_Binding < Test::Unit::TestCase
+
+  def setup
+    a = 1
+    b = 2
+    x = "hello"
+    # the line number must be updated if it moves
+    @bind = binding; @this_line_no = 25
+  end
+
+  # []
+
+  def test_brackets
+    assert_equal( "hello", @bind["x"] )
+  end
+
+  # []=
+
+  def test_brackets_eq
+    assert_nothing_raised{ @bind["x"] = "goodbye" }
+    assert_equal( "goodbye", @bind["x"] )
+  end
+
+  # called
+
+  def test_called
+    assert_equal( :setup, @bind.called )
+  end
+
+  # caller
+
+  def test_caller
+    # how to test?
+    assert_nothing_raised{ @bind.caller }
+  end
+
+  # class (not really a test of Nano)
+
+  def test_class
+    assert_equal( TC_Binding, @bind.self.class )
+  end
+
+  # defined?
+
+  def test_defined?
+    assert( @bind.defined?("a") )
+  end
+
+  # eval
+
+  def test_eval
+    assert_equal( "hello", @bind.eval("x") )
+  end
+
+  # local variables
+
+  def test_local_variables
+    assert_equal( ["a","b","x"], @bind.local_variables )
+  end
+
+  # method_name
+
+  def test_method_name
+    assert_equal( 'setup', @bind.method_name )
+  end
+
+  # self
+
+  def test_self
+    assert_equal( self, @bind.self )
+  end
+
+  # __DIR__
+
+  def test___DIR__
+    assert_equal( File.dirname( @bind.__FILE__ ), @bind.__DIR__ )
+  end
+
+  # __FILE__
+
+  def test___FILE__
+    assert_equal( 'tc_binding.rb', File.basename( @bind.__FILE__ ) )
+  end
+
+  # __LINE__
+
+  def test___LINE__
+    assert_equal( @this_line_no, @bind.__LINE__ )
+  end
+
+end

data/test/binding/tc_binding_call_stack.rb

@@ -0,0 +1,12 @@
+
+require 'test/unit'
+require 'nano/binding/call_stack'
+
+class TC_BindingCallStack < Test::Unit::TestCase
+
+  def test_call_stack
+    # how to test?
+    assert_nothing_raised { call_stack }
+  end
+
+end

data/test/binding/tc_binding_of_caller.rb

@@ -0,0 +1,20 @@
+
+require 'test/unit'
+require 'nano/binding/of_caller'
+
+class TC_Binding < Test::Unit::TestCase
+
+  def inc_counter(amount = 1)
+    Binding.of_caller do |binding|
+      inc = eval("lambda { |arg| counter += arg }", binding)
+      inc.call(amount)
+    end
+  end
+
+  def test_of_caller
+    counter = 0
+    2.times { inc_counter }
+    assert_equal( 2, counter )
+  end
+
+end