ruby-internal 0.6.0

data/test/test_dump_proc.rb

@@ -0,0 +1,118 @@
+require 'test/unit'
+require 'rbconfig'
+
+dir = File.dirname(__FILE__)
+$:.unshift(dir) if not $:.include?(dir)
+$:.unshift("#{dir}/../lib") if not $:.include?("#{dir}/../lib")
+$:.unshift("#{dir}/../ext") if not $:.include?("#{dir}/../ext")
+
+require 'internal/proc'
+
+require 'node_samples'
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_Dump_Proc < Test::Unit::TestCase
+  module Foo
+    def foo(n=1)
+      # A fancy way to return 42
+      if false then
+        answer = 0
+      else
+        answer = 0
+        (1..42).each do |i|
+          answer += (i / i)
+        end
+      end
+      return n * answer
+    end
+  end
+
+  include Foo
+
+  Tmp_Foo = nil
+
+  # For the cvar proc test
+  @@a = 42
+
+  class TestClassBase
+    # for testing super()
+    def foo
+      return 42
+    end
+  end
+
+  class TestClass < TestClassBase
+    include Foo
+    FOO = 1
+    @foo = 2
+    @@foo = 3
+
+    # Make sure we have enough instance variables to exceed
+    # ROBJECT_EMBED_LEN_MAX
+    @bar1 = 1
+    @bar2 = 2
+    @bar3 = 3
+
+    class << self
+      FOO = 4
+      @foo = 5
+    end
+
+    # for testing cvar
+    # (can't be in base class due to change in 1.9 of class var lookup)
+    @@a = 42
+  end
+
+  @@test_class = TestClass
+
+  def initialize(test_method_name)
+    # TODO: This seems to be the only way to get tests defined with #
+    # define_method to run on 1.8.1 and earlier.
+    catch(:invalid_test) { super(test_method_name) }
+  end
+
+  extend Test::Unit::Assertions
+
+  Proc_Node_Samples.each do |node_name, sample_code|
+    p = proc {
+      p_orig = eval <<-END_DEF
+        proc {
+          #{sample_code}
+        }
+      END_DEF
+
+      #puts "dumping"
+      d = Marshal.dump(p_orig)
+      #puts "loading"
+      u = Marshal.load(d)
+      p_new = u.bind(binding)
+
+      orig_result = nil
+      orig_exc = nil
+      begin
+        orig_result = p_orig.call
+      rescue Exception => exc
+        orig_exc = exc
+      end
+
+      dup_result = nil
+      dup_exc = nil
+      begin
+        dup_result = p_new.call
+      rescue Exception => exc
+        dup_exc = exc
+      end
+
+      assert_equal orig_exc, dup_exc
+      assert_equal orig_result, dup_result
+    }
+    define_method "test_dump_proc_#{node_name}", p
+  end
+end
+
+if __FILE__ == $0 then
+  exit Test::Unit::AutoRunner.run
+end
+

data/test/test_helpers.rb

@@ -0,0 +1,61 @@
+$mini_unit_exit_code = 0
+
+def disable_mini_unit_auto_run
+  MiniTest::Unit.class_eval do
+    alias :run_ :run
+    def run(*args)
+      return $mini_unit_exit_code
+    end
+  end
+end
+
+def run_all_tests_with_mini_unit
+  begin
+    test = MiniTest::Unit.new
+    args = ARGV.dup
+    args << '-v'
+    $mini_unit_exit_code = test.run(args)
+    exit($mini_unit_exit_code)
+  ensure
+    disable_mini_unit_auto_run
+  end
+end
+
+def run_all_tests_with_test_unit
+  tests = []
+  ObjectSpace.each_object(Class) do |o|
+    if o < Test::Unit::TestCase then
+      tests << o
+    end
+  end
+
+  suite = Test::Unit::TestSuite.new("RubyInternal")
+  tests.each do |test|
+    test.suite.tests.each do |testcase|
+      suite << testcase
+    end
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  verbose = nil
+  begin
+    verbose = Test::Unit::UI.const_get(:VERBOSE)
+  rescue NameError
+    verbose = Test::Unit::UI::Console::TestRunner.const_get(:VERBOSE)
+  end
+
+  result = Test::Unit::UI::Console::TestRunner.run(
+      suite,
+      verbose)
+  exit(result.error_count + result.failure_count)
+end
+
+def run_all_tests
+  if defined?(MiniTest) then
+    run_all_tests_with_mini_unit
+  else
+    run_all_tests_with_test_unit
+  end
+end
+

data/test/test_method.rb

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'rbconfig'
+
+dir = File.dirname(__FILE__)
+$:.unshift(dir) if not $:.include?(dir)
+$:.unshift("#{dir}/../lib") if not $:.include?("#{dir}/../lib")
+$:.unshift("#{dir}/../ext") if not $:.include?("#{dir}/../ext")
+
+require 'internal/method'
+
+require "node_samples"
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_Method < Test::Unit::TestCase
+  module Foo
+    def foo(n=1)
+      # A fancy way to return 42
+      if false then
+        answer = 0
+      else
+        answer = 0
+        (1..42).each do |i|
+          answer += (i / i)
+        end
+      end
+      return n * answer
+    end
+  end
+
+  class MarshalMethodHelper
+    include Foo
+  end
+
+  include Foo
+
+  def test_method_node
+    m = method(:foo)
+    n = m.body
+    if defined?(RubyVM::InstructionSequence) then
+      # YARV
+      assert_equal Node::METHOD, n.class
+    else
+      # pre-YARV
+      assert_equal Node::SCOPE, n.class
+    end
+  end
+
+  def test_marshal_method
+    o = MarshalMethodHelper.new
+    m = o.method(:foo)
+    d = Marshal.dump(m)
+    m2 = Marshal.load(d)
+    assert_equal m.call, m2.call
+  end
+
+  def test_marshal_unbound_method
+    o = MarshalMethodHelper.new
+    u = o.method(:foo).unbind
+    d = Marshal.dump(u)
+    u2 = Marshal.load(d)
+    m = u.bind(o)
+    m2 = u.bind(o)
+    assert_equal m.call, m2.call
+  end
+end
+
+if __FILE__ == $0 then
+  exit Test::Unit::AutoRunner.run
+end
+

data/test/test_methodsig.rb

@@ -0,0 +1,267 @@
+require 'test/unit'
+
+dir = File.dirname(__FILE__)
+$:.unshift(dir) if not $:.include?(dir)
+$:.unshift("#{dir}/../lib") if not $:.include?("#{dir}/../lib")
+$:.unshift("#{dir}/../ext") if not $:.include?("#{dir}/../ext")
+
+require 'internal/method/signature'
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_Methodsig < Test::Unit::TestCase
+  def check_args(expected_arg_info, sig)
+    expected_arg_info.each do |name, value|
+      assert_equal name, sig.args[name].name
+      assert_equal value, sig.args[name].to_s
+      if value =~ /=/ then
+        default = value.sub(/.*=/, '')
+        assert_equal default, sig.args[name].default
+        assert_equal true, sig.args[name].optional?
+        assert_equal false, sig.args[name].required?
+        assert_equal false, sig.args[name].rest?
+        assert_equal false, sig.args[name].block?
+      elsif ?* == value[0] then
+        assert_equal nil, sig.args[name].default
+        assert_equal true, sig.args[name].optional?
+        assert_equal false, sig.args[name].required?
+        assert_equal true, sig.args[name].rest?
+        assert_equal false, sig.args[name].block?
+      elsif ?& == value[0] then
+        assert_equal nil, sig.args[name].default
+        assert_equal true, sig.args[name].optional?
+        assert_equal false, sig.args[name].required?
+        assert_equal false, sig.args[name].rest?
+        assert_equal true, sig.args[name].block?
+      else
+        assert_equal nil, sig.args[name].default
+        assert_equal false, sig.args[name].optional?
+        assert_equal true, sig.args[name].required?
+        assert_equal false, sig.args[name].rest?
+        assert_equal false, sig.args[name].block?
+      end
+    end
+    assert_equal expected_arg_info.size, sig.args.size
+  end
+
+  def no_args_no_parens
+  end
+
+  def test_no_args_no_parens
+    name = :no_args_no_parens
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [], sig.arg_names
+    check_args({}, sig)
+    assert_equal "#{self.class.name}##{name}()", sig.to_s
+  end
+
+  def no_args_with_parens()
+  end
+
+  def test_no_args_with_parens
+    name = :no_args_with_parens
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [], sig.arg_names
+    check_args({}, sig)
+    assert_equal "#{self.class.name}##{name}()", sig.to_s
+  end
+
+  def one_arg(a)
+  end
+
+  def test_one_arg
+    name = :one_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a], sig.arg_names
+    check_args({:a => "a"}, sig)
+    assert_equal "#{self.class.name}##{name}(a)", sig.to_s
+  end
+
+  def two_args(a, b)
+  end
+
+  def test_two_args
+    name = :two_args
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b], sig.arg_names
+    check_args({:a=>"a", :b=>"b"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b)", sig.to_s
+  end
+
+  def two_args_with_locals(a, b)
+    x = 1
+    y = 2
+  end
+
+  def test_two_args_with_locals
+    name = :two_args_with_locals
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b], sig.arg_names
+    check_args({:a=>"a", :b=>"b"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b)", sig.to_s
+  end
+
+  def three_args(a, b, c)
+  end
+
+  def test_three_args
+    name = :three_args
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b, :c], sig.arg_names
+    check_args({:a=>"a", :b=>"b", :c=>"c"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b, c)", sig.to_s
+  end
+
+  def block_arg(&b)
+  end
+
+  def test_block_arg
+    name = :block_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:b], sig.arg_names
+    check_args({:b=>"&b"}, sig)
+    assert_equal "#{self.class.name}##{name}(&b)", sig.to_s
+  end
+
+  def rest_arg(*r)
+  end
+
+  def test_rest_arg
+    name = :rest_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:r], sig.arg_names
+    check_args({:r=>"*r"}, sig)
+    assert_equal "#{self.class.name}##{name}(*r)", sig.to_s
+  end
+
+  def block_and_rest_arg(*r, &b)
+  end
+
+  def test_block_and_rest_arg
+    name = :block_and_rest_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:r, :b], sig.arg_names
+    check_args({:r=>"*r", :b=>"&b"}, sig)
+    assert_equal "#{self.class.name}##{name}(*r, &b)", sig.to_s
+  end
+
+  def default_arg(a = 1)
+  end
+
+  def test_default_arg
+    name = :default_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a], sig.arg_names
+    check_args({:a=>"a=1"}, sig)
+    assert_equal "#{self.class.name}##{name}(a=1)", sig.to_s
+  end
+
+  def default_and_nondefault_arg(a, b = 42)
+  end
+
+  def test_default_and_nondefault_arg
+    name = :default_and_nondefault_arg
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b], sig.arg_names
+    check_args({:a=>"a", :b=>"b=42"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b=42)", sig.to_s
+  end
+
+  def default_and_rest(a = 42, *r)
+  end
+
+  def test_default_and_rest
+    name = :default_and_rest
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :r], sig.arg_names
+    check_args({:a=>"a=42", :r=>"*r"}, sig)
+    assert_equal "#{self.class.name}##{name}(a=42, *r)", sig.to_s
+  end
+
+  def default_and_rest_and_block(a = 42, *r, &b)
+  end
+
+  def test_default_and_rest_and_block
+    name = :default_and_rest_and_block
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :r, :b], sig.arg_names
+    check_args({:a=>"a=42", :r=>"*r", :b=>"&b"}, sig)
+    assert_equal "#{self.class.name}##{name}(a=42, *r, &b)", sig.to_s
+  end
+
+  def nondefault_and_default_and_rest_and_block(a, b = 42, *r, &block)
+  end
+
+  def test_nondefault_and_default_and_rest_and_block
+    name = :nondefault_and_default_and_rest_and_block
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b, :r, :block], sig.arg_names
+    check_args({:a=>"a", :b=>"b=42", :r=>"*r", :block=>"&block"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b=42, *r, &block)", sig.to_s
+  end
+
+  def nondefault_and_default_and_rest_and_block_with_locals(a, b = 42, *r, &block)
+    x = 1
+    y = 2
+  end
+
+  def test_nondefault_and_default_and_rest_and_block_with_locals
+    name = :nondefault_and_default_and_rest_and_block_with_locals
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b, :r, :block], sig.arg_names
+    check_args({:a=>"a", :b=>"b=42", :r=>"*r", :block=>"&block"}, sig)
+    assert_equal "#{self.class.name}##{name}(a, b=42, *r, &block)", sig.to_s
+  end
+
+  def three_default_and_rest_and_block_with_locals(a = 42, b = 43, c = 44, *r, &block)
+    x = 1
+    y = 2
+  end
+
+  def test_three_default_and_rest_and_block_with_locals
+    name = :three_default_and_rest_and_block_with_locals
+    sig = method(name).signature
+    assert_equal self.class, sig.origin_class
+    assert_equal name.to_s, sig.name
+    assert_equal [:a, :b, :c, :r, :block], sig.arg_names
+    check_args({:a=>"a=42", :b=>"b=43", :c=>"c=44", :r=>"*r", :block=>"&block"}, sig)
+    assert_equal "#{self.class.name}##{name}(a=42, b=43, c=44, *r, &block)", sig.to_s
+  end
+end
+
+if __FILE__ == $0 then
+  require 'test_helpers'
+  run_all_tests()
+end
+