acunote-ruby-prof 0.9.2

data/test/measurement_test.rb

@@ -0,0 +1,122 @@
+#!/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)
+
+      RubyProf::measure_mode = RubyProf::MEMORY
+      result = RubyProf.profile {Array.new}
+      total = result.threads.values.first.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/method_elimination_test.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class ESTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MethodEliminationTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_setting_parent
+    result = RubyProf.profile do
+      1000.times { 1+1 }
+    end
+    method_infos = result.threads.values.first
+    assert(m1 = method_infos[0])
+    assert(c1 = m1.call_infos.first)
+    assert_equal(c1, c1.parent = c1)
+    assert_equal c1, c1.parent
+  end
+
+  def test_methods_can_be_eliminated
+    RubyProf.start
+    5.times{ESTPT.new.a}
+    result = RubyProf.stop
+    # result.dump
+    eliminated = result.eliminate_methods!([/Integer#times/])
+    # puts eliminated.inspect
+    # result.dump
+    eliminated.each do |m|
+      assert_method_has_been_eliminated(result, m)
+    end
+  end
+
+  private
+  def assert_method_has_been_eliminated(result, eliminated_method)
+    result.threads.each do |thread_id, methods|
+      methods.each do |method|
+        method.call_infos.each do |ci|
+          assert(ci.target != eliminated_method, "broken self")
+          assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent
+          ci.children.each do |callee|
+            assert(callee.target != eliminated_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end

data/test/module_test.rb

@@ -0,0 +1,44 @@
+#!/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
+
+    # Length should be 5
+    assert_equal(5, methods.length)
+
+    # these methods should be in there... (hard to tell order though).
+    for name in ['ModuleTest#test_nested_modules','Bar#hello','Kernel#sleep','<Module::Bar>#hello','<Module::Foo>#hello']
+      assert methods.map(&:full_name).include? name
+    end
+  end
+end

data/test/multi_printer_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class MSTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MultiPrinterTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_all_profiles_can_be_created
+    start_time = Time.now
+    RubyProf.start
+    5.times{MSTPT.new.a}
+    result = RubyProf.stop
+    end_time = Time.now
+    expected_time = end_time - start_time
+    stack = graph = nil
+    assert_nothing_raised { stack, graph = print(result) }
+    re = Regexp.new('
+\s*<table>
+\s*<tr>
+\s*<th>Thread ID</th>
+\s*<th>Total Time</th>
+\s*</tr>
+\s*
+\s*<tr>
+\s*<td><a href="#\d+">\d+</a></td>
+\s*<td>([\.0-9]+)</td>
+\s*</tr>
+\s*
+\s*</table>')
+    assert graph =~ re
+    display_time = $1.to_f
+    difference = (expected_time-display_time).abs
+    assert_in_delta expected_time, display_time, 0.005
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = Dir::tmpdir
+    profile = "ruby_prof_#{test}"
+    printer = RubyProf::MultiPrinter.new(result)
+    printer.print(:path => path, :profile => profile,
+                  :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")
+    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+      system("open '#{printer.stack_profile}'")
+    end
+    if GC.respond_to?(:dump_file_and_line_info)
+      GC.start
+      GC.dump_file_and_line_info("heap.dump")
+    end
+    [File.open(printer.stack_profile){|f|f.read}, File.open(printer.graph_profile){|f|f.read}]
+  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,55 @@
+# 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=1000)
+  # 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,164 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+require 'stringio'
+require 'fileutils'
+require 'rubygems'
+
+# --  Tests ----
+class PrintersTest < Test::Unit::TestCase
+
+  def go
+    run_primes(1000)
+  end
+
+  def setup
+    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test and get same measurements on linux and doze
+    @result = RubyProf.profile do
+      begin
+        run_primes(1000)
+        go
+      rescue => e
+        p e
+      end
+    end
+
+  end
+
+  def test_printers
+    assert_nothing_raised do
+      output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
+
+      printer = RubyProf::FlatPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::GraphHtmlPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::GraphPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::CallTreePrinter.new(@result)
+      printer.print(output)
+      output_dir = 'examples2'
+      
+      if ENV['SAVE_NEW_PRINTER_EXAMPLES']
+        output_dir = 'examples'
+      end
+      FileUtils.mkdir_p output_dir
+      
+      printer = RubyProf::DotPrinter.new(@result)
+      File.open("#{output_dir}/graph.dot", "w") {|f| printer.print(f)}
+
+      printer = RubyProf::CallStackPrinter.new(@result)
+      File.open("#{output_dir}/stack.html", "w") {|f| printer.print(f, :application => "primes")}
+
+      printer = RubyProf::MultiPrinter.new(@result)
+      printer.print(:path => "#{output_dir}", :profile => "multi", :application => "primes")
+      for file in ['empty.png', 'graph.dot', 'minus.png', 'multi.flat.txt', 'multi.graph.html', 'multi.grind.dat', 'multi.stack.html', 'plus.png', 'stack.html']
+        existant_file = output_dir + '/' + file
+        assert File.size(existant_file) > 0
+      end
+    end
+  end
+
+  def test_flat_string
+    output = helper_test_flat_string RubyProf::FlatPrinter
+    assert_no_match(/prime.rb/, output)
+  end
+
+  def helper_test_flat_string klass
+    output = ''
+
+    printer = klass.new(@result)
+    printer.print(output)
+
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Total: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
+    output
+  end
+
+  def test_flat_string_with_numbers
+    output = helper_test_flat_string RubyProf::FlatPrinterWithLineNumbers
+    assert_match(/prime.rb/, output)
+    assert_no_match(/ruby_runtime:0/, output)
+    assert_match(/called from/, output)
+
+    # should combine common parents
+    # lodo remove...
+    #if RUBY_VERSION < '1.9'
+    #require 'ruby-debug'
+    #debugger
+    #print output
+      assert_equal(3, output.scan(/Object#is_prime/).length) # failing this is prolly a 1.9.2 core bug
+    #else
+    #  # 1.9
+    #  require 'ruby-debug'
+    #  debugger
+    #  assert_equal(2, output.scan(/Object#is_prime/).length)
+    #end
+    assert_no_match(/\.\/test\/prime.rb/, output) # don't use relative paths
+  end
+
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    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)
+    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)
+    printer.print(output)
+    assert_match(/fn=Object#find_primes/i, output)
+    assert_match(/events: wall_time/i, output)
+    assert_no_match(/d\d\d\d\d\d/, output) # old bug looked [in error] like Object::run_primes(d5833116)
+  end
+
+  def do_nothing
+    start = Time.now
+    while(Time.now == start)
+    end
+  end
+
+  def test_all_with_small_percentiles
+
+    result = RubyProf.profile do
+      sleep 2
+      do_nothing
+    end
+
+    # RubyProf::CallTreePrinter doesn't "do" a min_percent
+    # RubyProf::FlatPrinter only outputs if self time > percent...
+    # RubyProf::FlatPrinterWithLineNumbers same
+    for klass in [ RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
+      printer = klass.new(result)
+      out = ''
+      output = printer.print(out, :min_percent => 0.00000001 )
+      assert_match(/do_nothing/, out)
+    end
+
+  end
+
+
+
+end