Move spec/rubyspec to spec/ruby for consistency

* Other ruby implementations use the spec/ruby directory.
  [Misc #13792] [ruby-core:82287]

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@59979 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

spec/ruby/core/objectspace/_id2ref_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace._id2ref" do
+  it "converts an object id to a reference to the object" do
+    s = "I am a string"
+    r = ObjectSpace._id2ref(s.object_id)
+    r.should == s
+  end
+
+  it "retrieves a Fixnum by object_id" do
+    f = 1
+    r = ObjectSpace._id2ref(f.object_id)
+    r.should == f
+  end
+
+  it "retrieves a Symbol by object_id" do
+    s = :sym
+    r = ObjectSpace._id2ref(s.object_id)
+    r.should == s
+  end
+
+  it 'raises RangeError when an object could not be found' do
+    proc { ObjectSpace._id2ref(1 << 60) }.should raise_error(RangeError)
+  end
+end

spec/ruby/core/objectspace/add_finalizer_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.add_finalizer" do
+  it "needs to be reviewed for spec completeness"
+end

spec/ruby/core/objectspace/call_finalizer_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.call_finalizer" do
+  it "needs to be reviewed for spec completeness"
+end

spec/ruby/core/objectspace/count_objects_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.count_objects" do
+  it "needs to be reviewed for spec completeness"
+end

spec/ruby/core/objectspace/define_finalizer_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+# NOTE: A call to define_finalizer does not guarantee that the
+# passed proc or callable will be called at any particular time.
+# It is highly questionable whether these aspects of ObjectSpace
+# should be spec'd at all.
+describe "ObjectSpace.define_finalizer" do
+  it "raises an ArgumentError if the action does not respond to call" do
+    lambda {
+      ObjectSpace.define_finalizer("", mock("ObjectSpace.define_finalizer no #call"))
+    }.should raise_error(ArgumentError)
+  end
+
+  it "accepts an object and a proc" do
+    handler = lambda { |obj| obj }
+    ObjectSpace.define_finalizer("garbage", handler).should == [0, handler]
+  end
+
+  it "accepts an object and a callable" do
+    handler = mock("callable")
+    def handler.call(obj) end
+    ObjectSpace.define_finalizer("garbage", handler).should == [0, handler]
+  end
+
+  it "raises ArgumentError trying to define a finalizer on a non-reference" do
+    lambda {
+      ObjectSpace.define_finalizer(:blah) { 1 }
+    }.should raise_error(ArgumentError)
+  end
+
+  # see [ruby-core:24095]
+  with_feature :fork do
+    it "calls finalizer on process termination" do
+      rd, wr = IO.pipe
+      pid = Process.fork do
+        rd.close
+        handler = ObjectSpaceFixtures.scoped(wr)
+        obj = "Test"
+        ObjectSpace.define_finalizer(obj, handler)
+        exit 0
+      end
+
+      wr.close
+      begin
+        rd.read.should == "finalized"
+      ensure
+        rd.close
+        Process.wait pid
+      end
+    end
+
+    it "calls finalizer at exit even if it is self-referencing" do
+      rd, wr = IO.pipe
+      pid = Process.fork do
+        rd.close
+        obj = "Test"
+        handler = Proc.new { wr.write "finalized"; wr.close }
+        ObjectSpace.define_finalizer(obj, handler)
+        exit 0
+      end
+
+      wr.close
+      begin
+        rd.read.should == "finalized"
+      ensure
+        rd.close
+        Process.wait pid
+      end
+    end
+
+    # These specs are defined under the fork specs because there is no
+    # deterministic way to force finalizers to be run, except process exit, so
+    # we rely on that.
+    it "allows multiple finalizers with different 'callables' to be defined" do
+      rd1, wr1 = IO.pipe
+      rd2, wr2 = IO.pipe
+
+      pid = Kernel::fork do
+        rd1.close
+        rd2.close
+        obj = mock("ObjectSpace.define_finalizer multiple")
+
+        ObjectSpace.define_finalizer(obj, Proc.new { wr1.write "finalized1"; wr1.close })
+        ObjectSpace.define_finalizer(obj, Proc.new { wr2.write "finalized2"; wr2.close })
+
+        exit 0
+      end
+
+      wr1.close
+      wr2.close
+
+      rd1.read.should == "finalized1"
+      rd2.read.should == "finalized2"
+
+      rd1.close
+      rd2.close
+      Process.wait pid
+    end
+  end
+end

spec/ruby/core/objectspace/each_object_spec.rb

@@ -0,0 +1,225 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "ObjectSpace.each_object" do
+  it "calls the block once for each living, non-immediate object in the Ruby process" do
+    klass = Class.new
+    new_obj = klass.new
+
+    yields = 0
+    count = ObjectSpace.each_object(klass) do |obj|
+      obj.should == new_obj
+      yields += 1
+    end
+    count.should == 1
+    yields.should == 1
+
+    # this is needed to prevent the new_obj from being GC'd too early
+    new_obj.should_not == nil
+  end
+
+  it "calls the block once for each class, module in the Ruby process" do
+    klass = Class.new
+    mod = Module.new
+
+    [klass, mod].each do |k|
+      yields = 0
+      got_it = false
+      count = ObjectSpace.each_object(k.class) do |obj|
+        got_it = true if obj == k
+        yields += 1
+      end
+      got_it.should == true
+      count.should == yields
+    end
+  end
+
+  it "returns an enumerator if not given a block" do
+    klass = Class.new
+    new_obj = klass.new
+
+    counter = ObjectSpace.each_object(klass)
+    counter.should be_an_instance_of(Enumerator)
+    counter.each{}.should == 1
+    # this is needed to prevent the new_obj from being GC'd too early
+    new_obj.should_not == nil
+  end
+
+  it "finds an object stored in a global variable" do
+    $object_space_global_variable = ObjectSpaceFixtures::ObjectToBeFound.new(:global)
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:global)
+  end
+
+  it "finds an object stored in a top-level constant" do
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:top_level_constant)
+  end
+
+  it "finds an object stored in a second-level constant" do
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:second_level_constant)
+  end
+
+  it "finds an object stored in a local variable" do
+    local = ObjectSpaceFixtures::ObjectToBeFound.new(:local)
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local)
+  end
+
+  it "finds an object stored in a local variable captured in a block explicitly" do
+    proc = Proc.new {
+      local_in_block = ObjectSpaceFixtures::ObjectToBeFound.new(:local_in_block_explicit)
+      Proc.new { local_in_block }
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local_in_block_explicit)
+  end
+
+  it "finds an object stored in a local variable captured in a block implicitly" do
+    proc = Proc.new {
+      local_in_block = ObjectSpaceFixtures::ObjectToBeFound.new(:local_in_block_implicit)
+      Proc.new { }
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local_in_block_implicit)
+  end
+
+  it "finds an object stored in a local variable captured in by a method defined with a block" do
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:captured_by_define_method)
+  end
+
+  it "finds an object stored in a local variable captured in a Proc#binding" do
+    binding = Proc.new {
+      local_in_proc_binding = ObjectSpaceFixtures::ObjectToBeFound.new(:local_in_proc_binding)
+      Proc.new { }.binding
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local_in_proc_binding)
+  end
+
+  it "finds an object stored in a local variable captured in a Kernel#binding" do
+    b = Proc.new {
+      local_in_kernel_binding = ObjectSpaceFixtures::ObjectToBeFound.new(:local_in_kernel_binding)
+      binding
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local_in_kernel_binding)
+  end
+
+  it "finds an object stored in a local variable set in a binding manually" do
+    b = binding
+    b.eval("local = ObjectSpaceFixtures::ObjectToBeFound.new(:local_in_manual_binding)")
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:local_in_manual_binding)
+  end
+
+  it "finds an object stored in an array" do
+    array = [ObjectSpaceFixtures::ObjectToBeFound.new(:array)]
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:array)
+  end
+
+  it "finds an object stored in a hash key" do
+    hash = {ObjectSpaceFixtures::ObjectToBeFound.new(:hash_key) => :value}
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:hash_key)
+  end
+
+  it "finds an object stored in a hash value" do
+    hash = {a: ObjectSpaceFixtures::ObjectToBeFound.new(:hash_value)}
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:hash_value)
+  end
+
+  it "finds an object stored in an instance variable" do
+    local = ObjectSpaceFixtures::ObjectWithInstanceVariable.new
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:instance_variable)
+  end
+
+  it "finds an object stored in a thread local" do
+    thread = Thread.new {}
+    thread.thread_variable_set(:object_space_thread_local, ObjectSpaceFixtures::ObjectToBeFound.new(:thread_local))
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:thread_local)
+    thread.join
+  end
+
+  it "finds an object stored in a fiber local" do
+    Thread.current[:object_space_fiber_local] = ObjectSpaceFixtures::ObjectToBeFound.new(:fiber_local)
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:fiber_local)
+  end
+
+  it "finds an object captured in an at_exit handler" do
+    Proc.new {
+      local = ObjectSpaceFixtures::ObjectToBeFound.new(:at_exit)
+
+      at_exit do
+        local
+      end
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:at_exit)
+  end
+
+  it "finds an object captured in finalizer" do
+    alive = Object.new
+
+    Proc.new {
+      local = ObjectSpaceFixtures::ObjectToBeFound.new(:finalizer)
+
+      ObjectSpace.define_finalizer(alive, Proc.new {
+        local
+      })
+    }.call
+
+    ObjectSpaceFixtures.to_be_found_symbols.should include(:finalizer)
+
+    alive.should_not be_nil
+  end
+
+  describe "on singleton classes" do
+    before :each do
+      @klass = Class.new
+      instance = @klass.new
+      @sclass = instance.singleton_class
+      @meta = @klass.singleton_class
+    end
+
+    it "does not walk hidden metaclasses" do
+      klass = Class.new.singleton_class
+      ancestors = ObjectSpace.each_object(Class).select { |c| klass.is_a? c }
+      hidden = ancestors.find { |h| h.inspect.include? klass.inspect }
+      hidden.should == nil
+    end
+
+    ruby_version_is ""..."2.3" do
+      it "does not walk singleton classes" do
+        @sclass.should be_kind_of(@meta)
+        ObjectSpace.each_object(@meta).to_a.should_not include(@sclass)
+      end
+    end
+
+    ruby_version_is "2.3" do
+      it "walks singleton classes" do
+        @sclass.should be_kind_of(@meta)
+        ObjectSpace.each_object(@meta).to_a.should include(@sclass)
+      end
+    end
+  end
+
+  it "walks a class and its normal descendants when passed the class's singleton class" do
+    a = Class.new
+    b = Class.new(a)
+    c = Class.new(a)
+    d = Class.new(b)
+
+    c_instance = c.new
+    c_sclass = c_instance.singleton_class
+
+    expected = [ a, b, c, d ]
+
+    # singleton classes should be walked only on >= 2.3
+    ruby_version_is "2.3" do
+      expected << c_sclass
+      c_sclass.should be_kind_of(a.singleton_class)
+    end
+
+    b.extend Enumerable # included modules should not be walked
+
+    classes = ObjectSpace.each_object(a.singleton_class).to_a
+
+    classes.sort_by(&:object_id).should == expected.sort_by(&:object_id)
+  end
+end

spec/ruby/core/objectspace/finalizers_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.finalizers" do
+  it "needs to be reviewed for spec completeness"
+end

spec/ruby/core/objectspace/fixtures/classes.rb

@@ -0,0 +1,64 @@
+module ObjectSpaceFixtures
+  def self.garbage
+    blah
+  end
+
+  def self.blah
+    o = "hello"
+    @garbage_objid = o.object_id
+    return o
+  end
+
+  @last_objid = nil
+
+  def self.last_objid
+    @last_objid
+  end
+
+  def self.garbage_objid
+    @garbage_objid
+  end
+
+  def self.make_finalizer
+    proc { |obj_id| @last_objid = obj_id }
+  end
+
+  def self.define_finalizer
+    handler = lambda { |obj| ScratchPad.record :finalized }
+    ObjectSpace.define_finalizer "#{rand 5}", handler
+  end
+
+  def self.scoped(wr)
+    return Proc.new { wr.write "finalized"; wr.close }
+  end
+
+  class ObjectToBeFound
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class ObjectWithInstanceVariable
+    def initialize
+      @instance_variable = ObjectToBeFound.new(:instance_variable)
+    end
+  end
+
+  def self.to_be_found_symbols
+    ObjectSpace.each_object(ObjectToBeFound).map do |o|
+      o.name
+    end
+  end
+
+  o = ObjectToBeFound.new(:captured_by_define_method)
+  define_method :capturing_method do
+    o
+  end
+
+  SECOND_LEVEL_CONSTANT = ObjectToBeFound.new(:second_level_constant)
+
+end
+
+OBJECT_SPACE_TOP_LEVEL_CONSTANT = ObjectSpaceFixtures::ObjectToBeFound.new(:top_level_constant)

spec/ruby/core/objectspace/garbage_collect_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.garbage_collect" do
+
+  it "can be invoked without any exceptions" do
+    lambda { ObjectSpace.garbage_collect }.should_not raise_error
+  end
+
+  it "doesn't accept any arguments" do
+    lambda { ObjectSpace.garbage_collect(1) }.should raise_error(ArgumentError)
+  end
+
+  it "ignores the supplied block" do
+    lambda { ObjectSpace.garbage_collect {} }.should_not raise_error
+  end
+
+  it "always returns nil" do
+    ObjectSpace.garbage_collect.should == nil
+    ObjectSpace.garbage_collect.should == nil
+  end
+
+end

spec/ruby/core/objectspace/remove_finalizer_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.remove_finalizer" do
+  it "needs to be reviewed for spec completeness"
+end

spec/ruby/core/objectspace/undefine_finalizer_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "ObjectSpace.undefine_finalizer" do
+  it "needs to be reviewed for spec completeness"
+end