ruby-prof 1.7.2 → 2.0.0

data/test/printer_flat_test.rb

@@ -1,99 +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
+#!/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

@@ -1,59 +1,62 @@
-#!/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
+#!/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 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 = StringIO.new
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output.string)
+    assert_match( %r{<th>Total</th>}i, output.string)
+    assert_match(/Object#run_primes/i, output.string)
+  end
+
+  def test_graph_html_result_sorting_by_total_time_is_default
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    output = StringIO.new
+    printer.print(output)
+    total_times = graph_html_output_nth_column_values(output.string, 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|
+      output = StringIO.new
+      printer.print(output, sort_method: sort_method)
+      times = graph_html_output_nth_column_values(output.string, n)
+      assert_sorted times
+    end
+  end
+end

data/test/printer_graph_test.rb

@@ -1,40 +1,42 @@
-#!/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
+#!/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 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|
+      output = StringIO.new
+      printer.print(output, sort_method: sort_method)
+      times = graph_output_nth_column_values(output.string, n)
+      assert_sorted times
+    end
+  end
+end

data/test/printers_test.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # encoding: UTF-8
 
 require File.expand_path('../test_helper', __FILE__)
@@ -12,7 +11,7 @@ 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}
+    measure_modes = {wall_time: RubyProf::WALL_TIME, process_time: RubyProf::PROCESS_TIME, allocations: RubyProf::ALLOCATIONS}
 
     @results = {}
 
@@ -24,13 +23,13 @@ class PrintersTest < TestCase
   end
 
   def test_printers
-    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
+    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.print(path: Dir.tmpdir)
 
     printer = RubyProf::FlatPrinter.new(@results[:wall_time])
     printer.print(output)
@@ -47,10 +46,10 @@ class PrintersTest < TestCase
     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")}
+    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")
+    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)
@@ -58,63 +57,50 @@ class PrintersTest < TestCase
     end
   end
 
-  def test_refuses_io_objects
+  def test_refuses_positional_arguments
     p = RubyProf::MultiPrinter.new(@results[:wall_time])
-    begin
+    assert_raises(ArgumentError) do
       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)
+    assert_match(/prime.rb/, output.string)
   end
 
   def helper_test_flat_string(klass)
-    output = ''
+    output = StringIO.new
 
     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)
+    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
   end
 
   def test_graph_html_string
-    output = ''
+    output = StringIO.new
     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)
+    assert_match(/<!DOCTYPE html>/i, output.string)
+    assert_match( %r{<th>Total</th>}i, output.string)
+    assert_match(/Object#run_primes/i, output.string)
   end
 
   def test_graph_string
-    output = ''
+    output = StringIO.new
     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)
+    assert_match(/Thread ID: -?\d+/i, output.string)
+    assert_match(/Fiber ID: -?\d+/i, output.string)
+    assert_match(/Total Time: \d+\.\d+/i, output.string)
+    assert_match(/Object#run_primes/i, output.string)
   end
 
   def do_nothing
@@ -133,14 +119,14 @@ class PrintersTest < TestCase
     # 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)
+      out = StringIO.new
+      printer.print(out, min_percent: 0.00000001)
+      assert_match(/do_nothing/, out.string)
     end
   end
 
   def test_print_footer
-    results_keys = [:wall_time, :process_time, :allocations, :memory]
+    results_keys = [:wall_time, :process_time, :allocations]
     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.",
@@ -157,7 +143,7 @@ class PrintersTest < TestCase
     ]
 
     results_keys.each do |key|
-      output = ''
+      output = StringIO.new
       printer = RubyProf::GraphPrinter.new(@results[key])
       printer.print(output)
 
@@ -166,12 +152,10 @@ class PrintersTest < TestCase
         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)
+        assert_match(pattern, output.string)
       end
     end
   end