ruby-prof 1.4.4-x64-mingw-ucrt

data/test/measure_times.rb

@@ -0,0 +1,56 @@
+# Some classes used in measurement tests
+require 'singleton'
+
+module RubyProf
+  class C1
+    def C1.sleep_wait
+      sleep(0.1)
+    end
+
+    def C1.busy_wait
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - starting) < 0.1
+      end
+    end
+
+    def sleep_wait
+      sleep(0.2)
+    end
+
+    def busy_wait
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - starting) < 0.2
+      end
+    end
+  end
+
+  module M1
+    def sleep_wait
+      sleep(0.3)
+    end
+
+    def busy_wait
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - starting) < 0.3
+      end
+    end
+  end
+
+  class C2
+    include M1
+    extend M1
+  end
+
+  class C3
+    include Singleton
+    def sleep_wait
+      sleep(0.3)
+    end
+
+    def busy_wait
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - starting) < 0.2
+      end
+    end
+  end
+end

data/test/measure_wall_time_test.rb

@@ -0,0 +1,426 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class MeasureWallTimeTest < 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_mode
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::measure_mode)
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      RubyProf::C1.sleep_wait
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.1, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('MeasureWallTimeTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#sleep_wait', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.03)
+    assert_in_delta(0, methods[0].wait_time, 0.03)
+    assert_in_delta(0, methods[0].self_time, 0.03)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.03)
+    assert_in_delta(0, methods[1].wait_time, 0.03)
+    assert_in_delta(0, methods[1].self_time, 0.03)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.03)
+    assert_in_delta(0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.1, methods[2].self_time, 0.03)
+  end
+
+  def test_class_methods_threaded
+    result = RubyProf.profile do
+      background_thread = Thread.new do
+        RubyProf::C1.sleep_wait
+      end
+      background_thread.join
+    end
+
+    assert_equal(2, result.threads.count)
+
+    thread = result.threads.first
+    assert_in_delta(0.1, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    # Check times
+    assert_equal('MeasureWallTimeTest#test_class_methods_threaded', methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.03)
+    assert_in_delta(0.0, methods[0].wait_time, 0.03)
+    assert_in_delta(0.0, methods[0].self_time, 0.03)
+    assert_in_delta(0.1, methods[0].children_time, 0.03)
+
+    assert_equal('Thread#join', methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.03)
+    assert_in_delta(0.1, methods[1].wait_time, 0.03)
+    assert_in_delta(0.0, methods[1].self_time, 0.03)
+    assert_in_delta(0.0, methods[1].children_time, 0.03)
+
+    assert_equal('<Class::Thread>#new', methods[2].full_name)
+    assert_in_delta(0.0, methods[2].total_time, 0.03)
+    assert_in_delta(0.0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.0, methods[2].self_time, 0.03)
+    assert_in_delta(0.0, methods[2].children_time, 0.03)
+
+    assert_equal('Thread#initialize', methods[3].full_name)
+    assert_in_delta(0.0, methods[3].total_time, 0.03)
+    assert_in_delta(0.0, methods[3].wait_time, 0.03)
+    assert_in_delta(0.0, methods[3].self_time, 0.03)
+    assert_in_delta(0.0, methods[3].children_time, 0.03)
+
+    thread = result.threads.last
+    assert_in_delta(0.1, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    methods = result.threads.last.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check times
+    assert_equal('MeasureWallTimeTest#test_class_methods_threaded', methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.03)
+    assert_in_delta(0.0, methods[0].wait_time, 0.03)
+    assert_in_delta(0.0, methods[0].self_time, 0.03)
+    assert_in_delta(0.1, methods[0].children_time, 0.03)
+
+    assert_equal('<Class::RubyProf::C1>#sleep_wait', methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.03)
+    assert_in_delta(0.0, methods[1].wait_time, 0.03)
+    assert_in_delta(0.0, methods[1].self_time, 0.03)
+    assert_in_delta(0.1, methods[1].children_time, 0.03)
+
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_in_delta(0.1, methods[2].total_time, 0.03)
+    assert_in_delta(0.0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.1, methods[2].self_time, 0.03)
+    assert_in_delta(0.0, methods[2].children_time, 0.03)
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C1.new.sleep_wait
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.2, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(5, methods.length)
+    names = methods.map(&:full_name)
+
+    # order can differ
+    assert(names.include?("BasicObject#initialize"))
+
+    # Check times
+    method = methods[0]
+    assert_equal('MeasureWallTimeTest#test_instance_methods', method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0, method.wait_time, 0.03)
+    assert_in_delta(0, method.self_time, 0.03)
+
+    method = methods[1]
+    assert_equal('RubyProf::C1#sleep_wait', method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0, method.wait_time, 0.03)
+    assert_in_delta(0, method.self_time, 0.03)
+
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0, method.wait_time, 0.03)
+    assert_in_delta(0.2, method.self_time, 0.03)
+
+    method = methods[3]
+    assert_equal('Class#new', method.full_name)
+    assert_in_delta(0, method.total_time, 0.03)
+    assert_in_delta(0, method.wait_time, 0.03)
+    assert_in_delta(0, method.self_time, 0.03)
+
+    method = methods[4]
+    assert_equal('BasicObject#initialize', method.full_name)
+    assert_in_delta(0, method.total_time, 0.03)
+    assert_in_delta(0, method.wait_time, 0.03)
+    assert_in_delta(0, method.self_time, 0.03)
+  end
+
+  def test_instance_methods_block
+    result = RubyProf.profile do
+      1.times { RubyProf::C1.new.sleep_wait }
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(6, methods.length)
+
+    # Check times
+    method = methods[0]
+    assert_equal("MeasureWallTimeTest#test_instance_methods_block", method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.2, method.children_time, 0.03)
+
+    method = methods[1]
+    assert_equal("Integer#times", method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.2, method.children_time, 0.03)
+
+    method = methods[2]
+    assert_equal("RubyProf::C1#sleep_wait", method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.2, method.children_time, 0.03)
+
+    method = methods[3]
+    assert_equal("Kernel#sleep", method.full_name)
+    assert_in_delta(0.2, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.2, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+
+    method = methods[4]
+    assert_equal("Class#new", method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+
+    method = methods[5]
+    assert_equal("BasicObject#initialize", method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+  end
+
+  def test_instance_methods_threaded
+    result = RubyProf.profile do
+      background_thread = Thread.new do
+        RubyProf::C1.new.sleep_wait
+      end
+      background_thread.join
+    end
+
+    assert_equal(2, result.threads.count)
+
+    thread = result.threads.first
+    assert_in_delta(0.2, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    # Check times
+    assert_equal('MeasureWallTimeTest#test_instance_methods_threaded', methods[0].full_name)
+    assert_in_delta(0.2, methods[0].total_time, 0.03)
+    assert_in_delta(0.0, methods[0].wait_time, 0.03)
+    assert_in_delta(0.0, methods[0].self_time, 0.03)
+    assert_in_delta(0.2, methods[0].children_time, 0.03)
+
+    assert_equal('Thread#join', methods[1].full_name)
+    assert_in_delta(0.2, methods[1].total_time, 0.03)
+    assert_in_delta(0.2, methods[1].wait_time, 0.03)
+    assert_in_delta(0.0, methods[1].self_time, 0.03)
+    assert_in_delta(0.0, methods[1].children_time, 0.03)
+
+    assert_equal('<Class::Thread>#new', methods[2].full_name)
+    assert_in_delta(0.0, methods[2].total_time, 0.03)
+    assert_in_delta(0.0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.0, methods[2].self_time, 0.03)
+    assert_in_delta(0.0, methods[2].children_time, 0.03)
+
+    assert_equal('Thread#initialize', methods[3].full_name)
+    assert_in_delta(0.0, methods[3].total_time, 0.03)
+    assert_in_delta(0.0, methods[3].wait_time, 0.03)
+    assert_in_delta(0.0, methods[3].self_time, 0.03)
+    assert_in_delta(0.0, methods[3].children_time, 0.03)
+
+    thread = result.threads.last
+    assert_in_delta(0.2, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    methods = result.threads.last.methods.sort.reverse
+    assert_equal(5, methods.length)
+
+    # Check times
+    assert_equal('MeasureWallTimeTest#test_instance_methods_threaded', methods[0].full_name)
+    assert_in_delta(0.2, methods[0].total_time, 0.03)
+    assert_in_delta(0.0, methods[0].wait_time, 0.03)
+    assert_in_delta(0.0, methods[0].self_time, 0.03)
+    assert_in_delta(0.2, methods[0].children_time, 0.03)
+
+    assert_equal('RubyProf::C1#sleep_wait', methods[1].full_name)
+    assert_in_delta(0.2, methods[1].total_time, 0.03)
+    assert_in_delta(0.0, methods[1].wait_time, 0.03)
+    assert_in_delta(0.0, methods[1].self_time, 0.03)
+    assert_in_delta(0.2, methods[1].children_time, 0.03)
+
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_in_delta(0.2, methods[2].total_time, 0.03)
+    assert_in_delta(0.0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.2, methods[2].self_time, 0.03)
+    assert_in_delta(0.0, methods[2].children_time, 0.03)
+
+    assert_equal('Class#new', methods[3].full_name)
+    assert_in_delta(0.0, methods[3].total_time, 0.03)
+    assert_in_delta(0.0, methods[3].wait_time, 0.03)
+    assert_in_delta(0.0, methods[3].self_time, 0.03)
+    assert_in_delta(0.0, methods[3].children_time, 0.03)
+
+    assert_equal('BasicObject#initialize', methods[4].full_name)
+    assert_in_delta(0.0, methods[4].total_time, 0.03)
+    assert_in_delta(0.0, methods[4].wait_time, 0.03)
+    assert_in_delta(0.0, methods[4].self_time, 0.03)
+    assert_in_delta(0.0, methods[4].children_time, 0.03)
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      RubyProf::C2.sleep_wait
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_module_methods', methods[0].full_name)
+    assert_equal('RubyProf::M1#sleep_wait', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.03)
+    assert_in_delta(0, methods[0].self_time, 0.03)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
+    assert_in_delta(0, methods[1].wait_time, 0.03)
+    assert_in_delta(0, methods[1].self_time, 0.03)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.3, methods[2].self_time, 0.1)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C2.new.sleep_wait
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(5, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('MeasureWallTimeTest#test_module_instance_methods', names[0])
+    assert_equal('RubyProf::M1#sleep_wait', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+
+    # order can differ
+    assert(names.include?("BasicObject#initialize"))
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.1)
+    assert_in_delta(0, methods[0].self_time, 0.1)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.03)
+    assert_in_delta(0, methods[1].wait_time, 0.03)
+    assert_in_delta(0, methods[1].self_time, 0.03)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.03)
+    assert_in_delta(0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.3, methods[2].self_time, 0.03)
+
+    assert_in_delta(0, methods[3].total_time, 0.03)
+    assert_in_delta(0, methods[3].wait_time, 0.03)
+    assert_in_delta(0, methods[3].self_time, 0.03)
+
+    assert_in_delta(0, methods[4].total_time, 0.03)
+    assert_in_delta(0, methods[4].wait_time, 0.03)
+    assert_in_delta(0, methods[4].self_time, 0.03)
+  end
+
+  def test_singleton_methods
+    result = RubyProf.profile do
+      RubyProf::C3.instance.sleep_wait
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(7, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_singleton_methods', methods[0].full_name)
+    assert_in_delta(0.3, methods[0].total_time, 0.03)
+    assert_in_delta(0.0, methods[0].wait_time, 0.03)
+    assert_in_delta(0.0, methods[0].self_time, 0.03)
+    assert_in_delta(0.3, methods[0].children_time, 0.03)
+
+    assert_equal('RubyProf::C3#sleep_wait', methods[1].full_name)
+    assert_in_delta(0.3, methods[1].total_time, 0.03)
+    assert_in_delta(0.0, methods[1].wait_time, 0.03)
+    assert_in_delta(0.0, methods[1].self_time, 0.03)
+    assert_in_delta(0.3, methods[1].children_time, 0.03)
+
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_in_delta(0.3, methods[2].total_time, 0.03)
+    assert_in_delta(0.0, methods[2].wait_time, 0.03)
+    assert_in_delta(0.3, methods[2].self_time, 0.03)
+    assert_in_delta(0.0, methods[2].children_time, 0.03)
+
+    method = methods.detect {|a_method| a_method.full_name == 'Singleton::SingletonClassMethods#instance'}
+    assert_equal('Singleton::SingletonClassMethods#instance', method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+
+    method = methods.detect {|a_method| a_method.full_name == 'Thread::Mutex#synchronize'}
+    assert_equal('Thread::Mutex#synchronize', method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+
+    method = methods.detect {|a_method| a_method.full_name == 'Class#new'}
+    assert_equal('Class#new', method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+
+    method = methods.detect {|a_method| a_method.full_name == 'BasicObject#initialize'}
+    assert_equal('BasicObject#initialize', method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
+  end
+end

data/test/multi_printer_test.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class MSTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MultiPrinterTest < 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_refuses_io_objects
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print(STDOUT)
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/IO/, e.to_s)
+    end
+  end
+
+  def test_refuses_non_hashes
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print([])
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/hash/, e.to_s)
+    end
+  end
+
+  private
+
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = Dir.tmpdir
+    profile = "ruby_prof_#{test}"
+    printer = RubyProf::MultiPrinter.new(result)
+    printer.print(:path => path, :profile => profile,
+                  :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")
+    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+      system("open '#{printer.stack_profile}'")
+    end
+    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
+  end
+end

data/test/no_method_class_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Make sure this works with no class or method
+result = RubyProf.profile do
+  sleep 1
+end
+
+methods = result.threads.first.methods
+global_method = methods.sort_by {|method| method.full_name}.first
+if global_method.full_name != 'Kernel#sleep'
+  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
+end