ruby-prof 1.8.0-x64-mswin64-140

data/test/exclude_methods_test.rb

@@ -0,0 +1,363 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+module ExcludeMethodsModule
+  def c
+    1.times { |i| ExcludeMethodsModule.d }
+  end
+
+  def self.d
+    1.times { |i| ExcludeMethodsClass.e }
+  end
+end
+
+class ExcludeMethodsClass
+  include ExcludeMethodsModule
+
+  def a
+    1.times { |i| b }
+  end
+
+  def b
+    1.times { |i| c; self.class.e }
+  end
+
+  def self.e
+    1.times { |i| f }
+  end
+
+  def self.f
+    sleep 0.1
+  end
+end
+
+class ExcludeMethodsTest < TestCase
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3')
+    def test_methods_can_be_profiled
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(10, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('Integer#times', methods[2].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
+      assert_equal('Kernel#sleep', methods[6].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[7].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[8].full_name)
+      assert_equal('Kernel#class', methods[9].full_name)
+    end
+
+    def test_methods_can_be_hidden1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+
+    def test_methods_can_be_hidden2
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+      prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
+      prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(7, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('Kernel#sleep', methods[4].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[5].full_name)
+      assert_equal('Kernel#class', methods[6].full_name)
+    end
+
+    def test_exclude_common_methods1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      prf.exclude_common_methods!
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+
+    def test_exclude_common_methods2
+      obj = ExcludeMethodsClass.new
+
+      result = RubyProf::Profile.profile(exclude_common: true) { 5.times {obj.a} }
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    end
+  elsif Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.4')
+    def test_methods_can_be_profiled
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(13, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('Integer#times', methods[2].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
+      assert_equal('Kernel#sleep', methods[6].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[7].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[8].full_name)
+      assert_equal('Kernel#block_given?', methods[9].full_name)
+      assert_equal('Integer#succ', methods[10].full_name)
+      assert_equal('Integer#<', methods[11].full_name)
+      assert_equal('Kernel#class', methods[12].full_name)
+    end
+
+    def test_methods_can_be_hidden1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(12, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#block_given?', methods[8].full_name)
+      assert_equal('Integer#succ', methods[9].full_name)
+      assert_equal('Integer#<', methods[10].full_name)
+      assert_equal('Kernel#class', methods[11].full_name)
+    end
+
+    def test_methods_can_be_hidden2
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+      prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
+      prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(10, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('Kernel#sleep', methods[4].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[5].full_name)
+      assert_equal('Kernel#block_given?', methods[6].full_name)
+      assert_equal('Integer#succ', methods[7].full_name)
+      assert_equal('Integer#<', methods[8].full_name)
+      assert_equal('Kernel#class', methods[9].full_name)
+    end
+
+    def test_exclude_common_methods1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      prf.exclude_common_methods!
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+
+    def test_exclude_common_methods2
+      obj = ExcludeMethodsClass.new
+
+      result = RubyProf::Profile.profile(exclude_common: true) { 5.times {obj.a} }
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+  else
+    def test_methods_can_be_profiled
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(12, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('Integer#times', methods[2].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
+      assert_equal('Kernel#sleep', methods[6].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[7].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[8].full_name)
+      assert_equal('Integer#succ', methods[9].full_name)
+      assert_equal('Integer#<', methods[10].full_name)
+      assert_equal('Kernel#class', methods[11].full_name)
+    end
+
+    def test_methods_can_be_hidden1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(11, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Integer#succ', methods[8].full_name)
+      assert_equal('Integer#<', methods[9].full_name)
+      assert_equal('Kernel#class', methods[10].full_name)
+    end
+
+    def test_methods_can_be_hidden2
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new
+
+      prf.exclude_methods!(Integer, :times)
+      prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
+      prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('Kernel#sleep', methods[4].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[5].full_name)
+      assert_equal('Integer#succ', methods[6].full_name)
+      assert_equal('Integer#<', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+
+    def test_exclude_common_methods1
+      obj = ExcludeMethodsClass.new
+      prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+      prf.exclude_common_methods!
+
+      result = prf.profile {obj.a}
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+
+    def test_exclude_common_methods2
+      obj = ExcludeMethodsClass.new
+
+      result = RubyProf::Profile.profile(exclude_common: true) { 5.times {obj.a} }
+      methods = result.threads.first.methods.sort.reverse
+
+      assert_equal(9, methods.count)
+      assert_equal('ExcludeMethodsTest#test_exclude_common_methods2', methods[0].full_name)
+      assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+      assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+      assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+      assert_equal('Kernel#sleep', methods[5].full_name)
+      assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+      assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+      assert_equal('Kernel#class', methods[8].full_name)
+    end
+  end
+
+  private
+
+  def assert_method_has_been_excluded(result, excluded_method)
+    result.threads.each do |thread|
+      thread.methods.each do |method|
+        method.call_trees.each do |ci|
+          assert(ci.target != excluded_method, "broken self")
+          assert(ci.parent.target != excluded_method, "broken parent") if ci.parent
+          ci.children.each do |callee|
+            assert(callee.target != excluded_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end

data/test/exclude_threads_test.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+
+# --  Tests ----
+class ExcludeThreadsTest < TestCase
+  def test_exclude_threads
+
+    def thread1_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    def thread2_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    thread1 = Thread.new do
+      thread1_proc
+    end
+
+    thread2 = Thread.new do
+      thread2_proc
+    end
+
+    result = RubyProf::Profile.profile(exclude_threads: [thread2]) do
+      thread1.join
+      thread2.join
+    end
+
+    assert_equal(2, result.threads.length)
+
+    output = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.full_name.index("ExcludeThreadsTest#thread") == 0
+          output.push(m.full_name)
+        end
+      end
+    end
+
+    assert_equal(1, output.length)
+    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
+  end
+end

data/test/fiber_test.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fiber'
+require 'timeout'
+require 'set'
+
+# --  Tests ----
+class FiberTest < TestCase
+  def enumerator_with_fibers
+    enum = Enumerator.new do |yielder|
+      [1,2].each do |x|
+        yielder.yield x
+      end
+    end
+
+    enum.next
+    enum.next
+  end
+
+  def fiber_yield_resume
+    fiber = Fiber.new do
+              Fiber.yield 1
+              Fiber.yield 2
+            end
+
+    fiber.resume
+    fiber.resume
+  end
+
+  def test_fibers
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { enumerator_with_fibers }
+
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
+
+    method = methods[0]
+    assert_equal('FiberTest#test_fibers', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[1]
+    assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[2]
+    assert_equal('Enumerator#next', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[3]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[4]
+    assert_equal('Enumerator#initialize', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    thread2 = result.threads[1]
+    methods = thread2.methods.sort.reverse
+    assert_equal(4, methods.count)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[0]
+    assert_equal('Enumerator#each', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[1]
+    assert_equal('Enumerator::Generator#each', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[2]
+    assert_equal('Array#each', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[3]
+    assert_equal('Enumerator::Yielder#yield', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+  end
+
+  def test_fiber_resume
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { fiber_yield_resume }
+
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
+
+    method = methods[0]
+    assert_equal('FiberTest#test_fiber_resume', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[1]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[2]
+    assert_equal('Fiber#resume', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[3]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[4]
+    assert_equal('Fiber#initialize', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    thread1 = result.threads[1]
+    methods = thread1.methods.sort.reverse
+    assert_equal(2, methods.count)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[0]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+
+    method = methods[1]
+    assert_equal('<Class::Fiber>#yield', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+  end
+end