ruby-prof 0.6.0 → 0.7.0

data/test/duplicate_names_test.rb

@@ -2,7 +2,6 @@
 
 require 'test/unit'
 require 'ruby-prof'
-require 'test_helper'
 
 class DuplicateNames < Test::Unit::TestCase
   def test_names
@@ -22,12 +21,12 @@ class DuplicateNames < Test::Unit::TestCase
     end
     
     # There should be 3 foo methods
-    methods = result.threads.values.first
+    methods = result.threads.values.first.sort.reverse
     
     methods = methods.select do |method|
       method.full_name == 'DuplicateNames::Foo::Bar#foo'
     end
-    
+
     assert_equal(3, methods.length)
   end
 end

data/test/exceptions_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+
+class ExceptionsTest < Test::Unit::TestCase
+  def test_profile
+    result = begin
+      RubyProf.profile do 
+        raise(RuntimeError, 'Test error')
+      end
+    rescue => e
+    end    
+    assert_not_nil(result)
+  end
+end

data/test/exclude_threads_test.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+
+# --  Tests ----
+class ExcludeThreadsTest < Test::Unit::TestCase
+  def test_exclude_threads
+
+    def thread1_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    def thread2_proc
+      sleep(0.5)
+      sleep(2)
+    end
+        
+    thread1 = Thread.new do 
+      thread1_proc
+    end
+
+    thread2 = Thread.new do
+      thread2_proc
+    end
+
+    RubyProf::exclude_threads = [ thread2 ]
+ 
+    RubyProf.start
+
+    thread1.join
+    thread2.join
+
+    result = RubyProf.stop
+
+    RubyProf::exclude_threads = nil
+
+    assert_equal(2, result.threads.length)
+
+    output = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.full_name.index("ExcludeThreadsTest#thread") == 0
+          output.push(m.full_name)
+        end
+      end
+    end
+
+    assert_equal(1, output.length)
+    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
+  end
+end

data/test/line_number_test.rb

@@ -1,9 +1,7 @@
 #!/usr/bin/env ruby
-
 require 'test/unit'
 require 'ruby-prof'
 require 'prime'
-require 'test_helper'
 
 class LineNumbers
   def method1
@@ -11,6 +9,7 @@ class LineNumbers
   end
   
   def method2
+    a = 3
     method1
   end
   
@@ -33,15 +32,15 @@ class LineNumbersTest < Test::Unit::TestCase
     
     method = methods[0]
     assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
-    assert_equal(28, method.line)
+    assert_equal(27, method.line)
     
     method = methods[1]
-    assert_equal('LineNumbers#method1', method.full_name)
-    assert_equal(9, method.line)
+    assert_equal('LineNumbers#method2', method.full_name)
+    assert_equal(11, method.line)
     
     method = methods[2]
-    assert_equal('LineNumbers#method2', method.full_name)
-    assert_equal(13, method.line)
+    assert_equal('LineNumbers#method1', method.full_name)
+    assert_equal(7, method.line)
   end
   
   def test_c_function
@@ -51,19 +50,24 @@ class LineNumbersTest < Test::Unit::TestCase
       numbers.method3
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.values.first.sort_by {|method| method.full_name}
     assert_equal(3, methods.length)
-    
+
+    # Methods:
+    #   LineNumbers#method3
+    #   LineNumbersTest#test_c_function
+    #   Kernel#sleep
+
     method = methods[0]
-    assert_equal('LineNumbersTest#test_c_function', method.full_name)
-    assert_equal(51, method.line)
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
     
     method = methods[1]
     assert_equal('LineNumbers#method3', method.full_name)
-    assert_equal(17, method.line)
+    assert_equal(16, method.line)
     
     method = methods[2]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(0, method.line)
+    assert_equal('LineNumbersTest#test_c_function', method.full_name)
+    assert_equal(50, method.line)
   end
 end

data/test/measurement_test.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+
+class MeasurementTest < Test::Unit::TestCase
+  def setup
+    GC.enable_stats if GC.respond_to?(:enable_stats)
+  end
+
+  def teardown
+    GC.disable_stats if GC.respond_to?(:disable_stats)
+  end
+
+  def test_process_time_mode
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+    assert_equal(RubyProf::PROCESS_TIME, RubyProf::measure_mode)
+  end
+
+  def test_process_time
+    t = RubyProf.measure_process_time
+    assert_kind_of(Float, t)
+
+    u = RubyProf.measure_process_time
+    assert(u >= t, [t, u].inspect)
+  end
+
+  def test_wall_time_mode
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::measure_mode)
+  end
+
+  def test_wall_time
+    t = RubyProf.measure_wall_time
+    assert_kind_of Float, t
+
+    u = RubyProf.measure_wall_time
+    assert u >= t, [t, u].inspect
+  end
+
+  if RubyProf::CPU_TIME
+    def test_cpu_time_mode
+      RubyProf::measure_mode = RubyProf::CPU_TIME
+      assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
+    end
+    
+    def test_cpu_time
+      RubyProf.cpu_frequency = 2.33e9
+
+      t = RubyProf.measure_cpu_time
+      assert_kind_of Float, t
+
+      u = RubyProf.measure_cpu_time
+      assert u > t, [t, u].inspect
+    end
+  end
+
+  if RubyProf::ALLOCATIONS
+    def test_allocations_mode
+      RubyProf::measure_mode = RubyProf::ALLOCATIONS
+      assert_equal(RubyProf::ALLOCATIONS, RubyProf::measure_mode)
+    end
+
+    def test_allocations
+      t = RubyProf.measure_allocations
+      assert_kind_of Integer, t
+
+      u = RubyProf.measure_allocations
+      assert u > t, [t, u].inspect
+    end
+  end
+
+  if RubyProf::MEMORY
+    def test_memory_mode
+      RubyProf::measure_mode = RubyProf::MEMORY
+      assert_equal(RubyProf::MEMORY, RubyProf::measure_mode)
+    end
+
+    def test_memory
+      t = RubyProf.measure_memory
+      assert_kind_of Integer, t
+
+      u = RubyProf.measure_memory
+      assert(u >= t, [t, u].inspect)
+
+      result = RubyProf.profile {Array.new}
+      total = result.threads.values.first.methods.inject(0) { |sum, m| sum + m.total_time }
+
+      assert(total > 0, 'Should measure more than zero kilobytes of memory usage')
+      assert_not_equal(0, total % 1, 'Should not truncate fractional kilobyte measurements')
+    end
+  end
+
+  if RubyProf::GC_RUNS
+    def test_gc_runs_mode
+      RubyProf::measure_mode = RubyProf::GC_RUNS
+      assert_equal(RubyProf::GC_RUNS, RubyProf::measure_mode)
+    end
+
+    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
+    end
+  end
+
+  if RubyProf::GC_TIME
+    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
+    end
+  end
+end

data/test/module_test.rb

@@ -1,8 +1,6 @@
 #!/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
@@ -33,20 +31,19 @@ class ModuleTest < Test::Unit::TestCase
       hello
     end
 
-    methods = result.threads.values.first
-    methods = methods.sort.reverse
+    methods = result.threads.values.first.sort.reverse
       
-    # Length should be 4
+    # Length should be 5
     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[2]
+    assert_equal('Kernel#sleep', method.full_name)
     
     method = methods[3]
     assert_equal('<Module::Bar>#hello', method.full_name)

data/test/no_method_class_test.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-
 require 'ruby-prof'
 
 # Make sure this works with no class or method
@@ -7,8 +6,8 @@ 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}")
+methods = result.threads.values.first
+global_method = methods.sort_by {|method| method.full_name}.first
+if global_method.full_name != 'Global#[No method]'
+  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
 end

data/test/prime.rb

@@ -1,6 +1,6 @@
 # A silly little test program that finds prime numbers.  It
 # is intentionally badly designed to show off the use
-# or ruby-prof.
+# of ruby-prof.
 # 
 # Source from http://people.cs.uchicago.edu/~bomb154/154/maclabs/profilers-lab/
 
@@ -44,7 +44,7 @@ def find_largest(primes)
 end
 
 def run_primes
-  length = 500  
+  length = 10
   maxnum = 10000
   
   # Create random numbers
@@ -55,6 +55,4 @@ def run_primes
   
   # Find the largest primes
   largest = find_largest(primes)
-end
-
-run_primes
+end

data/test/prime_test.rb

@@ -1,24 +1,13 @@
 #!/usr/bin/env ruby
-
 require 'test/unit'
 require 'ruby-prof'
 require 'prime'
-require 'test_helper'
-
 
 # --  Tests ----
-class PrimeTest < Test::Unit::TestCase
+class PrimeTest< Test::Unit::TestCase
   def test_consistency
     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
 end

data/test/printers_test.rb

@@ -2,13 +2,11 @@
 require 'test/unit'
 require 'ruby-prof'
 require 'prime'
-require 'test_helper'
-
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
-  
   def setup
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
     @result = RubyProf.profile do
       run_primes
     end
@@ -31,18 +29,18 @@ class PrintersTest < Test::Unit::TestCase
     assert(true)
   end
 
-  def test_flatprinter_duckfriendliness
+  def test_flat_string
     output = ''
     
     printer = RubyProf::FlatPrinter.new(@result)
-    assert_nothing_raised { printer.print( output ) }
+    assert_nothing_raised { printer.print(output) }
     
-    assert_match( /Thread ID: \d+/i, output )
-    assert_match( /Total: \d+\.\d+/i, output )
-    assert_match( /Object#run_primes/i, output )
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Total: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
   end
     
-  def test_graphhtmlprinter_duckfriendliness
+  def test_graph_html_string
     output = ''
     printer = RubyProf::GraphHtmlPrinter.new(@result)
     assert_nothing_raised { printer.print(output) }
@@ -52,17 +50,17 @@ class PrintersTest < Test::Unit::TestCase
     assert_match( /Object#run_primes/i, output )
   end
     
-  def test_graphprinter_duckfriendliness
+  def test_graph_string
     output = ''
     printer = RubyProf::GraphPrinter.new(@result)
     assert_nothing_raised { printer.print(output) }
 
-    assert_match( /Thread ID: \d+/i, output )
+    assert_match( /Thread ID: -?\d+/i, output )
     assert_match( /Total Time: \d+\.\d+/i, output )
     assert_match( /Object#run_primes/i, output )
   end
     
-  def test_calltreeprinter_duckfriendliness
+  def test_call_tree_string
     output = ''
     printer = RubyProf::CallTreePrinter.new(@result)
     assert_nothing_raised { printer.print(output) }
@@ -70,5 +68,4 @@ class PrintersTest < Test::Unit::TestCase
     assert_match(/fn=Object::find_primes/i, output)
     assert_match(/events: process_time/i, output)
   end
-
 end