ruby-prof 0.8.1-x86-mingw32 → 0.11.0.rc1-x86-mingw32

data/test/singleton_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
+# encoding: UTF-8
 
-require 'test/unit'
-require 'ruby-prof'
+require File.expand_path('../test_helper', __FILE__)
 require 'timeout'
 
 # --  Test for bug [#5657]
@@ -32,6 +32,7 @@ class SingletonTest < Test::Unit::TestCase
       assert_equal(1, a.as.size)
     end
     printer = RubyProf::FlatPrinter.new(result)
-    printer.print(STDOUT)
+    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : ''
+    printer.print(output)
   end
-end
+end

data/test/stack_printer_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class STPT
+  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 StackPrinterTest < Test::Unit::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_stack_can_be_printed
+    start_time = Time.now
+    RubyProf.start
+    5.times{STPT.new.a}
+    result = RubyProf.stop
+    end_time = Time.now
+    expected_time = end_time - start_time
+
+    file_contents = nil
+    assert_nothing_raised { file_contents = print(result) }
+    assert file_contents =~ /Thread: (\d+) \(100\.00% ~ ([.0-9]+)\)/
+    actual_time = $2.to_f
+    assert_in_delta(expected_time, actual_time, 0.01)
+  end
+
+  def test_method_elimination
+    RubyProf.start
+    5.times{STPT.new.a}
+    result = RubyProf.stop
+    assert_nothing_raised {
+      # result.dump
+      result.eliminate_methods!([/Integer#times/])
+      # $stderr.puts "================================"
+      # result.dump
+      print(result)
+    }
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    testfile_name = "#{Dir::tmpdir}/ruby_prof_#{test}.html"
+    printer = RubyProf::CallStackPrinter.new(result)
+    File.open(testfile_name, "w") {|f| printer.print(f, :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")}
+    system("open '#{testfile_name}'") if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+    File.open(testfile_name, "r"){|f| f.read}
+  end
+end

data/test/stack_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
+# encoding: UTF-8
 
-require 'test/unit'
-require 'ruby-prof'
+require File.expand_path('../test_helper', __FILE__)
 
 # Test data
 #     A
@@ -76,7 +76,7 @@ class StackTest < Test::Unit::TestCase
     call_info = method.call_infos[0]
     assert_equal('StackTest#test_call_sequence->StackClass#a', call_info.call_sequence)
     assert_equal(3, call_info.children.length)
-    
+
     # Check Kernel#sleep
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
@@ -107,10 +107,10 @@ class StackTest < Test::Unit::TestCase
     method = methods[3]
     assert_equal('StackClass#c', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(5, method.total_time, 0.01)
+    assert_in_delta(5, method.total_time, 0.05)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.05)
     assert_equal(1, method.call_infos.length)
 
     call_info = method.call_infos[0]
@@ -121,10 +121,10 @@ class StackTest < Test::Unit::TestCase
     method = methods[4]
     assert_equal('StackClass#b', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(4, method.total_time, 0.01)
+    assert_in_delta(4, method.total_time, 0.05)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(4, method.children_time, 0.01)
+    assert_in_delta(4, method.children_time, 0.05)
     assert_equal(2, method.call_infos.length)
 
     call_info = method.call_infos[0]

data/test/start_stop_test.rb

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 
-require 'test/unit'
-require 'ruby-prof'
- 
 class StartStopTest < Test::Unit::TestCase
   def setup
     # Need to use wall time for this test due to the sleep calls
@@ -22,6 +22,23 @@ class StartStopTest < Test::Unit::TestCase
     sleep(2)
     @result = RubyProf.stop
   end
+  
+  def test_extra_stop_should_raise
+    RubyProf.start
+    assert_raise(RuntimeError) do
+      RubyProf.start
+    end
+    
+    assert_raise(RuntimeError) do
+      RubyProf.profile {}
+    end
+    
+    RubyProf.stop # ok
+    assert_raise(RuntimeError) do
+      RubyProf.stop
+    end
+  end
+    
 
   def test_different_methods
     method1
@@ -56,10 +73,10 @@ class StartStopTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('StartStopTest#method2', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.05)
     assert_equal(1, method.call_infos.length)
 
     call_info = method.call_infos[0]
@@ -92,4 +109,4 @@ class StartStopTest < Test::Unit::TestCase
     assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
   end
-end
+end

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+# Make RubyMine happy
+if ENV["RM_INFO"] || ENV["TEAMCITY_VERSION"]
+  gem 'win32console'
+  gem 'minitest-reporters'
+  require 'minitest/reporters'
+  MiniTest::Unit.runner = MiniTest::SuiteRunner.new
+  MiniTest::Unit.runner.reporters << MiniTest::Reporters::RubyMineReporter.new
+end
+
+# 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'
+require 'test/unit'
+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
+  
+  if RUBY_VERSION < '1.9'
+    PARENT = Object
+  else
+    PARENT = BasicObject
+  end
+
+end

data/test/test_suite.rb

@@ -1,23 +1,37 @@
-require 'test/unit'
+# encoding: utf-8
 
-require 'aggregate_test'
-require 'basic_test'
-require 'duplicate_names_test'
-require 'exceptions_test'
-require 'line_number_test'
-require 'measurement_test'
-require 'module_test'
-require 'no_method_class_test'
-require 'prime_test'
-require 'printers_test'
-require 'recursive_test'
-require 'singleton_test'
-require 'stack_test'
-require 'start_stop_test'
-require 'thread_test'
-require 'unique_call_path_test'
+require File.expand_path("../test_helper", __FILE__)
+
+%w(aggregate_test
+   basic_test
+   duplicate_names_test
+   dynamic_method_test
+   enumerable_test
+   exceptions_test
+   exclude_threads_test
+   line_number_test
+
+   measure_allocations_test
+   measure_cpu_time_test
+   measure_gc_runs_test
+   measure_gc_time_test
+   measure_memory_test
+   measure_process_time_test
+   measure_wall_time_test
+
+   method_elimination_test
+   module_test
+   multi_printer_test
+   no_method_class_test
+   prime_test
+   printers_test
+   recursive_test
+   singleton_test
+   stack_test
+   stack_printer_test
+   start_stop_test
+   thread_test
+   unique_call_path_test).each do |test|
+  require File.expand_path("../#{test}", __FILE__)
+end
 
-# Can't use this one here cause it breaks
-# the rest of the unit tets (Ruby Prof gets
-# started twice).
-#require 'profile_unit_test'

data/test/thread_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'ruby-prof'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 require 'timeout'
 
 # --  Tests ----
@@ -21,11 +22,11 @@ class ThreadTest < Test::Unit::TestCase
     result = RubyProf.stop
     assert_equal(2, result.threads.keys.length) # this should pass...
   end
-  
+
   def test_thread_identity
     RubyProf.start
     thread = Thread.new do
-      sleep(1)    
+      sleep(1)
     end
     thread.join
     result = RubyProf.stop
@@ -36,16 +37,16 @@ class ThreadTest < Test::Unit::TestCase
 
     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    
+        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
@@ -55,7 +56,7 @@ class ThreadTest < Test::Unit::TestCase
     end
     thread.join
     result = RubyProf.stop
-    
+
     # Check background thread
     assert_equal(2, result.threads.length)
     methods = result.threads[thread.object_id].sort.reverse
@@ -65,9 +66,9 @@ class ThreadTest < Test::Unit::TestCase
     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.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(1, method.children_time, 0.01)
+    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)
@@ -76,10 +77,10 @@ class ThreadTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(1, method.total_time, 0.01)
-    assert_in_delta(1.0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
+    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]
@@ -96,11 +97,11 @@ class ThreadTest < Test::Unit::TestCase
     # 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.01)
+    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.01)
+    assert_in_delta(1, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -110,10 +111,10 @@ class ThreadTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('Thread#join', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01) 
-    assert_in_delta(1.0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
+    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]
@@ -123,10 +124,10 @@ class ThreadTest < Test::Unit::TestCase
     method = methods[2]
     assert_equal('<Class::Thread>#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
+    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]
@@ -136,28 +137,28 @@ class ThreadTest < Test::Unit::TestCase
     method = methods[3]
     assert_equal('Thread#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
+    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
   def test_thread_back_and_forth
-  	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
-  	assert result.threads.values.flatten.sort[-1].total_time < 10 # 10s  	
+        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
+        assert result.threads.values.flatten.sort[-1].total_time < 10 # 10s. Amazingly, this can fail in OS X at times. Amazing.
   end
-  
+
   def test_thread
     result = RubyProf.profile do
       begin