ruby-prof 0.10.8 → 0.11.0.rc1

data/test/bug_test.rb

@@ -0,0 +1,6 @@
+50000.times do
+  begin
+    raise "error"
+  rescue
+  end
+end

data/test/duplicate_names_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__)
 
 class DuplicateNames < Test::Unit::TestCase
   def test_names

data/test/dynamic_method_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+
+class DynamicMethodTest < Test::Unit::TestCase
+  def test_dynamic_method
+    result = RubyProf.profile do
+      1.times {RubyProf::C1.new.hello}
+    end
+
+    # Methods called
+    #  Kernel#sleep
+    #  <Class::BasicObject>#allocate
+    #  BasicObject#initialize
+    #  RubyProf::C1#hello
+    #  Class#new
+    #  Integer#times
+    #  DynamicMethodTest#test_dynamic_method
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(7, methods.length)
+
+    # Check times
+    assert_equal("DynamicMethodTest#test_dynamic_method", methods[0].full_name)
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0.0, methods[0].wait_time, 0.02)
+    assert_in_delta(0.0, methods[0].self_time, 0.02)
+
+    assert_equal("Integer#times", methods[1].full_name)
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0.0, methods[1].wait_time, 0.02)
+    assert_in_delta(0.0, methods[1].self_time, 0.02)
+
+    assert_equal("RubyProf::C1#hello", methods[2].full_name)
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0.0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.0, methods[2].self_time, 0.02)
+
+    assert_equal("Kernel#sleep", methods[3].full_name)
+    assert_in_delta(0.2, methods[3].total_time, 0.01)
+    assert_in_delta(0.0, methods[3].wait_time, 0.01)
+    assert_in_delta(0.2, methods[3].self_time, 0.01)
+
+    assert_equal("Class#new", methods[4].full_name)
+    assert_in_delta(0.0, methods[4].total_time, 0.01)
+    assert_in_delta(0.0, methods[4].wait_time, 0.01)
+    assert_in_delta(0.0, methods[4].self_time, 0.01)
+
+    assert_equal("<Class::#{RubyProf::PARENT}>#allocate", methods[5].full_name)
+    assert_in_delta(0.0, methods[5].total_time, 0.01)
+    assert_in_delta(0.0, methods[5].wait_time, 0.01)
+    assert_in_delta(0.0, methods[5].self_time, 0.01)
+
+    assert_equal("#{RubyProf::PARENT}#initialize", methods[6].full_name)
+    assert_in_delta(0.0, methods[5].total_time, 0.01)
+    assert_in_delta(0.0, methods[5].wait_time, 0.01)
+    assert_in_delta(0.0, methods[5].self_time, 0.01)
+  end
+end

data/test/enumerable_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 for bug
 # http://github.com/rdp/ruby-prof/issues#issue/12

data/test/exceptions_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__)
 
 class ExceptionsTest < Test::Unit::TestCase
   def test_profile
@@ -8,7 +9,7 @@ class ExceptionsTest < Test::Unit::TestCase
       RubyProf.profile do
         raise(RuntimeError, 'Test error')
       end
-    rescue => e
+    rescue
     end
     assert_not_nil(result)
   end

data/test/exclude_threads_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__)
 
 
 # --  Tests ----

data/test/exec_test.rb

@@ -1,11 +1,11 @@
 #!/usr/bin/env ruby
+# encoding: UTF-8
 
-require 'test/unit'
-require 'os'
+require File.expand_path('../test_helper', __FILE__)
 
 # --  Test for bug when it loads with no frames
 
-class EnumerableTest < Test::Unit::TestCase
+class ExecTest < Test::Unit::TestCase
   def test_being_able_to_run_its_binary
     Dir.chdir(File.dirname(__FILE__)) do
       assert system(OS.ruby_bin + " ruby-prof-bin do_nothing.rb")

data/test/line_number_test.rb

@@ -1,15 +1,15 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'ruby-prof'
-require 'prime'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 
 class LineNumbers
   def method1
-    a = 3
+    3
   end
 
   def method2
-    a = 3
+    3
     method1
   end
 

data/test/measure_allocations_test.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureAllocationsTest < Test::Unit::TestCase
+  def test_allocations_mode
+    RubyProf::measure_mode = RubyProf::ALLOCATIONS
+    assert_equal(RubyProf::ALLOCATIONS, RubyProf::measure_mode)
+  end
+
+  def test_allocations_enabled_defined
+    assert(defined?(RubyProf::ALLOCATIONS_ENABLED))
+  end
+
+  if RubyProf::ALLOCATIONS_ENABLED
+    def test_allocations
+      t = RubyProf.measure_allocations
+      assert_kind_of Integer, t
+
+      u = RubyProf.measure_allocations
+      assert u > t, [t, u].inspect
+    end
+  end
+end

data/test/measure_cpu_time_test.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureCpuTimeTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::CPU_TIME
+  end
+
+  def test_mode
+    RubyProf::measure_mode = RubyProf::CPU_TIME
+    assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
+  end
+
+  def test_cpu_time_enabled_defined
+    assert(defined?(RubyProf::CPU_TIME_ENABLED))
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print
+
+    # Length should be 3:
+    #   MeasureCpuTimeTest#test_class_methods
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('MeasureCpuTimeTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C1.new.hello
+    end
+
+    # Methods called
+    #   MeasureCpuTimeTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
+    assert_equal('RubyProf::C1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    # order can differ
+    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
+    assert(names.include?("#{RubyProf::PARENT}#initialize"))
+
+    # Check times
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      RubyProf::C2.hello
+    end
+
+    # Methods:
+    #   MeasureCpuTimeTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
+    assert_equal('RubyProf::M1#hello', 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.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.3, methods[2].self_time, 0.1)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C2.new.hello
+    end
+
+    # Methods:
+    #   MeasureCpuTimeTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
+    assert_equal('RubyProf::M1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
+    assert(names.include?("#{RubyProf::PARENT}#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.02)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_singleton
+    c3 = RubyProf::C3.new
+
+    class << c3
+      def hello
+      end
+    end
+
+    result = RubyProf.profile do
+      c3.hello
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(2, methods.length)
+
+    assert_equal('MeasureCpuTimeTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::RubyProf::C3>#hello', methods[1].full_name)
+
+    assert_in_delta(0, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  end
+end

data/test/measure_gc_runs_test.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasuremeGCRunsTest < Test::Unit::TestCase
+  def test_gc_runs_mode
+    RubyProf::measure_mode = RubyProf::GC_RUNS
+    assert_equal(RubyProf::GC_RUNS, RubyProf::measure_mode)
+  end
+
+  def test_gc_runs_enabled_defined
+    assert(defined?(RubyProf::GC_RUNS_ENABLED))
+  end
+
+  if RubyProf::GC_RUNS_ENABLED
+    def test_gc_runs
+      t = RubyProf.measure_gc_runs
+      assert_kind_of Integer, t
+
+      GC.start
+
+      u = RubyProf.measure_gc_runs
+      assert u > t, [t, u].inspect
+      RubyProf::measure_mode = RubyProf::GC_RUNS
+      memory_test_helper
+    end
+  end
+end

data/test/measure_gc_time_test.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureGCTimeTest < Test::Unit::TestCase
+  def test_gc_time_mode
+    RubyProf::measure_mode = RubyProf::GC_TIME
+    assert_equal(RubyProf::GC_TIME, RubyProf::measure_mode)
+  end
+
+  def test_gc_time_enabled_defined
+    assert(defined?(RubyProf::GC_TIME_ENABLED))
+  end
+
+  if RubyProf::GC_TIME_ENABLED
+    def test_gc_time
+      t = RubyProf.measure_gc_time
+      assert_kind_of Integer, t
+
+      GC.start
+
+      u = RubyProf.measure_gc_time
+      assert u > t, [t, u].inspect
+      RubyProf::measure_mode = RubyProf::GC_TIME
+      memory_test_helper
+    end
+  end
+end