ruby-prof 1.7.1 → 2.0.0

data/test/measurement_test.rb

@@ -1,82 +1,82 @@
-# 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
+# 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 +1,146 @@
-#!/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)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[1]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[2]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[3]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-  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)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[1]
-    assert_in_delta(1.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.5, thread.call_tree.target.children_time, 0.1)
-  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)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[1]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[2]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[3]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
-  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)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
-
-    thread = result.threads[1]
-    assert_in_delta(3.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(2.0, thread.call_tree.target.children_time, 0.1)
-  end
-end
-end
+#!/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,95 +1,100 @@
-# 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
-    assert_match(/undefined method `instance_method' for nil/, error.message)
-  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
+# 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