rdp-ruby-prof 0.7.4

data/test/duplicate_names_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+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.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

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+class LineNumbers
+  def method1
+    a = 3
+  end
+  
+  def method2
+    a = 3
+    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(27, method.line)
+    
+    method = methods[1]
+    assert_equal('LineNumbers#method2', method.full_name)
+    assert_equal(11, method.line)
+    
+    method = methods[2]
+    assert_equal('LineNumbers#method1', method.full_name)
+    assert_equal(7, method.line)
+  end
+  
+  def test_c_function
+    numbers = LineNumbers.new
+    
+    result = RubyProf.profile do
+      numbers.method3
+    end
+
+    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('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+    
+    method = methods[1]
+    assert_equal('LineNumbers#method3', method.full_name)
+    assert_equal(16, method.line)
+    
+    method = methods[2]
+    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

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+
+# 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.sort.reverse
+      
+    # 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('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)
+    
+    method = methods[4]
+    assert_equal('<Module::Foo>#hello', method.full_name)
+  end 
+end

data/test/no_method_class_test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'ruby-prof'
+
+# Make sure this works with no class or method
+result = RubyProf.profile do 
+  sleep 1
+end
+
+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

@@ -0,0 +1,58 @@
+# A silly little test program that finds prime numbers.  It
+# is intentionally badly designed to show off the use
+# of ruby-prof.
+# 
+# Source from http://people.cs.uchicago.edu/~bomb154/154/maclabs/profilers-lab/
+
+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
+
+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
+
+def run_primes
+  length = 10
+  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)
+end

data/test/prime_test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+# --  Tests ----
+class PrimeTest< Test::Unit::TestCase
+  def test_consistency
+    result = RubyProf.profile do
+      run_primes
+    end
+  end
+end

data/test/printers_test.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+# --  Tests ----
+class PrintersTest < Test::Unit::TestCase
+  def setup
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+    @result = RubyProf.profile do
+      run_primes
+    end
+  end
+    
+  def test_printers
+    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
+
+  def test_flat_string
+    output = ''
+    
+    printer = RubyProf::FlatPrinter.new(@result)
+    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)
+  end
+    
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match( /DTD HTML 4\.01/i, output )
+    assert_match( %r{<th>Total Time</th>}i, output )
+    assert_match( /Object#run_primes/i, output )
+  end
+    
+  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( /Total Time: \d+\.\d+/i, output )
+    assert_match( /Object#run_primes/i, output )
+  end
+    
+  def test_call_tree_string
+    output = ''
+    printer = RubyProf::CallTreePrinter.new(@result)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match(/fn=Object::find_primes/i, output)
+    assert_match(/events: process_time/i, output)
+  end
+end