ruby-prof 0.4.1-mswin32 → 0.5.0-mswin32

data/test/prime3.rb

@@ -0,0 +1,17 @@
+
+def make_random_array(length, maxnum)
+	result = Array.new(length)
+	result.each_index do |i|
+		result[i] = rand(maxnum)
+	end
+		
+	result
+end
+ 
+def is_prime(x)
+	y = 2
+	y.upto(x-1) do |i|
+		return false if (x % i) == 0
+	end
+	true
+end

data/test/prime_test.rb

@@ -10,15 +10,15 @@ require 'test_helper'
 class PrimeTest < Test::Unit::TestCase
   def test_consistency
     result = RubyProf.profile do
-			run_primes
-		end
-		
-	  result.threads.values.each do |methods|
-			methods.values.each do |method|
-    		check_parent_times(method)
-    		check_parent_calls(method)
-    		check_child_times(method)		
-			end
-  	end
+      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
 end

data/test/printers_test.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-
 require 'test/unit'
 require 'ruby-prof'
 require 'prime'
@@ -8,21 +7,24 @@ require 'test_helper'
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
-  def test_printer
+  def test_printers
     result = RubyProf.profile do
-			run_primes
-		end
+      run_primes
+    end
     
-		printer = RubyProf::FlatPrinter.new(result)
-    printer.print(STDOUT)
-
-		printer = RubyProf::GraphHtmlPrinter.new(result)
-    printer.print(STDOUT)
-        
-		printer = RubyProf::GraphPrinter.new(result)
+    printer = RubyProf::FlatPrinter.new(result)
     printer.print(STDOUT)
     
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    printer.print
+    
+    printer = RubyProf::GraphPrinter.new(result)
+    printer.print
+    
+    printer = RubyProf::CallTreePrinter.new(result)
+    printer.print(STDOUT)
+
     # we should get here
     assert(true)
   end
-end
+end

data/test/profile_unit_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+require 'ruby-prof/profile_test_case'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+# --  Tests ----
+class ProfileTest < Test::Unit::TestCase
+  def test_profile
+    sleep(2)    
+  end
+
+  def teardown
+    profile_dir = output_directory
+    assert(File.exists?(profile_dir))
+    
+    file_path = File.join(profile_dir, 'test_profile_profile_test.html')
+    assert(File.exists?(file_path))
+  end
+end

data/test/recursive_test.rb

@@ -2,9 +2,10 @@
 
 require 'test/unit'
 require 'ruby-prof'
-require 'timeout'
 require 'test_helper'
 
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
 
 def simple(n)
   sleep(1)
@@ -13,6 +14,17 @@ def simple(n)
   simple(n)
 end
 
+def cycle(n)
+  sub_cycle(n)
+end
+
+def sub_cycle(n)
+  sleep(1)
+  n -= 1
+  return if n == 0
+  cycle(n)
+end
+
 def factorial(n)
   if n < 2 then
     n
@@ -24,18 +36,94 @@ end
 
 # --  Tests ----
 class RecursiveTest < Test::Unit::TestCase
-	def test_recursive
+  def test_recursive
     result = RubyProf.profile do
-  		simple(3)
+      simple(2)
+    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
+    
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)   
+
+    method = methods[0]
+    assert_equal('RecursiveTest#test_recursive', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(1, method.children.length)
+
+    method = methods[1]
+    assert_equal('Object#simple', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(4, method.children.length)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(2, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(2, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[3]
+    assert_equal('Object#simple-1', method.full_name)
+    assert_in_delta(1, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(1, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(3, method.children.length)
+    
+    method = methods[4]
+    assert_equal('Fixnum#==', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(2, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[5]
+    assert_equal('Fixnum#-', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(2, method.parents.length)
+    assert_equal(0, method.children.length)
+  end
+  
+  def test_cycle
+    result = RubyProf.profile do
+      cycle(2)
     end
-   
     result.threads.values.each do |methods|
-			methods.values.each do |method|
-    		check_parent_times(method)
-    		check_parent_calls(method)
-    		check_child_times(method)		
-			end
-  	end
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
   end
   
   def test_factorial
@@ -45,11 +133,11 @@ class RecursiveTest < Test::Unit::TestCase
     end
    
     result.threads.values.each do |methods|
-			methods.values.each do |method|
-    		check_parent_times(method)
-    		check_parent_calls(method)
-    		check_child_times(method)		
-			end
-  	end
-  end  	
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end   
 end

data/test/singleton_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'timeout'
+
+# --  Test for bug [#5657]
+# http://rubyforge.org/tracker/index.php?func=detail&aid=5657&group_id=1814&atid=7060
+
+
+class A
+  attr_accessor :as
+  def initialize
+    @as = []
+    class << @as
+      def <<(an_a)
+        super
+      end
+    end
+  end
+
+  def <<(an_a)
+    @as << an_a
+  end
+end
+
+class SingletonTest < Test::Unit::TestCase
+  def test_singleton
+    result = RubyProf.profile do
+      a = A.new
+      a << :first_thing
+      assert_equal(1, a.as.size)
+    end
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print(STDOUT)
+  end
+end
+

data/test/start_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+
+def start
+  RubyProf.start
+end
+
+def wait_around
+  sleep(2)
+end
+
+def stop
+  RubyProf.stop
+end
+
+start
+wait_around
+result = stop
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT)

data/test/test_helper.rb

@@ -1,45 +1,49 @@
 def print_results(result)
-	printer = RubyProf::FlatPrinter.new(result)
-	printer.print(STDOUT)
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
     
-	STDOUT << "\n" * 2
+  STDOUT << "\n" * 2
     
-	printer = RubyProf::GraphPrinter.new(result)
-	printer.print(STDOUT)
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print(STDOUT)
 end
 
 def check_parent_times(method)
-	return if method.parents.length == 0 
+  return if method.parents.length == 0 
 
-	parents_self_time = method.parents.values.inject(0) do |sum, call_info|
-		sum + call_info.self_time
-	end
-	assert_in_delta(method.self_time, parents_self_time, 0.01, method.name)	
+  parents_self_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.self_time
+  end
+
+  assert_in_delta(method.self_time, parents_self_time, 0.01, method.full_name) 
     
-	parents_children_time = method.parents.values.inject(0) do |sum, call_info|
-		sum + call_info.children_time
-	end
-	assert_in_delta(method.children_time, parents_children_time, 0.01, method.name)
+  parents_wait_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.wait_time
+  end
+
+  assert_in_delta(method.wait_time, parents_wait_time, 0.01, method.full_name)
+   
+  parents_children_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.children_time
+  end
+  assert_in_delta(method.children_time, parents_children_time, 0.01, method.full_name)
 end
   
 def check_parent_calls(method)
-	return if method.parents.length == 0 
-	
-	parent_calls = method.parents.values.inject(0) do |sum, call_info|
-		sum + call_info.called
-	end
-	assert_equal(method.called, parent_calls, method.name)	
+  return if method.parents.length == 0 
+  
+  parent_calls = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.called
+  end
+  assert_equal(method.called, parent_calls, method.full_name)  
 end
   
 def check_child_times(method)
-	return if method.children.length == 0
+  return if method.children.length == 0
     
-	children_total_time = method.children.values.inject(0) do |sum, call_info|
-		sum + call_info.total_time
-	end
-	
-	assert_in_delta(method.children_time, children_total_time, 0.01, method.name)
-end
+  children_total_time = method.children.inject(0) do |sum, call_info|
+    sum + call_info.total_time
+  end
   
-
-
+  assert_in_delta(method.children_time, children_total_time, 0.01, method.full_name)
+end

data/test/test_suite.rb

@@ -1,10 +1,18 @@
 # file ts_dbaccess.rb
 require 'test/unit'
 require 'basic_test'
-require 'module_test'
 require 'duplicate_names_test'
-require 'timing_test'
+require 'measure_mode_test'
+require 'module_test'
+require 'no_method_class_test'
 require 'prime_test'
 require 'printers_test'
 require 'recursive_test'
+require 'singleton_test'
 require 'thread_test'
+require 'timing_test'
+
+# 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

@@ -5,28 +5,134 @@ require 'ruby-prof'
 require 'timeout'
 require 'test_helper'
 
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
 # --  Tests ----
 class ThreadTest < Test::Unit::TestCase
-  def test_thread
+  def test_thread_timings
     RubyProf.start
     
-    begin
-      status = Timeout::timeout(2) do
-      	while true
-        	next
-      	end
-    	end
-   	rescue Timeout::Error
-   	end
-   
+    sleep(2)    
+
+    thread = Thread.new do
+      sleep(0.5)
+      sleep(2)
+    end
+    
+    thread.join
+    
     result = RubyProf.stop
+
+    values = result.threads.values.sort do |value1, value2|
+      value1.length <=> value2.length
+    end
+    
+    # Check background thread
+    methods = values.first.sort.reverse
+    assert_equal(2, methods.length)
+    
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0.5, method.wait_time, 0.02)
+    assert_in_delta(2.0, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(1, method.children.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(2.0, method.self_time, 0.02)
+    assert_in_delta(0.5, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    # Check foreground thread
+    methods = values.last.sort.reverse
+    assert_equal(5, methods.length)
+    methods = methods.sort.reverse
+    
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_in_delta(4.5, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2.0, method.wait_time, 0.02)
+    assert_in_delta(2.5, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(3, method.children.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(0.5, method.self_time, 0.02)
+    assert_in_delta(2.0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(2.0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    
+    method = methods[3]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[4]
+    assert_equal('<Class::Thread>#new', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(1, method.children.length)
+  end
+
+  def test_thread
+    result = RubyProf.profile do 
+      begin
+        status = Timeout::timeout(2) do
+          while true
+            next
+          end
+        end
+      rescue Timeout::Error
+      end
+    end
+    
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    File.open('c:/temp/test.html', 'w') do |file|
+      printer.print(file)
+    end
     
-    result.threads.values.each do |methods|
-			methods.values.each do |method|
-    		check_parent_times(method)
-    		check_parent_calls(method)
-    		check_child_times(method)		
-			end
-  	end
+    result.threads.each do |thread_id, methods|
+      STDOUT << "thread: " << thread_id << "\n"
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
   end
 end