ruby-prof 0.17.0 → 0.18.0

data/test/thread_test.rb

@@ -1,187 +1,187 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'timeout'
-require 'benchmark'
-
-# --  Tests ----
-class ThreadTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_thread_count
-    RubyProf.start
-
-    thread = Thread.new do
-      sleep(1)
-    end
-
-    thread.join
-    result = RubyProf.stop
-    assert_equal(2, result.threads.length)
-  end
-
-  def test_thread_identity
-    RubyProf.start
-    sleep_thread = Thread.new do
-      sleep(1)
-    end
-    sleep_thread.join
-    result = RubyProf.stop
-
-    thread_ids = result.threads.map {|thread| thread.id}.sort
-    threads = [Thread.current, sleep_thread]
-    assert_equal(2, result.threads.length)
-
-    assert(thread_ids.include?(threads[0].object_id))
-    assert(thread_ids.include?(threads[1].object_id))
-
-    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
-    assert(threads.include?(ObjectSpace._id2ref(thread_ids[0])))
-
-    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
-    assert(threads.include?(ObjectSpace._id2ref(thread_ids[1])))
-  end
-
-  def test_thread_timings
-    RubyProf.start
-    thread = Thread.new do
-      sleep 0
-      # force it to hit thread.join, below, first
-      # thus forcing sleep(1), below, to be counted as (wall) self_time
-      # since we currently count time "in some other thread" as self.wait_time
-      # for whatever reason
-      sleep(1)
-    end
-    thread.join
-    result = RubyProf.stop
-
-    # Check background thread
-    assert_equal(2, result.threads.length)
-
-    rp_thread = result.threads.detect {|t| t.id == thread.object_id}
-    methods = rp_thread.methods.sort.reverse
-    # fails on travis. why?
-    # expected_methods = ["ThreadTest#test_thread_timings", "Kernel#sleep"]
-    # assert_equal(expected_methods, methods.map(&:full_name))
-
-    method = methods[0]
-    assert_equal('ThreadTest#test_thread_timings', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(1, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[1]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(1.0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    # Check foreground thread
-    rp_thread = result.threads.detect {|athread| athread.id == Thread.current.object_id}
-    methods = rp_thread.methods.sort.reverse
-    assert_equal(4, methods.length)
-    methods = methods.sort.reverse
-
-    method = methods[0]
-    assert_equal('ThreadTest#test_thread_timings', method.full_name)
-    # the sub calls to Object#new, when popped,
-    # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
-    # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
-    assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(1, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
-    assert_equal(2, call_info.children.length)
-
-    method = methods[1]
-    assert_equal('Thread#join', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(1.0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings->Thread#join', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    method = methods[2]
-    assert_equal('<Class::Thread>#new', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[3]
-    assert_equal('Thread#initialize', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new->Thread#initialize', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-  end
-
-  # useless test: what does it test?
-  def test_thread_back_and_forth
-    result = nil
-    seconds = Benchmark.realtime do
-      result = RubyProf.profile do
-        a = Thread.new { 100_000.times { sleep 0 }}
-        b = Thread.new { 100_000.times { sleep 0 }}
-        a.join
-        b.join
-      end
-    end
-    methods = result.threads.map {|thread| thread.methods}
-    timings = methods.flatten.sort
-    assert(timings[-1].total_time < seconds)
-  end
-
-  # useless test: what does it test?
-  def test_thread
-    RubyProf.profile do
-      begin
-        Timeout::timeout(2) do
-          while true
-            next
-          end
-        end
-      rescue Timeout::Error
-      end
-    end
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'timeout'
+require 'benchmark'
+
+# --  Tests ----
+class ThreadTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_thread_count
+    RubyProf.start
+
+    thread = Thread.new do
+      sleep(1)
+    end
+
+    thread.join
+    result = RubyProf.stop
+    assert_equal(2, result.threads.length)
+  end
+
+  def test_thread_identity
+    RubyProf.start
+    sleep_thread = Thread.new do
+      sleep(1)
+    end
+    sleep_thread.join
+    result = RubyProf.stop
+
+    thread_ids = result.threads.map {|thread| thread.id}.sort
+    threads = [Thread.current, sleep_thread]
+    assert_equal(2, result.threads.length)
+
+    assert(thread_ids.include?(threads[0].object_id))
+    assert(thread_ids.include?(threads[1].object_id))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[0])))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[1])))
+  end
+
+  def test_thread_timings
+    RubyProf.start
+    thread = Thread.new do
+      sleep 0
+      # force it to hit thread.join, below, first
+      # thus forcing sleep(1), below, to be counted as (wall) self_time
+      # since we currently count time "in some other thread" as self.wait_time
+      # for whatever reason
+      sleep(1)
+    end
+    thread.join
+    result = RubyProf.stop
+
+    # Check background thread
+    assert_equal(2, result.threads.length)
+
+    rp_thread = result.threads.detect {|t| t.id == thread.object_id}
+    methods = rp_thread.methods.sort.reverse
+    # fails on travis. why?
+    # expected_methods = ["ThreadTest#test_thread_timings", "Kernel#sleep"]
+    # assert_equal(expected_methods, methods.map(&:full_name))
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.05)
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(1.0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    # Check foreground thread
+    rp_thread = result.threads.detect {|athread| athread.id == Thread.current.object_id}
+    methods = rp_thread.methods.sort.reverse
+    assert_equal(4, methods.length)
+    methods = methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    # the sub calls to Object#new, when popped,
+    # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
+    # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.05)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
+    assert_equal(2, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(1.0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings->Thread#join', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[2]
+    assert_equal('<Class::Thread>#new', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[3]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new->Thread#initialize', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+
+  # useless test: what does it test?
+  def test_thread_back_and_forth
+    result = nil
+    seconds = Benchmark.realtime do
+      result = RubyProf.profile do
+        a = Thread.new { 100_000.times { sleep 0 }}
+        b = Thread.new { 100_000.times { sleep 0 }}
+        a.join
+        b.join
+      end
+    end
+    methods = result.threads.map {|thread| thread.methods}
+    timings = methods.flatten.sort
+    assert(timings[-1].total_time < seconds)
+  end
+
+  # useless test: what does it test?
+  def test_thread
+    RubyProf.profile do
+      begin
+        Timeout::timeout(2) do
+          while true
+            next
+          end
+        end
+      rescue Timeout::Error
+      end
+    end
+  end
+end

data/test/unique_call_path_test.rb

@@ -1,202 +1,202 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class UniqueCallPath
-  def method_a(i)
-    if i==1
-      method_b
-    else
-      method_c
-    end
-  end
-
-  def method_b
-    method_c
-  end
-
-  def method_c
-  end
-
-  def method_k(i)
-    method_a(i)
-  end
-end
-
-
-# --  Tests ----
-class UniqueCallPathTest < TestCase
-  def test_root_method
-    unique_call_path = UniqueCallPath.new
-
-    result = RubyProf.profile do
-      unique_call_path.method_a(1)
-    end
-
-    root_methods = Array.new
-    result.threads.each do |thread|
-      thread.methods.each do | m |
-        if m.root?
-          root_methods.push(m)
-        end
-      end
-    end
-
-    assert_equal(1, root_methods.length)
-    assert_equal("UniqueCallPathTest#test_root_method", root_methods[0].full_name)
-  end
-
-  def test_root_children
-    unique_call_path = UniqueCallPath.new
-
-    result = RubyProf.profile do
-      unique_call_path.method_a(1)
-      unique_call_path.method_k(2)
-    end
-
-    root_methods = Array.new
-    result.threads.each do |thread|
-      thread.methods.each do | m |
-        if m.root?
-          root_methods.push(m)
-        end
-      end
-    end
-
-    assert_equal(1, root_methods.length)
-
-    root_children = Array.new
-    root_methods[0].children.each do | c |
-      if c.parent.target.eql?(root_methods[0])
-        root_children.push(c)
-      end
-    end
-
-    children = root_children.sort do |c1, c2|
-      c1.target.full_name <=> c2.target.full_name
-    end
-
-    assert_equal(2, children.length)
-    assert_equal("UniqueCallPath#method_a", children[0].target.full_name)
-    assert_equal("UniqueCallPath#method_k", children[1].target.full_name)
-  end
-
-  def test_children_of
-    unique_call_path = UniqueCallPath.new
-
-    result = RubyProf.profile do
-      unique_call_path.method_a(1)
-      unique_call_path.method_k(2)
-    end
-
-    root_methods = Array.new
-    result.threads.each do |thread|
-      thread.methods.each do | m |
-        if m.root?
-          root_methods.push(m)
-        end
-      end
-    end
-
-    assert_equal(1, root_methods.length)
-    method = root_methods[0]
-    assert_equal('UniqueCallPathTest#test_children_of', method.full_name)
-
-    call_info_a = nil
-    root_methods[0].children.each do | c |
-      if c.target.full_name == "UniqueCallPath#method_a"
-        call_info_a = c
-        break
-      end
-    end
-
-    assert !call_info_a.nil?
-
-    children_of_a = Array.new
-
-    call_info_a.children.each do | c |
-      if c.parent.eql?(call_info_a)
-        children_of_a.push(c)
-      end
-    end
-
-    assert_equal(2, call_info_a.target.children.length)
-
-    children_of_a = children_of_a.sort do |c1, c2|
-      c1.target.full_name <=> c2.target.full_name
-    end
-
-    assert_equal(1, children_of_a.length)
-    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
-  end
-
-  def test_id2ref
-    unique_call_path = UniqueCallPath.new
-
-    result = RubyProf.profile do
-      unique_call_path.method_a(1)
-    end
-
-    root_methods = Array.new
-    result.threads.each do |thread|
-      thread.methods.each do | m |
-        if m.root?
-          root_methods.push(m)
-        end
-      end
-    end
-
-    child = root_methods[0].children[0]
-
-    refute_equal(0, child.object_id)
-    #assert_equal(RubyProf::CallInfo.id2ref(child.id).target.full_name, child.target.full_name)
-  end
-
-  def test_unique_path
-    unique_call_path = UniqueCallPath.new
-
-    result = RubyProf.profile do
-      unique_call_path.method_a(1)
-      unique_call_path.method_k(1)
-    end
-
-    root_methods = Array.new
-    result.threads.each do |thread|
-      thread.methods.each do | m |
-        if m.root?
-          root_methods.push(m)
-        end
-      end
-    end
-
-    assert_equal(1, root_methods.length)
-
-    call_info_a = nil
-    root_methods[0].children.each do | c |
-      if c.target.full_name == "UniqueCallPath#method_a"
-        call_info_a = c
-        break
-      end
-    end
-
-    assert !call_info_a.nil?
-
-    children_of_a = Array.new
-    call_info_a.children.each do |c|
-      if c.parent.eql?(call_info_a)
-        children_of_a.push(c)
-      end
-    end
-
-    assert_equal(2, call_info_a.target.children.length)
-
-    children_of_a = children_of_a.sort do |c1, c2|
-      c1.target.full_name <=> c2.target.full_name
-    end
-
-    assert_equal(1, children_of_a.length)
-    assert_equal(1, children_of_a[0].called)
-    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class UniqueCallPath
+  def method_a(i)
+    if i==1
+      method_b
+    else
+      method_c
+    end
+  end
+
+  def method_b
+    method_c
+  end
+
+  def method_c
+  end
+
+  def method_k(i)
+    method_a(i)
+  end
+end
+
+
+# --  Tests ----
+class UniqueCallPathTest < TestCase
+  def test_root_method
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+    assert_equal("UniqueCallPathTest#test_root_method", root_methods[0].full_name)
+  end
+
+  def test_root_children
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_methods = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+
+    root_children = Array.new
+    root_methods[0].children.each do | c |
+      if c.parent.target.eql?(root_methods[0])
+        root_children.push(c)
+      end
+    end
+
+    children = root_children.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, children.length)
+    assert_equal("UniqueCallPath#method_a", children[0].target.full_name)
+    assert_equal("UniqueCallPath#method_k", children[1].target.full_name)
+  end
+
+  def test_children_of
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_methods = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+    method = root_methods[0]
+    assert_equal('UniqueCallPathTest#test_children_of', method.full_name)
+
+    call_info_a = nil
+    root_methods[0].children.each do | c |
+      if c.target.full_name == "UniqueCallPath#method_a"
+        call_info_a = c
+        break
+      end
+    end
+
+    assert !call_info_a.nil?
+
+    children_of_a = Array.new
+
+    call_info_a.children.each do | c |
+      if c.parent.eql?(call_info_a)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(2, call_info_a.target.children.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(1, children_of_a.length)
+    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+  end
+
+  def test_id2ref
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    child = root_methods[0].children[0]
+
+    refute_equal(0, child.object_id)
+    #assert_equal(RubyProf::CallInfo.id2ref(child.id).target.full_name, child.target.full_name)
+  end
+
+  def test_unique_path
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+
+    call_info_a = nil
+    root_methods[0].children.each do | c |
+      if c.target.full_name == "UniqueCallPath#method_a"
+        call_info_a = c
+        break
+      end
+    end
+
+    assert !call_info_a.nil?
+
+    children_of_a = Array.new
+    call_info_a.children.each do |c|
+      if c.parent.eql?(call_info_a)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(2, call_info_a.target.children.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(1, children_of_a.length)
+    assert_equal(1, children_of_a[0].called)
+    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+  end
+end