ruby-prof 0.18.0-x64-mingw32

data/test/start_stop_test.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class StartStopTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def method1
+     RubyProf.start
+     method2
+  end
+
+  def method2
+     method3
+  end
+
+  def method3
+    sleep(2)
+    @result = RubyProf.stop
+  end
+  
+  def test_extra_stop_should_raise
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    
+    assert_raises(RuntimeError) do
+      RubyProf.profile {}
+    end
+    
+    RubyProf.stop # ok
+    assert_raises(RuntimeError) do
+      RubyProf.stop
+    end
+  end
+    
+
+  def test_different_methods
+    method1
+
+    # Ruby prof should be stopped
+    assert_equal(false, RubyProf.running?)
+
+
+    # Length should be 4:
+    #   StartStopTest#method1
+    #   StartStopTest#method2
+    #   StartStopTest#method3
+    #   Kernel#sleep
+
+    methods = @result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    # Check StackTest#test_call_sequence
+    method = methods[0]
+    assert_equal('StartStopTest#method1', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('StartStopTest#method2', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[2]
+    assert_equal('StartStopTest#method3', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.self_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,267 @@
+# encoding: UTF-8
+
+require "rubygems"
+gem "minitest"
+
+# To make testing/debugging easier, test within this source tree versus an installed gem
+dir = File.dirname(__FILE__)
+root = File.expand_path(File.join(dir, '..'))
+lib = File.expand_path(File.join(root, 'lib'))
+ext = File.expand_path(File.join(root, 'ext', 'ruby_prof'))
+
+$LOAD_PATH << lib
+$LOAD_PATH << ext
+
+require 'ruby-prof'
+
+# stub deprecation warnings
+module RubyProf
+  module SuppressDeprecationWarnings
+    def deprecation_warning(*args)
+      super if ENV['SHOW_RUBY_PROF_DEPRECATION_WARNINGS'] == '1'
+    end
+  end
+  extend SuppressDeprecationWarnings
+end
+
+require 'minitest/autorun'
+
+class TestCase < Minitest::Test
+  # I know this sucks, but ...
+  def assert_nothing_raised(*)
+    yield
+  end
+
+  def before_setup
+    # make sure to exclude all threads except the one running the test
+    # minitest allocates a thread pool and they would otherwise show
+    # up in the profile data, breaking tests randomly
+    RubyProf.exclude_threads = Thread.list.select{|t| t != Thread.current}
+  end
+
+  def after_teardown
+    # reset exclude threads after testing
+    RubyProf.exclude_threads = nil
+  end
+end
+
+require File.expand_path('../prime', __FILE__)
+
+# Some classes used in measurement tests
+module RubyProf
+  class C1
+    def C1.hello
+      sleep(0.1)
+    end
+
+    def hello
+      sleep(0.2)
+    end
+  end
+
+  module M1
+    def hello
+      sleep(0.3)
+    end
+  end
+
+  class C2
+    include M1
+    extend M1
+  end
+
+  class C3
+    def hello
+      sleep(0.4)
+    end
+  end
+
+  module M4
+    def hello
+      sleep(0.5)
+    end
+  end
+
+  module M5
+    include M4
+    def goodbye
+      hello
+    end
+  end
+
+  class C6
+    include M5
+    def test
+      goodbye
+    end
+  end
+
+  class C7
+    def self.busy_wait
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.1; end
+    end
+
+    def self.sleep_wait
+      sleep 0.1
+    end
+
+    def busy_wait
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.2; end
+    end
+
+    def sleep_wait
+      sleep 0.2
+    end
+  end
+
+  module M7
+    def busy_wait
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.3; end
+    end
+
+    def sleep_wait
+      sleep 0.3
+    end
+  end
+
+  class C8
+    include M7
+    extend M7
+  end
+
+  def self.ruby_major_version
+    match = RUBY_VERSION.match(/(\d)\.(\d)/)
+    return Integer(match[1])
+  end
+
+  def self.ruby_minor_version
+    match = RUBY_VERSION.match(/(\d)\.(\d)/)
+    return Integer(match[2])
+  end
+
+  def self.parent_object
+    if ruby_major_version == 1 && ruby_minor_version == 8
+      Object
+    else
+      BasicObject
+    end
+  end
+
+  def self.ruby_2?
+    ruby_major_version == 2
+  end
+
+  # store printer output in this directory
+  def self.tmpdir
+    path = File.expand_path('../../tmp', __FILE__)
+    unless Dir.exist?(path)
+      Dir.mkdir(path)
+    end
+    path
+  end
+end
+
+module MemoryTestHelper
+  def memory_test_helper
+    result = RubyProf.profile {Array.new}
+    total = result.threads.first.methods.inject(0) { |sum, m| sum + m.total_time }
+    assert(total < 1_000_000, 'Total should not have subtract overflow error')
+    total
+  end
+end
+
+module PrinterTestHelper
+  Metrics = Struct.new(:name, :total, :self_t, :wait, :child, :calls)
+  class Metrics
+    def pp
+      "%s[total: %.2f, self: %.2f, wait: %.2f, child: %.2f, calls: %s]" %
+        [name, total, self_t, wait, child, calls]
+    end
+  end
+
+  Entry = Struct.new(:total_p, :self_p, :metrics, :parents, :children)
+  class Entry
+    def child(name)
+      children.detect{|m| m.name == name}
+    end
+
+    def parent(name)
+      parents.detect{|m| m.name == name}
+    end
+
+    def pp
+      res = ""
+      res << "NODE (total%%: %.2f, self%%: %.2f) %s\n" % [total_p, self_p, metrics.pp]
+      res << "  PARENTS:\n"
+      parents.each {|m| res << "    " + m.pp << "\n"}
+      res << "  CHILDREN:\n"
+      children.each {|m| res << "    " + m.pp << "\n"}
+      res
+    end
+  end
+
+  class MetricsArray < Array
+    def metrics_for(name)
+      detect {|e| e.metrics.name == name}
+    end
+
+    def pp(io = STDOUT)
+      entries = map do |e|
+        begin
+          e.pp
+        rescue
+          puts $!.message + e.inspect
+          ""
+        end
+      end
+      io.puts entries.join("--------------------------------------------------\n")
+    end
+
+    def self.parse(str)
+      res = new
+      entry = nil
+      relatives = []
+      state = :preamble
+
+      str.each_line do |l|
+        line = l.chomp.strip
+        if line =~ /-----/
+          if state == :preamble
+            state = :parsing_parents
+            entry = Entry.new
+          elsif state == :parsing_parents
+            entry = Entry.new
+          elsif state == :parsing_children
+            entry.children = relatives
+            res << entry
+            entry = Entry.new
+            relatives = []
+            state = :parsing_parents
+          end
+        elsif line =~ /^\s*$/ || line =~ /indicates recursively called methods/
+          next
+        elsif state != :preamble
+          elements = line.split(/\s+/)
+          method = elements.pop
+          numbers = elements[0..-2].map(&:to_f)
+          metrics = Metrics.new(method, *numbers[-4..-1], elements[-1])
+          if numbers.size == 6
+            entry.metrics = metrics
+            entry.total_p = numbers[0]
+            entry.self_p = numbers[1]
+            entry.parents = relatives
+            entry.children = relatives = []
+            state = :parsing_children
+            res << entry
+          else
+            relatives << metrics
+          end
+        end
+      end
+      res
+    end
+  end
+end

data/test/thread_test.rb

@@ -0,0 +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