ruby-prof 1.4.5-x64-mingw-ucrt → 1.5.0-x64-mingw-ucrt

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,197 @@
1
+ # frozen_string_literal: true
2
+
3
+ require File.expand_path('../test_helper', __FILE__)
4
+ require_relative './call_tree_builder'
5
+ require 'base64'
6
+
7
+ class CallTreeTest < Minitest::Test
8
+ def test_initialize
9
+ method_info = RubyProf::MethodInfo.new(Base64, :encode64)
10
+ call_tree = RubyProf::CallTree.new(method_info)
11
+ assert_equal(method_info, call_tree.target)
12
+ end
13
+
14
+ def test_measurement
15
+ method_info = RubyProf::MethodInfo.new(Base64, :encode64)
16
+ call_tree = RubyProf::CallTree.new(method_info)
17
+
18
+ assert_equal(0, call_tree.total_time)
19
+ assert_equal(0, call_tree.self_time)
20
+ assert_equal(0, call_tree.wait_time)
21
+ assert_equal(0, call_tree.children_time)
22
+ assert_equal(0, call_tree.called)
23
+ end
24
+
25
+ def test_compare
26
+ method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
27
+ call_tree_1 = RubyProf::CallTree.new(method_info_1)
28
+ method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
29
+ call_tree_2 = RubyProf::CallTree.new(method_info_2)
30
+ assert_equal(0, call_tree_1 <=> call_tree_2)
31
+
32
+ method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
33
+ call_tree_1 = RubyProf::CallTree.new(method_info_1)
34
+ call_tree_1.measurement.total_time = 1
35
+ method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
36
+ call_tree_2 = RubyProf::CallTree.new(method_info_2)
37
+ assert_equal(1, call_tree_1 <=> call_tree_2)
38
+
39
+ method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
40
+ call_tree_1 = RubyProf::CallTree.new(method_info_1)
41
+ method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
42
+ call_tree_2 = RubyProf::CallTree.new(method_info_2)
43
+ call_tree_2.measurement.total_time = 1
44
+ assert_equal(-1, call_tree_1 <=> call_tree_2)
45
+ end
46
+
47
+ def test_to_s
48
+ method_info = RubyProf::MethodInfo.new(Base64, :encode64)
49
+ call_tree = RubyProf::CallTree.new(method_info)
50
+ assert_equal("<RubyProf::CallTree - Base64#encode64>", call_tree.to_s)
51
+ end
52
+
53
+ def test_add_child
54
+ method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
55
+ call_tree_parent = RubyProf::CallTree.new(method_info_parent)
56
+
57
+ method_info_child = RubyProf::MethodInfo.new(Array, :pack)
58
+ call_tree_child = RubyProf::CallTree.new(method_info_child)
59
+
60
+ assert_equal(0, call_tree_parent.children.size)
61
+ assert_nil(call_tree_child.parent)
62
+
63
+ result = call_tree_parent.add_child(call_tree_child)
64
+ assert_equal(1, call_tree_parent.children.size)
65
+ assert_equal(call_tree_child, call_tree_parent.children.first)
66
+ assert_equal(call_tree_child, result)
67
+ assert_equal(call_tree_parent, call_tree_child.parent)
68
+ end
69
+
70
+ def test_add_child_gc
71
+ GC.stress = true
72
+
73
+ begin
74
+ method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
75
+ call_tree_parent = RubyProf::CallTree.new(method_info_parent)
76
+
77
+ method_info_child = RubyProf::MethodInfo.new(Array, :pack)
78
+ call_tree_child = RubyProf::CallTree.new(method_info_child)
79
+ call_tree_parent.add_child(call_tree_child)
80
+
81
+ # Free the child first
82
+ call_tree_child = nil
83
+ GC.start
84
+
85
+ # Now free the parent and make sure it doesn't free the child a second time
86
+ call_tree_parent = nil
87
+ GC.start
88
+
89
+ assert(true)
90
+ ensure
91
+ GC.stress = false
92
+ end
93
+ end
94
+
95
+ def test_merge
96
+ call_tree_1 = create_call_tree_1
97
+ call_tree_2 = create_call_tree_2
98
+ call_tree_1.merge!(call_tree_2)
99
+
100
+ # Root
101
+ call_tree = call_tree_1
102
+ assert_equal(:root, call_tree.target.method_name)
103
+ assert_in_delta(11.6, call_tree.total_time, 0.00001)
104
+ assert_in_delta(0, call_tree.self_time, 0.00001)
105
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
106
+ assert_in_delta(11.6, call_tree.children_time, 0.00001)
107
+
108
+ assert_in_delta(11.6, call_tree.target.total_time, 0.00001)
109
+ assert_in_delta(0, call_tree.target.self_time, 0.00001)
110
+ assert_in_delta(0, call_tree.target.wait_time, 0.00001)
111
+ assert_in_delta(11.6, call_tree.target.children_time, 0.00001)
112
+
113
+ # a
114
+ call_tree = call_tree_1.children[0]
115
+ assert_equal(:a, call_tree.target.method_name)
116
+
117
+ assert_in_delta(4.1, call_tree.total_time, 0.00001)
118
+ assert_in_delta(0, call_tree.self_time, 0.00001)
119
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
120
+ assert_in_delta(4.1, call_tree.children_time, 0.00001)
121
+
122
+ assert_in_delta(4.1, call_tree.target.total_time, 0.00001)
123
+ assert_in_delta(0, call_tree.target.self_time, 0.00001)
124
+ assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
125
+ assert_in_delta(4.1, call_tree.target.children_time, 0.00001)
126
+
127
+ # aa
128
+ call_tree = call_tree_1.children[0].children[0]
129
+ assert_equal(:aa, call_tree.target.method_name)
130
+
131
+ assert_in_delta(1.5, call_tree.total_time, 0.00001)
132
+ assert_in_delta(1.5, call_tree.self_time, 0.00001)
133
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
134
+ assert_in_delta(0.0, call_tree.children_time, 0.00001)
135
+
136
+ assert_in_delta(1.5, call_tree.target.total_time, 0.00001)
137
+ assert_in_delta(1.5, call_tree.target.self_time, 0.00001)
138
+ assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
139
+ assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
140
+
141
+ # ab
142
+ call_tree = call_tree_1.children[0].children[1]
143
+ assert_equal(:ab, call_tree.target.method_name)
144
+
145
+ assert_in_delta(2.6, call_tree.total_time, 0.00001)
146
+ assert_in_delta(2.6, call_tree.self_time, 0.00001)
147
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
148
+ assert_in_delta(0.0, call_tree.children_time, 0.00001)
149
+
150
+ assert_in_delta(2.6, call_tree.target.total_time, 0.00001)
151
+ assert_in_delta(2.6, call_tree.target.self_time, 0.00001)
152
+ assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
153
+ assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
154
+
155
+ # b
156
+ call_tree = call_tree_1.children[1]
157
+ assert_equal(:b, call_tree.target.method_name)
158
+
159
+ assert_in_delta(7.5, call_tree.total_time, 0.00001)
160
+ assert_in_delta(0, call_tree.self_time, 0.00001)
161
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
162
+ assert_in_delta(7.5, call_tree.children_time, 0.00001)
163
+
164
+ assert_in_delta(7.5, call_tree.target.total_time, 0.00001)
165
+ assert_in_delta(0, call_tree.target.self_time, 0.00001)
166
+ assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
167
+ assert_in_delta(7.5, call_tree.target.children_time, 0.00001)
168
+
169
+ # bb
170
+ call_tree = call_tree_1.children[1].children[0]
171
+ assert_equal(:bb, call_tree.target.method_name)
172
+
173
+ assert_in_delta(6.6, call_tree.total_time, 0.00001)
174
+ assert_in_delta(6.6, call_tree.self_time, 0.00001)
175
+ assert_in_delta(0.0, call_tree.wait_time, 0.00001)
176
+ assert_in_delta(0.0, call_tree.children_time, 0.00001)
177
+
178
+ assert_in_delta(6.6, call_tree.target.total_time, 0.00001)
179
+ assert_in_delta(6.6, call_tree.target.self_time, 0.00001)
180
+ assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
181
+ assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
182
+
183
+ # ba
184
+ call_tree = call_tree_1.children[1].children[1]
185
+ assert_equal(:ba, call_tree.target.method_name)
186
+
187
+ assert_in_delta(0.9, call_tree.total_time, 0.00001)
188
+ assert_in_delta(0.7, call_tree.self_time, 0.00001)
189
+ assert_in_delta(0.2, call_tree.wait_time, 0.00001)
190
+ assert_in_delta(0.0, call_tree.children_time, 0.00001)
191
+
192
+ assert_in_delta(0.9, call_tree.target.total_time, 0.00001)
193
+ assert_in_delta(0.7, call_tree.target.self_time, 0.00001)
194
+ assert_in_delta(0.2, call_tree.target.wait_time, 0.00001)
195
+ assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
196
+ end
197
+ end
@@ -26,7 +26,7 @@ class CallTreesTest < TestCase
26
26
  call_trees = method.call_trees
27
27
  assert_empty(call_trees.callers)
28
28
  assert_equal(1, call_trees.callees.length)
29
- assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
29
+ assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
30
30
  assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
31
31
 
32
32
  method = thread.methods[1]
@@ -34,10 +34,10 @@ class CallTreesTest < TestCase
34
34
 
35
35
  call_trees = method.call_trees
36
36
  assert_equal(1, call_trees.callers.length)
37
- assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
37
+ assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
38
38
  assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
39
39
  assert_equal(1, call_trees.callees.length)
40
- assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
40
+ assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
41
41
  assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
42
42
 
43
43
  method = thread.methods[2]
@@ -45,7 +45,7 @@ class CallTreesTest < TestCase
45
45
 
46
46
  call_trees = method.call_trees
47
47
  assert_equal(1, call_trees.callers.length)
48
- assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
48
+ assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
49
49
  assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
50
50
  assert_empty(call_trees.callees)
51
51
  end
data/test/fiber_test.rb CHANGED
@@ -5,9 +5,25 @@ require File.expand_path('../test_helper', __FILE__)
5
5
  require 'fiber'
6
6
  require 'timeout'
7
7
  require 'set'
8
+ require_relative './scheduler'
8
9
 
9
10
  # -- Tests ----
10
11
  class FiberTest < TestCase
12
+ def worker
13
+ sleep(0.5)
14
+ end
15
+
16
+ def concurrency
17
+ scheduler = Scheduler.new
18
+ Fiber.set_scheduler(scheduler)
19
+
20
+ 3.times do
21
+ Fiber.schedule do |a|
22
+ worker
23
+ end
24
+ end
25
+ Fiber.scheduler.close
26
+ end
11
27
 
12
28
  def enumerator_with_fibers
13
29
  enum = Enumerator.new do |yielder|
@@ -36,7 +52,7 @@ class FiberTest < TestCase
36
52
  end
37
53
 
38
54
  def test_fibers
39
- result = RubyProf.profile { enumerator_with_fibers }
55
+ result = RubyProf.profile { enumerator_with_fibers }
40
56
 
41
57
  assert_equal(2, result.threads.size)
42
58
 
@@ -47,42 +63,82 @@ class FiberTest < TestCase
47
63
  method = methods[0]
48
64
  assert_equal('FiberTest#test_fibers', method.full_name)
49
65
  assert_equal(1, method.called)
66
+ assert_in_delta(0, method.total_time)
67
+ assert_in_delta(0, method.self_time)
68
+ assert_in_delta(0, method.wait_time)
69
+ assert_in_delta(0, method.children_time)
50
70
 
51
71
  method = methods[1]
52
72
  assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
53
73
  assert_equal(1, method.called)
74
+ assert_in_delta(0, method.total_time)
75
+ assert_in_delta(0, method.self_time)
76
+ assert_in_delta(0, method.wait_time)
77
+ assert_in_delta(0, method.children_time)
54
78
 
55
79
  method = methods[2]
56
80
  assert_equal('Enumerator#next', method.full_name)
57
81
  assert_equal(2, method.called)
82
+ assert_in_delta(0, method.total_time)
83
+ assert_in_delta(0, method.self_time)
84
+ assert_in_delta(0, method.wait_time)
85
+ assert_in_delta(0, method.children_time)
58
86
 
59
87
  method = methods[3]
60
88
  assert_equal('Class#new', method.full_name)
61
89
  assert_equal(1, method.called)
90
+ assert_in_delta(0, method.total_time)
91
+ assert_in_delta(0, method.self_time)
92
+ assert_in_delta(0, method.wait_time)
93
+ assert_in_delta(0, method.children_time)
62
94
 
63
95
  method = methods[4]
64
96
  assert_equal('Enumerator#initialize', method.full_name)
65
97
  assert_equal(1, method.called)
98
+ assert_in_delta(0, method.total_time)
99
+ assert_in_delta(0, method.self_time)
100
+ assert_in_delta(0, method.wait_time)
101
+ assert_in_delta(0, method.children_time)
66
102
 
67
103
  thread2 = result.threads[1]
68
104
  methods = thread2.methods.sort.reverse
69
105
  assert_equal(4, methods.count)
106
+ assert_in_delta(0, method.total_time)
107
+ assert_in_delta(0, method.self_time)
108
+ assert_in_delta(0, method.wait_time)
109
+ assert_in_delta(0, method.children_time)
70
110
 
71
111
  method = methods[0]
72
112
  assert_equal('Enumerator#each', method.full_name)
73
113
  assert_equal(1, method.called)
114
+ assert_in_delta(0, method.total_time)
115
+ assert_in_delta(0, method.self_time)
116
+ assert_in_delta(0, method.wait_time)
117
+ assert_in_delta(0, method.children_time)
74
118
 
75
119
  method = methods[1]
76
120
  assert_equal('Enumerator::Generator#each', method.full_name)
77
121
  assert_equal(1, method.called)
122
+ assert_in_delta(0, method.total_time)
123
+ assert_in_delta(0, method.self_time)
124
+ assert_in_delta(0, method.wait_time)
125
+ assert_in_delta(0, method.children_time)
78
126
 
79
127
  method = methods[2]
80
128
  assert_equal('Array#each', method.full_name)
81
129
  assert_equal(1, method.called)
130
+ assert_in_delta(0, method.total_time)
131
+ assert_in_delta(0, method.self_time)
132
+ assert_in_delta(0, method.wait_time)
133
+ assert_in_delta(0, method.children_time)
82
134
 
83
135
  method = methods[3]
84
136
  assert_equal('Enumerator::Yielder#yield', method.full_name)
85
137
  assert_equal(2, method.called)
138
+ assert_in_delta(0, method.total_time)
139
+ assert_in_delta(0, method.self_time)
140
+ assert_in_delta(0, method.wait_time)
141
+ assert_in_delta(0, method.children_time)
86
142
  end
87
143
 
88
144
  def test_fiber_resume
@@ -97,33 +153,99 @@ class FiberTest < TestCase
97
153
  method = methods[0]
98
154
  assert_equal('FiberTest#test_fiber_resume', method.full_name)
99
155
  assert_equal(1, method.called)
156
+ assert_in_delta(0, method.total_time)
157
+ assert_in_delta(0, method.self_time)
158
+ assert_in_delta(0, method.wait_time)
159
+ assert_in_delta(0, method.children_time)
100
160
 
101
161
  method = methods[1]
102
162
  assert_equal('FiberTest#fiber_yield_resume', method.full_name)
103
163
  assert_equal(1, method.called)
164
+ assert_in_delta(0, method.total_time)
165
+ assert_in_delta(0, method.self_time)
166
+ assert_in_delta(0, method.wait_time)
167
+ assert_in_delta(0, method.children_time)
104
168
 
105
169
  method = methods[2]
106
170
  assert_equal('Fiber#resume', method.full_name)
107
171
  assert_equal(2, method.called)
172
+ assert_in_delta(0, method.total_time)
173
+ assert_in_delta(0, method.self_time)
174
+ assert_in_delta(0, method.wait_time)
175
+ assert_in_delta(0, method.children_time)
108
176
 
109
177
  method = methods[3]
110
178
  assert_equal('Class#new', method.full_name)
111
179
  assert_equal(1, method.called)
180
+ assert_in_delta(0, method.total_time)
181
+ assert_in_delta(0, method.self_time)
182
+ assert_in_delta(0, method.wait_time)
183
+ assert_in_delta(0, method.children_time)
112
184
 
113
185
  method = methods[4]
114
186
  assert_equal('Fiber#initialize', method.full_name)
115
187
  assert_equal(1, method.called)
188
+ assert_in_delta(0, method.total_time)
189
+ assert_in_delta(0, method.self_time)
190
+ assert_in_delta(0, method.wait_time)
191
+ assert_in_delta(0, method.children_time)
116
192
 
117
193
  thread1 = result.threads[1]
118
194
  methods = thread1.methods.sort.reverse
119
195
  assert_equal(2, methods.count)
196
+ assert_in_delta(0, method.total_time)
197
+ assert_in_delta(0, method.self_time)
198
+ assert_in_delta(0, method.wait_time)
199
+ assert_in_delta(0, method.children_time)
120
200
 
121
201
  method = methods[0]
122
202
  assert_equal('FiberTest#fiber_yield_resume', method.full_name)
123
203
  assert_equal(1, method.called)
204
+ assert_in_delta(0, method.total_time)
205
+ assert_in_delta(0, method.self_time)
206
+ assert_in_delta(0, method.wait_time)
207
+ assert_in_delta(0, method.children_time)
124
208
 
125
209
  method = methods[1]
126
210
  assert_equal('<Class::Fiber>#yield', method.full_name)
127
211
  assert_equal(2, method.called)
212
+ assert_in_delta(0, method.total_time)
213
+ assert_in_delta(0, method.self_time)
214
+ assert_in_delta(0, method.wait_time)
215
+ assert_in_delta(0, method.children_time)
216
+ end
217
+
218
+ if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
219
+ def test_times_no_merge
220
+ result = RubyProf.profile { concurrency }
221
+
222
+ assert_equal(4, result.threads.size)
223
+
224
+ result.threads.each do |thread|
225
+ assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
226
+ assert_in_delta(0.0, thread.call_tree.target.self_time)
227
+ assert_in_delta(0.0, thread.call_tree.target.wait_time)
228
+ assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
229
+ end
230
+ end
231
+
232
+ def test_times_merge
233
+ result = RubyProf.profile { concurrency }
234
+ result.merge!
235
+
236
+ assert_equal(2, result.threads.size)
237
+
238
+ thread = result.threads[0]
239
+ assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
240
+ assert_in_delta(0.0, thread.call_tree.target.self_time)
241
+ assert_in_delta(0.0, thread.call_tree.target.wait_time)
242
+ assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
243
+
244
+ thread = result.threads[1]
245
+ assert_in_delta(1.5, thread.call_tree.target.total_time, 0.2)
246
+ assert_in_delta(0.0, thread.call_tree.target.self_time)
247
+ assert_in_delta(0.0, thread.call_tree.target.wait_time)
248
+ assert_in_delta(1.5, thread.call_tree.target.children_time, 0.2)
249
+ end
128
250
  end
129
251
  end
data/test/gc_test.rb CHANGED
@@ -67,16 +67,18 @@ class GcTest < TestCase
67
67
  end
68
68
 
69
69
  def test_hold_onto_measurements
70
- measurements = 5.times.reduce(Array.new) do |array, i|
71
- profile = run_profile
72
- measurements_2 = profile.threads.map(&:methods).flatten.map(&:measurement)
73
- array.concat(measurements_2)
74
- array
75
- end
70
+ # Run a profile
71
+ profile = run_profile
72
+
73
+ # Get measurement objects
74
+ measurements = profile.threads.map(&:methods).flatten.map(&:measurement)
75
+
76
+ # Free the profiles which frees the measurements
77
+ profile = nil
76
78
 
77
79
  GC.start
78
80
 
79
- measurements.each do |measurement|
81
+ measurements.each_with_index do |measurement|
80
82
  error = assert_raises(RuntimeError) do
81
83
  measurement.total_time
82
84
  end
@@ -19,12 +19,10 @@ class LineNumbers
19
19
  end
20
20
 
21
21
  def method_3
22
- sleep(0.3)
23
22
  method_4
24
23
  end
25
24
 
26
25
  def method_4
27
- sleep(1.2)
28
26
  end
29
27
  end
30
28
 
@@ -37,20 +35,24 @@ class LineNumbersTest < TestCase
37
35
  numbers.method_1
38
36
  end
39
37
 
40
- methods = result.threads.first.methods.sort.reverse
41
- assert_equal(7, methods.length)
38
+ # Sort methods by name to have stable results
39
+ methods = result.threads.first.methods.sort_by(&:full_name)
40
+ assert_equal(6, methods.length)
42
41
 
43
42
  # Method 0
44
43
  method = methods[0]
45
- assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
46
- assert_equal(37, method.line)
44
+ assert_equal('Integer#times', method.full_name)
45
+ assert_equal(0, method.line)
47
46
 
48
- assert_equal(0, method.call_trees.callers.count)
47
+ assert_equal(1, method.call_trees.callers.count)
48
+ call_tree = method.call_trees.callers[0]
49
+ assert_equal('LineNumbers#method_2', call_tree.parent.target.full_name)
50
+ assert_equal(15, call_tree.line)
49
51
 
50
52
  assert_equal(1, method.call_trees.callees.count)
51
53
  call_tree = method.call_trees.callees[0]
52
- assert_equal('LineNumbers#method_1', call_tree.target.full_name)
53
- assert_equal(37, call_tree.line)
54
+ assert_equal('LineNumbers#method_3', call_tree.target.full_name)
55
+ assert_equal(17, call_tree.line)
54
56
 
55
57
  # Method 1
56
58
  method = methods[1]
@@ -60,7 +62,7 @@ class LineNumbersTest < TestCase
60
62
  assert_equal(1, method.call_trees.callers.count)
61
63
  call_tree = method.call_trees.callers[0]
62
64
  assert_equal('LineNumbersTest#test_function_line_no', call_tree.parent.target.full_name)
63
- assert_equal(37, call_tree.line)
65
+ assert_equal(35, call_tree.line)
64
66
 
65
67
  assert_equal(2, method.call_trees.callees.count)
66
68
  call_tree = method.call_trees.callees[0]
@@ -73,6 +75,21 @@ class LineNumbersTest < TestCase
73
75
 
74
76
  # Method 2
75
77
  method = methods[2]
78
+ assert_equal('LineNumbers#method_2', method.full_name)
79
+ assert_equal(13, method.line)
80
+
81
+ assert_equal(1, method.call_trees.callers.count)
82
+ call_tree = method.call_trees.callers[0]
83
+ assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
84
+ assert_equal(8, call_tree.line)
85
+
86
+ assert_equal(1, method.call_trees.callees.count)
87
+ call_tree = method.call_trees.callees[0]
88
+ assert_equal('Integer#times', call_tree.target.full_name)
89
+ assert_equal(15, call_tree.line)
90
+
91
+ # Method 3
92
+ method = methods[3]
76
93
  assert_equal('LineNumbers#method_3', method.full_name)
77
94
  assert_equal(21, method.line)
78
95
 
@@ -85,74 +102,33 @@ class LineNumbersTest < TestCase
85
102
  assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
86
103
  assert_equal(10, call_tree.line)
87
104
 
88
- assert_equal(2, method.call_trees.callees.count)
105
+ assert_equal(1, method.call_trees.callees.count)
89
106
  call_tree = method.call_trees.callees[0]
90
- assert_equal('Kernel#sleep', call_tree.target.full_name)
91
- assert_equal(22, call_tree.line)
92
-
93
- call_tree = method.call_trees.callees[1]
94
107
  assert_equal('LineNumbers#method_4', call_tree.target.full_name)
95
- assert_equal(23, call_tree.line)
96
-
97
- # Method 3
98
- method = methods[3]
99
- assert_equal('Kernel#sleep', method.full_name)
100
- assert_equal(0, method.line)
101
-
102
- assert_equal(2, method.call_trees.callers.count)
103
- call_tree = method.call_trees.callers[0]
104
- assert_equal('LineNumbers#method_3', call_tree.parent.target.full_name)
105
108
  assert_equal(22, call_tree.line)
106
109
 
107
- call_tree = method.call_trees.callers[1]
108
- assert_equal('LineNumbers#method_4', call_tree.parent.target.full_name)
109
- assert_equal(27, call_tree.line)
110
-
111
- assert_equal(0, method.call_trees.callees.count)
112
-
113
110
  # Method 4
114
111
  method = methods[4]
115
112
  assert_equal('LineNumbers#method_4', method.full_name)
116
- assert_equal(26, method.line)
113
+ assert_equal(25, method.line)
117
114
 
118
115
  assert_equal(1, method.call_trees.callers.count)
119
116
  call_tree = method.call_trees.callers[0]
120
117
  assert_equal('LineNumbers#method_3', call_tree.parent.target.full_name)
121
- assert_equal(23, call_tree.line)
118
+ assert_equal(22, call_tree.line)
122
119
 
123
- assert_equal(1, method.call_trees.callees.count)
124
- call_tree = method.call_trees.callees[0]
125
- assert_equal('Kernel#sleep', call_tree.target.full_name)
126
- assert_equal(27, call_tree.line)
120
+ assert_equal(0, method.call_trees.callees.count)
127
121
 
128
122
  # Method 5
129
123
  method = methods[5]
130
- assert_equal('LineNumbers#method_2', method.full_name)
131
- assert_equal(13, method.line)
132
-
133
- assert_equal(1, method.call_trees.callers.count)
134
- call_tree = method.call_trees.callers[0]
135
- assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
136
- assert_equal(8, call_tree.line)
137
-
138
- assert_equal(1, method.call_trees.callees.count)
139
- call_tree = method.call_trees.callees[0]
140
- assert_equal('Integer#times', call_tree.target.full_name)
141
- assert_equal(15, call_tree.line)
142
-
143
- # Method 6
144
- method = methods[6]
145
- assert_equal('Integer#times', method.full_name)
146
- assert_equal(0, method.line)
124
+ assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
125
+ assert_equal(35, method.line)
147
126
 
148
- assert_equal(1, method.call_trees.callers.count)
149
- call_tree = method.call_trees.callers[0]
150
- assert_equal('LineNumbers#method_2', call_tree.parent.target.full_name)
151
- assert_equal(15, call_tree.line)
127
+ assert_equal(0, method.call_trees.callers.count)
152
128
 
153
129
  assert_equal(1, method.call_trees.callees.count)
154
130
  call_tree = method.call_trees.callees[0]
155
- assert_equal('LineNumbers#method_3', call_tree.target.full_name)
156
- assert_equal(17, call_tree.line)
131
+ assert_equal('LineNumbers#method_1', call_tree.target.full_name)
132
+ assert_equal(35, call_tree.line)
157
133
  end
158
134
  end