ruby-prof 2.0.4 → 2.0.5

data/test/measurement_test.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasurementTest < Minitest::Test
-  def test_initialize
-    measurement = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    assert_equal(3.3, measurement.total_time)
-    assert_equal(2.2, measurement.self_time)
-    assert_equal(1.1, measurement.wait_time)
-    assert_equal(4, measurement.called)
-  end
-
-  def test_clone
-    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement_2 = measurement_1.clone
-
-    refute(measurement_1.equal?(measurement_2))
-    refute(measurement_1.eql?(measurement_2))
-    refute(measurement_1 == measurement_2)
-
-    assert_equal(measurement_1.total_time, measurement_2.total_time)
-    assert_equal(measurement_1.self_time, measurement_2.self_time)
-    assert_equal(measurement_1.wait_time, measurement_2.wait_time)
-    assert_equal(measurement_1.called, measurement_2.called)
-  end
-
-  def test_dup
-    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement_2 = measurement_1.dup
-
-    refute(measurement_1.equal?(measurement_2))
-    refute(measurement_1.eql?(measurement_2))
-    refute(measurement_1 == measurement_2)
-
-    assert_equal(measurement_1.total_time, measurement_2.total_time)
-    assert_equal(measurement_1.self_time, measurement_2.self_time)
-    assert_equal(measurement_1.wait_time, measurement_2.wait_time)
-    assert_equal(measurement_1.called, measurement_2.called)
-  end
-
-  def test_merge!
-    measurement1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement2 = RubyProf::Measurement.new(3, 2, 1, 3)
-
-    measurement1.merge!(measurement2)
-
-    assert_equal(6.3, measurement1.total_time)
-    assert_equal(4.2, measurement1.self_time)
-    assert_equal(2.1, measurement1.wait_time)
-    assert_equal(7, measurement1.called)
-
-    assert_equal(3, measurement2.total_time)
-    assert_equal(2, measurement2.self_time)
-    assert_equal(1, measurement2.wait_time)
-    assert_equal(3, measurement2.called)
-  end
-
-  def test_set_total_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.total_time = 5.1
-    assert_equal(5.1, measurement.total_time)
-  end
-
-  def test_set_self_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.self_time = 3.1
-    assert_equal(3.1, measurement.self_time)
-  end
-
-  def test_set_wait_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.wait_time = 1.1
-    assert_equal(1.1, measurement.wait_time)
-  end
-
-  def test_set_called
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.called = 2
-    assert_equal(2, measurement.called)
-  end
-end

data/test/merge_test.rb

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
-
-require_relative './scheduler'
-
-  # --  Tests ----
-class MergeTest < TestCase
-  def worker1
-    sleep(0.5)
-  end
-
-  def worker2
-    sleep(0.5)
-    sleep(0.5)
-  end
-
-  def worker3
-    sleep(0.5)
-  end
-
-  def concurrency_single_worker
-    scheduler = Scheduler.new
-    Fiber.set_scheduler(scheduler)
-
-    3.times do
-      Fiber.schedule do
-        worker1
-      end
-    end
-    Fiber.scheduler.close
-  end
-
-  def concurrency_multiple_workers
-    scheduler = Scheduler.new
-    Fiber.set_scheduler(scheduler)
-
-    3.times do |i|
-      Fiber.schedule do
-        method = "worker#{i + 1}".to_sym
-        send(method)
-      end
-    end
-    Fiber.scheduler.close
-  end
-
-  def test_single_worker_unmerged
-    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_single_worker }
-    assert_equal(4, result.threads.size)
-
-    thread = result.threads[0]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[1]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[2]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[3]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-  end
-
-  def test_single_worker_merged
-    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_single_worker }
-    result.merge!
-
-    assert_equal(2, result.threads.size)
-
-    thread = result.threads[0]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[1]
-    assert_in_delta(1.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(1.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-  end
-
-  def test_multiple_workers_unmerged
-    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_multiple_workers }
-    assert_equal(4, result.threads.count)
-
-    thread = result.threads[0]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[1]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[2]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[3]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-  end
-
-  def test_multiple_workers_merged
-    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_multiple_workers }
-    result.merge!
-
-    assert_equal(2, result.threads.count)
-
-    thread = result.threads[0]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-
-    thread = result.threads[1]
-    assert_in_delta(3.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
-    assert_in_delta(1.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
-    assert_in_delta(2.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
-  end
-end
-end

data/test/method_info_test.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', __FILE__)
-require 'base64'
-
-class MethodInfoTest < Minitest::Test
-  def test_initialize
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal("Base64", method_info.klass_name)
-    assert_equal(:encode64, method_info.method_name)
-    assert_equal("Base64#encode64", method_info.full_name)
-    assert_equal(0, method_info.klass_flags)
-    assert_match(/base64\.rb/, method_info.source_file)
-    assert_kind_of(Integer, method_info.line)
-    refute(method_info.recursive?)
-
-    assert_kind_of(RubyProf::Measurement, method_info.measurement)
-    assert_kind_of(RubyProf::CallTrees, method_info.call_trees)
-    assert_empty(method_info.allocations)
-  end
-
-  def test_initialize_nil_klass
-    error = assert_raises(NoMethodError) do
-      RubyProf::MethodInfo.new(nil, nil)
-    end
-
-    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.4')
-      assert_match(/undefined method `instance_method' for nil/, error.message)
-    else
-      assert_match(/undefined method 'instance_method' for nil/, error.message)
-    end
-  end
-
-  def test_initialize_nil_method_name
-    error = assert_raises(TypeError) do
-      RubyProf::MethodInfo.new(Base64, nil)
-    end
-    assert_equal("nil is not a symbol nor a string", error.to_s)
-  end
-
-  def test_initialize_unknown_location
-    method_info = RubyProf::MethodInfo.new(Array, :size)
-    assert_equal('Array', method_info.klass_name)
-    assert_equal(:size, method_info.method_name)
-    assert_nil(method_info.source_file)
-    assert_equal(0, method_info.line)
-  end
-
-  def test_measurement
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal(0, method_info.total_time)
-    assert_equal(0, method_info.self_time)
-    assert_equal(0, method_info.wait_time)
-    assert_equal(0, method_info.children_time)
-    assert_equal(0, method_info.called)
-  end
-
-  def test_compare
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal(0, method_info_1 <=> method_info_2)
-
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal(-1, method_info_1 <=> method_info_2)
-
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :decode64)
-    assert_equal(1, method_info_1 <=> method_info_2)
-  end
-
-  def test_eql?
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert(method_info_1.eql?(method_info_2))
-  end
-
-  def test_equal?
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    refute(method_info_1.equal?(method_info_2))
-  end
-
-  def test_equality
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert(method_info_1 == method_info_2)
-  end
-
-  def test_hash
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal(method_info_1.hash, method_info_2.hash)
-  end
-
-  def test_to_s
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    assert_equal("Base64#encode64 (c: 0, tt: 0.0, st: 0.0, wt: 0.0, ct: 0.0)", method_info.to_s)
-  end
-end

data/test/multi_printer_test.rb

@@ -1,52 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# 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 < TestCase
-  def test_refuses_positional_arguments
-    # we don't need a real profile for this test
-    p = RubyProf::MultiPrinter.new nil
-    assert_raises(ArgumentError) do
-      p.print(STDOUT)
-    end
-  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
-    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
-  end
-end

data/test/no_method_class_test.rb

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Make sure this works with no class or method
-result = RubyProf::Profile.profile do
-  sleep 1
-end
-
-methods = result.threads.first.methods
-global_method = methods.sort_by {|method| method.full_name}.first
-if global_method.full_name != 'Kernel#sleep'
-  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
-end

data/test/pause_resume_test.rb

@@ -1,171 +0,0 @@
-#!/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 +0,0 @@
-# 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 +0,0 @@
-#!/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,28 +0,0 @@
-#!/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 +0,0 @@
-#!/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