ruby-prof 0.4.1 → 0.5.0

data/test/basic_test.rb

@@ -4,16 +4,22 @@ 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
 
@@ -24,11 +30,13 @@ end
 
 class C3
   def hello
+    sleep(0.4)
   end
 end
 
 module M4
   def hello
+    sleep(0.5)
   end
 end
 
@@ -58,7 +66,7 @@ class BasicTest < Test::Unit::TestCase
   def test_double_profile
     RubyProf.start
     assert_raise(RuntimeError) do
-    	RubyProf.start
+      RubyProf.start
     end
     
     assert_raise(RuntimeError) do
@@ -71,68 +79,79 @@ class BasicTest < Test::Unit::TestCase
   
   def test_no_block
     assert_raise(ArgumentError) do
-			RubyProf.profile
-  	end
+      RubyProf.profile
+    end
   end
   
   def test_class_and_instance_methods
     result = RubyProf.profile do
-	    C1.hello
-	    C1.new.hello
+      C1.hello
+      C1.new.hello
     end
-  
+ 
     methods = result.threads.values.first
     
     # Length should be 6:
-    # 	1 top level,
-    # 	1 Class.new
-    #		1 Class:Object allocate
+    #   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
-    assert_equal(6, methods.length)
+    #   1 sleep
+    assert_equal(7, methods.length)
     
-    # Check class method
-    method1 = methods['<Class::C1>#hello']
-    assert_not_nil(method1)
+    # Check the names
+    methods = methods.sort.reverse
     
-    # Check instance method
-    method1 = methods['C1#hello']
-    assert_not_nil(method1)
+    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)
+    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
+      C2.hello
+      C2.new.hello
     end
   
     methods = result.threads.values.first
    
-    # Length should be 5:
-    # 	1 top level,
-    # 	1 Class.new
-    #		1 Class:Object allocate
-    #   1 for Object.initialize
-    #   1 for hello
-    assert_equal(5, methods.length)
+    # 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
     
-    # Check class method
-    method1 = methods['M1#hello']
-    assert_not_nil(method1)
-    assert_equal(2, method1.called)
+    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+    assert_equal('M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_equal('Class#new', methods[3].full_name)
+    assert_equal('<Class::Object>#allocate', 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
+      def hello
+      end
+    end
   
     result = RubyProf.profile do
-	  	c3.hello
+      c3.hello
     end
   
     methods = result.threads.values.first
@@ -142,7 +161,18 @@ class BasicTest < Test::Unit::TestCase
     assert_equal(2, methods.length)
     
     # Check singleton method
-    method1 = methods['<Object::C3>#hello']
-    assert_not_nil(method1)
+    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

@@ -7,31 +7,27 @@ 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}
+      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
-			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
-		print_results(result)
-		
-		# There should be 3 foo methods
-		methods = result.threads.values.first
-		
-		method_info = methods['DuplicateNames::Foo::Bar#foo']
-		assert_not_nil(method_info)
-		
-		method_info = methods['DuplicateNames::Foo::Bar#foo_1']
-		assert_not_nil(method_info)
-		
-		method_info = methods['DuplicateNames::Foo::Bar#foo_2']
-		assert_not_nil(method_info)
-	end
+      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/gc.log

@@ -0,0 +1,5 @@
+GC Warning: Finalization cycle involving 99c25f0
+GC Warning: Finalization cycle involving 99c25f0
+GC Warning: Finalization cycle involving 99c25f0
+GC Warning: Finalization cycle involving 99c25f0
+GC Warning: Finalization cycle involving 99c25f0

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 unless RubyProf.constants.include?('ALLOCATIONS')
+    
+    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

@@ -4,42 +4,55 @@ 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 BasicTest < Test::Unit::TestCase
+class ModuleTest < Test::Unit::TestCase
   def test_nested_modules
-		result = RubyProf.profile do
-			hello
-		end
-
-		methods = result.threads.values.first
-	    
-  	# Length should be 4s
-  	assert_equal(4, methods.length)
+    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('Bar#hello', method.full_name)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    
+    method = methods[3]
+    assert_equal('<Module::Bar>#hello', method.full_name)
     
-  	method1 = methods['Bar#hello']
-  	assert_not_nil(method1)
-  	
-  	method1 = methods['<Module::Bar>#hello']
-  	assert_not_nil(method1)
-  	
-  	method1 = methods['<Module::Foo>#hello']
-  	assert_not_nil(method1)
-	end	
+    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

data/test/prime1.rb

@@ -0,0 +1,17 @@
+require 'prime2'
+require 'prime3'
+
+def run_primes
+  length = 500	
+  maxnum = 10000
+  
+  # Create random numbers
+  random_array = make_random_array(length, maxnum)
+  
+  # Find the primes
+  primes = find_primes(random_array)
+  
+  # Find the largest primes
+  largest = find_largest(primes)
+  #puts "largest is #{largest}"
+end

data/test/prime2.rb

@@ -0,0 +1,26 @@
+require 'prime3'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+def find_primes(arr)
+  result = arr.select do |value|
+    is_prime(value)
+  end
+  result
+end
+
+def find_largest(primes)
+  largest = primes.first
+
+  # Intentionally use upto for example purposes
+  # (upto is also called from is_prime)
+  0.upto(primes.length-1) do |i|
+    sleep(0.02)
+    prime = primes[i]
+    if prime > largest
+      largest = prime
+    end
+  end
+  largest
+end