ruby-prof 0.6.0-x86-mswin32-60

data/test/basic_test.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+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
+
+class BasicTest < Test::Unit::TestCase
+  def test_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+  
+  def test_double_profile
+    RubyProf.start
+    assert_raise(RuntimeError) do
+      RubyProf.start
+    end
+    
+    assert_raise(RuntimeError) do
+      RubyProf.profile do
+        puts 1
+      end
+    end
+    RubyProf.stop
+  end
+  
+  def test_no_block
+    assert_raise(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+  
+  def test_class_and_instance_methods
+    result = RubyProf.profile do
+      C1.hello
+      C1.new.hello
+    end
+    
+    methods = result.threads.values.first
+    
+    # Length should be 7:
+    #   1 test_class_and_instance_methods (this method)
+    #   1 Class.new
+    #   1 Class:Object allocate
+    #   1 for Object.initialize
+    #   1 for Class hello
+    #   1 for Object hello
+    #   1 sleep
+    assert_equal(7, methods.length)
+    
+    # Check the names
+    methods = methods.sort.reverse
+    
+    assert_equal('BasicTest#test_class_and_instance_methods', methods[0].full_name)
+    assert_equal('Kernel#sleep', methods[1].full_name)
+    assert_equal('C1#hello', methods[2].full_name)
+    assert_equal('<Class::C1>#hello', methods[3].full_name)
+    
+    # The last three methods have total times of zero
+    assert_equal(0, methods[4].total_time)
+    assert_equal(0, methods[5].total_time)
+    assert_equal(0, methods[6].total_time)
+    
+    #assert_equal('Class#new', methods[4].full_name)
+    #assert_equal('<Class::Object>#allocate', methods[5].full_name)
+    #assert_equal('Object#initialize', methods[6].full_name)
+  end
+  
+  def test_module_methods
+    result = RubyProf.profile do
+      C2.hello
+      C2.new.hello
+    end
+  
+    methods = result.threads.values.first
+   
+    # Length should be 6:
+    #   1 BasicTest#test_module_methods (this method)
+    #   1 Class#new
+    #   1 <Class::Object>#allocate
+    #   1 Object#initialize
+    #   1 M1#hello
+    #   1 Kernel#sleep
+
+    assert_equal(6, methods.length)
+
+    # Check the names
+    methods = methods.sort.reverse
+    
+    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+    assert_equal('Kernel#sleep', methods[1].full_name)
+    assert_equal('M1#hello', methods[2].full_name)
+    
+    # The last three methods have times of zero
+    assert_equal(0, methods[3].total_time)
+    assert_equal(0, methods[4].total_time)
+    assert_equal(0, methods[5].total_time)
+    
+    #assert_equal('<Class::Object>#allocate', methods[3].full_name)
+    #assert_equal('Class#new', methods[4].full_name)
+    #assert_equal('Object#initialize', methods[5].full_name)
+  end
+  
+  def test_singleton
+    c3 = C3.new
+    
+    class << c3
+      def hello
+      end
+    end
+  
+    result = RubyProf.profile do
+      c3.hello
+    end
+  
+    methods = result.threads.values.first
+    
+    # Length should be 2 - one for top level
+    # and one for the singleton method.
+    assert_equal(2, methods.length)
+    
+    # Check singleton method
+    methods = methods.sort.reverse
+    
+    assert_equal('BasicTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::C3>#hello', methods[1].full_name)
+  end
+  
+  def test_traceback
+    RubyProf.start
+    assert_raise(NoMethodError) do
+      RubyProf.xxx
+    end
+    
+    RubyProf.stop
+  end   
+end

data/test/duplicate_names_test.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+class DuplicateNames < Test::Unit::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.values.first
+    
+    methods = methods.select do |method|
+      method.full_name == 'DuplicateNames::Foo::Bar#foo'
+    end
+    
+    assert_equal(3, methods.length)
+  end
+end

data/test/line_number_test.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+require 'test_helper'
+
+class LineNumbers
+  def method1
+    a = 3
+  end
+  
+  def method2
+    method1
+  end
+  
+  def method3
+    sleep(1)
+  end
+end
+
+# --  Tests ----
+class LineNumbersTest < Test::Unit::TestCase
+  def test_function_line_no
+    numbers = LineNumbers.new
+    
+    result = RubyProf.profile do
+      numbers.method2
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+    
+    method = methods[0]
+    assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
+    assert_equal(28, method.line)
+    
+    method = methods[1]
+    assert_equal('LineNumbers#method1', method.full_name)
+    assert_equal(9, method.line)
+    
+    method = methods[2]
+    assert_equal('LineNumbers#method2', method.full_name)
+    assert_equal(13, method.line)
+  end
+  
+  def test_c_function
+    numbers = LineNumbers.new
+    
+    result = RubyProf.profile do
+      numbers.method3
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+    
+    method = methods[0]
+    assert_equal('LineNumbersTest#test_c_function', method.full_name)
+    assert_equal(51, method.line)
+    
+    method = methods[1]
+    assert_equal('LineNumbers#method3', method.full_name)
+    assert_equal(17, method.line)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+  end
+end

data/test/measure_mode_test.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+require 'prime'
+
+
+# --  Tests ----
+class MeasureModeTest < Test::Unit::TestCase
+
+  def test_process_time
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+    assert_equal(RubyProf::PROCESS_TIME, RubyProf::measure_mode)
+    result = RubyProf.profile do
+      run_primes
+    end
+    
+    result.threads.each do |thread_id, methods|
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end
+  
+  def test_wall_time
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::measure_mode)
+    result = RubyProf.profile do
+      run_primes
+    end
+    
+    result.threads.values.each do |methods|
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end
+  
+  def test_cpu
+    return unless RubyProf.constants.include?('CPU_TIME')
+    
+    RubyProf::measure_mode = RubyProf::CPU_TIME
+    assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
+    result = RubyProf.profile do
+      run_primes
+    end
+    
+    result.threads.values.each do |methods|
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end
+  
+  def test_allocated_objects
+    return if RubyProf::ALLOCATIONS.nil?
+    
+    RubyProf::measure_mode = RubyProf::ALLOCATIONS
+    
+    assert_equal(RubyProf::ALLOCATIONS, RubyProf::measure_mode)
+    
+    result = RubyProf.profile do
+      Array.new
+    end
+  end
+  
+  def test_invalid
+    assert_raise(ArgumentError) do
+      RubyProf::measure_mode = 7777
+    end
+  end
+end

data/test/module_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+module Foo
+  def Foo::hello
+    sleep(0.5)
+  end
+end
+
+module Bar
+  def Bar::hello
+    sleep(0.5)
+    Foo::hello
+  end
+  
+  def hello
+    sleep(0.5)
+    Bar::hello
+  end
+end
+
+include Bar
+
+class ModuleTest < Test::Unit::TestCase
+  def test_nested_modules
+    result = RubyProf.profile do
+      hello
+    end
+
+    methods = result.threads.values.first
+    methods = methods.sort.reverse
+      
+    # Length should be 4
+    assert_equal(5, methods.length)
+    
+    method = methods[0]
+    assert_equal('ModuleTest#test_nested_modules', method.full_name)
+    
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    
+    method = methods[2]
+    assert_equal('Bar#hello', method.full_name)
+    
+    method = methods[3]
+    assert_equal('<Module::Bar>#hello', method.full_name)
+    
+    method = methods[4]
+    assert_equal('<Module::Foo>#hello', method.full_name)
+  end 
+end

data/test/no_method_class_test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'ruby-prof'
+
+# Make sure this works with no class or method
+result = RubyProf.profile do 
+  sleep 1
+end
+
+method = result.threads.values.first.sort.last
+
+if method.full_name != 'Global#[No method]'
+  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{method.full_name}")
+end