ruby-prof 1.8.0-x64-mswin64-140

data/test/printer_flat_test.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrinterFlatTest < TestCase
+  def run_profile
+    RubyProf::Profile.profile(:measure_mode => RubyProf::WALL_TIME) do
+      run_primes(1000, 5000)
+    end
+  end
+
+  def flat_output_nth_column_values(output, n)
+    only_method_calls = output.split("\n").select { |line| line =~ /^\s+\d+/ }
+    only_method_calls.collect { |line| line.split(/\s+/)[n] }
+  end
+
+  def helper_test_flat_string(klass)
+    output = StringIO.new
+
+    printer = klass.new(self.run_profile)
+    printer.print(output)
+
+    assert_match(/Thread ID: -?\d+/i, output.string)
+    assert_match(/Fiber ID: -?\d+/i, output.string)
+    assert_match(/Total: \d+\.\d+/i, output.string)
+    assert_match(/Object#run_primes/i, output.string)
+    output.string
+  end
+
+  def assert_sorted(array)
+    array = array.map(&:to_f) # allow for > 10s times to sort right, since lexographically 4.0 > 10.0
+    assert_equal(array, array.sort.reverse)
+  end
+
+  def test_flat_string
+    output = helper_test_flat_string(RubyProf::FlatPrinter)
+    assert_match(/prime.rb/, output)
+  end
+
+  def test_flat_result_sorting_by_self_time_is_default
+    printer = RubyProf::FlatPrinter.new(self.run_profile)
+
+    output = StringIO.new
+    printer.print(output)
+    self_times = flat_output_nth_column_values(output.string, 3)
+
+    assert_sorted self_times
+  end
+
+  def test_flat_result_sorting
+    printer = RubyProf::FlatPrinter.new(self.run_profile)
+
+    sort_method_with_column_number = {:total_time => 2, :self_time => 3, :wait_time => 4, :children_time => 5}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      output = StringIO.new
+      printer.print(output, :sort_method => sort_method)
+
+      times = flat_output_nth_column_values(output.string, n)
+      assert_sorted(times)
+    end
+  end
+
+  def test_flat_result_max_percent
+    printer = RubyProf::FlatPrinter.new(self.run_profile)
+
+    output = StringIO.new
+    printer.print(output, max_percent: 1)
+    self_percents = flat_output_nth_column_values(output.string, 1).map(&:to_f)
+
+    assert self_percents.max < 1
+  end
+
+  def test_flat_result_filter_by_total_time
+    printer = RubyProf::FlatPrinter.new(self.run_profile)
+
+    output = StringIO.new
+    printer.print(output, filter_by: :total_time, min_percent: 50)
+    total_times = flat_output_nth_column_values(output.string, 2).map(&:to_f)
+
+    assert (total_times.min / total_times.max) >= 0.5
+  end
+
+  def test_flat_result_filter_by_self_time
+    printer = RubyProf::FlatPrinter.new(self.run_profile)
+
+    output = StringIO.new
+    printer.print(output, filter_by: :self_time, min_percent: 0.1)
+    self_percents = flat_output_nth_column_values(output.string, 1).map(&:to_f)
+
+    assert self_percents.min >= 0.1
+  end
+end

data/test/printer_graph_html_test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrinterGraphHtmlTest < TestCase
+  def setup
+    super
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      run_primes(1000, 5000)
+    end
+  end
+
+  def graph_html_output_nth_column_values(output, n)
+    only_root_calls = output.split('<tr class="method">')
+    only_root_calls.delete_at(0)
+    only_root_calls.collect {|line| line.scan(/[\d\.]+/)[n - 1] }
+  end
+
+  def assert_sorted array
+    array = array.map{|n| n.to_f} # allow for > 10s times to sort right, since lexographically 4.0 > 10.0
+    assert_equal array, array.sort.reverse, "Array #{array.inspect} is not sorted"
+  end
+
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output)
+    assert_match( %r{<th>Total</th>}i, output)
+    assert_match(/Object#run_primes/i, output)
+  end
+
+  def test_graph_html_result_sorting_by_total_time_is_default
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    printer.print(output = '')
+    total_times = graph_html_output_nth_column_values(output, 3)
+
+    assert_sorted total_times
+  end
+
+  def test_graph_html_result_sorting
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+
+    sort_method_with_column_number = {:total_time => 3, :self_time => 4, :wait_time => 5, :children_time => 6}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = graph_html_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+end

data/test/printer_graph_test.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrinterGraphTest < TestCase
+  def setup
+    super
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      run_primes(1000, 5000)
+    end
+  end
+
+  def graph_output_nth_column_values(output, n)
+    only_root_calls = output.split("\n").select { |line| line =~ /^ +[\d\.]+%/ }
+    only_root_calls.collect { |line| line.split(/ +/)[n] }
+  end
+
+  def assert_sorted(array)
+    array = array.map {|n| n.to_f} # allow for > 10s times to sort right, since lexographically 4.0 > 10.0
+    assert_equal(array, array.sort.reverse, "Array #{array.inspect} is not sorted")
+  end
+
+  def test_graph_results_sorting
+    printer = RubyProf::GraphPrinter.new(@result)
+
+    sort_method_with_column_number = {:total_time => 3, :self_time => 4, :wait_time => 5, :children_time => 6}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = graph_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+end

data/test/printers_test.rb

@@ -0,0 +1,178 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrintersTest < TestCase
+  def setup
+    super
+    # WALL_TIME, PROCESS_TIME, ALLOCATIONS and MEMORY as types of measuremen
+    measure_modes = {wall_time: RubyProf::WALL_TIME, process_time: RubyProf::PROCESS_TIME, allocations: RubyProf::ALLOCATIONS, memory: RubyProf::MEMORY}
+
+    @results = {}
+
+    measure_modes.each do |key, value|
+      @results[key] = RubyProf::Profile.profile(measure_mode: value) do
+        run_primes(1000, 5000)
+      end
+    end
+  end
+
+  def test_printers
+    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
+
+    printer = RubyProf::CallStackPrinter.new(@results[:wall_time])
+    printer.print(output)
+
+    printer = RubyProf::CallTreePrinter.new(@results[:wall_time])
+    printer.print(:path => Dir.tmpdir)
+
+    printer = RubyProf::FlatPrinter.new(@results[:wall_time])
+    printer.print(output)
+
+    printer = RubyProf::GraphHtmlPrinter.new(@results[:wall_time])
+    printer.print(output)
+
+    printer = RubyProf::GraphPrinter.new(@results[:wall_time])
+    printer.print(output)
+  end
+
+  def test_print_to_files
+    printer = RubyProf::DotPrinter.new(@results[:wall_time])
+    File.open("#{Dir.tmpdir}/graph.dot", "w") {|f| printer.print(f)}
+
+    printer = RubyProf::CallStackPrinter.new(@results[:wall_time])
+    File.open("#{Dir.tmpdir}/stack.html", "w") {|f| printer.print(f, :application => "primes")}
+
+    printer = RubyProf::MultiPrinter.new(@results[:wall_time])
+    printer.print(:path => Dir.tmpdir, :profile => "multi", :application => "primes")
+
+    ['graph.dot', 'multi.flat.txt', 'multi.graph.html', "multi.callgrind.out.#{$$}", 'multi.stack.html', 'stack.html'].each do |file_name|
+      file_path = File.join(Dir.tmpdir, file_name)
+      refute(File.empty?(file_path))
+    end
+  end
+
+  def test_refuses_io_objects
+    p = RubyProf::MultiPrinter.new(@results[:wall_time])
+    begin
+      p.print(STDOUT)
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/IO/, e.to_s)
+    end
+  end
+
+  def test_refuses_non_hashes
+    p = RubyProf::MultiPrinter.new (@results[:wall_time])
+    begin
+      p.print([])
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/hash/, e.to_s)
+    end
+  end
+
+  def test_flat_string
+    output = helper_test_flat_string(RubyProf::FlatPrinter)
+    assert_match(/prime.rb/, output)
+  end
+
+  def helper_test_flat_string(klass)
+    output = ''
+
+    printer = klass.new(@results[:wall_time])
+    printer.print(output)
+
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Fiber ID: -?\d+/i, output)
+    assert_match(/Total: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
+    output
+  end
+
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@results[:wall_time])
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output)
+    assert_match( %r{<th>Total</th>}i, output)
+    assert_match(/Object#run_primes/i, output)
+  end
+
+  def test_graph_string
+    output = ''
+    printer = RubyProf::GraphPrinter.new(@results[:wall_time])
+    printer.print(output)
+
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Fiber ID: -?\d+/i, output)
+    assert_match(/Total Time: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
+  end
+
+  def do_nothing
+    start = Time.now
+    while(Time.now == start)
+    end
+  end
+
+  def test_all_with_small_percentiles
+    result = RubyProf::Profile.profile do
+      sleep 2
+      do_nothing
+    end
+
+    # RubyProf::CallTreePrinter doesn't "do" a min_percent
+    # RubyProf::FlatPrinter only outputs if self time > percent...
+    for klass in [RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
+      printer = klass.new(result)
+      out = ''
+      printer.print(out, :min_percent => 0.00000001)
+      assert_match(/do_nothing/, out)
+    end
+  end
+
+  def test_print_footer
+    results_keys = [:wall_time, :process_time, :allocations, :memory]
+    expected_matches = [
+      "The percentage of time spent by this method relative to the total time in the entire program.",
+      "The total time spent by this method and its children.",
+      "The time spent by this method.",
+      "The time spent by this method's children.",
+      "The percentage of allocations made by this method relative to the total allocations in the entire program.",
+      "The total number of allocations made by this method and its children.",
+      "The number of allocations made by this method.",
+      "The number of allocations made by this method's children.",
+      "The percentage of memory used by this method relative to the total memory in the entire program.",
+      "The total memory used by this method and its children.",
+      "The memory used by this method.",
+      "The memory used by this method's children."
+    ]
+
+    results_keys.each do |key|
+      output = ''
+      printer = RubyProf::GraphPrinter.new(@results[key])
+      printer.print(output)
+
+      case key
+      when :wall_time, :process_time
+        matches = expected_matches[0..3]
+      when :allocations
+        matches = expected_matches[4..7]
+      when :memory
+        matches = expected_matches[8..11]
+      end
+
+      matches.each do |pattern|
+        assert_match(pattern, output)
+      end
+    end
+  end
+end

data/test/printing_recursive_graph_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+
+# --- code to be tested ---
+module PRGT
+  extend self
+
+  def f(n)
+    n.times { sleep 0.1 }
+  end
+
+  def g(n)
+    n.times { sleep 0.2 }
+  end
+
+  def run
+    2.times { f(2); g(4) }
+  end
+end
+
+# --- expected test output ---
+=begin
+Measure Mode: wall_time
+Thread ID: 1307675084040
+Fiber ID: 1307708787440
+Total Time: 2.0939999999973224
+Sort by:
+
+  %total   %self      total       self       wait      child            calls     name
+--------------------------------------------------------------------------------
+                      1.657      0.000      0.000      1.657              2/2     Integer#times
+  79.13%   0.00%      1.657      0.000      0.000      1.657                2     PRGT#g
+                      1.657      0.000      0.000      1.657              2/5     Integer#times
+--------------------------------------------------------------------------------
+                      2.094      2.094      0.000      0.000            12/12     Integer#times
+ 100.00% 100.00%      2.094      2.094      0.000      0.000               12     Kernel#sleep
+--------------------------------------------------------------------------------
+                      0.437      0.000      0.000      0.437              2/2     Integer#times
+  20.87%   0.00%      0.437      0.000      0.000      0.437                2     PRGT#f
+                      0.437      0.000      0.000      0.437              2/5     Integer#times
+--------------------------------------------------------------------------------
+                      0.437      0.000      0.000      0.437              2/5     PRGT#f
+                      1.657      0.000      0.000      1.657              2/5     PRGT#g
+                      2.094      0.000      0.000      2.094              1/5     PRGT#run
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                5    *Integer#times
+                      2.094      2.094      0.000      0.000            12/12     Kernel#sleep
+                      1.657      0.000      0.000      1.657              2/2     PRGT#g
+                      0.437      0.000      0.000      0.437              2/2     PRGT#f
+--------------------------------------------------------------------------------
+                      2.094      0.000      0.000      2.094              1/1     PrintingRecursiveGraphTest#setup
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PRGT#run
+                      2.094      0.000      0.000      2.094              1/5     Integer#times
+--------------------------------------------------------------------------------
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PrintingRecursiveGraphTest#setup
+                      2.094      0.000      0.000      2.094              1/1     PRGT#run
+
+* indicates recursively called methods
+=end
+
+class PrintingRecursiveGraphTest < TestCase
+  def setup
+    super
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      PRGT.run
+    end
+  end
+
+  def test_printing_rescursive_graph
+    printer = RubyProf::GraphPrinter.new(@result)
+    buffer = ''
+    printer.print(StringIO.new(buffer))
+    puts buffer if ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1"
+
+    refute_nil(buffer)
+  end
+end

data/test/profile_test.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
+
+class ProfileTest < TestCase
+  def test_measure_mode
+    profile = RubyProf::Profile.new(:measure_mode => RubyProf::PROCESS_TIME)
+    assert_equal(RubyProf::PROCESS_TIME, profile.measure_mode)
+  end
+
+  def test_measure_mode_string
+    profile = RubyProf::Profile.new(:measure_mode => RubyProf::PROCESS_TIME)
+    assert_equal("process_time", profile.measure_mode_string)
+  end
+
+  def test_add_thread
+    profile = RubyProf::Profile.new
+    assert_empty(profile.threads)
+
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    profile.add_thread(thread)
+    assert_equal(1, profile.threads.size)
+    assert(thread.equal?(profile.threads.first))
+  end
+
+  def test_add_threads
+    call_tree_1 = create_call_tree_1
+    ruby_thread_1 = Thread.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, ruby_thread_1, Fiber.current)
+
+    call_tree_2 = create_call_tree_2
+    ruby_thread_2 = Thread.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, ruby_thread_2, Fiber.current)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+    assert_equal(1, profile.threads.count)
+  end
+
+  def test_add_fibers
+    call_tree_1 = create_call_tree_1
+    fiber_1 = Fiber.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, fiber_1)
+
+    call_tree_2 = create_call_tree_2
+    fiber_2 = Fiber.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, fiber_2)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+    assert_equal(2, profile.threads.count)
+  end
+
+  def test_remove_thread
+    profile = RubyProf::Profile.new
+    assert_empty(profile.threads)
+
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    profile.add_thread(thread)
+    assert_equal(1, profile.threads.size)
+    assert(thread.equal?(profile.threads.first))
+
+    removed = profile.remove_thread(thread)
+    assert_equal(0, profile.threads.size)
+    assert(removed.equal?(thread))
+  end
+
+  def test_merge
+    call_tree_1 = create_call_tree_1
+    fiber_1 = Thread.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, fiber_1)
+
+    call_tree_2 = create_call_tree_2
+    fiber_2 = Thread.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, fiber_2)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+
+    profile.merge!
+    assert_equal(1, profile.threads.count)
+
+    assert_equal(thread_1, profile.threads.first)
+
+    assert_in_delta(11.6, thread_1.call_tree.total_time, 0.00001)
+    assert_in_delta(0, thread_1.call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, thread_1.call_tree.wait_time, 0.00001)
+    assert_in_delta(11.6, thread_1.call_tree.children_time, 0.00001)
+  end
+end

data/test/rack_test.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class FakeRackApp
+  def call(env)
+  end
+end
+
+module Rack
+  class Request
+    def initialize(env)
+      if env == :fake_env
+        @env = {}
+      else
+        @env = env
+      end
+    end
+
+    def path
+      @env[:path] || '/path/to/resource.json'
+    end
+  end
+end
+
+class RackTest < TestCase
+  def test_create_print_path
+    path = Dir.mktmpdir
+    Dir.delete(path)
+
+    Rack::RubyProf.new(FakeRackApp.new, :path => path)
+
+    assert(Dir.exist?(path))
+  end
+
+  def test_create_profile_reports
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path)
+
+    adapter.call(:fake_env)
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_skip_paths
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :skip_paths => [%r{\.json$}])
+
+    adapter.call(:fake_env)
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(!File.exist?(file_path))
+    end
+  end
+
+  def test_only_paths
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :only_paths => [%r{\.json$}])
+
+    adapter.call({path: '/path/to/resource.json'})
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+
+    adapter.call({path: '/path/to/resource.html'})
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.html-#{base_name}")
+      assert(!File.exist?(file_path))
+    end
+  end
+
+  def test_allows_lazy_filename_setting
+    path = Dir.mktmpdir
+
+    printer = {::RubyProf::FlatPrinter => lambda { 'dynamic.txt' }}
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :printers => printer)
+
+    adapter.call(:fake_env)
+
+    file_path = ::File.join(path, 'path-to-resource.json-dynamic.txt')
+    assert(File.exist?(file_path))
+  end
+end