ruby-prof 1.8.0-x64-mswin64-140

data/test/call_tree_test.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
+require 'base64'
+
+class CallTreeTest < Minitest::Test
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal(method_info, call_tree.target)
+  end
+
+  def test_measurement
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+
+    assert_equal(0, call_tree.total_time)
+    assert_equal(0, call_tree.self_time)
+    assert_equal(0, call_tree.wait_time)
+    assert_equal(0, call_tree.children_time)
+    assert_equal(0, call_tree.called)
+  end
+
+  def test_compare
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(0, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    call_tree_1.measurement.total_time = 1
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(1, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    call_tree_2.measurement.total_time = 1
+    assert_equal(-1, call_tree_1 <=> call_tree_2)
+  end
+
+  def test_to_s
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal("<RubyProf::CallTree - Base64#encode64>", call_tree.to_s)
+  end
+
+  def test_add_child
+    method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+    method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+    call_tree_child = RubyProf::CallTree.new(method_info_child)
+
+    assert_equal(0, call_tree_parent.children.size)
+    assert_nil(call_tree_child.parent)
+
+    result = call_tree_parent.add_child(call_tree_child)
+    assert_equal(1, call_tree_parent.children.size)
+    assert_equal(call_tree_child, call_tree_parent.children.first)
+    assert_equal(call_tree_child, result)
+    assert_equal(call_tree_parent, call_tree_child.parent)
+  end
+
+  def test_add_child_gc
+    GC.stress = true
+
+    begin
+      method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+      call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+      method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+      call_tree_child = RubyProf::CallTree.new(method_info_child)
+      call_tree_parent.add_child(call_tree_child)
+
+      # Free the child first
+      call_tree_child = nil
+      GC.start
+
+      # Now free the parent and make sure it doesn't free the child a second time
+      call_tree_parent = nil
+      GC.start
+
+      assert(true)
+    ensure
+      GC.stress = false
+    end
+  end
+end

data/test/call_tree_visitor_test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class CallTreeVisitorTest < TestCase
+  def test_visit
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      RubyProf::C1.sleep_wait
+    end
+
+    visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
+
+    method_names = Array.new
+
+    visitor.visit do |call_tree, event|
+      method_names << call_tree.target.full_name if event == :enter
+    end
+
+    assert_equal(3, method_names.length)
+    assert_equal("CallTreeVisitorTest#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/call_trees_test.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Tests ----
+class CallTreesTest < TestCase
+  def some_method_1
+    some_method_2
+  end
+
+  def some_method_2
+  end
+
+  def test_call_infos
+    result = RubyProf::Profile.profile do
+      some_method_1
+    end
+
+    thread = result.threads.first
+    assert_equal(3, thread.methods.length)
+
+    method = thread.methods[0]
+    assert_equal('CallTreesTest#test_call_infos', method.full_name)
+
+    call_trees = method.call_trees
+    assert_empty(call_trees.callers)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[1]
+    assert_equal('CallTreesTest#some_method_1', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[2]
+    assert_equal('CallTreesTest#some_method_2', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
+    assert_empty(call_trees.callees)
+  end
+
+  def test_gc
+    result = RubyProf::Profile.profile do
+      some_method_1
+    end
+
+    method = result.threads.first.methods[1]
+
+    100.times do |i|
+      method.call_trees.callers
+      GC.start
+    end
+    assert(true)
+  end
+end

data/test/compatibility_test.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class CompatibilityTest < TestCase
+  def setup
+    super
+    Gem::Deprecate.skip = true
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def teardown
+    super
+    Gem::Deprecate.skip = false
+  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
+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 DuplicateNamesTest < TestCase
+  def test_names
+    result = RubyProf::Profile.profile do
+      str = %{module Foo; class Bar; def foo; end end end}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNamesTest.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNamesTest.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 == 'DuplicateNamesTest::Foo::Bar#foo'
+    end
+
+    assert_equal(3, methods.length)
+  end
+end

data/test/dynamic_method_test.rb

@@ -0,0 +1,50 @@
+#!/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 test_dynamic_method
+    medley = FruitMedley.new
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) 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
+      Integer#==
+    )
+
+    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
+  end
+end

data/test/enumerable_test.rb

@@ -0,0 +1,23 @@
+#!/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.profile do
+      3.times {  [1,2,3].any? {|n| n} }
+    end
+    methods = if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3')
+                %w(EnumerableTest#test_enumerable Integer#times Array#any?)
+              elsif Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.4')
+                %w(EnumerableTest#test_enumerable Integer#times Kernel#block_given? Integer#< Array#any? Integer#succ)
+              else
+                %w(EnumerableTest#test_enumerable Integer#times Integer#< Array#any? Integer#succ)
+              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.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.profile(:allow_exceptions => true) do
+        raise(RuntimeError, 'Test error')
+      end
+    end
+  end
+end