ruby-prof 0.17.0 → 0.18.0

data/test/printing_recursive_graph_test.rb

@@ -1,127 +1,127 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'stringio'
-require 'fileutils'
-
-# --- 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: 70238775664960
-Fiber ID: 70238784046840
-Total Time: 2.040249824523926
-Sort by: total_time
-
-  %total   %self      total       self       wait      child            calls    Name
---------------------------------------------------------------------------------
- 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PrintingRecursiveGraphTest#setup
-                      2.040      0.000      0.000      2.040              1/1      PRGT#run
---------------------------------------------------------------------------------
-                      2.040      0.000      0.000      2.040              1/1      PrintingRecursiveGraphTest#setup
- 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PRGT#run
-                      2.040      0.000      0.000      2.040              1/5      Integer#times
---------------------------------------------------------------------------------
-                      0.409      0.000      0.000      0.409              2/5      Prgt#f
-                      1.631      0.000      0.000      1.631              2/5      PRGT#g
-                      2.040      0.000      0.000      2.040              1/5      PRGT#run
- 100.00%   0.00%      2.040      0.000      0.000      2.040                5     *Integer#times
-                      2.040      2.040      0.000      0.000            12/12      Kernel#sleep
-                      1.631      0.000      0.000      1.631              2/2      PRGT#g
-                      0.409      0.000      0.000      0.409              2/2      PRGT#f
---------------------------------------------------------------------------------
-                      2.040      2.040      0.000      0.000            12/12      Integer#times
-  99.99%  99.99%      2.040      2.040      0.000      0.000               12      Kernel#sleep
---------------------------------------------------------------------------------
-                      1.631      0.000      0.000      1.631              2/2      Integer#times
-  79.94%   0.00%      1.631      0.000      0.000      1.631                2      PRGT#g
-                      1.631      0.000      0.000      1.631              2/5      Integer#times
---------------------------------------------------------------------------------
-                      0.409      0.000      0.000      0.409              2/2      Integer#times
-  20.05%   0.00%      0.409      0.000      0.000      0.409                2      PRGT#f
-                      0.409      0.000      0.000      0.409              2/5      Integer#times
-
-* indicates recursively called methods
-=end
-
-class PrintingRecursiveGraphTest < TestCase
-  include PrinterTestHelper
-
-  def setup
-    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile 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"
-
-    parsed_output = MetricsArray.parse(buffer)
-
-    assert( integer_times  = parsed_output.metrics_for("*Integer#times") )
-
-    actual_parents = integer_times.parents.map(&:name)
-    expected_parents = %w(PRGT#f PRGT#g PRGT#run)
-    assert_equal expected_parents, actual_parents
-
-    actual_children = integer_times.children.map(&:name)
-    expected_children = %w(Kernel#sleep PRGT#g PRGT#f)
-    assert_equal expected_children, actual_children
-
-    assert( fp = integer_times.parent("PRGT#f") )
-    assert_in_delta(fp.total, fp.child, 0.01)
-    assert_equal("2/5", fp.calls)
-
-    assert( gp = integer_times.parent("PRGT#g") )
-    assert_in_delta(gp.total, gp.child, 0.01)
-    assert_equal("2/5", gp.calls)
-
-    assert( rp = integer_times.parent("PRGT#run") )
-    assert_in_delta(rp.total, rp.child, 0.01)
-    assert_equal("1/5", rp.calls)
-
-    assert_in_delta(4*fp.total, gp.total, 0.05)
-    assert_in_delta(fp.total + gp.total, rp.total, 0.05)
-    assert_in_delta(integer_times.metrics.total, rp.total, 0.05)
-
-    assert( fc = integer_times.child("PRGT#f") )
-    assert_in_delta(fc.total, fc.child, 0.01)
-    assert_equal("2/2", fc.calls)
-
-    assert( gc = integer_times.child("PRGT#g") )
-    assert_in_delta(gc.total, gc.child, 0.01)
-    assert_equal("2/2", gc.calls)
-
-    assert( ks = integer_times.child("Kernel#sleep") )
-    assert_in_delta(ks.total, ks.self_t, 0.01)
-    assert_equal("12/12", ks.calls)
-
-    assert_in_delta(4*fc.total, gc.total, 0.05)
-    assert_in_delta(fp.total + gc.total, ks.total, 0.05)
-    assert_in_delta(integer_times.metrics.total, ks.total, 0.05)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'fileutils'
+
+# --- 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: 70238775664960
+Fiber ID: 70238784046840
+Total Time: 2.040249824523926
+Sort by: total_time
+
+  %total   %self      total       self       wait      child            calls    Name
+--------------------------------------------------------------------------------
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PrintingRecursiveGraphTest#setup
+                      2.040      0.000      0.000      2.040              1/1      PRGT#run
+--------------------------------------------------------------------------------
+                      2.040      0.000      0.000      2.040              1/1      PrintingRecursiveGraphTest#setup
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PRGT#run
+                      2.040      0.000      0.000      2.040              1/5      Integer#times
+--------------------------------------------------------------------------------
+                      0.409      0.000      0.000      0.409              2/5      Prgt#f
+                      1.631      0.000      0.000      1.631              2/5      PRGT#g
+                      2.040      0.000      0.000      2.040              1/5      PRGT#run
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                5     *Integer#times
+                      2.040      2.040      0.000      0.000            12/12      Kernel#sleep
+                      1.631      0.000      0.000      1.631              2/2      PRGT#g
+                      0.409      0.000      0.000      0.409              2/2      PRGT#f
+--------------------------------------------------------------------------------
+                      2.040      2.040      0.000      0.000            12/12      Integer#times
+  99.99%  99.99%      2.040      2.040      0.000      0.000               12      Kernel#sleep
+--------------------------------------------------------------------------------
+                      1.631      0.000      0.000      1.631              2/2      Integer#times
+  79.94%   0.00%      1.631      0.000      0.000      1.631                2      PRGT#g
+                      1.631      0.000      0.000      1.631              2/5      Integer#times
+--------------------------------------------------------------------------------
+                      0.409      0.000      0.000      0.409              2/2      Integer#times
+  20.05%   0.00%      0.409      0.000      0.000      0.409                2      PRGT#f
+                      0.409      0.000      0.000      0.409              2/5      Integer#times
+
+* indicates recursively called methods
+=end
+
+class PrintingRecursiveGraphTest < TestCase
+  include PrinterTestHelper
+
+  def setup
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    @result = RubyProf.profile 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"
+
+    parsed_output = MetricsArray.parse(buffer)
+
+    assert( integer_times  = parsed_output.metrics_for("*Integer#times") )
+
+    actual_parents = integer_times.parents.map(&:name)
+    expected_parents = %w(PRGT#f PRGT#g PRGT#run)
+    assert_equal expected_parents, actual_parents
+
+    actual_children = integer_times.children.map(&:name)
+    expected_children = %w(Kernel#sleep PRGT#g PRGT#f)
+    assert_equal expected_children, actual_children
+
+    assert( fp = integer_times.parent("PRGT#f") )
+    assert_in_delta(fp.total, fp.child, 0.01)
+    assert_equal("2/5", fp.calls)
+
+    assert( gp = integer_times.parent("PRGT#g") )
+    assert_in_delta(gp.total, gp.child, 0.01)
+    assert_equal("2/5", gp.calls)
+
+    assert( rp = integer_times.parent("PRGT#run") )
+    assert_in_delta(rp.total, rp.child, 0.01)
+    assert_equal("1/5", rp.calls)
+
+    assert_in_delta(4*fp.total, gp.total, 0.05)
+    assert_in_delta(fp.total + gp.total, rp.total, 0.05)
+    assert_in_delta(integer_times.metrics.total, rp.total, 0.05)
+
+    assert( fc = integer_times.child("PRGT#f") )
+    assert_in_delta(fc.total, fc.child, 0.01)
+    assert_equal("2/2", fc.calls)
+
+    assert( gc = integer_times.child("PRGT#g") )
+    assert_in_delta(gc.total, gc.child, 0.01)
+    assert_equal("2/2", gc.calls)
+
+    assert( ks = integer_times.child("Kernel#sleep") )
+    assert_in_delta(ks.total, ks.self_t, 0.01)
+    assert_equal("12/12", ks.calls)
+
+    assert_in_delta(4*fc.total, gc.total, 0.05)
+    assert_in_delta(fp.total + gc.total, ks.total, 0.05)
+    assert_in_delta(integer_times.metrics.total, ks.total, 0.05)
+  end
+end

data/test/rack_test.rb

@@ -1,157 +1,157 @@
-#!/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
-
-module Rack
-  class RubyProf
-    attr_reader :_profiler
-
-    def public_delete_profiler!
-      delete_profiler!
-    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
-
-  def test_works_for_multiple_requests
-    path = Dir.mktmpdir
-
-    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 2)
-
-    # make a 1st request, and check that this didn't create any files
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    # now a second request should create all the expected files
-    adapter.call(:fake_env)
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-
-    # let's clean up
-    FileUtils.rm_rf(Dir["#{path}/*"])
-
-    # and do the same again for the next 2 requests
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    adapter.call(:fake_env)
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-  end
-
-  def test_tries_to_print_results_if_shut_down_before_max_requests_reached
-    path = Dir.mktmpdir
-
-    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 100)
-
-    # make a 1st request, and check that this didn't create any files
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    adapter.public_delete_profiler!
-
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-1-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-  end
-
-  def test_it_uses_separate_profilers_if_not_aggregating_multiple_requests
-    adapter1 = Rack::RubyProf.new(FakeRackApp.new)
-    adapter2 = Rack::RubyProf.new(FakeRackApp.new)
-
-    assert(adapter1.object_id != adapter2.object_id)
-  end
-end
+#!/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
+
+module Rack
+  class RubyProf
+    attr_reader :_profiler
+
+    def public_delete_profiler!
+      delete_profiler!
+    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
+
+  def test_works_for_multiple_requests
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 2)
+
+    # make a 1st request, and check that this didn't create any files
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    # now a second request should create all the expected files
+    adapter.call(:fake_env)
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+
+    # let's clean up
+    FileUtils.rm_rf(Dir["#{path}/*"])
+
+    # and do the same again for the next 2 requests
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    adapter.call(:fake_env)
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_tries_to_print_results_if_shut_down_before_max_requests_reached
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 100)
+
+    # make a 1st request, and check that this didn't create any files
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    adapter.public_delete_profiler!
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-1-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_it_uses_separate_profilers_if_not_aggregating_multiple_requests
+    adapter1 = Rack::RubyProf.new(FakeRackApp.new)
+    adapter2 = Rack::RubyProf.new(FakeRackApp.new)
+
+    assert(adapter1.object_id != adapter2.object_id)
+  end
+end