acunote-ruby-prof 0.9.2

data/test/basic_test.rb

@@ -0,0 +1,290 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+class C1
+  def C1.hello
+    sleep(0.1)
+  end
+
+  def hello
+    sleep(0.2)
+  end
+end
+
+module M1
+  def hello
+    sleep(0.3)
+  end
+end
+
+class C2
+  include M1
+  extend M1
+end
+
+class C3
+  def hello
+    sleep(0.4)
+  end
+end
+
+module M4
+  def hello
+    sleep(0.5)
+  end
+end
+
+module M5
+  include M4
+  def goodbye
+    hello
+  end
+end
+
+class C6
+  include M5
+  def test
+    goodbye
+  end
+end
+
+class BasicTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+
+  def test_double_profile
+    RubyProf.start
+    assert_raise(RuntimeError) do
+      RubyProf.start
+    end
+
+    assert_raise(RuntimeError) do
+      RubyProf.profile do
+        puts 1
+      end
+    end
+    RubyProf.stop
+  end
+
+  def test_no_block
+    assert_raise(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      C1.hello
+    end
+
+    # Length should be 3:
+    #   BasicTest#test_class_methods
+    #   <Class::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('BasicTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+  end
+
+  if RUBY_VERSION < '1.9'
+    PARENT = Object
+  else
+    PARENT = BasicObject
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      C1.new.hello
+    end
+
+    # Methods called
+    #   BasicTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('BasicTest#test_instance_methods', names[0])
+    assert_equal('C1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    # order can differ
+    assert(names.include?("<Class::#{PARENT}>#allocate"))
+    assert(names.include?("#{PARENT}#initialize"))
+
+    # Check times
+    assert_in_delta(0.2, 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.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      C2.hello
+    end
+
+    # Methods:
+    #   BasicTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+    assert_equal('M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.3, methods[2].self_time, 0.1)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
+      C2.new.hello
+    end
+
+    # Methods:
+    #   BasicTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('BasicTest#test_module_instance_methods', names[0])
+    assert_equal('M1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    assert(names.include?("<Class::#{PARENT}>#allocate"))
+    assert(names.include?("#{PARENT}#initialize"))
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.1)
+    assert_in_delta(0, methods[0].self_time, 0.1)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_singleton
+    c3 = C3.new
+
+    class << c3
+      def hello
+      end
+    end
+
+    result = RubyProf.profile do
+      c3.hello
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(2, methods.length)
+
+    assert_equal('BasicTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::C3>#hello', methods[1].full_name)
+
+    assert_in_delta(0, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  end
+
+  def test_traceback
+    RubyProf.start
+    assert_raise(NoMethodError) do
+      RubyProf.xxx
+    end
+
+    RubyProf.stop
+  end
+end

data/test/current_failures_windows

@@ -0,0 +1,8 @@
+1.8 passes, 1.9 however...
+
+  1) Failure:
+test_flat_string_with_numbers(PrintersTest) [E:/dev/ruby/ruby-prof/test/printers_test.rb:68]:
+<2> expected but was
+<29>.
+
+which is expected until core backports a recent fix.

data/test/duplicate_names_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+class DuplicateNames < Test::Unit::TestCase
+  def test_names
+    result = RubyProf::profile do
+      str = %{module Foo; class Bar; def foo; end end end}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+    end
+
+    # There should be 3 foo methods
+    methods = result.threads.values.first.sort.reverse
+
+    methods = methods.select do |method|
+      method.full_name == 'DuplicateNames::Foo::Bar#foo'
+    end
+
+    assert_equal(3, methods.length)
+  end
+end

data/test/enumerable_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+# --  Test for bug
+# http://github.com/rdp/ruby-prof/issues#issue/12
+
+class EnumerableTest < Test::Unit::TestCase
+  def test_enumerable
+    result = RubyProf.profile do
+      3.times {  [1,2,3].any? {|n| n} }
+    end
+    assert result.threads.to_a.first[1].length == 4
+  end
+end

data/test/exceptions_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+
+class ExceptionsTest < Test::Unit::TestCase
+  def test_profile
+    result = begin
+      RubyProf.profile do
+        raise(RuntimeError, 'Test error')
+      end
+    rescue => e
+    end
+    assert_not_nil(result)
+  end
+end

data/test/exclude_threads_test.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+
+# --  Tests ----
+class ExcludeThreadsTest < Test::Unit::TestCase
+  def test_exclude_threads
+
+    def thread1_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    def thread2_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    thread1 = Thread.new do
+      thread1_proc
+    end
+
+    thread2 = Thread.new do
+      thread2_proc
+    end
+
+    RubyProf::exclude_threads = [ thread2 ]
+
+    RubyProf.start
+
+    thread1.join
+    thread2.join
+
+    result = RubyProf.stop
+
+    RubyProf::exclude_threads = nil
+
+    assert_equal(2, result.threads.length)
+
+    output = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.full_name.index("ExcludeThreadsTest#thread") == 0
+          output.push(m.full_name)
+        end
+      end
+    end
+
+    assert_equal(1, output.length)
+    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
+  end
+end

data/test/exec_test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'os'
+
+# --  Test for bug when it loads with no frames
+
+class EnumerableTest < Test::Unit::TestCase
+  def test_being_able_to_run_its_binary
+    Dir.chdir(File.dirname(__FILE__)) do
+      assert system(OS.ruby_bin + " ruby-prof-bin do_nothing.rb")
+    end
+  end
+end

data/test/line_number_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+class LineNumbers
+  def method1
+    a = 3
+  end
+
+  def method2
+    a = 3
+    method1
+  end
+
+  def method3
+    sleep(1)
+  end
+end
+
+# --  Tests ----
+class LineNumbersTest < Test::Unit::TestCase
+  def test_function_line_no
+    numbers = LineNumbers.new
+
+    result = RubyProf.profile do
+      numbers.method2
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    method = methods[0]
+    assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
+    assert_equal(27, method.line)
+
+    method = methods[1]
+    assert_equal('LineNumbers#method2', method.full_name)
+    assert_equal(11, method.line)
+
+    method = methods[2]
+    assert_equal('LineNumbers#method1', method.full_name)
+    assert_equal(7, method.line)
+  end
+
+  def test_c_function
+    numbers = LineNumbers.new
+
+    result = RubyProf.profile do
+      numbers.method3
+    end
+
+    methods = result.threads.values.first.sort_by {|method| method.full_name}
+    assert_equal(3, methods.length)
+
+    # Methods:
+    #   LineNumbers#method3
+    #   LineNumbersTest#test_c_function
+    #   Kernel#sleep
+
+    method = methods[0]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+
+    method = methods[1]
+    assert_equal('LineNumbers#method3', method.full_name)
+    assert_equal(16, method.line)
+
+    method = methods[2]
+    assert_equal('LineNumbersTest#test_c_function', method.full_name)
+    assert_equal(50, method.line)
+  end
+end