ruby-internal 0.6.0

data/test/test_as_expression.rb

@@ -0,0 +1,229 @@
+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_dump_class.rb

@@ -0,0 +1,187 @@
+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/module'
+require 'internal/object'
+
+$stdout.sync = true
+$stderr.sync = true
+
+# Instance methods defined in Class get returned by
+# rb_class_instance_methods, though they are not in the class's method
+# table.  Having this here ensures that we don't accidentally try to
+# dump methods that aren't in the class we are trying to dump.
+class Class
+  def xyzzy
+  end
+end
+
+class TC_Dump_Class < 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
+
+  Tmp_Foo = nil
+
+  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 setup
+    self.class.instance_eval do
+      remove_const :TestClass if defined?(TestClass)
+      const_set :TestClass, @@test_class
+    end
+  end
+
+  def test_marshal_class
+    begin
+      assert_equal 5, TestClass.singleton_class.instance_eval('@foo')
+      assert_equal 2, TestClass.instance_eval('@foo')
+
+      d = Marshal.dump(TestClass)
+
+      # Thread critical should have been reset by the class restorer
+      if not defined?(RubyVM) then
+        assert_equal false, Thread.critical
+      end
+
+      # Make sure the class instance variables are still set
+      assert_equal 5, TestClass.singleton_class.instance_eval('@foo')
+      assert_equal 2, TestClass.instance_eval('@foo')
+
+      orig_test_class = TestClass
+      orig_test_class_iv = TestClass.instance_variables
+      self.class.instance_eval { remove_const :TestClass }
+
+      c = Marshal.load(d)
+      assert_equal(TestClass, c)
+      assert_not_equal(orig_test_class, c)
+      assert_equal Class, c.class
+
+      a = c.ancestors
+      assert a.include?(Object)
+      assert a.include?(Kernel)
+      assert a.include?(Foo)
+      assert a.include?(c)
+
+      # Class instance variables
+      assert_equal orig_test_class_iv.sort, c.instance_variables.sort
+      result = c.instance_eval do
+        @foo
+      end
+      assert_equal 2, result
+
+      # Constant lookup (constants are really just special instance
+      # variables)
+      assert_equal 1, c::FOO
+
+      # Constant lookup in singleton class
+      result = class << c
+        FOO
+      end
+      assert_equal 4, result
+
+      # Singleton class instance variable lookup
+      result = class << c
+        @foo
+      end
+      assert_equal 5, result
+
+      # Class variable lookup
+      # This is a little bit messy, but it was the only way I could figure
+      # to get at @@foo
+      self.class.instance_eval do
+        remove_const :Tmp_Foo
+        const_set :Tmp_Foo, c
+      end
+      eval "class Tmp_Foo; $at_at_foo = @@foo; end"
+      result = $at_at_foo
+      assert_equal 3, result
+
+      # Test method call
+      f = c.new
+      assert_equal 42, f.foo()
+      assert_equal 42*42, f.foo(42)
+
+      # Thread critical should have been reset by the class restorer
+      if not defined?(RubyVM) then
+        assert_equal false, Thread.critical
+      end
+
+      # Also make sure the class instance variables are still set
+      assert_equal 5, TestClass.singleton_class.instance_eval('@foo')
+      assert_equal 2, TestClass.instance_eval('@foo')
+
+    ensure
+      if not defined?(RubyVM) then
+        Thread.critical = false
+      end
+    end
+  end
+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_Dump_Class.suite
+    else
+      suite = Test::Unit::TestSuite.new('TC_Dump_Class')
+      TC_Dump_Class.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_dump_method.rb

@@ -0,0 +1,144 @@
+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 'internal/noex'
+require 'internal/module'
+
+require 'node_samples'
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_Dump_Module < 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
+
+  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
+
+  Method_Node_Samples.each do |node_name, sample_code|
+    p = proc {
+      c = TestClass.dup
+      c.class_eval <<-END_DEF
+        def foo
+          #{sample_code}
+        end
+      END_DEF
+      TC_Dump_Module.const_set("TestClass__#{node_name}", c)
+
+      o = c.new
+      m = o.method(:foo)
+      n = m.body
+      # puts "dumping first method"
+      # p sample_code
+      # pp o.method(:foo).body
+      d = Marshal.dump(n)
+      n2 = Marshal.load(d)
+
+      klass2 = Class.new(TestClassBase)
+      klass2.class_eval do
+        # for testing cvar
+        # (can't be in base class due to change in 1.9 of class var lookup)
+        @@a = 42
+        add_method(:foo, n2, Noex::PUBLIC)
+      end
+      obj1 = o
+      obj2 = klass2.new
+
+      orig_result = nil
+      orig_exc = nil
+      begin
+        orig_result = o.foo() { 17 }
+      rescue Exception => exc
+        orig_exc = exc
+      end
+
+      # puts "getting obj2 method"
+      # m = obj2.method(:foo)
+      # puts "getting obj2 method body"
+      # b = m.body
+      # puts "getting type"
+      # p b.class
+      # p b.members
+      # p b.rval
+      # p b.next
+      # p b.tbl
+      # puts "dumping second method"
+      # pp obj2.method(:foo).body
+      dup_result = nil
+      dup_exc = nil
+      begin
+        dup_result = obj2.foo() { 17 }
+      rescue Exception => exc
+        dup_exc = exc
+      end
+
+      assert_equal orig_exc, dup_exc
+      assert_equal orig_result, dup_result
+    }
+    define_method "test_dump_method_#{node_name}", p
+  end
+end
+
+if __FILE__ == $0 then
+  exit Test::Unit::AutoRunner.run
+end
+