jeremy-ruby-prof 0.6.1

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

data/test/prime.rb

@@ -0,0 +1,60 @@
+# A silly little test program that finds prime numbers.  It
+# is intentionally badly designed to show off the use
+# or 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 = 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)
+end
+
+run_primes

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

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

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+require 'test_helper'
+
+
+# --  Tests ----
+class PrintersTest < Test::Unit::TestCase
+  
+  def setup
+    @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_flatprinter_duckfriendliness
+    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_graphhtmlprinter_duckfriendliness
+    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_graphprinter_duckfriendliness
+    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_calltreeprinter_duckfriendliness
+    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

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

@@ -0,0 +1,144 @@
+#!/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
+
+def simple(n)
+  sleep(1)
+  n -= 1
+  return if n == 0
+  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
+  else 
+    n * factorial(n-1)
+  end
+end
+
+
+# --  Tests ----
+class RecursiveTest < Test::Unit::TestCase
+  def test_recursive
+    result = RubyProf.profile do
+      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.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end
+  
+  def test_factorial
+    result = RubyProf.profile do
+      # Around 700 on windows causes "stack level too deep" error
+      factorial(650)
+    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