nano 0.8.1

data/test/module/tc_instance_methods.rb

@@ -0,0 +1,45 @@
+
+require 'test/unit'
+
+# fixture
+
+class O
+  def a ; end
+end
+
+# get a hold of the original definition _before require_
+$imF = Module.instance_method( :instance_methods )
+
+require 'nano/module/instance_methods'
+
+class TC_Methods < Test::Unit::TestCase
+
+  def test_instance_methods
+    assert_equal( $imF.bind(O).call.sort, O.instance_methods )
+  end
+
+  def test_instance_methods_true
+    assert_equal( $imF.bind(O).call(true).sort, O.instance_methods(true) )
+  end
+
+  def test_public_instance_methods
+    assert_equal( O.public_instance_methods.sort, O.instance_methods )
+  end
+
+  def test_private_instance_methods
+    assert_equal( O.private_instance_methods.sort, O.instance_methods(:private) )
+  end
+
+  def test_protected_instance_methods
+    assert_equal( O.protected_instance_methods.sort, O.instance_methods(:protected) )
+  end
+
+  def test_local_instance_methods
+    assert_equal( ["a"], O.instance_methods(:local) )
+  end
+
+  def test_instance_method_local_and_ancestors
+    assert_equal( $imF.bind(O).call(true).sort, O.instance_methods(:local, :ancestors) )
+  end
+
+end

data/test/module/tc_memoize.rb

@@ -0,0 +1,38 @@
+
+require 'test/unit'
+
+require 'nano/module/memoize'
+
+# fixture
+
+class T
+  def initialize(a)
+    @a = a
+  end
+  def a
+    "#{@a ^ 3 + 4}"
+  end
+  memoize :a
+end
+
+# test
+
+class TC_Memoize < Test::Unit::TestCase
+
+  def setup
+    @t = T.new(2)
+  end
+
+  def test_memoize_01
+    assert_equal( @t.a, @t.a )
+  end
+
+  def test_memoize_02
+    assert_equal( @t.a.__id__, @t.a.__id__ )
+  end
+
+  def test_memoize_03
+    assert_equal( @t.a.__id__, @t.a.__id__ )
+  end
+
+end

data/test/module/tc_module.rb

@@ -0,0 +1,349 @@
+
+require 'test/unit'
+
+require 'nano/module/alias_module_function'
+#require 'nano/module/attr_accessor'
+#require 'nano/module/attr_checker'
+#require 'nano/module/attr_key'
+#require 'nano/module/attr'
+#require 'nano/module/attr_reader'
+#require 'nano/module/attr_setter'
+#require 'nano/module/attr_sort'
+#require 'nano/module/attr_writer'
+require 'nano/module/basename'
+require 'nano/module/by_name'
+#require 'nano/module/cattr'
+require 'nano/module/cattr_accessor'
+#require 'nano/module/cattr_tester'
+require 'nano/module/cattr_reader'
+#require 'nano/module/cattr_setter'
+require 'nano/module/cattr_writer'
+#require 'nano/module/clone_removing'
+#require 'nano/module/clone_renaming'
+#require 'nano/module/clone_using'
+require 'nano/module/dirname'
+require 'nano/module/equate_on'
+require 'nano/module/generate_instance_method_name'
+require 'nano/module/include_as'
+require 'nano/module/initializer'
+require 'nano/module/integrate'
+#require 'nano/module/memoize'
+require 'nano/module/modspace'
+require 'nano/module/namespace'
+require 'nano/module/redefine_method'
+require 'nano/module/redef'
+require 'nano/module/redirect'
+require 'nano/module/remove'
+require 'nano/module/rename_method'
+require 'nano/module/rename'
+require 'nano/module/sort_on'
+require 'nano/module/undef'
+require 'nano/module/wrap_method'
+require 'nano/module/wrap'
+
+
+module MockModule
+
+  # for alias_module_method
+
+  def x ; 33 ; end
+  module_function :x
+  alias_module_function :y, :x
+
+  # for integrate
+
+  def mm ; 77 ; end
+
+end
+
+module MockModule2
+
+  # for remove
+
+  def the_removed_method ; 'here' ; end
+
+  # for undef
+
+  def the_undefined_method ; 'here' ; end
+
+end
+
+class MockObject
+
+  include MockModule2
+
+  # for cattr
+
+  def initialize
+    @@a = 10
+  end
+
+  def b ; @@b ; end
+
+  # for include_as
+
+  include_as :include_as_mod => MockModule
+
+  # for integrate
+
+  integrate MockModule do
+    rename :mi, :mm
+  end
+
+  # for namespace
+
+  namespace(:hope) {
+    def watch ; 'watch' ; end
+  }
+
+  # for redirect
+
+  def red1 ; 1 ; end
+  redirect :red2 => :red1
+
+  # for redefine_method / redef
+
+  def fixture_method_a; "a"; end
+  def fixture_method_b; "b"; end
+
+  redefine_method( :fixture_method_a ) { nil }  
+  redef( :fixture_method_b ) { "x" }
+
+  # for remove
+
+  def the_removed_method ; 'not here' ; end
+  remove :the_removed_method
+
+  # for rename_method / rename
+
+  def toot; 55 ; end
+  def soos; 66 ; end
+  rename_method :tweet, :toot
+  rename :sweet, :soos
+
+  # for undef
+
+  def the_undefined_method ; 'not here' ; end
+  undef :the_undefined_method
+
+  # for wrap_method / wrap
+
+  def fixture_method_c; "c"; end
+  def fixture_method_d; "d"; end
+
+  wrap_method( :fixture_method_c ) { |old| old.call }
+  wrap( :fixture_method_d ) { |old| old.call + "e" }
+
+end
+
+
+# test
+
+class TC_Module < Test::Unit::TestCase
+
+  def setup
+    @m = MockObject.new
+  end
+
+  # alias_module_function
+
+  def test_alias_module_function
+    assert_equal( 33, MockModule.y )
+    #assert_equal( 33, @m.send(:y) )  # use send b/c private
+  end
+
+  # basename
+
+  def test_basename
+    assert_equal( "TestCase", ::Test::Unit::TestCase.basename )
+  end
+
+  # by_name
+
+  def test_by_name
+    c = ::Test::Unit::TestCase.name
+    assert_equal( ::Test::Unit::TestCase, Module.by_name(c) )
+    c = "Test::Unit::TestCase"
+    assert_equal( ::Test::Unit::TestCase, Class.by_name(c) )
+  end
+
+  # cattr_reader
+
+  def test_cattr_reader
+    assert_nothing_raised {
+      MockObject.class_eval { cattr_reader :a }
+    }
+    t = MockObject.new
+    assert_equal( 10, t.a )
+  end
+
+  # cattr_writer
+
+  def test_cattr_writer
+    assert_nothing_raised {
+      MockObject.class_eval { cattr_writer :b }
+    }
+    t = MockObject.new
+    t.b = 5
+    assert_equal( 5, t.b )
+  end
+
+  # cattr_accessor
+
+  def test_cattr_accessor
+    assert_nothing_raised {
+      MockObject.class_eval { cattr_accessor :c }
+    }
+    t = MockObject.new
+    t.c = 50
+    assert_equal( 50, t.c )
+  end
+
+  # dirname
+
+  def test_dirname
+    assert_equal( 'Test::Unit', ::Test::Unit::TestCase.dirname )
+  end
+
+  # equate_on
+
+  def test_equate_on
+    c = Class.new
+    c.class_eval { attr_accessor :a, :b ; equate_on :a,:b }
+    c1,c2 = c.new,c.new
+    c1.a = 10; c1.b = 20
+    c2.a = 10; c2.b = 20
+    assert_equal( c1, c2 )
+    c1.a = 10; c1.b = 10
+    c2.a = 10; c2.b = 20
+    assert_not_equal( c1, c2 )
+    c1.a = 10; c1.b = 20
+    c2.a = 20; c2.b = 20
+    assert_not_equal( c1, c2 )
+  end
+
+  # generate_instance_method_name
+
+  def test_generate_instance_method_name
+    assert_nothing_raised { MockObject.generate_instance_method_name(:b) }
+  end
+
+  # include_as
+
+  def test_include_as
+    assert_equal( 77, @m.include_as_mod.mm )
+  end
+
+  # initializer
+
+  def test_attr_initializer
+    cc = Class.new
+    cc.class_eval {
+      initializer :ai
+      attr_reader :ai
+    }
+    c = cc.new(10)
+    assert_equal( 10, c.ai )
+  end
+
+  # integrate
+
+  def test_integrate
+    assert_equal( 77, @m.mi )
+  end
+
+  # modspace
+
+  def test_modspace
+    assert_equal( Test::Unit, Test::Unit::TestCase.modspace )
+    assert_equal( ::Test::Unit, ::Test::Unit::TestCase.modspace )
+  end
+
+  # namespace
+
+  def test_namespace
+    assert_equal( 'watch', @m.hope.watch )
+  end
+
+  # redefine_method
+
+  def test_redefine_method
+    assert_equal( "a", @m.fixture_method_a )
+  end
+
+  # redef
+
+  def test_redefine_method
+    assert_equal( "x", @m.fixture_method_b )
+  end
+
+  # redirect
+
+  def test_redirect
+    t = MockObject.new
+    assert_equal( 1, t.red2 )
+  end
+
+  # remove
+
+  def test_remove
+    assert_equal( 'here', @m.the_removed_method )
+  end
+
+  # rename_method
+
+  def test_rename_method
+    assert( ! @m.respond_to?( :toot ) )
+    assert(   @m.respond_to?( :tweet ) )
+  end
+
+  # rename
+
+  def test_rename
+    assert( ! @m.respond_to?( :soos ) )
+    assert(   @m.respond_to?( :sweet ) )
+  end
+
+  # sort_on
+
+  def test_sort_on
+    c = Class.new
+    c.class_eval {
+      def initialize(a,b)
+        @a=a; @b=b
+      end
+      sort_on :a,:b
+    }
+    a = [c.new(10,20),c.new(10,30)]
+    assert_equal( a, a.sort )
+    a = [c.new(10,30),c.new(10,20)]
+    assert_equal( a.reverse, a.sort )
+    a = [c.new(10,10),c.new(20,10)]
+    assert_equal( a, a.sort )
+    a = [c.new(20,10),c.new(10,10)]
+    assert_equal( a.reverse, a.sort )
+    a = [c.new(10,30),c.new(20,10)]
+    assert_equal( a, a.sort )
+  end
+
+  # undef
+
+  def test_undef
+    assert( ! respond_to?( :the_undefined_method ) )
+  end
+
+  # wrap_method
+
+  def test_wrap_method
+    assert_equal( "c", @m.fixture_method_c )
+  end
+
+  # wrap
+
+  def test_wrap
+    assert_equal( "de", @m.fixture_method_d )
+  end
+
+end
+
+

data/test/nilclass/tc_method_missing.rb

@@ -0,0 +1,12 @@
+
+require 'test/unit'
+
+require 'nano/nilclass/method_missing.rb'
+
+class TC_NilClass < Test::Unit::TestCase
+
+  def test_method_missing
+    assert_equal( nil, nil.anything_at_all )
+  end
+
+end

data/test/nilclass/tc_nilclass.rb

@@ -0,0 +1,59 @@
+
+require 'test/unit'
+
+require 'nano/nilclass/%5B%5D'
+require 'nano/nilclass/empty%3F'
+require 'nano/nilclass/include%3F'
+require 'nano/nilclass/length'
+require 'nano/nilclass/size'
+require 'nano/nilclass/to_f'
+require 'nano/nilclass/to_h'
+
+
+class TC_NilClass < Test::Unit::TestCase
+
+  # []
+
+  def test_brackets
+    assert_equal( nil, nil[] )
+    assert_equal( nil, nil[1] )
+    assert_equal( nil, nil[1,2,3] )
+  end
+
+  # empty?
+
+  def test_empty?
+    assert( nil.empty? )
+  end
+
+  # include?
+
+  def test_include?
+    assert_equal( nil, nil.include? )
+  end
+
+  # length
+
+  def test_length
+    assert_equal( 0, nil.length )
+  end
+
+  # size
+
+  def test_length
+    assert_equal( 0, nil.size )
+  end
+
+  # to_f
+
+  def test_to_f
+    assert_equal( 0.0, nil.to_f )
+  end
+
+  # to_h
+
+  def test_to_h
+    assert_equal( {}, nil.to_h )
+  end
+
+end