ruby-internal 0.8.2 → 0.8.3

data/test/test_as_expression.rb

@@ -1,229 +0,0 @@
-require 'test/unit'
-require 'timeout'
-
-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/node/as_expression'
-require 'internal/method/as_expression'
-require 'internal/proc/as_expression'
-
-require 'expression_samples'
-
-$stdout.sync = true
-$stderr.sync = true
-
-class TC_As_Expression < Test::Unit::TestCase
-  extend Test::Unit::Assertions
-
-  # Some of the samples use this
-  def foo(*a, &b)
-    return b.call(1, 2) if b
-    return a
-  end
-
-  EXPRESSION_SAMPLES.each do |name, code|
-    p = proc {
-      p_orig = eval("proc { #{code} }")
-      code_new = p_orig.body.as_expression
-      # p code, code_new
-      p_new = eval("proc { #{code_new} }")
-      result_orig = result_new = nil
-      exc_orig = exc_new = nil
-      timeout(1) { begin; result_orig = p_orig.call; rescue; exc_orig = $!; end }
-      timeout(1) { begin; result_new = p_new.call; rescue; exc_new = $!; end }
-      assert_equal(result_orig, result_new)
-      assert_equal(exc_orig.class, exc_new.class)
-      if exc_orig and exc_new then
-        assert_equal(exc_orig.message, exc_new.message)
-      end
-    }
-    define_method "test_#{name}", p
-  end
-
-  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
-
-  def method_no_args
-    42
-  end
-
-  def test_method_no_args_as_expression
-    m = method(:method_no_args)
-    assert_equal 'def method_no_args(); 42; end', m.as_expression
-  end
-
-  def method_one_arg(a)
-    42
-  end
-
-  def test_method_one_arg_as_expression
-    m = method(:method_one_arg)
-    assert_equal 'def method_one_arg(a); 42; end', m.as_expression
-  end
-
-  def method_two_args(a, b)
-    42
-  end
-
-  def test_method_two_args_as_expression
-    m = method(:method_two_args)
-    assert_equal 'def method_two_args(a, b); 42; end', m.as_expression
-  end
-
-  def method_rest_arg(*rest)
-    42
-  end
-
-  def test_method_rest_arg_as_expression
-    m = method(:method_rest_arg)
-    assert_equal 'def method_rest_arg(*rest); 42; end', m.as_expression
-  end
-
-  def method_block_arg(&block)
-    42
-  end
-
-  def test_method_block_arg_as_expression
-    m = method(:method_block_arg)
-    assert_equal 'def method_block_arg(&block); 42; end', m.as_expression
-  end
-
-  def method_rest_and_block_arg(*rest, &block)
-    42
-  end
-
-  def test_method_rest_and_block_arg_as_expression
-    m = method(:method_rest_and_block_arg)
-    assert_equal 'def method_rest_and_block_arg(*rest, &block); 42; end', m.as_expression
-  end
-
-  def method_two_args_and_rest_and_block_arg(a, b, *rest, &block)
-    42
-  end
-
-  def test_method_two_args_and_rest_and_block_arg_as_expression
-    m = method(:method_two_args_and_rest_and_block_arg)
-    assert_equal 'def method_two_args_and_rest_and_block_arg(a, b, *rest, &block); 42; end', m.as_expression
-  end
-
-  def method_two_default_args(a = 1, b = 2)
-    42
-  end
-
-  def test_method_two_default_args_as_expression
-    m = method(:method_two_default_args)
-    assert_equal('def method_two_default_args(a=1, b=2); 42; end', m.as_expression)
-  end
-
-  def method_with_body(a, b)
-    a + b
-  end
-
-  def test_method_with_body_as_expression
-    m = method(:method_with_body)
-    assert_equal 'def method_with_body(a, b); a + b; end', m.as_expression
-  end
-
-  def test_proc_no_args_as_expression
-    p = proc { }
-    assert_equal 'proc { }', p.as_expression
-  end
-
-  def test_proc_empty_args_as_expression
-    if not defined?(RubyVM) then
-      # indistinguishable from proc { } on YARV
-      p = proc { || }
-      assert_equal 'proc { || }', p.as_expression
-    end
-  end
-
-  def test_proc_one_arg_as_expression
-    p = proc { |a| }
-    assert_equal 'proc { |a| }', p.as_expression
-  end
-
-  def test_proc_one_array_arg_as_expression
-    p = proc { |a,| }
-    assert_equal 'proc { |a,| }', p.as_expression
-  end
-
-  def test_proc_two_args_as_expression
-    p = proc { |a, b| }
-    assert_equal 'proc { |a, b| }', p.as_expression
-  end
-
-  def test_proc_rest_arg_as_expression
-    p = proc { |*rest| }
-    assert_equal 'proc { |*rest| }', p.as_expression
-  end
-
-  def test_proc_two_args_and_rest_arg_as_expression
-    p = proc { |a, b, *rest| }
-    assert_equal 'proc { |a, b, *rest| }', p.as_expression
-  end
-
-  def test_proc_with_body_as_expression
-    p = proc { |a, b| a + b }
-    assert_equal 'proc { |a, b| a + b }', p.as_expression
-  end
-
-  def setup
-    @foo = 42
-  end
-
-  # 1.7 and later
-  def foo(*args)
-    return args
-  end
-
-  def remove_foo
-    self.class.remove_foo
-  end
-
-  # 1.6
-  def self.foo(*args)
-    return args
-  end
-
-  def self.remove_foo
-    self.class_eval { remove_const(:FOO) if const_defined?(:FOO) }
-  end
-
-  @@foo = 10
-
-  FOO = 57
-
-  class ObjectWithFooAccessor
-    attr_accessor :foo
-  end
-
-  OWFA = ObjectWithFooAccessor.new
-end
-
-if __FILE__ == $0 then
-  require 'test/unit/ui/console/testrunner'
-
-  if Test::Unit.const_defined?(:AutoRunner) then
-    exit Test::Unit::AutoRunner.run
-  else
-    if ARGV.empty? then
-      suite = TC_As_Expression.suite
-    else
-      suite = Test::Unit::TestSuite.new('TC_As_Expression')
-      TC_As_Expression.suite.tests.each do |test|
-        ARGV.each do |arg|
-          suite << test if /#{arg}/ =~ test.name
-        end
-      end
-    end
-    result = Test::Unit::UI::Console::TestRunner.run(suite)
-    exit(result.error_count + result.failure_count)
-  end
-end
-

data/test/test_methodsig.rb

@@ -1,267 +0,0 @@
-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
-