ruby-prof 1.7.2 → 2.0.0

data/test/pause_resume_test.rb

@@ -1,171 +1,171 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require_relative 'measure_times'
-
-class PauseResumeTest < TestCase
-  def test_pause_resume
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-    # Measured
-    profile.start
-    RubyProf::C1.sleep_wait
-
-    # Not measured
-    profile.pause
-    sleep 1
-    RubyProf::C1.sleep_wait
-
-    # Measured
-    profile.resume
-    RubyProf::C1.sleep_wait
-
-    result = profile.stop
-
-    # Length should be 3:
-    #   PauseResumeTest#test_pause_resume
-    #   <Class::RubyProf::C1>#sleep_wait
-    #   Kernel#sleep
-
-    methods = result.threads.first.methods.sort_by {|method_info| method_info.full_name}
-    # remove methods called by pause/resume
-    called_methods = ['Array#include?', 'Fixnum#==', 'Kernel#respond_to?', 'Kernel#respond_to_missing?']
-    methods.reject!{|m| called_methods.include?(m.full_name) }
-    # TODO: fix pause/resume to not include those methods in the first place
-    assert_equal(3, methods.length)
-
-    # Check the names
-    assert_equal('<Class::RubyProf::C1>#sleep_wait', methods[0].full_name)
-    assert_equal('Kernel#sleep', methods[1].full_name)
-    assert_equal('PauseResumeTest#test_pause_resume', methods[2].full_name)
-
-    # Check times
-    assert_in_delta(0.22, methods[0].total_time, 0.02)
-    assert_in_delta(0, methods[0].wait_time, 0.02)
-    assert_in_delta(0, methods[0].self_time, 0.02)
-
-    assert_in_delta(0.22, methods[1].total_time, 0.02)
-    assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.22, methods[1].self_time, 0.02)
-
-    assert_in_delta(0.22, methods[2].total_time, 0.02)
-    assert_in_delta(0, methods[2].wait_time, 0.02)
-    assert_in_delta(0, methods[2].self_time, 0.02)
-  end
-
-  # pause/resume in the same frame
-  def test_pause_resume_1
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-
-    profile.start
-    method_1a
-
-    profile.pause
-    method_1b
-
-    profile.resume
-    method_1c
-
-    result = profile.stop
-    assert_in_delta(0.65, result.threads[0].methods.select {|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
-  end
-  def method_1a; sleep 0.22 end
-  def method_1b; sleep 1   end
-  def method_1c; sleep 0.4 end
-
-  # pause in parent frame, resume in child
-  def test_pause_resume_2
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-
-    profile.start
-    method_2a
-
-    profile.pause
-    sleep 0.5
-    method_2b(profile)
-
-    result = profile.stop
-    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
-  end
-  def method_2a; sleep 0.22 end
-  def method_2b(profile); sleep 0.5; profile.resume; sleep 0.4 end
-
-  # pause in child frame, resume in parent
-  def test_pause_resume_3
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-
-    profile.start
-    method_3a(profile)
-
-    sleep 0.5
-    profile.resume
-    method_3b
-
-    result = profile.stop
-    assert_in_delta(0.65, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
-  end
-
-  def method_3a(profile)
-    sleep 0.22
-    profile.pause
-    sleep 0.5
-  end
-
-  def method_3b
-    sleep 0.4
-  end
-
-  def test_pause_seq
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-    profile.start ; assert !profile.paused?
-    profile.pause ; assert profile.paused?
-    profile.resume; assert !profile.paused?
-    profile.pause ; assert profile.paused?
-    profile.pause ; assert profile.paused?
-    profile.resume; assert !profile.paused?
-    profile.resume; assert !profile.paused?
-    profile.stop  ; assert !profile.paused?
-  end
-
-  def test_pause_block
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-    profile.start
-    profile.pause
-    assert profile.paused?
-
-    times_block_invoked = 0
-    retval= profile.resume{
-      times_block_invoked += 1
-      120 + times_block_invoked
-    }
-    assert_equal 1, times_block_invoked
-    assert profile.paused?
-
-    assert_equal 121, retval, "resume() should return the result of the given block."
-
-    profile.stop
-  end
-
-  def test_pause_block_with_error
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-    profile.start
-    profile.pause
-    assert profile.paused?
-
-    begin
-      profile.resume{ raise }
-      flunk 'Exception expected.'
-    rescue
-      assert profile.paused?
-    end
-
-    profile.stop
-  end
-
-  def test_resume_when_not_paused
-    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-    profile.start ; assert !profile.paused?
-    profile.resume; assert !profile.paused?
-    profile.stop  ; assert !profile.paused?
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative 'measure_times'
+
+class PauseResumeTest < TestCase
+  def test_pause_resume
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    # Measured
+    profile.start
+    RubyProf::C1.sleep_wait
+
+    # Not measured
+    profile.pause
+    sleep 1
+    RubyProf::C1.sleep_wait
+
+    # Measured
+    profile.resume
+    RubyProf::C1.sleep_wait
+
+    result = profile.stop
+
+    # Length should be 3:
+    #   PauseResumeTest#test_pause_resume
+    #   <Class::RubyProf::C1>#sleep_wait
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort_by {|method_info| method_info.full_name}
+    # remove methods called by pause/resume
+    called_methods = ['Array#include?', 'Fixnum#==', 'Kernel#respond_to?', 'Kernel#respond_to_missing?']
+    methods.reject!{|m| called_methods.include?(m.full_name) }
+    # TODO: fix pause/resume to not include those methods in the first place
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('<Class::RubyProf::C1>#sleep_wait', methods[0].full_name)
+    assert_equal('Kernel#sleep', methods[1].full_name)
+    assert_equal('PauseResumeTest#test_pause_resume', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.22, methods[0].total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, methods[0].wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, methods[0].self_time, 0.05 * delta_multiplier)
+
+    assert_in_delta(0.22, methods[1].total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, methods[1].wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0.22, methods[1].self_time, 0.05 * delta_multiplier)
+
+    assert_in_delta(0.22, methods[2].total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, methods[2].wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, methods[2].self_time, 0.05 * delta_multiplier)
+  end
+
+  # pause/resume in the same frame
+  def test_pause_resume_1
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+    profile.start
+    method_1a
+
+    profile.pause
+    method_1b
+
+    profile.resume
+    method_1c
+
+    result = profile.stop
+    assert_in_delta(0.65, result.threads[0].methods.select {|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05 * delta_multiplier)
+  end
+  def method_1a; sleep 0.22 end
+  def method_1b; sleep 1   end
+  def method_1c; sleep 0.4 end
+
+  # pause in parent frame, resume in child
+  def test_pause_resume_2
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+    profile.start
+    method_2a
+
+    profile.pause
+    sleep 0.5
+    method_2b(profile)
+
+    result = profile.stop
+    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05 * delta_multiplier)
+  end
+  def method_2a; sleep 0.22 end
+  def method_2b(profile); sleep 0.5; profile.resume; sleep 0.4 end
+
+  # pause in child frame, resume in parent
+  def test_pause_resume_3
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+
+    profile.start
+    method_3a(profile)
+
+    sleep 0.5
+    profile.resume
+    method_3b
+
+    result = profile.stop
+    assert_in_delta(0.65, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05 * delta_multiplier)
+  end
+
+  def method_3a(profile)
+    sleep 0.22
+    profile.pause
+    sleep 0.5
+  end
+
+  def method_3b
+    sleep 0.4
+  end
+
+  def test_pause_seq
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start ; assert !profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.stop  ; assert !profile.paused?
+  end
+
+  def test_pause_block
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start
+    profile.pause
+    assert profile.paused?
+
+    times_block_invoked = 0
+    retval= profile.resume{
+      times_block_invoked += 1
+      120 + times_block_invoked
+    }
+    assert_equal 1, times_block_invoked
+    assert profile.paused?
+
+    assert_equal 121, retval, "resume() should return the result of the given block."
+
+    profile.stop
+  end
+
+  def test_pause_block_with_error
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start
+    profile.pause
+    assert profile.paused?
+
+    begin
+      profile.resume{ raise }
+      flunk 'Exception expected.'
+    rescue
+      assert profile.paused?
+    end
+
+    profile.stop
+  end
+
+  def test_resume_when_not_paused
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start ; assert !profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.stop  ; assert !profile.paused?
+  end
+end

data/test/prime.rb

@@ -1,54 +1,54 @@
-# 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|
-    prime = primes[i]
-    if prime > largest
-      largest = prime
-    end
-  end
-  largest
-end
-
-def run_primes(length=10, maxnum=1_000)
-  # Create random numbers
-  random_array = make_random_array(length, maxnum)
-
-  # Find the primes
-  primes = find_primes(random_array)
-
-  # Find the largest primes
-  find_largest(primes)
-end
+# 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|
+    prime = primes[i]
+    if prime > largest
+      largest = prime
+    end
+  end
+  largest
+end
+
+def run_primes(length=10, maxnum=1_000)
+  # Create random numbers
+  random_array = make_random_array(length, maxnum)
+
+  # Find the primes
+  primes = find_primes(random_array)
+
+  # Find the largest primes
+  find_largest(primes)
+end

data/test/prime_script.rb

@@ -1,6 +1,6 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# This file is used to test bin/ruby-prof
-require_relative './prime'
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# This file is used to test bin/ruby-prof
+require_relative './prime'
 run_primes(100, 1_000_000)

data/test/printer_call_stack_test.rb

@@ -1,27 +1,28 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'fileutils'
-require 'tmpdir'
-require_relative 'prime'
-
-# --  Tests ----
-class PrinterCallStackTest < 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 test_graph_html_string
-    output = ''
-    printer = RubyProf::CallStackPrinter.new(@result)
-    printer.print(output)
-
-    assert_match(/<!DOCTYPE html>/i, output)
-    assert_match(/Object#run_primes/i, output)
-  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 PrinterCallStackTest < 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 test_graph_html_string
+    output = StringIO.new
+    printer = RubyProf::CallStackPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output.string)
+    assert_match(/Object#run_primes/i, output.string)
+  end
+end

data/test/printer_call_tree_test.rb

@@ -1,30 +1,30 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'fileutils'
-require 'tmpdir'
-require_relative 'prime'
-
-# --  Tests ----
-class PrinterCallTreeTest < 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 test_call_tree_string
-    printer = RubyProf::CallTreePrinter.new(@result)
-
-    printer.print(:path => Dir.tmpdir)
-    main_output_file_name = File.join(Dir.tmpdir, "callgrind.out.#{$$}")
-    assert(File.exist?(main_output_file_name))
-    output = File.read(main_output_file_name)
-    assert_match(/fn=Object::find_primes/i, output)
-    assert_match(/events: wall_time/i, output)
-    refute_match(/d\d\d\d\d\d/, output) # old bug looked [in error] like Object::run_primes(d5833116)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrinterCallTreeTest < 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 test_call_tree_string
+    printer = RubyProf::CallTreePrinter.new(@result)
+
+    printer.print(path: Dir.tmpdir)
+    main_output_file_name = File.join(Dir.tmpdir, "callgrind.out.#{$$}")
+    assert(File.exist?(main_output_file_name))
+    output = File.read(main_output_file_name)
+    assert_match(/fn=Object::find_primes/i, output)
+    assert_match(/events: wall_time/i, output)
+    refute_match(/d\d\d\d\d\d/, output) # old bug looked [in error] like Object::run_primes(d5833116)
+  end
+end

data/test/printer_flame_graph_test.rb

@@ -0,0 +1,82 @@
+#!/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 PrinterFlameGraphTest < 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 test_flame_graph_string
+    output = StringIO.new
+    printer = RubyProf::FlameGraphPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output.string)
+    assert_match(/flame-svg/, output.string)
+    assert_match(/Object#run_primes/i, output.string)
+  end
+
+  def test_flame_graph_stringio
+    output = StringIO.new
+    printer = RubyProf::FlameGraphPrinter.new(@result)
+    printer.print(output)
+
+    result = output.string
+    assert_match(/<!DOCTYPE html>/i, result)
+    assert_match(/flame-svg/, result)
+    assert_match(/Object#run_primes/i, result)
+  end
+
+  def test_flame_graph_contains_svg_elements
+    output = StringIO.new
+    printer = RubyProf::FlameGraphPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<svg/, output.string)
+    assert_match(/renderNode/, output.string)
+  end
+
+  def test_flame_graph_contains_json_data
+    output = StringIO.new
+    printer = RubyProf::FlameGraphPrinter.new(@result)
+    printer.print(output)
+
+    # The template embeds thread data as JSON
+    assert_match(/"name"/, output.string)
+    assert_match(/"value"/, output.string)
+    assert_match(/"children"/, output.string)
+  end
+
+  def test_flame_graph_custom_title
+    output = StringIO.new
+    printer = RubyProf::FlameGraphPrinter.new(@result)
+    printer.print(output, title: "Custom Flame Graph")
+
+    assert_match(/Custom Flame Graph/, output.string)
+  end
+
+  def test_flame_graph_file_output
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "flame_graph.html")
+      File.open(path, "wb") do |file|
+        printer = RubyProf::FlameGraphPrinter.new(@result)
+        printer.print(file)
+      end
+
+      content = File.read(path)
+      assert_match(/<!DOCTYPE html>/i, content)
+      assert_match(/Object#run_primes/i, content)
+    end
+  end
+end