ruby-prof 1.0.0

data/test/abstract_printer_test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class AbstractPrinterTest < TestCase
+  def setup
+    @result = {}
+    @printer = RubyProf::AbstractPrinter.new(@result)
+    @options = {}
+    @printer.setup_options(@options)
+  end
+
+  private
+
+  def with_const_stubbed(name, value)
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    old_value = Object.const_get(name)
+
+    Object.const_set(name, value)
+    yield
+    Object.const_set(name, old_value)
+
+    $VERBOSE = old_verbose
+  end
+end

data/test/alias_test.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+class AliasTest < TestCase
+  class TestMe
+    def some_method
+      sleep(0.1)
+    end
+
+    alias :some_method_original :some_method
+    def some_method
+      some_method_original
+    end
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  # This test only correct works on Ruby 2.5 and higher because - see:
+  # https://bugs.ruby-lang.org/issues/12747
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+    def test_alias
+      result = RubyProf.profile do
+        TestMe.new.some_method
+      end
+
+      methods = result.threads.first.methods
+      assert_equal(6, methods.count)
+
+      # Method 0
+      method = methods[0]
+      assert_equal('AliasTest#test_alias', method.full_name)
+      assert_equal(28, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_nil(call_info.parent)
+      assert_equal(28, call_info.line)
+
+      assert_equal(2, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('Class#new', call_info.target.full_name)
+      assert_equal(28, call_info.line)
+
+      call_info = method.callees[1]
+      assert_equal('AliasTest::TestMe#some_method', call_info.target.full_name)
+      assert_equal(28, call_info.line)
+
+      # Method 1
+      method = methods[1]
+      assert_equal('Class#new', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
+      assert_equal(28, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('BasicObject#initialize', call_info.target.full_name)
+      assert_equal(0, call_info.line)
+
+      # Method 2
+      method = methods[2]
+      assert_equal('BasicObject#initialize', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('Class#new', call_info.parent.full_name)
+      assert_equal(0, call_info.line)
+
+      assert_equal(0, method.callees.count)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('AliasTest::TestMe#some_method', method.full_name)
+      assert_equal(13, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
+      assert_equal(28, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_info.target.full_name)
+      assert_equal(14, call_info.line)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('AliasTest::TestMe#some_method_original', method.full_name)
+      assert_equal(8, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest::TestMe#some_method', call_info.parent.full_name)
+      assert_equal(14, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('Kernel#sleep', call_info.target.full_name)
+      assert_equal(9, call_info.line)
+
+      # Method 5
+      method = methods[5]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_info.parent.full_name)
+      assert_equal(9, call_info.line)
+
+      assert_equal(0, method.callees.count)
+    end
+  end
+end

data/test/basic_test.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class BasicTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def start
+    RubyProf.start
+    RubyProf::C1.sleep_wait
+  end
+
+  def test_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+
+  def test_double_profile
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    RubyProf.stop
+  end
+
+  def test_no_block
+    assert_raises(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+
+  def test_traceback
+    RubyProf.start
+    assert_raises(NoMethodError) do
+      RubyProf.xxx
+    end
+
+    RubyProf.stop
+  end
+
+  def test_leave_method
+    start
+    sleep 0.15
+    profile = RubyProf.stop
+
+    assert_equal(1, profile.threads.count)
+
+    thread = profile.threads.first
+    assert_in_delta(0.25, thread.total_time, 0.05)
+
+    root_methods = thread.root_methods.sort
+    assert_equal(2, root_methods.count)
+    assert_equal("BasicTest#start", root_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method", root_methods[1].full_name)
+
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
+
+    # Check times
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.05)
+    assert_in_delta(0.0,  methods[0].wait_time, 0.05)
+    assert_in_delta(0.0,  methods[0].self_time, 0.05)
+
+    assert_equal("BasicTest#start", methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.05)
+    assert_in_delta(0.0, methods[1].wait_time, 0.05)
+    assert_in_delta(0.0, methods[1].self_time, 0.05)
+
+    assert_equal("BasicTest#test_leave_method", methods[2].full_name)
+    assert_in_delta(0.15, methods[2].total_time, 0.05)
+    assert_in_delta(0.0, methods[2].wait_time, 0.05)
+    assert_in_delta(0.0, methods[2].self_time, 0.05)
+
+    assert_equal("Kernel#sleep", methods[3].full_name)
+    assert_in_delta(0.25, methods[3].total_time, 0.05)
+    assert_in_delta(0.0, methods[3].wait_time, 0.05)
+    assert_in_delta(0.25, methods[3].self_time, 0.05)
+  end
+
+  def test_leave_method_2
+    start
+    RubyProf::C1.sleep_wait
+    RubyProf::C1.sleep_wait
+    profile = RubyProf.stop
+
+    assert_equal(1, profile.threads.count)
+
+    thread = profile.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.05)
+
+    root_methods = thread.root_methods.sort
+    assert_equal(2, root_methods.count)
+    assert_equal("BasicTest#start", root_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method_2", root_methods[1].full_name)
+
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
+
+    # Check times
+    assert_equal("BasicTest#start", methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.05)
+    assert_in_delta(0.0, methods[0].wait_time, 0.05)
+    assert_in_delta(0.0, methods[0].self_time, 0.05)
+
+    assert_equal("BasicTest#test_leave_method_2", methods[1].full_name)
+    assert_in_delta(0.2, methods[1].total_time, 0.05)
+    assert_in_delta(0.0, methods[1].wait_time, 0.05)
+    assert_in_delta(0.0, methods[1].self_time, 0.05)
+
+    assert_equal("Kernel#sleep", methods[2].full_name)
+    assert_in_delta(0.3, methods[2].total_time, 0.05)
+    assert_in_delta(0.0, methods[2].wait_time, 0.05)
+    assert_in_delta(0.3, methods[2].self_time, 0.05)
+
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[3].full_name)
+    assert_in_delta(0.3, methods[3].total_time, 0.05)
+    assert_in_delta(0.0, methods[3].wait_time, 0.05)
+    assert_in_delta(0.0, methods[3].self_time, 0.05)
+  end
+end

data/test/call_info_visitor_test.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class CallInfoVisitorTest < 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_visit
+    result = RubyProf.profile do
+      RubyProf::C1.sleep_wait
+    end
+
+    visitor = RubyProf::CallInfoVisitor.new(result.threads.first.root_methods)
+
+    method_names = Array.new
+
+    visitor.visit do |call_info, event|
+      method_names << call_info.target.full_name if event == :enter
+    end
+
+    assert_equal(3, method_names.length)
+    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", method_names[1])
+    assert_equal("Kernel#sleep", method_names[2])
+  end
+end
+

data/test/duplicate_names_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class DuplicateNames < TestCase
+  def test_names
+    result = RubyProf::profile do
+      str = %{module Foo; class Bar; def foo; end end end}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+    end
+
+    # There should be 3 foo methods
+    methods = result.threads.first.methods.sort.reverse
+
+    methods = methods.select do |method|
+      method.full_name == 'DuplicateNames::Foo::Bar#foo'
+    end
+
+    assert_equal(3, methods.length)
+  end
+end

data/test/dynamic_method_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+class DynamicMethodTest < TestCase
+
+  class FruitMedley
+    define_method(:apple) do
+      sleep(0.1)
+      "I'm a peach"
+    end
+
+    define_method(:orange) do
+      sleep(0.2)
+      "I'm an orange"
+    end
+
+    [:banana, :peach].each_with_index do |fruit,i|
+      define_method(fruit) do
+        sleep(i == 0 ? 0.3 : 0.4)
+        "I'm a #{fruit}"
+      end
+    end
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_dynamic_method
+    medley = FruitMedley.new
+    result = RubyProf.profile do
+      medley.apple
+      medley.orange
+      medley.banana
+      medley.peach
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    expected_method_names = %w(
+      DynamicMethodTest#test_dynamic_method
+      Kernel#sleep
+      DynamicMethodTest::FruitMedley#peach
+      DynamicMethodTest::FruitMedley#banana
+      DynamicMethodTest::FruitMedley#orange
+      DynamicMethodTest::FruitMedley#apple
+      Symbol#to_s
+    )
+    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
+  end
+end

data/test/enumerable_test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Test for bug
+# http://github.com/rdp/ruby-prof/issues#issue/12
+
+class EnumerableTest < TestCase
+  def test_enumerable
+    result = RubyProf.profile do
+      3.times {  [1,2,3].any? {|n| n} }
+    end
+    methods = if RUBY_VERSION >= "2.2.0"
+      %w(EnumerableTest#test_enumerable Integer#times Array#any?)
+    else
+      %w(EnumerableTest#test_enumerable Integer#times Enumerable#any? Array#each)
+    end
+    assert_equal(methods, result.threads.first.methods.map(&:full_name))
+  end
+end

data/test/exceptions_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class ExceptionsTest < TestCase
+  def test_profile
+    result = begin
+      RubyProf.profile do
+        raise(RuntimeError, 'Test error')
+      end
+    rescue
+    end
+    assert_kind_of(RubyProf::Profile, result)
+  end
+
+  def test_profile_allows_exceptions
+    assert_raises(RuntimeError) do
+      RubyProf.profile(:allow_exceptions => true) do
+        raise(RuntimeError, 'Test error')
+      end
+    end
+  end
+end