ruby/test/objspace/test_objspace.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

928 строки
28 KiB
Ruby
Исходник Обычный вид История

# frozen_string_literal: false
require "test/unit"
require "objspace"
begin
require "json"
rescue LoadError
end
class TestObjSpace < Test::Unit::TestCase
def test_memsize_of
assert_equal(0, ObjectSpace.memsize_of(true))
assert_equal(0, ObjectSpace.memsize_of(nil))
assert_equal(0, ObjectSpace.memsize_of(1))
assert_kind_of(Integer, ObjectSpace.memsize_of(Object.new))
assert_kind_of(Integer, ObjectSpace.memsize_of(Class))
assert_kind_of(Integer, ObjectSpace.memsize_of(""))
assert_kind_of(Integer, ObjectSpace.memsize_of([]))
assert_kind_of(Integer, ObjectSpace.memsize_of({}))
assert_kind_of(Integer, ObjectSpace.memsize_of(//))
f = File.new(__FILE__)
assert_kind_of(Integer, ObjectSpace.memsize_of(f))
f.close
assert_kind_of(Integer, ObjectSpace.memsize_of(/a/.match("a")))
assert_kind_of(Integer, ObjectSpace.memsize_of(Struct.new(:a)))
assert_operator(ObjectSpace.memsize_of(Regexp.new("(a)"*1000).match("a"*1000)),
:>,
ObjectSpace.memsize_of(//.match("")))
end
def test_memsize_of_root_shared_string
a = "a" * GC::INTERNAL_CONSTANTS[:RVARGC_MAX_ALLOCATE_SIZE]
b = a.dup
c = nil
ObjectSpace.each_object(String) {|x| break c = x if x == a and x.frozen?}
rv_size = GC::INTERNAL_CONSTANTS[:BASE_SLOT_SIZE]
assert_equal([rv_size, rv_size, a.length + 1 + rv_size], [a, b, c].map {|x| ObjectSpace.memsize_of(x)})
end
def test_argf_memsize
size = ObjectSpace.memsize_of(ARGF)
assert_kind_of(Integer, size)
assert_operator(size, :>, 0)
argf = ARGF.dup
argf.inplace_mode = nil
size = ObjectSpace.memsize_of(argf)
argf.inplace_mode = "inplace_mode_suffix"
assert_equal(size, ObjectSpace.memsize_of(argf))
end
def test_memsize_of_all
assert_kind_of(Integer, a = ObjectSpace.memsize_of_all)
assert_kind_of(Integer, b = ObjectSpace.memsize_of_all(String))
assert_operator(a, :>, b)
assert_operator(a, :>, 0)
assert_operator(b, :>, 0)
assert_raise(TypeError) {ObjectSpace.memsize_of_all('error')}
end
def test_count_objects_size
res = ObjectSpace.count_objects_size
assert_not_empty(res)
assert_operator(res[:TOTAL], :>, 0)
end
def test_count_objects_size_with_hash
arg = {}
ObjectSpace.count_objects_size(arg)
assert_not_empty(arg)
arg = {:TOTAL => 1 }
ObjectSpace.count_objects_size(arg)
assert_not_empty(arg)
end
def test_count_objects_size_with_wrong_type
assert_raise(TypeError) { ObjectSpace.count_objects_size(0) }
end
def test_count_nodes
res = ObjectSpace.count_nodes
assert_not_empty(res)
arg = {}
ObjectSpace.count_nodes(arg)
assert_not_empty(arg)
bug8014 = '[ruby-core:53130] [Bug #8014]'
assert_empty(arg.select {|k, v| !(Symbol === k && Integer === v)}, bug8014)
end if false
def test_count_tdata_objects
res = ObjectSpace.count_tdata_objects
assert_not_empty(res)
arg = {}
ObjectSpace.count_tdata_objects(arg)
assert_not_empty(arg)
end
def test_count_imemo_objects
res = ObjectSpace.count_imemo_objects
assert_not_empty(res)
assert_not_nil(res[:imemo_cref])
assert_not_empty res.inspect
arg = {}
res = ObjectSpace.count_imemo_objects(arg)
assert_not_empty(res)
end
def test_memsize_of_iseq
2019-06-30 03:34:41 +03:00
iseqw = RubyVM::InstructionSequence.compile('def a; a = :b; a; end')
# Use anonymous class as a basic object size because size of Object.new can be increased
2021-05-12 11:40:52 +03:00
base_obj_size = ObjectSpace.memsize_of(Class.new.new)
assert_operator(ObjectSpace.memsize_of(iseqw), :>, base_obj_size)
end
def test_reachable_objects_from
opts = %w[--disable-gem --disable=frozen-string-literal -robjspace]
assert_separately opts, "#{<<-"begin;"}\n#{<<-'end;'}"
begin;
This commit implements the Object Shapes technique in CRuby. Object Shapes is used for accessing instance variables and representing the "frozenness" of objects. Object instances have a "shape" and the shape represents some attributes of the object (currently which instance variables are set and the "frozenness"). Shapes form a tree data structure, and when a new instance variable is set on an object, that object "transitions" to a new shape in the shape tree. Each shape has an ID that is used for caching. The shape structure is independent of class, so objects of different types can have the same shape. For example: ```ruby class Foo def initialize # Starts with shape id 0 @a = 1 # transitions to shape id 1 @b = 1 # transitions to shape id 2 end end class Bar def initialize # Starts with shape id 0 @a = 1 # transitions to shape id 1 @b = 1 # transitions to shape id 2 end end foo = Foo.new # `foo` has shape id 2 bar = Bar.new # `bar` has shape id 2 ``` Both `foo` and `bar` instances have the same shape because they both set instance variables of the same name in the same order. This technique can help to improve inline cache hits as well as generate more efficient machine code in JIT compilers. This commit also adds some methods for debugging shapes on objects. See `RubyVM::Shape` for more details. For more context on Object Shapes, see [Feature: #18776] Co-Authored-By: Aaron Patterson <tenderlove@ruby-lang.org> Co-Authored-By: Eileen M. Uchitelle <eileencodes@gmail.com> Co-Authored-By: John Hawthorn <john@hawthorn.email>
2022-09-23 20:54:42 +03:00
assert_equal(nil, ObjectSpace.reachable_objects_from(nil))
assert_equal([Array, 'a', 'b', 'c'], ObjectSpace.reachable_objects_from(['a', 'b', 'c']))
assert_equal([Array, 'a', 'a', 'a'], ObjectSpace.reachable_objects_from(['a', 'a', 'a']))
assert_equal([Array, 'a', 'a'], ObjectSpace.reachable_objects_from(['a', v = 'a', v]))
assert_equal([Array, 'a'], ObjectSpace.reachable_objects_from([v = 'a', v, v]))
long_ary = Array.new(1_000){''}
max = 0
ObjectSpace.each_object{|o|
refs = ObjectSpace.reachable_objects_from(o)
max = [refs.size, max].max
unless refs.nil?
refs.each_with_index {|ro, i|
assert_not_nil(ro, "#{i}: this referenced object is internal object")
}
end
}
assert_operator(max, :>=, long_ary.size+1, "1000 elems + Array class")
end;
end
def test_reachable_objects_during_iteration
omit 'flaky on Visual Studio with: [BUG] Unnormalized Fixnum value' if /mswin/ =~ RUBY_PLATFORM
opts = %w[--disable-gem --disable=frozen-string-literal -robjspace]
assert_separately opts, "#{<<-"begin;"}\n#{<<-'end;'}"
begin;
ObjectSpace.each_object{|o|
o.inspect
ObjectSpace.reachable_objects_from(Class)
}
end;
end
def test_reachable_objects_from_root
root_objects = ObjectSpace.reachable_objects_from_root
assert_operator(root_objects.size, :>, 0)
root_objects.each{|category, objects|
assert_kind_of(String, category)
assert_kind_of(Array, objects)
assert_operator(objects.size, :>, 0)
}
end
def test_reachable_objects_size
assert_separately %w[--disable-gem -robjspace], "#{<<~"begin;"}\n#{<<~'end;'}"
begin;
ObjectSpace.each_object{|o|
ObjectSpace.reachable_objects_from(o).each{|reached_obj|
size = ObjectSpace.memsize_of(reached_obj)
assert_kind_of(Integer, size)
assert_operator(size, :>=, 0)
}
}
end;
end
def test_trace_object_allocations_stop_first
assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
begin;
require "objspace"
2021-04-25 18:10:39 +03:00
# Make sure stopping before the tracepoints are initialized doesn't raise. See [Bug #17020]
ObjectSpace.trace_object_allocations_stop
end;
end
def test_trace_object_allocations
ObjectSpace.trace_object_allocations_clear # clear object_table to get rid of erroneous detection for c0
Class.name
o0 = Object.new
ObjectSpace.trace_object_allocations{
o1 = Object.new; line1 = __LINE__; c1 = GC.count
o2 = "xyzzy" ; line2 = __LINE__; c2 = GC.count
o3 = [1, 2] ; line3 = __LINE__; c3 = GC.count
assert_equal(nil, ObjectSpace.allocation_sourcefile(o0))
assert_equal(nil, ObjectSpace.allocation_sourceline(o0))
assert_equal(nil, ObjectSpace.allocation_generation(o0))
assert_equal(line1, ObjectSpace.allocation_sourceline(o1))
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(o1))
assert_equal(c1, ObjectSpace.allocation_generation(o1))
assert_equal(Class.name, ObjectSpace.allocation_class_path(o1))
assert_equal(:new, ObjectSpace.allocation_method_id(o1))
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(o2))
assert_equal(line2, ObjectSpace.allocation_sourceline(o2))
assert_equal(c2, ObjectSpace.allocation_generation(o2))
assert_equal(self.class.name, ObjectSpace.allocation_class_path(o2))
assert_equal(__method__, ObjectSpace.allocation_method_id(o2))
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(o3))
assert_equal(line3, ObjectSpace.allocation_sourceline(o3))
assert_equal(c3, ObjectSpace.allocation_generation(o3))
assert_equal(self.class.name, ObjectSpace.allocation_class_path(o3))
assert_equal(__method__, ObjectSpace.allocation_method_id(o3))
# [Bug #19456]
o4 =
# This line intentionally left blank
# This line intentionally left blank
1.0 / 0.0; line4 = __LINE__; _c4 = GC.count
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(o4))
assert_equal(line4, ObjectSpace.allocation_sourceline(o4))
# The line number should be based on newarray instead of getinstancevariable.
line5 = __LINE__; o5 = [ # newarray (leaf)
@ivar, # getinstancevariable (not leaf)
]
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(o5))
assert_equal(line5, ObjectSpace.allocation_sourceline(o5))
# [Bug #19482]
EnvUtil.under_gc_stress do
100.times do
Class.new
end
end
}
end
def test_trace_object_allocations_start_stop_clear
ObjectSpace.trace_object_allocations_clear # clear object_table to get rid of erroneous detection for obj3
GC.disable # suppress potential object reuse. see [Bug #11271]
begin
ObjectSpace.trace_object_allocations_start
begin
ObjectSpace.trace_object_allocations_start
begin
ObjectSpace.trace_object_allocations_start
obj0 = Object.new
ensure
ObjectSpace.trace_object_allocations_stop
obj1 = Object.new
end
ensure
ObjectSpace.trace_object_allocations_stop
obj2 = Object.new
end
ensure
ObjectSpace.trace_object_allocations_stop
obj3 = Object.new
end
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(obj0))
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(obj1))
assert_equal(__FILE__, ObjectSpace.allocation_sourcefile(obj2))
assert_equal(nil , ObjectSpace.allocation_sourcefile(obj3)) # after tracing
ObjectSpace.trace_object_allocations_clear
assert_equal(nil, ObjectSpace.allocation_sourcefile(obj0))
assert_equal(nil, ObjectSpace.allocation_sourcefile(obj1))
assert_equal(nil, ObjectSpace.allocation_sourcefile(obj2))
assert_equal(nil, ObjectSpace.allocation_sourcefile(obj3))
ensure
GC.enable
end
def test_trace_object_allocations_gc_stress
2021-03-31 16:14:15 +03:00
EnvUtil.under_gc_stress do
ObjectSpace.trace_object_allocations{
proc{}
}
end
assert true # success
end
def test_dump_flags
# Ensure that the fstring is promoted to old generation
4.times { GC.start }
info = ObjectSpace.dump("foo".freeze)
assert_match(/"wb_protected":true, "old":true/, info)
assert_match(/"fstring":true/, info)
JSON.parse(info) if defined?(JSON)
end
if defined?(RubyVM::Shape)
2023-05-21 04:03:28 +03:00
class TooComplex; end
def test_dump_too_complex_shape
omit "flaky test"
2023-05-21 04:03:28 +03:00
RubyVM::Shape::SHAPE_MAX_VARIATIONS.times do
TooComplex.new.instance_variable_set(:"@a#{_1}", 1)
end
tc = TooComplex.new
info = ObjectSpace.dump(tc)
assert_not_match(/"too_complex_shape"/, info)
tc.instance_variable_set(:@new_ivar, 1)
info = ObjectSpace.dump(tc)
assert_match(/"too_complex_shape":true/, info)
if defined?(JSON)
assert_true(JSON.parse(info)["too_complex_shape"])
end
end
end
class NotTooComplex ; end
def test_dump_not_too_complex_shape
tc = NotTooComplex.new
tc.instance_variable_set(:@new_ivar, 1)
info = ObjectSpace.dump(tc)
assert_not_match(/"too_complex_shape"/, info)
if defined?(JSON)
assert_nil(JSON.parse(info)["too_complex_shape"])
end
end
def test_dump_to_default
line = nil
info = nil
ObjectSpace.trace_object_allocations do
line = __LINE__ + 1
str = "hello w"
info = ObjectSpace.dump(str)
end
assert_dump_object(info, line)
end
def test_dump_to_io
line = nil
info = IO.pipe do |r, w|
th = Thread.start {r.read}
ObjectSpace.trace_object_allocations do
line = __LINE__ + 1
str = "hello w"
ObjectSpace.dump(str, output: w)
end
w.close
th.value
end
assert_dump_object(info, line)
end
def assert_dump_object(info, line)
loc = caller_locations(1, 1)[0]
assert_match(/"type":"STRING"/, info)
assert_match(/"embedded":true, "bytesize":7, "value":"hello w", "encoding":"UTF-8"/, info)
assert_match(/"file":"#{Regexp.escape __FILE__}", "line":#{line}/, info)
assert_match(/"method":"#{loc.base_label}"/, info)
JSON.parse(info) if defined?(JSON)
end
def test_dump_array
# Empty array
info = ObjectSpace.dump([])
assert_include(info, '"length":0, "embedded":true')
assert_not_include(info, '"shared":true')
# Non-embed array
arr = (1..10).to_a
info = ObjectSpace.dump(arr)
assert_include(info, '"length":10')
assert_not_include(info, '"embedded":true')
assert_not_include(info, '"shared":true')
# Shared array
arr1 = (1..10).to_a
arr = []
arr.replace(arr1)
info = ObjectSpace.dump(arr)
assert_include(info, '"length":10, "shared":true')
assert_not_include(info, '"embedded":true')
end
def test_dump_object
klass = Class.new
# Empty object
info = ObjectSpace.dump(klass.new)
assert_include(info, '"embedded":true')
assert_include(info, '"ivars":0')
# Non-embed object
obj = klass.new
5.times { |i| obj.instance_variable_set("@ivar#{i}", 0) }
info = ObjectSpace.dump(obj)
assert_not_include(info, '"embedded":true')
assert_include(info, '"ivars":5')
end
2020-08-17 16:29:51 +03:00
def test_dump_control_char
assert_include(ObjectSpace.dump("\x0f"), '"value":"\u000f"')
2020-08-17 16:36:48 +03:00
assert_include(ObjectSpace.dump("\C-?"), '"value":"\u007f"')
2020-08-17 16:29:51 +03:00
end
def test_dump_special_consts
# [ruby-core:69692] [Bug #11291]
assert_equal('null', ObjectSpace.dump(nil))
assert_equal('true', ObjectSpace.dump(true))
assert_equal('false', ObjectSpace.dump(false))
assert_equal('0', ObjectSpace.dump(0))
assert_equal('{"type":"SYMBOL", "value":"foo"}', ObjectSpace.dump(:foo))
end
def test_dump_singleton_class
assert_include(ObjectSpace.dump(Object), '"name":"Object"')
assert_include(ObjectSpace.dump(Kernel), '"name":"Kernel"')
assert_include(ObjectSpace.dump(Object.new.singleton_class), '"real_class_name":"Object"')
singleton = Object.new.singleton_class
singleton_dump = ObjectSpace.dump(singleton)
assert_include(singleton_dump, '"singleton":true')
if defined?(JSON)
assert_equal(Object, singleton.superclass)
superclass_address = JSON.parse(ObjectSpace.dump(Object)).fetch('address')
assert_equal(superclass_address, JSON.parse(singleton_dump).fetch('superclass'))
end
end
def test_dump_special_floats
assert_match(/"value":"NaN"/, ObjectSpace.dump(Float::NAN))
assert_match(/"value":"Inf"/, ObjectSpace.dump(Float::INFINITY))
assert_match(/"value":"\-Inf"/, ObjectSpace.dump(-Float::INFINITY))
end
def test_dump_dynamic_symbol
dump = ObjectSpace.dump(("foobar%x" % rand(0x10000)).to_sym)
assert_match(/"type":"SYMBOL"/, dump)
assert_match(/"value":"foobar\h+"/, dump)
end
def test_dump_includes_imemo_type
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
ObjectSpace.dump_all(output: :stdout)
end
p dump_my_heap_please
end;
assert_equal 'nil', output.pop
heap = output.find_all { |l|
obj = JSON.parse(l)
obj['type'] == "IMEMO" && obj['imemo_type']
}
assert_operator heap.length, :>, 0
end
end
def test_dump_all_full
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
ObjectSpace.dump_all(output: :stdout, full: true)
end
p dump_my_heap_please
end;
assert_equal 'nil', output.pop
heap = output.find_all { |l| JSON.parse(l)['type'] == "NONE" }
assert_operator heap.length, :>, 0
end
end
def test_dump_all_single_generation
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
GC.start
ObjectSpace.trace_object_allocations_start
gc_gen = GC.count
puts gc_gen
@obj1 = Object.new
GC.start
@obj2 = Object.new
ObjectSpace.dump_all(output: :stdout, since: gc_gen, shapes: false)
end
p dump_my_heap_please
end;
assert_equal 'nil', output.pop
since = output.shift.to_i
assert_operator output.size, :>, 0
generations = output.map { |l| JSON.parse(l) }.map { |o| o["generation"] }.uniq.sort
assert_equal [since, since + 1], generations
end
end
def test_dump_addresses_match_dump_all_addresses
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
obj = Object.new
puts ObjectSpace.dump(obj)
ObjectSpace.dump_all(output: $stdout)
end
p $stdout == dump_my_heap_please
end;
assert_equal 'true', output.pop
needle = JSON.parse(output.first)
addr = needle['address']
found = output.drop(1).find { |l| JSON.parse(l)['address'] == addr }
assert found, "object #{addr} should be findable in full heap dump"
end
end
def test_dump_class_addresses_match_dump_all_addresses
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
obj = Object.new
puts ObjectSpace.dump(obj)
ObjectSpace.dump_all(output: $stdout)
end
p $stdout == dump_my_heap_please
end;
assert_equal 'true', output.pop
needle = JSON.parse(output.first)
addr = needle['class']
found = output.drop(1).find { |l| JSON.parse(l)['address'] == addr }
assert found, "object #{addr} should be findable in full heap dump"
end
end
def test_dump_objects_dumps_page_slot_sizes
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
ObjectSpace.dump_all(output: $stdout)
end
p $stdout == dump_my_heap_please
end;
assert_equal 'true', output.pop
assert(output.count > 1)
output.each { |l|
obj = JSON.parse(l)
next if obj["type"] == "ROOT"
next if obj["type"] == "SHAPE"
assert_not_nil obj["slot_size"]
assert_equal 0, obj["slot_size"] % GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
}
end
end
def test_dump_callinfo_includes_mid
assert_in_out_err(%w[-robjspace --disable-gems], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
class Foo
def foo
super(bar: 123) # should not crash on 0 mid
end
def bar
baz(bar: 123) # mid: baz
end
end
ObjectSpace.dump_all(output: $stdout)
end;
assert_empty error
assert(output.count > 1)
assert_includes output.grep(/"imemo_type":"callinfo"/).join("\n"), '"mid":"baz"'
end
end
def test_dump_string_coderange
assert_includes ObjectSpace.dump("TEST STRING"), '"coderange":"7bit"'
unknown = "TEST STRING".dup.force_encoding(Encoding::UTF_16BE)
2.times do # ensure that dumping the string doesn't mutate it
assert_includes ObjectSpace.dump(unknown), '"coderange":"unknown"'
end
assert_includes ObjectSpace.dump("Fée"), '"coderange":"valid"'
assert_includes ObjectSpace.dump("\xFF"), '"coderange":"broken"'
end
def test_dump_escapes_method_name
method_name = "foo\"bar"
klass = Class.new do
define_method(method_name) { "TEST STRING" }
end
ObjectSpace.trace_object_allocations_start
obj = klass.new.send(method_name)
dump = ObjectSpace.dump(obj)
assert_includes dump, '"method":"foo\"bar"'
parsed = JSON.parse(dump)
assert_equal "foo\"bar", parsed["method"]
ensure
ObjectSpace.trace_object_allocations_stop
end
def test_dump_includes_slot_size
str = "TEST"
dump = ObjectSpace.dump(str)
assert_includes dump, "\"slot_size\":#{GC::INTERNAL_CONSTANTS[:BASE_SLOT_SIZE]}"
end
def test_dump_reference_addresses_match_dump_all_addresses
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}\n#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
obj = Object.new
obj2 = Object.new
obj2.instance_variable_set(:@ref, obj)
puts ObjectSpace.dump(obj)
ObjectSpace.dump_all(output: $stdout)
end
p $stdout == dump_my_heap_please
end;
assert_equal 'true', output.pop
needle = JSON.parse(output.first)
addr = needle['address']
found = output.drop(1).find { |l| (JSON.parse(l)['references'] || []).include? addr }
assert found, "object #{addr} should be findable in full heap dump"
end
end
def assert_test_string_entry_correct_in_dump_all(output)
# `TEST STRING` appears twice in the output of `ObjectSpace.dump_all`
# 1. To create the T_STRING object for the literal string "TEST STRING"
# 2. When it is assigned to the `str` variable with a new encoding
#
# This test makes assertions on the assignment to `str`, so we look for
# the second appearance of /TEST STRING/ in the output
test_string_in_dump_all = output.grep(/TEST2/)
begin
assert_equal(2, test_string_in_dump_all.size, "number of strings")
rescue Test::Unit::AssertionFailedError => e
STDERR.puts e.inspect
STDERR.puts test_string_in_dump_all
if test_string_in_dump_all.size == 3
STDERR.puts "This test is skipped because it seems hard to fix."
else
raise
end
end
strs = test_string_in_dump_all.reject do |s|
s.include?("fstring")
end
assert_equal(1, strs.length)
entry_hash = JSON.parse(strs[0])
assert_equal(5, entry_hash["bytesize"], "bytesize is wrong")
assert_equal("TEST2", entry_hash["value"], "value is wrong")
assert_equal("UTF-8", entry_hash["encoding"], "encoding is wrong")
assert_equal("-", entry_hash["file"], "file is wrong")
assert_equal(4, entry_hash["line"], "line is wrong")
assert_equal("dump_my_heap_please", entry_hash["method"], "method is wrong")
assert_not_nil(entry_hash["generation"])
end
def test_dump_all
opts = %w[--disable-gem --disable=frozen-string-literal -robjspace]
assert_in_out_err(opts, "#{<<-"begin;"}#{<<-'end;'}") do |output, error|
begin;
def dump_my_heap_please
ObjectSpace.trace_object_allocations_start
GC.start
str = "TEST2".force_encoding("UTF-8")
ObjectSpace.dump_all(output: :stdout)
end
p dump_my_heap_please
end;
assert_test_string_entry_correct_in_dump_all(output)
end
assert_in_out_err(%w[-robjspace], "#{<<-"begin;"}#{<<-'end;'}") do |(output), (error)|
begin;
def dump_my_heap_please
ObjectSpace.trace_object_allocations_start
GC.start
(str = "TEST2").force_encoding("UTF-8")
ObjectSpace.dump_all().path
end
puts dump_my_heap_please
end;
assert_nil(error)
dump = File.readlines(output)
File.unlink(output)
assert_test_string_entry_correct_in_dump_all(dump)
end
if defined?(JSON)
args = [
"-rjson", "-",
EnvUtil.rubybin,
"--disable=gems", "-robjspace", "-eObjectSpace.dump_all(output: :stdout)",
]
assert_ruby_status(args, "#{<<~"begin;"}\n#{<<~"end;"}")
begin;
IO.popen(ARGV) do |f|
f.each_line.map { |x| JSON.load(x) }
end
end;
end
end
def test_dump_uninitialized_file
assert_in_out_err(%[-robjspace], <<-RUBY) do |(output), (error)|
puts ObjectSpace.dump(File.allocate)
RUBY
assert_nil error
assert_match(/"type":"FILE"/, output)
assert_not_match(/"fd":/, output)
end
end
def traverse_classes klass
h = {}
while klass && !h.has_key?(klass)
h[klass] = true
klass = ObjectSpace.internal_class_of(klass)
end
end
def test_internal_class_of
i = 0
ObjectSpace.each_object{|o|
traverse_classes ObjectSpace.internal_class_of(o)
i += 1
}
assert_operator i, :>, 0
end
def test_internal_class_of_on_ast
children = ObjectSpace.reachable_objects_from(RubyVM::AbstractSyntaxTree.parse("kadomatsu"))
children.each {|child| ObjectSpace.internal_class_of(child).itself} # this used to crash
end
def test_name_error_message
begin
bar
rescue => err
_, m = ObjectSpace.reachable_objects_from(err)
end
assert_equal(m, m.clone)
end
def traverse_super_classes klass
while klass
klass = ObjectSpace.internal_super_of(klass)
end
end
def all_super_classes klass
klasses = []
while klass
klasses << klass
klass = ObjectSpace.internal_super_of(klass)
end
klasses
end
def test_internal_super_of
klasses = all_super_classes(String)
String.ancestors.each{|k|
case k
when Class
assert_equal(true, klasses.include?(k), k.inspect)
when Module
assert_equal(false, klasses.include?(k), k.inspect) # Internal object (T_ICLASS)
end
}
i = 0
ObjectSpace.each_object(Module){|o|
traverse_super_classes ObjectSpace.internal_super_of(o)
i += 1
}
assert_operator i, :>, 0
end
def test_count_symbols
assert_separately(%w[-robjspace], "#{<<~';;;'}")
h0 = ObjectSpace.count_symbols
syms = (1..128).map{|i| ("xyzzy#{i}_#{Process.pid}_#{rand(1_000_000)}_" * 128).to_sym}
syms << Class.new{define_method(syms[-1]){}}
h = ObjectSpace.count_symbols
m = proc {h0.inspect + "\n" + h.inspect}
assert_equal 127, h[:mortal_dynamic_symbol] - h0[:mortal_dynamic_symbol], m
assert_equal 1, h[:immortal_dynamic_symbol] - h0[:immortal_dynamic_symbol], m
assert_operator h[:immortal_static_symbol], :>=, Object.methods.size, m
assert_equal h[:immortal_symbol], h[:immortal_dynamic_symbol] + h[:immortal_static_symbol], m
;;;
end
def test_anonymous_class_name
assert_not_include ObjectSpace.dump(Class.new), '"name"'
assert_not_include ObjectSpace.dump(Module.new), '"name"'
end
def test_objspace_trace
assert_in_out_err(%w[-robjspace/trace], "#{<<-"begin;"}\n#{<<-'end;'}") do |out, err|
begin;
a = "foo"
b = "b" + "a" + "r"
c = 42
p a, b, c
end;
assert_equal ["objspace/trace is enabled"], err
assert_equal 3, out.size
assert_equal '"foo" @ -:2', out[0]
assert_equal '"bar" @ -:3', out[1]
assert_equal '42', out[2]
end
end
def load_allocation_path_helper method, to_binary: false
Tempfile.create(["test_ruby_load_allocation_path", ".rb"]) do |t|
path = t.path
str = "#{Time.now.to_f.to_s}_#{rand.to_s}"
t.puts script = <<~RUBY
# frozen-string-literal: true
return if Time.now.to_i > 0
$gv = 'rnd-#{str}' # unreachable, but the string literal was written
RUBY
t.close
if to_binary
bin = RubyVM::InstructionSequence.compile_file(t.path).to_binary
bt = Tempfile.new(['test_ruby_load_allocation_path', '.yarb'], mode: File::Constants::WRONLY)
bt.write bin
bt.close
path = bt.path
end
assert_separately(%w[-robjspace -rtempfile], <<~RUBY)
GC.disable
path = "#{path}"
ObjectSpace.trace_object_allocations do
#{method}
end
n = 0
dump = ObjectSpace.dump_all(output: :string)
dump.each_line do |line|
if /"value":"rnd-#{str}"/ =~ line && /"frozen":true/ =~ line
assert Regexp.new('"file":"' + "#{path}") =~ line
assert Regexp.new('"line":') !~ line
n += 1
end
rescue ArgumentError
end
assert_equal(1, n)
RUBY
ensure
bt.unlink if bt
end
end
def test_load_allocation_path_load
load_allocation_path_helper 'load(path)'
end
def test_load_allocation_path_compile_file
load_allocation_path_helper 'RubyVM::InstructionSequence.compile_file(path)'
end
def test_load_allocation_path_load_from_binary
# load_allocation_path_helper 'iseq = RubyVM::InstructionSequence.load_from_binary(File.binread(path))', to_binary: true
end
def test_utf8_method_names
name = "utf8_╯°□°╯︵┻━┻"
obj = ObjectSpace.trace_object_allocations do
__send__(name)
end
dump = ObjectSpace.dump(obj)
assert_equal name, JSON.parse(dump)["method"], dump
end
def test_dump_shapes
json = ObjectSpace.dump_shapes(output: :string)
json.each_line do |line|
assert_include(line, '"type":"SHAPE"')
end
assert_empty ObjectSpace.dump_shapes(output: :string, since: RubyVM.stat(:next_shape_id))
assert_equal 2, ObjectSpace.dump_shapes(output: :string, since: RubyVM.stat(:next_shape_id) - 2).lines.size
end
private
def utf8_°°
"1#{2}"
end
end