ruby-prof 1.4.3 → 1.4.4

Sign up to get free protection for your applications and to get access to all the features.
Files changed (36) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES +25 -9
  3. data/{README.rdoc → README.md} +2 -2
  4. data/Rakefile +3 -3
  5. data/ext/ruby_prof/rp_call_tree.c +0 -2
  6. data/ext/ruby_prof/rp_call_tree.h +1 -1
  7. data/ext/ruby_prof/rp_measure_allocations.c +10 -13
  8. data/ext/ruby_prof/rp_measure_memory.c +8 -4
  9. data/ext/ruby_prof/rp_measure_process_time.c +7 -6
  10. data/ext/ruby_prof/rp_measurement.c +1 -1
  11. data/ext/ruby_prof/rp_measurement.h +1 -1
  12. data/ext/ruby_prof/rp_profile.c +18 -3
  13. data/ext/ruby_prof/vc/ruby_prof.vcxproj +8 -6
  14. data/lib/ruby-prof/assets/call_stack_printer.html.erb +2 -1
  15. data/lib/ruby-prof/printers/call_tree_printer.rb +3 -7
  16. data/lib/ruby-prof/printers/graph_html_printer.rb +1 -1
  17. data/lib/ruby-prof/version.rb +1 -1
  18. data/ruby-prof.gemspec +2 -3
  19. data/test/alias_test.rb +97 -101
  20. data/test/duplicate_names_test.rb +4 -4
  21. data/test/dynamic_method_test.rb +23 -9
  22. data/test/marshal_test.rb +15 -2
  23. data/test/measure_allocations.rb +1 -5
  24. data/test/measure_allocations_test.rb +27 -69
  25. data/test/measure_memory_test.rb +688 -0
  26. data/test/measure_process_time_test.rb +1564 -735
  27. data/test/measure_wall_time_test.rb +6 -15
  28. data/test/printer_call_tree_test.rb +2 -2
  29. data/test/recursive_test.rb +372 -148
  30. data/test/test_helper.rb +4 -8
  31. data/test/unique_call_path_test.rb +24 -8
  32. data/test/yarv_test.rb +8 -4
  33. metadata +10 -26
  34. data/test/measure_allocations_trace_test.rb +0 -375
  35. data/test/measure_memory_trace_test.rb +0 -1460
  36. data/test/temp.rb +0 -20
data/test/measure_process_time_test.rb CHANGED
@@ -15,771 +15,1600 @@ class MeasureProcessTimeTest < TestCase
15
15
  assert_equal(RubyProf::PROCESS_TIME, RubyProf::measure_mode)
16
16
  end
17
17
 
18
- def test_class_methods_sleep
19
- result = RubyProf.profile do
20
- RubyProf::C1.sleep_wait
21
- end
18
+ # These tests run to fast for Windows to detect any used process time
19
+ if !windows?
20
+ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
21
+ def test_class_methods_sleep
22
+ result = RubyProf.profile do
23
+ RubyProf::C1.sleep_wait
24
+ end
25
+
26
+ thread = result.threads.first
27
+ assert_in_delta(0.0, thread.total_time, 0.05)
28
+
29
+ methods = result.threads.first.methods.sort.reverse
30
+ assert_equal(3, methods.length)
31
+
32
+ # Check times
33
+ method = methods[0]
34
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep', method.full_name)
35
+ assert_in_delta(0.0, method.total_time, 0.05)
36
+ assert_in_delta(0.0, method.wait_time, 0.05)
37
+ assert_in_delta(0.0, method.self_time, 0.05)
38
+ assert_in_delta(0.0, method.children_time, 0.05)
39
+
40
+ method = methods[1]
41
+ assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
42
+ assert_in_delta(0.0, method.total_time, 0.05)
43
+ assert_in_delta(0.0, method.wait_time, 0.05)
44
+ assert_in_delta(0.0, method.self_time, 0.05)
45
+ assert_in_delta(0.0, method.children_time, 0.05)
46
+
47
+ method = methods[2]
48
+ assert_equal('Kernel#sleep', method.full_name)
49
+ assert_in_delta(0.0, method.total_time, 0.05)
50
+ assert_in_delta(0.0, method.wait_time, 0.05)
51
+ assert_in_delta(0.0, method.self_time, 0.05)
52
+ assert_in_delta(0.0, method.children_time, 0.05)
53
+ end
22
54
 
23
- thread = result.threads.first
24
- assert_in_delta(0.0, thread.total_time, 0.05)
25
-
26
- methods = result.threads.first.methods.sort.reverse
27
- assert_equal(3, methods.length)
28
-
29
- # Check times
30
- method = methods[0]
31
- assert_equal('MeasureProcessTimeTest#test_class_methods_sleep', method.full_name)
32
- assert_in_delta(0.0, method.total_time, 0.05)
33
- assert_in_delta(0.0, method.wait_time, 0.05)
34
- assert_in_delta(0.0, method.self_time, 0.05)
35
- assert_in_delta(0.0, method.children_time, 0.05)
36
-
37
- method = methods[1]
38
- assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
39
- assert_in_delta(0.0, method.total_time, 0.05)
40
- assert_in_delta(0.0, method.wait_time, 0.05)
41
- assert_in_delta(0.0, method.self_time, 0.05)
42
- assert_in_delta(0.0, method.children_time, 0.05)
43
-
44
- method = methods[2]
45
- assert_equal('Kernel#sleep', method.full_name)
46
- assert_in_delta(0.0, method.total_time, 0.05)
47
- assert_in_delta(0.0, method.wait_time, 0.05)
48
- assert_in_delta(0.0, method.self_time, 0.05)
49
- assert_in_delta(0.0, method.children_time, 0.05)
50
- end
55
+ def test_class_methods_sleep_threaded
56
+ result = RubyProf.profile do
57
+ background_thread = Thread.new do
58
+ RubyProf::C1.sleep_wait
59
+ end
60
+ background_thread.join
61
+ end
62
+
63
+ assert_equal(2, result.threads.count)
64
+
65
+ thread = result.threads.first
66
+ assert_in_delta(0.0, thread.total_time, 0.05)
67
+
68
+ methods = result.threads.first.methods.sort.reverse
69
+ assert_equal(4, methods.length)
70
+
71
+ # Check times
72
+ method = methods[0]
73
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
74
+ assert_in_delta(0.0, method.total_time, 0.05)
75
+ assert_in_delta(0.0, method.wait_time, 0.05)
76
+ assert_in_delta(0.0, method.self_time, 0.05)
77
+ assert_in_delta(0.0, method.children_time, 0.05)
78
+
79
+ method = methods[1]
80
+ assert_equal('Thread#join', method.full_name)
81
+ assert_in_delta(0.0, method.total_time, 0.05)
82
+ assert_in_delta(0.0, method.wait_time, 0.05)
83
+ assert_in_delta(0.0, method.self_time, 0.05)
84
+ assert_in_delta(0.0, method.children_time, 0.05)
85
+
86
+ method = methods[2]
87
+ assert_equal('<Class::Thread>#new', method.full_name)
88
+ assert_in_delta(0.0, method.total_time, 0.05)
89
+ assert_in_delta(0.0, method.wait_time, 0.05)
90
+ assert_in_delta(0.0, method.self_time, 0.05)
91
+ assert_in_delta(0.0, method.children_time, 0.05)
92
+
93
+ method = methods[3]
94
+ assert_equal('Thread#initialize', method.full_name)
95
+ assert_in_delta(0.0, method.total_time, 0.05)
96
+ assert_in_delta(0.0, method.wait_time, 0.05)
97
+ assert_in_delta(0.0, method.self_time, 0.05)
98
+ assert_in_delta(0.0, method.children_time, 0.05)
99
+
100
+ thread = result.threads.last
101
+ assert_in_delta(0.0, thread.total_time, 0.05)
102
+
103
+ methods = result.threads.first.methods.sort.reverse
104
+ assert_equal(4, methods.length)
105
+
106
+ methods = result.threads.last.methods.sort.reverse
107
+ assert_equal(3, methods.length)
108
+
109
+ # Check times
110
+ method = methods[0]
111
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
112
+ assert_in_delta(0.0, method.total_time, 0.05)
113
+ assert_in_delta(0.0, method.wait_time, 0.05)
114
+ assert_in_delta(0.0, method.self_time, 0.05)
115
+ assert_in_delta(0.0, method.children_time, 0.05)
116
+
117
+ method = methods[1]
118
+ assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
119
+ assert_in_delta(0.0, method.total_time, 0.05)
120
+ assert_in_delta(0.0, method.wait_time, 0.05)
121
+ assert_in_delta(0.0, method.self_time, 0.05)
122
+ assert_in_delta(0.0, method.children_time, 0.05)
123
+
124
+ method = methods[2]
125
+ assert_equal('Kernel#sleep', method.full_name)
126
+ assert_in_delta(0.0, method.total_time, 0.05)
127
+ assert_in_delta(0.0, method.wait_time, 0.05)
128
+ assert_in_delta(0.0, method.self_time, 0.05)
129
+ assert_in_delta(0.0, method.children_time, 0.05)
130
+ end
51
131
 
52
- def test_class_methods_sleep_threaded
53
- result = RubyProf.profile do
54
- background_thread = Thread.new do
55
- RubyProf::C1.sleep_wait
132
+ def test_class_methods_busy
133
+ result = RubyProf.profile do
134
+ RubyProf::C1.busy_wait
135
+ end
136
+
137
+ thread = result.threads.first
138
+ assert_in_delta(0.08, thread.total_time, 0.05)
139
+
140
+ methods = result.threads.first.methods.sort.reverse
141
+ assert_equal(3, methods.length)
142
+
143
+ # Check times
144
+ method = methods[0]
145
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy', method.full_name)
146
+ assert_in_delta(0.1, method.total_time, 0.05)
147
+ assert_in_delta(0.0, method.wait_time, 0.05)
148
+ assert_in_delta(0.0, method.self_time, 0.05)
149
+ assert_in_delta(0.1, method.children_time, 0.05)
150
+
151
+ method = methods[1]
152
+ assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
153
+ assert_in_delta(0.1, method.total_time, 0.05)
154
+ assert_in_delta(0.0, method.wait_time, 0.05)
155
+ assert_in_delta(0.06, method.self_time, 0.05)
156
+ assert_in_delta(0.07, method.children_time, 0.05)
157
+
158
+ method = methods[2]
159
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
160
+ assert_in_delta(0.05, method.total_time, 0.05)
161
+ assert_in_delta(0.0, method.wait_time, 0.05)
162
+ assert_in_delta(0.05, method.self_time, 0.05)
163
+ assert_in_delta(0.0, method.children_time, 0.05)
56
164
  end
57
- background_thread.join
58
- end
59
165
 
60
- assert_equal(2, result.threads.count)
61
-
62
- thread = result.threads.first
63
- assert_in_delta(0.0, thread.total_time, 0.05)
64
-
65
- methods = result.threads.first.methods.sort.reverse
66
- assert_equal(4, methods.length)
67
-
68
- # Check times
69
- method = methods[0]
70
- assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
71
- assert_in_delta(0.0, method.total_time, 0.05)
72
- assert_in_delta(0.0, method.wait_time, 0.05)
73
- assert_in_delta(0.0, method.self_time, 0.05)
74
- assert_in_delta(0.0, method.children_time, 0.05)
75
-
76
- method = methods[1]
77
- assert_equal('Thread#join', method.full_name)
78
- assert_in_delta(0.0, method.total_time, 0.05)
79
- assert_in_delta(0.0, method.wait_time, 0.05)
80
- assert_in_delta(0.0, method.self_time, 0.05)
81
- assert_in_delta(0.0, method.children_time, 0.05)
82
-
83
- method = methods[2]
84
- assert_equal('<Class::Thread>#new', method.full_name)
85
- assert_in_delta(0.0, method.total_time, 0.05)
86
- assert_in_delta(0.0, method.wait_time, 0.05)
87
- assert_in_delta(0.0, method.self_time, 0.05)
88
- assert_in_delta(0.0, method.children_time, 0.05)
89
-
90
- method = methods[3]
91
- assert_equal('Thread#initialize', method.full_name)
92
- assert_in_delta(0.0, method.total_time, 0.05)
93
- assert_in_delta(0.0, method.wait_time, 0.05)
94
- assert_in_delta(0.0, method.self_time, 0.05)
95
- assert_in_delta(0.0, method.children_time, 0.05)
96
-
97
- thread = result.threads.last
98
- assert_in_delta(0.0, thread.total_time, 0.05)
99
-
100
- methods = result.threads.first.methods.sort.reverse
101
- assert_equal(4, methods.length)
102
-
103
- methods = result.threads.last.methods.sort.reverse
104
- assert_equal(3, methods.length)
105
-
106
- # Check times
107
- method = methods[0]
108
- assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
109
- assert_in_delta(0.0, method.total_time, 0.05)
110
- assert_in_delta(0.0, method.wait_time, 0.05)
111
- assert_in_delta(0.0, method.self_time, 0.05)
112
- assert_in_delta(0.0, method.children_time, 0.05)
113
-
114
- method = methods[1]
115
- assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
116
- assert_in_delta(0.0, method.total_time, 0.05)
117
- assert_in_delta(0.0, method.wait_time, 0.05)
118
- assert_in_delta(0.0, method.self_time, 0.05)
119
- assert_in_delta(0.0, method.children_time, 0.05)
120
-
121
- method = methods[2]
122
- assert_equal('Kernel#sleep', method.full_name)
123
- assert_in_delta(0.0, method.total_time, 0.05)
124
- assert_in_delta(0.0, method.wait_time, 0.05)
125
- assert_in_delta(0.0, method.self_time, 0.05)
126
- assert_in_delta(0.0, method.children_time, 0.05)
127
- end
166
+ def test_class_methods_busy_threaded
167
+ result = RubyProf.profile do
168
+ background_thread = Thread.new do
169
+ RubyProf::C1.busy_wait
170
+ end
171
+ background_thread.join
172
+ end
173
+
174
+ assert_equal(2, result.threads.count)
175
+
176
+ thread = result.threads.first
177
+ assert_in_delta(0.1, thread.total_time, 0.05)
178
+
179
+ methods = result.threads.first.methods.sort.reverse
180
+ assert_equal(4, methods.length)
181
+
182
+ # Check times
183
+ method = methods[0]
184
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
185
+ assert_in_delta(0.1, method.total_time, 0.05)
186
+ assert_in_delta(0.0, method.wait_time, 0.05)
187
+ assert_in_delta(0.0, method.self_time, 0.05)
188
+ assert_in_delta(0.1, method.children_time, 0.05)
189
+
190
+ method = methods[1]
191
+ assert_equal('Thread#join', method.full_name)
192
+ assert_in_delta(0.1, method.total_time, 0.05)
193
+ assert_in_delta(0.1, method.wait_time, 0.05)
194
+ assert_in_delta(0.0, method.self_time, 0.05)
195
+ assert_in_delta(0.0, method.children_time, 0.05)
196
+
197
+ method = methods[2]
198
+ assert_equal('<Class::Thread>#new', method.full_name)
199
+ assert_in_delta(0.0, method.total_time, 0.05)
200
+ assert_in_delta(0.0, method.wait_time, 0.05)
201
+ assert_in_delta(0.0, method.self_time, 0.05)
202
+ assert_in_delta(0.0, method.children_time, 0.05)
203
+
204
+ method = methods[3]
205
+ assert_equal('Thread#initialize', method.full_name)
206
+ assert_in_delta(0.0, method.total_time, 0.05)
207
+ assert_in_delta(0.0, method.wait_time, 0.05)
208
+ assert_in_delta(0.0, method.self_time, 0.05)
209
+ assert_in_delta(0.0, method.children_time, 0.05)
210
+
211
+ thread = result.threads.last
212
+ assert_in_delta(0.1, thread.total_time, 0.05)
213
+
214
+ methods = result.threads.first.methods.sort.reverse
215
+ assert_equal(4, methods.length)
216
+
217
+ methods = result.threads.last.methods.sort.reverse
218
+ assert_equal(3, methods.length)
219
+
220
+ # Check times
221
+ method = methods[0]
222
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
223
+ assert_in_delta(0.1, method.total_time, 0.05)
224
+ assert_in_delta(0.0, method.wait_time, 0.05)
225
+ assert_in_delta(0.0, method.self_time, 0.05)
226
+ assert_in_delta(0.1, method.children_time, 0.05)
227
+
228
+ method = methods[1]
229
+ assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
230
+ assert_in_delta(0.1, method.total_time, 0.05)
231
+ assert_in_delta(0.0, method.wait_time, 0.05)
232
+ assert_in_delta(0.05, method.self_time, 0.05)
233
+ assert_in_delta(0.05, method.children_time, 0.05)
234
+
235
+ method = methods[2]
236
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
237
+ assert_in_delta(0.05, method.total_time, 0.05)
238
+ assert_in_delta(0.0, method.wait_time, 0.05)
239
+ assert_in_delta(0.05, method.self_time, 0.05)
240
+ assert_in_delta(0.0, method.children_time, 0.05)
241
+ end
128
242
 
129
- def test_class_methods_busy
130
- result = RubyProf.profile do
131
- RubyProf::C1.busy_wait
132
- end
243
+ def test_instance_methods_sleep
244
+ result = RubyProf.profile do
245
+ RubyProf::C1.new.sleep_wait
246
+ end
247
+
248
+ thread = result.threads.first
249
+ assert_in_delta(0.0, thread.total_time, 0.05)
250
+
251
+ methods = result.threads.first.methods.sort.reverse
252
+ assert_equal(5, methods.length)
253
+
254
+ # Check times
255
+ method = methods[0]
256
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep', method.full_name)
257
+ assert_in_delta(0.0, method.total_time, 0.05)
258
+ assert_in_delta(0.0, method.wait_time, 0.05)
259
+ assert_in_delta(0.0, method.self_time, 0.05)
260
+ assert_in_delta(0.0, method.children_time, 0.05)
261
+
262
+ method = methods[1]
263
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
264
+ assert_in_delta(0.0, method.total_time, 0.05)
265
+ assert_in_delta(0.0, method.wait_time, 0.05)
266
+ assert_in_delta(0.0, method.self_time, 0.05)
267
+ assert_in_delta(0.0, method.children_time, 0.05)
268
+
269
+ method = methods[2]
270
+ assert_equal('Kernel#sleep', method.full_name)
271
+ assert_in_delta(0.0, method.total_time, 0.05)
272
+ assert_in_delta(0.0, method.wait_time, 0.05)
273
+ assert_in_delta(0.0, method.self_time, 0.05)
274
+ assert_in_delta(0.0, method.children_time, 0.05)
275
+
276
+ method = methods[3]
277
+ assert_equal('Class#new', method.full_name)
278
+ assert_in_delta(0.0, method.total_time, 0.05)
279
+ assert_in_delta(0.0, method.wait_time, 0.05)
280
+ assert_in_delta(0.0, method.self_time, 0.05)
281
+ assert_in_delta(0.0, method.children_time, 0.05)
282
+
283
+ method = methods[4]
284
+ assert_equal('BasicObject#initialize', method.full_name)
285
+ assert_in_delta(0.0, method.total_time, 0.05)
286
+ assert_in_delta(0.0, method.wait_time, 0.05)
287
+ assert_in_delta(0.0, method.self_time, 0.05)
288
+ assert_in_delta(0.0, method.children_time, 0.05)
289
+ end
133
290
 
134
- thread = result.threads.first
135
- assert_in_delta(0.08, thread.total_time, 0.05)
136
-
137
- methods = result.threads.first.methods.sort.reverse
138
- assert_equal(3, methods.length)
139
-
140
- # Check times
141
- method = methods[0]
142
- assert_equal('MeasureProcessTimeTest#test_class_methods_busy', method.full_name)
143
- assert_in_delta(0.1, method.total_time, 0.05)
144
- assert_in_delta(0.0, method.wait_time, 0.05)
145
- assert_in_delta(0.0, method.self_time, 0.05)
146
- assert_in_delta(0.1, method.children_time, 0.05)
147
-
148
- method = methods[1]
149
- assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
150
- assert_in_delta(0.1, method.total_time, 0.05)
151
- assert_in_delta(0.0, method.wait_time, 0.05)
152
- assert_in_delta(0.06, method.self_time, 0.05)
153
- assert_in_delta(0.07, method.children_time, 0.05)
154
-
155
- method = methods[2]
156
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
157
- assert_in_delta(0.05, method.total_time, 0.05)
158
- assert_in_delta(0.0, method.wait_time, 0.05)
159
- assert_in_delta(0.05, method.self_time, 0.05)
160
- assert_in_delta(0.0, method.children_time, 0.05)
161
- end
291
+ def test_instance_methods_sleep_block
292
+ result = RubyProf.profile do
293
+ 1.times { RubyProf::C1.new.sleep_wait }
294
+ end
295
+
296
+ methods = result.threads.first.methods.sort.reverse
297
+ assert_equal(6, methods.length)
298
+
299
+ # Check times
300
+ method = methods[0]
301
+ assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep_block", method.full_name)
302
+ assert_in_delta(0.0, method.total_time, 0.05)
303
+ assert_in_delta(0.0, method.wait_time, 0.05)
304
+ assert_in_delta(0.0, method.self_time, 0.05)
305
+ assert_in_delta(0.0, method.children_time, 0.05)
306
+
307
+ method = methods[1]
308
+ assert_equal('Integer#times', method.full_name)
309
+ assert_in_delta(0.0, method.total_time, 0.05)
310
+ assert_in_delta(0.0, method.wait_time, 0.05)
311
+ assert_in_delta(0.0, method.self_time, 0.05)
312
+ assert_in_delta(0.0, method.children_time, 0.05)
313
+
314
+ method = methods[2]
315
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
316
+ assert_in_delta(0.0, method.total_time, 0.05)
317
+ assert_in_delta(0.0, method.wait_time, 0.05)
318
+ assert_in_delta(0.0, method.self_time, 0.05)
319
+ assert_in_delta(0.0, method.children_time, 0.05)
320
+
321
+ method = methods[3]
322
+ assert_equal('Kernel#sleep', method.full_name)
323
+ assert_in_delta(0.0, method.total_time, 0.05)
324
+ assert_in_delta(0.0, method.wait_time, 0.05)
325
+ assert_in_delta(0.0, method.self_time, 0.05)
326
+ assert_in_delta(0.0, method.children_time, 0.05)
327
+
328
+ method = methods[4]
329
+ assert_equal('Class#new', method.full_name)
330
+ assert_in_delta(0.0, method.total_time, 0.05)
331
+ assert_in_delta(0.0, method.wait_time, 0.05)
332
+ assert_in_delta(0.0, method.self_time, 0.05)
333
+ assert_in_delta(0.0, method.children_time, 0.05)
334
+
335
+ method = methods[5]
336
+ assert_equal('BasicObject#initialize', method.full_name)
337
+ assert_in_delta(0.0, method.total_time, 0.05)
338
+ assert_in_delta(0.0, method.wait_time, 0.05)
339
+ assert_in_delta(0.0, method.self_time, 0.05)
340
+ assert_in_delta(0.0, method.children_time, 0.05)
341
+ end
162
342
 
163
- def test_class_methods_busy_threaded
164
- result = RubyProf.profile do
165
- background_thread = Thread.new do
166
- RubyProf::C1.busy_wait
343
+ def test_instance_methods_sleep_threaded
344
+ result = RubyProf.profile do
345
+ background_thread = Thread.new do
346
+ RubyProf::C1.new.sleep_wait
347
+ end
348
+ background_thread.join
349
+ end
350
+
351
+ assert_equal(2, result.threads.count)
352
+
353
+ thread = result.threads.first
354
+ assert_in_delta(0.0, thread.total_time, 0.05)
355
+
356
+ methods = result.threads.first.methods.sort.reverse
357
+ assert_equal(4, methods.length)
358
+
359
+ # Check times
360
+ method = methods[0]
361
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
362
+ assert_in_delta(0.0, method.total_time, 0.05)
363
+ assert_in_delta(0.0, method.wait_time, 0.05)
364
+ assert_in_delta(0.0, method.self_time, 0.05)
365
+ assert_in_delta(0.0, method.children_time, 0.05)
366
+
367
+ method = methods[1]
368
+ assert_equal('Thread#join', method.full_name)
369
+ assert_in_delta(0.0, method.total_time, 0.05)
370
+ assert_in_delta(0.0, method.wait_time, 0.05)
371
+ assert_in_delta(0.0, method.self_time, 0.05)
372
+ assert_in_delta(0.0, method.children_time, 0.05)
373
+
374
+ method = methods[2]
375
+ assert_equal('<Class::Thread>#new', method.full_name)
376
+ assert_in_delta(0.0, method.total_time, 0.05)
377
+ assert_in_delta(0.0, method.wait_time, 0.05)
378
+ assert_in_delta(0.0, method.self_time, 0.05)
379
+ assert_in_delta(0.0, method.children_time, 0.05)
380
+
381
+ method = methods[3]
382
+ assert_equal('Thread#initialize', method.full_name)
383
+ assert_in_delta(0.0, method.total_time, 0.05)
384
+ assert_in_delta(0.0, method.wait_time, 0.05)
385
+ assert_in_delta(0.0, method.self_time, 0.05)
386
+ assert_in_delta(0.0, method.children_time, 0.05)
387
+
388
+ thread = result.threads.last
389
+ assert_in_delta(0.0, thread.total_time, 0.05)
390
+
391
+ methods = result.threads.first.methods.sort.reverse
392
+ assert_equal(4, methods.length)
393
+
394
+ methods = result.threads.last.methods.sort.reverse
395
+ assert_equal(5, methods.length)
396
+
397
+ # Check times
398
+ method = methods[0]
399
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
400
+ assert_in_delta(0.0, method.total_time, 0.05)
401
+ assert_in_delta(0.0, method.wait_time, 0.05)
402
+ assert_in_delta(0.0, method.self_time, 0.05)
403
+ assert_in_delta(0.0, method.children_time, 0.05)
404
+
405
+ method = methods[1]
406
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
407
+ assert_in_delta(0.0, method.total_time, 0.05)
408
+ assert_in_delta(0.0, method.wait_time, 0.05)
409
+ assert_in_delta(0.0, method.self_time, 0.05)
410
+ assert_in_delta(0.0, method.children_time, 0.05)
411
+
412
+ method = methods[2]
413
+ assert_equal('Kernel#sleep', method.full_name)
414
+ assert_in_delta(0.0, method.total_time, 0.05)
415
+ assert_in_delta(0.0, method.wait_time, 0.05)
416
+ assert_in_delta(0.0, method.self_time, 0.05)
417
+ assert_in_delta(0.0, method.children_time, 0.05)
418
+
419
+ method = methods[3]
420
+ assert_equal('Class#new', method.full_name)
421
+ assert_in_delta(0.0, method.total_time, 0.05)
422
+ assert_in_delta(0.0, method.wait_time, 0.05)
423
+ assert_in_delta(0.0, method.self_time, 0.05)
424
+ assert_in_delta(0.0, method.children_time, 0.05)
425
+
426
+ method = methods[4]
427
+ assert_equal('BasicObject#initialize', method.full_name)
428
+ assert_in_delta(0.0, method.total_time, 0.05)
429
+ assert_in_delta(0.0, method.wait_time, 0.05)
430
+ assert_in_delta(0.0, method.self_time, 0.05)
431
+ assert_in_delta(0.0, method.children_time, 0.05)
167
432
  end
168
- background_thread.join
169
- end
170
433
 
171
- assert_equal(2, result.threads.count)
172
-
173
- thread = result.threads.first
174
- assert_in_delta(0.1, thread.total_time, 0.05)
175
-
176
- methods = result.threads.first.methods.sort.reverse
177
- assert_equal(4, methods.length)
178
-
179
- # Check times
180
- method = methods[0]
181
- assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
182
- assert_in_delta(0.1, method.total_time, 0.05)
183
- assert_in_delta(0.0, method.wait_time, 0.05)
184
- assert_in_delta(0.0, method.self_time, 0.05)
185
- assert_in_delta(0.1, method.children_time, 0.05)
186
-
187
- method = methods[1]
188
- assert_equal('Thread#join', method.full_name)
189
- assert_in_delta(0.1, method.total_time, 0.05)
190
- assert_in_delta(0.1, method.wait_time, 0.05)
191
- assert_in_delta(0.0, method.self_time, 0.05)
192
- assert_in_delta(0.0, method.children_time, 0.05)
193
-
194
- method = methods[2]
195
- assert_equal('<Class::Thread>#new', method.full_name)
196
- assert_in_delta(0.0, method.total_time, 0.05)
197
- assert_in_delta(0.0, method.wait_time, 0.05)
198
- assert_in_delta(0.0, method.self_time, 0.05)
199
- assert_in_delta(0.0, method.children_time, 0.05)
200
-
201
- method = methods[3]
202
- assert_equal('Thread#initialize', method.full_name)
203
- assert_in_delta(0.0, method.total_time, 0.05)
204
- assert_in_delta(0.0, method.wait_time, 0.05)
205
- assert_in_delta(0.0, method.self_time, 0.05)
206
- assert_in_delta(0.0, method.children_time, 0.05)
207
-
208
- thread = result.threads.last
209
- assert_in_delta(0.1, thread.total_time, 0.05)
210
-
211
- methods = result.threads.first.methods.sort.reverse
212
- assert_equal(4, methods.length)
213
-
214
- methods = result.threads.last.methods.sort.reverse
215
- assert_equal(3, methods.length)
216
-
217
- # Check times
218
- method = methods[0]
219
- assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
220
- assert_in_delta(0.1, method.total_time, 0.05)
221
- assert_in_delta(0.0, method.wait_time, 0.05)
222
- assert_in_delta(0.0, method.self_time, 0.05)
223
- assert_in_delta(0.1, method.children_time, 0.05)
224
-
225
- method = methods[1]
226
- assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
227
- assert_in_delta(0.1, method.total_time, 0.05)
228
- assert_in_delta(0.0, method.wait_time, 0.05)
229
- assert_in_delta(0.05, method.self_time, 0.05)
230
- assert_in_delta(0.05, method.children_time, 0.05)
231
-
232
- method = methods[2]
233
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
234
- assert_in_delta(0.05, method.total_time, 0.05)
235
- assert_in_delta(0.0, method.wait_time, 0.05)
236
- assert_in_delta(0.05, method.self_time, 0.05)
237
- assert_in_delta(0.0, method.children_time, 0.05)
238
- end
434
+ def test_instance_methods_busy
435
+ result = RubyProf.profile do
436
+ RubyProf::C1.new.busy_wait
437
+ end
438
+
439
+ thread = result.threads.first
440
+ assert_in_delta(0.2, thread.total_time, 0.05)
441
+
442
+ methods = result.threads.first.methods.sort.reverse
443
+ assert_equal(5, methods.length)
444
+
445
+ # Check times
446
+ method = methods[0]
447
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy', method.full_name)
448
+ assert_in_delta(0.2, method.total_time, 0.05)
449
+ assert_in_delta(0.0, method.wait_time, 0.05)
450
+ assert_in_delta(0.0, method.self_time, 0.05)
451
+ assert_in_delta(0.2, method.children_time, 0.05)
452
+
453
+ method = methods[1]
454
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
455
+ assert_in_delta(0.2, method.total_time, 0.05)
456
+ assert_in_delta(0.0, method.wait_time, 0.05)
457
+ assert_in_delta(0.09, method.self_time, 0.05)
458
+ assert_in_delta(0.11, method.children_time, 0.05)
459
+
460
+ method = methods[2]
461
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
462
+ assert_in_delta(0.11, method.total_time, 0.05)
463
+ assert_in_delta(0.0, method.wait_time, 0.05)
464
+ assert_in_delta(0.11, method.self_time, 0.05)
465
+ assert_in_delta(0.0, method.children_time, 0.05)
466
+
467
+ method = methods[3]
468
+ assert_equal('Class#new', method.full_name)
469
+ assert_in_delta(0.0, method.total_time, 0.05)
470
+ assert_in_delta(0.0, method.wait_time, 0.05)
471
+ assert_in_delta(0.0, method.self_time, 0.05)
472
+ assert_in_delta(0.0, method.children_time, 0.05)
473
+
474
+ method = methods[4]
475
+ assert_equal('BasicObject#initialize', method.full_name)
476
+ assert_in_delta(0.0, method.total_time, 0.05)
477
+ assert_in_delta(0.0, method.wait_time, 0.05)
478
+ assert_in_delta(0.0, method.self_time, 0.05)
479
+ assert_in_delta(0.0, method.children_time, 0.05)
480
+ end
239
481
 
240
- def test_instance_methods_sleep
241
- result = RubyProf.profile do
242
- RubyProf::C1.new.sleep_wait
243
- end
482
+ def test_instance_methods_busy_block
483
+ result = RubyProf.profile do
484
+ 1.times { RubyProf::C1.new.busy_wait }
485
+ end
486
+
487
+ methods = result.threads.first.methods.sort.reverse
488
+ assert_equal(6, methods.length)
489
+
490
+ # Check times
491
+ method = methods[0]
492
+ assert_equal("MeasureProcessTimeTest#test_instance_methods_busy_block", method.full_name)
493
+ assert_in_delta(0.2, method.total_time, 0.05)
494
+ assert_in_delta(0.0, method.wait_time, 0.05)
495
+ assert_in_delta(0.0, method.self_time, 0.05)
496
+ assert_in_delta(0.2, method.children_time, 0.05)
497
+
498
+ method = methods[1]
499
+ assert_equal('Integer#times', method.full_name)
500
+ assert_in_delta(0.2, method.total_time, 0.05)
501
+ assert_in_delta(0.0, method.wait_time, 0.05)
502
+ assert_in_delta(0.0, method.self_time, 0.05)
503
+ assert_in_delta(0.2, method.children_time, 0.05)
504
+
505
+ method = methods[2]
506
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
507
+ assert_in_delta(0.2, method.total_time, 0.05)
508
+ assert_in_delta(0.0, method.wait_time, 0.05)
509
+ assert_in_delta(0.09, method.self_time, 0.05)
510
+ assert_in_delta(0.11, method.children_time, 0.05)
511
+
512
+ method = methods[3]
513
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
514
+ assert_in_delta(0.11, method.total_time, 0.05)
515
+ assert_in_delta(0.0, method.wait_time, 0.05)
516
+ assert_in_delta(0.11, method.self_time, 0.05)
517
+ assert_in_delta(0.0, method.children_time, 0.05)
518
+
519
+ method = methods[4]
520
+ assert_equal('Class#new', method.full_name)
521
+ assert_in_delta(0.0, method.total_time, 0.05)
522
+ assert_in_delta(0.0, method.wait_time, 0.05)
523
+ assert_in_delta(0.0, method.self_time, 0.05)
524
+ assert_in_delta(0.0, method.children_time, 0.05)
525
+
526
+ method = methods[5]
527
+ assert_equal('BasicObject#initialize', method.full_name)
528
+ assert_in_delta(0.0, method.total_time, 0.05)
529
+ assert_in_delta(0.0, method.wait_time, 0.05)
530
+ assert_in_delta(0.0, method.self_time, 0.05)
531
+ assert_in_delta(0.0, method.children_time, 0.05)
532
+ end
244
533
 
245
- thread = result.threads.first
246
- assert_in_delta(0.0, thread.total_time, 0.05)
247
-
248
- methods = result.threads.first.methods.sort.reverse
249
- assert_equal(5, methods.length)
250
-
251
- # Check times
252
- method = methods[0]
253
- assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep', method.full_name)
254
- assert_in_delta(0.0, method.total_time, 0.05)
255
- assert_in_delta(0.0, method.wait_time, 0.05)
256
- assert_in_delta(0.0, method.self_time, 0.05)
257
- assert_in_delta(0.0, method.children_time, 0.05)
258
-
259
- method = methods[1]
260
- assert_equal('RubyProf::C1#sleep_wait', method.full_name)
261
- assert_in_delta(0.0, method.total_time, 0.05)
262
- assert_in_delta(0.0, method.wait_time, 0.05)
263
- assert_in_delta(0.0, method.self_time, 0.05)
264
- assert_in_delta(0.0, method.children_time, 0.05)
265
-
266
- method = methods[2]
267
- assert_equal('Kernel#sleep', method.full_name)
268
- assert_in_delta(0.0, method.total_time, 0.05)
269
- assert_in_delta(0.0, method.wait_time, 0.05)
270
- assert_in_delta(0.0, method.self_time, 0.05)
271
- assert_in_delta(0.0, method.children_time, 0.05)
272
-
273
- method = methods[3]
274
- assert_equal('Class#new', method.full_name)
275
- assert_in_delta(0.0, method.total_time, 0.05)
276
- assert_in_delta(0.0, method.wait_time, 0.05)
277
- assert_in_delta(0.0, method.self_time, 0.05)
278
- assert_in_delta(0.0, method.children_time, 0.05)
279
-
280
- method = methods[4]
281
- assert_equal('BasicObject#initialize', method.full_name)
282
- assert_in_delta(0.0, method.total_time, 0.05)
283
- assert_in_delta(0.0, method.wait_time, 0.05)
284
- assert_in_delta(0.0, method.self_time, 0.05)
285
- assert_in_delta(0.0, method.children_time, 0.05)
286
- end
534
+ def test_instance_methods_busy_threaded
535
+ result = RubyProf.profile do
536
+ background_thread = Thread.new do
537
+ RubyProf::C1.new.busy_wait
538
+ end
539
+ background_thread.join
540
+ end
541
+
542
+ assert_equal(2, result.threads.count)
543
+
544
+ thread = result.threads.first
545
+ assert_in_delta(0.2, thread.total_time, 0.05)
546
+
547
+ methods = result.threads.first.methods.sort.reverse
548
+ assert_equal(4, methods.length)
549
+
550
+ # Check times
551
+ method = methods[0]
552
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
553
+ assert_in_delta(0.2, method.total_time, 0.05)
554
+ assert_in_delta(0.0, method.wait_time, 0.05)
555
+ assert_in_delta(0.0, method.self_time, 0.05)
556
+ assert_in_delta(0.2, method.children_time, 0.05)
557
+
558
+ method = methods[1]
559
+ assert_equal('Thread#join', method.full_name)
560
+ assert_in_delta(0.2, method.total_time, 0.05)
561
+ assert_in_delta(0.2, method.wait_time, 0.05)
562
+ assert_in_delta(0.0, method.self_time, 0.05)
563
+ assert_in_delta(0.0, method.children_time, 0.05)
564
+
565
+ method = methods[2]
566
+ assert_equal('<Class::Thread>#new', method.full_name)
567
+ assert_in_delta(0.0, method.total_time, 0.05)
568
+ assert_in_delta(0.0, method.wait_time, 0.05)
569
+ assert_in_delta(0.0, method.self_time, 0.05)
570
+ assert_in_delta(0.0, method.children_time, 0.05)
571
+
572
+ method = methods[3]
573
+ assert_equal('Thread#initialize', method.full_name)
574
+ assert_in_delta(0.0, method.total_time, 0.05)
575
+ assert_in_delta(0.0, method.wait_time, 0.05)
576
+ assert_in_delta(0.0, method.self_time, 0.05)
577
+ assert_in_delta(0.0, method.children_time, 0.05)
578
+
579
+ thread = result.threads.last
580
+ assert_in_delta(0.2, thread.total_time, 0.05)
581
+
582
+ methods = result.threads.first.methods.sort.reverse
583
+ assert_equal(4, methods.length)
584
+
585
+ methods = result.threads.last.methods.sort.reverse
586
+ assert_equal(5, methods.length)
587
+
588
+ # Check times
589
+ method = methods[0]
590
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
591
+ assert_in_delta(0.2, method.total_time, 0.05)
592
+ assert_in_delta(0.0, method.wait_time, 0.05)
593
+ assert_in_delta(0.0, method.self_time, 0.05)
594
+ assert_in_delta(0.2, method.children_time, 0.05)
595
+
596
+ method = methods[1]
597
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
598
+ assert_in_delta(0.2, method.total_time, 0.05)
599
+ assert_in_delta(0.0, method.wait_time, 0.05)
600
+ assert_in_delta(0.1, method.self_time, 0.05)
601
+ assert_in_delta(0.1, method.children_time, 0.05)
602
+
603
+ method = methods[2]
604
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
605
+ assert_in_delta(0.1, method.total_time, 0.05)
606
+ assert_in_delta(0.0, method.wait_time, 0.05)
607
+ assert_in_delta(0.1, method.self_time, 0.05)
608
+ assert_in_delta(0.0, method.children_time, 0.05)
609
+
610
+ method = methods[3]
611
+ assert_equal('Class#new', method.full_name)
612
+ assert_in_delta(0.0, method.total_time, 0.05)
613
+ assert_in_delta(0.0, method.wait_time, 0.05)
614
+ assert_in_delta(0.0, method.self_time, 0.05)
615
+ assert_in_delta(0.0, method.children_time, 0.05)
616
+
617
+ method = methods[4]
618
+ assert_equal('BasicObject#initialize', method.full_name)
619
+ assert_in_delta(0.0, method.total_time, 0.05)
620
+ assert_in_delta(0.0, method.wait_time, 0.05)
621
+ assert_in_delta(0.0, method.self_time, 0.05)
622
+ assert_in_delta(0.0, method.children_time, 0.05)
623
+ end
287
624
 
288
- def test_instance_methods_sleep_block
289
- result = RubyProf.profile do
290
- 1.times { RubyProf::C1.new.sleep_wait }
291
- end
625
+ def test_module_methods_sleep
626
+ result = RubyProf.profile do
627
+ RubyProf::C2.sleep_wait
628
+ end
629
+
630
+ thread = result.threads.first
631
+ assert_in_delta(0.0, thread.total_time, 0.05)
632
+
633
+ methods = result.threads.first.methods.sort.reverse
634
+ assert_equal(3, methods.length)
635
+
636
+ # Check times
637
+ method = methods[0]
638
+ assert_equal('MeasureProcessTimeTest#test_module_methods_sleep', method.full_name)
639
+ assert_in_delta(0.0, method.total_time, 0.05)
640
+ assert_in_delta(0.0, method.wait_time, 0.05)
641
+ assert_in_delta(0.0, method.self_time, 0.05)
642
+ assert_in_delta(0.0, method.children_time, 0.05)
643
+
644
+ method = methods[1]
645
+ assert_equal('RubyProf::M1#sleep_wait', method.full_name)
646
+ assert_in_delta(0.0, method.total_time, 0.05)
647
+ assert_in_delta(0.0, method.wait_time, 0.05)
648
+ assert_in_delta(0.0, method.self_time, 0.05)
649
+ assert_in_delta(0.0, method.children_time, 0.05)
650
+
651
+ method = methods[2]
652
+ assert_equal('Kernel#sleep', method.full_name)
653
+ assert_in_delta(0.0, method.total_time, 0.05)
654
+ assert_in_delta(0.0, method.wait_time, 0.05)
655
+ assert_in_delta(0.0, method.self_time, 0.05)
656
+ assert_in_delta(0.0, method.children_time, 0.05)
657
+ end
292
658
 
293
- methods = result.threads.first.methods.sort.reverse
294
- assert_equal(6, methods.length)
295
-
296
- # Check times
297
- method = methods[0]
298
- assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep_block", method.full_name)
299
- assert_in_delta(0.0, method.total_time, 0.05)
300
- assert_in_delta(0.0, method.wait_time, 0.05)
301
- assert_in_delta(0.0, method.self_time, 0.05)
302
- assert_in_delta(0.0, method.children_time, 0.05)
303
-
304
- method = methods[1]
305
- assert_equal('Integer#times', method.full_name)
306
- assert_in_delta(0.0, method.total_time, 0.05)
307
- assert_in_delta(0.0, method.wait_time, 0.05)
308
- assert_in_delta(0.0, method.self_time, 0.05)
309
- assert_in_delta(0.0, method.children_time, 0.05)
310
-
311
- method = methods[2]
312
- assert_equal('RubyProf::C1#sleep_wait', method.full_name)
313
- assert_in_delta(0.0, method.total_time, 0.05)
314
- assert_in_delta(0.0, method.wait_time, 0.05)
315
- assert_in_delta(0.0, method.self_time, 0.05)
316
- assert_in_delta(0.0, method.children_time, 0.05)
317
-
318
- method = methods[3]
319
- assert_equal('Kernel#sleep', method.full_name)
320
- assert_in_delta(0.0, method.total_time, 0.05)
321
- assert_in_delta(0.0, method.wait_time, 0.05)
322
- assert_in_delta(0.0, method.self_time, 0.05)
323
- assert_in_delta(0.0, method.children_time, 0.05)
324
-
325
- method = methods[4]
326
- assert_equal('Class#new', method.full_name)
327
- assert_in_delta(0.0, method.total_time, 0.05)
328
- assert_in_delta(0.0, method.wait_time, 0.05)
329
- assert_in_delta(0.0, method.self_time, 0.05)
330
- assert_in_delta(0.0, method.children_time, 0.05)
331
-
332
- method = methods[5]
333
- assert_equal('BasicObject#initialize', method.full_name)
334
- assert_in_delta(0.0, method.total_time, 0.05)
335
- assert_in_delta(0.0, method.wait_time, 0.05)
336
- assert_in_delta(0.0, method.self_time, 0.05)
337
- assert_in_delta(0.0, method.children_time, 0.05)
338
- end
659
+ def test_module_methods_busy
660
+ result = RubyProf.profile do
661
+ RubyProf::C2.busy_wait
662
+ end
663
+
664
+ thread = result.threads.first
665
+ assert_in_delta(0.3, thread.total_time, 0.05)
666
+
667
+ methods = result.threads.first.methods.sort.reverse
668
+ assert_equal(3, methods.length)
669
+
670
+ # Check times
671
+ method = methods[0]
672
+ assert_equal('MeasureProcessTimeTest#test_module_methods_busy', method.full_name)
673
+ assert_in_delta(0.3, method.total_time, 0.05)
674
+ assert_in_delta(0.0, method.wait_time, 0.05)
675
+ assert_in_delta(0.0, method.self_time, 0.05)
676
+ assert_in_delta(0.3, method.children_time, 0.05)
677
+
678
+ method = methods[1]
679
+ assert_equal('RubyProf::M1#busy_wait', method.full_name)
680
+ assert_in_delta(0.3, method.total_time, 0.05)
681
+ assert_in_delta(0.0, method.wait_time, 0.05)
682
+ assert_in_delta(0.15, method.self_time, 0.05)
683
+ assert_in_delta(0.15, method.children_time, 0.05)
684
+
685
+ method = methods[2]
686
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
687
+ assert_in_delta(0.15, method.total_time, 0.05)
688
+ assert_in_delta(0.0, method.wait_time, 0.05)
689
+ assert_in_delta(0.15, method.self_time, 0.05)
690
+ assert_in_delta(0.0, method.children_time, 0.05)
691
+ end
339
692
 
340
- def test_instance_methods_sleep_threaded
341
- result = RubyProf.profile do
342
- background_thread = Thread.new do
343
- RubyProf::C1.new.sleep_wait
693
+ def test_module_instance_methods_sleep
694
+ result = RubyProf.profile do
695
+ RubyProf::C2.new.sleep_wait
696
+ end
697
+
698
+ thread = result.threads.first
699
+ assert_in_delta(0.0, thread.total_time, 0.05)
700
+
701
+ methods = result.threads.first.methods.sort.reverse
702
+ assert_equal(5, methods.length)
703
+
704
+ # Check times
705
+ method = methods[0]
706
+ assert_equal('MeasureProcessTimeTest#test_module_instance_methods_sleep', method.full_name)
707
+ assert_in_delta(0.0, method.total_time, 0.05)
708
+ assert_in_delta(0.0, method.wait_time, 0.05)
709
+ assert_in_delta(0.0, method.self_time, 0.05)
710
+ assert_in_delta(0.0, method.children_time, 0.05)
711
+
712
+ method = methods[1]
713
+ assert_equal('RubyProf::M1#sleep_wait', method.full_name)
714
+ assert_in_delta(0.0, method.total_time, 0.05)
715
+ assert_in_delta(0.0, method.wait_time, 0.05)
716
+ assert_in_delta(0.0, method.self_time, 0.05)
717
+ assert_in_delta(0.0, method.children_time, 0.05)
718
+
719
+ method = methods[2]
720
+ assert_equal('Kernel#sleep', method.full_name)
721
+ assert_in_delta(0.0, method.total_time, 0.05)
722
+ assert_in_delta(0.0, method.wait_time, 0.05)
723
+ assert_in_delta(0.0, method.self_time, 0.05)
724
+ assert_in_delta(0.0, method.children_time, 0.05)
725
+
726
+ method = methods[3]
727
+ assert_equal('Class#new', method.full_name)
728
+ assert_in_delta(0.0, method.total_time, 0.05)
729
+ assert_in_delta(0.0, method.wait_time, 0.05)
730
+ assert_in_delta(0.0, method.self_time, 0.05)
731
+ assert_in_delta(0.0, method.children_time, 0.05)
732
+
733
+ method = methods[4]
734
+ assert_equal('BasicObject#initialize', method.full_name)
735
+ assert_in_delta(0.0, method.total_time, 0.05)
736
+ assert_in_delta(0.0, method.wait_time, 0.05)
737
+ assert_in_delta(0.0, method.self_time, 0.05)
738
+ assert_in_delta(0.0, method.children_time, 0.05)
344
739
  end
345
- background_thread.join
346
- end
347
740
 
348
- assert_equal(2, result.threads.count)
349
-
350
- thread = result.threads.first
351
- assert_in_delta(0.0, thread.total_time, 0.05)
352
-
353
- methods = result.threads.first.methods.sort.reverse
354
- assert_equal(4, methods.length)
355
-
356
- # Check times
357
- method = methods[0]
358
- assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
359
- assert_in_delta(0.0, method.total_time, 0.05)
360
- assert_in_delta(0.0, method.wait_time, 0.05)
361
- assert_in_delta(0.0, method.self_time, 0.05)
362
- assert_in_delta(0.0, method.children_time, 0.05)
363
-
364
- method = methods[1]
365
- assert_equal('Thread#join', method.full_name)
366
- assert_in_delta(0.0, method.total_time, 0.05)
367
- assert_in_delta(0.0, method.wait_time, 0.05)
368
- assert_in_delta(0.0, method.self_time, 0.05)
369
- assert_in_delta(0.0, method.children_time, 0.05)
370
-
371
- method = methods[2]
372
- assert_equal('<Class::Thread>#new', method.full_name)
373
- assert_in_delta(0.0, method.total_time, 0.05)
374
- assert_in_delta(0.0, method.wait_time, 0.05)
375
- assert_in_delta(0.0, method.self_time, 0.05)
376
- assert_in_delta(0.0, method.children_time, 0.05)
377
-
378
- method = methods[3]
379
- assert_equal('Thread#initialize', method.full_name)
380
- assert_in_delta(0.0, method.total_time, 0.05)
381
- assert_in_delta(0.0, method.wait_time, 0.05)
382
- assert_in_delta(0.0, method.self_time, 0.05)
383
- assert_in_delta(0.0, method.children_time, 0.05)
384
-
385
- thread = result.threads.last
386
- assert_in_delta(0.0, thread.total_time, 0.05)
387
-
388
- methods = result.threads.first.methods.sort.reverse
389
- assert_equal(4, methods.length)
390
-
391
- methods = result.threads.last.methods.sort.reverse
392
- assert_equal(5, methods.length)
393
-
394
- # Check times
395
- method = methods[0]
396
- assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
397
- assert_in_delta(0.0, method.total_time, 0.05)
398
- assert_in_delta(0.0, method.wait_time, 0.05)
399
- assert_in_delta(0.0, method.self_time, 0.05)
400
- assert_in_delta(0.0, method.children_time, 0.05)
401
-
402
- method = methods[1]
403
- assert_equal('RubyProf::C1#sleep_wait', method.full_name)
404
- assert_in_delta(0.0, method.total_time, 0.05)
405
- assert_in_delta(0.0, method.wait_time, 0.05)
406
- assert_in_delta(0.0, method.self_time, 0.05)
407
- assert_in_delta(0.0, method.children_time, 0.05)
408
-
409
- method = methods[2]
410
- assert_equal('Kernel#sleep', method.full_name)
411
- assert_in_delta(0.0, method.total_time, 0.05)
412
- assert_in_delta(0.0, method.wait_time, 0.05)
413
- assert_in_delta(0.0, method.self_time, 0.05)
414
- assert_in_delta(0.0, method.children_time, 0.05)
415
-
416
- method = methods[3]
417
- assert_equal('Class#new', method.full_name)
418
- assert_in_delta(0.0, method.total_time, 0.05)
419
- assert_in_delta(0.0, method.wait_time, 0.05)
420
- assert_in_delta(0.0, method.self_time, 0.05)
421
- assert_in_delta(0.0, method.children_time, 0.05)
422
-
423
- method = methods[4]
424
- assert_equal('BasicObject#initialize', method.full_name)
425
- assert_in_delta(0.0, method.total_time, 0.05)
426
- assert_in_delta(0.0, method.wait_time, 0.05)
427
- assert_in_delta(0.0, method.self_time, 0.05)
428
- assert_in_delta(0.0, method.children_time, 0.05)
429
- end
741
+ def test_module_instance_methods_busy
742
+ result = RubyProf.profile do
743
+ RubyProf::C2.new.busy_wait
744
+ end
745
+
746
+ thread = result.threads.first
747
+ assert_in_delta(0.3, thread.total_time, 0.05)
748
+
749
+ methods = result.threads.first.methods.sort.reverse
750
+ assert_equal(5, methods.length)
751
+
752
+ # Check times
753
+ method = methods[0]
754
+ assert_equal('MeasureProcessTimeTest#test_module_instance_methods_busy', method.full_name)
755
+ assert_in_delta(0.3, method.total_time, 0.05)
756
+ assert_in_delta(0.0, method.wait_time, 0.05)
757
+ assert_in_delta(0.0, method.self_time, 0.05)
758
+ assert_in_delta(0.3, method.children_time, 0.05)
759
+
760
+ method = methods[1]
761
+ assert_equal('RubyProf::M1#busy_wait', method.full_name)
762
+ assert_in_delta(0.3, method.total_time, 0.05)
763
+ assert_in_delta(0.0, method.wait_time, 0.05)
764
+ assert_in_delta(0.15, method.self_time, 0.05)
765
+ assert_in_delta(0.15, method.children_time, 0.05)
766
+
767
+ method = methods[2]
768
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
769
+ assert_in_delta(0.15, method.total_time, 0.05)
770
+ assert_in_delta(0.0, method.wait_time, 0.05)
771
+ assert_in_delta(0.15, method.self_time, 0.05)
772
+ assert_in_delta(0.0, method.children_time, 0.05)
773
+
774
+ method = methods[3]
775
+ assert_equal('Class#new', method.full_name)
776
+ assert_in_delta(0.0, method.total_time, 0.05)
777
+ assert_in_delta(0.0, method.wait_time, 0.05)
778
+ assert_in_delta(0.0, method.self_time, 0.05)
779
+ assert_in_delta(0.0, method.children_time, 0.05)
780
+
781
+ method = methods[4]
782
+ assert_equal('BasicObject#initialize', method.full_name)
783
+ assert_in_delta(0.0, method.total_time, 0.05)
784
+ assert_in_delta(0.0, method.wait_time, 0.05)
785
+ assert_in_delta(0.0, method.self_time, 0.05)
786
+ assert_in_delta(0.0, method.children_time, 0.05)
787
+ end
788
+ else
789
+ def test_class_methods_sleep
790
+ result = RubyProf.profile do
791
+ RubyProf::C1.sleep_wait
792
+ end
793
+
794
+ thread = result.threads.first
795
+ assert_in_delta(0.0, thread.total_time, 0.05)
796
+
797
+ methods = result.threads.first.methods.sort.reverse
798
+ assert_equal(3, methods.length)
799
+
800
+ # Check times
801
+ method = methods[0]
802
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep', method.full_name)
803
+ assert_in_delta(0.0, method.total_time, 0.05)
804
+ assert_in_delta(0.0, method.wait_time, 0.05)
805
+ assert_in_delta(0.0, method.self_time, 0.05)
806
+ assert_in_delta(0.0, method.children_time, 0.05)
807
+
808
+ method = methods[1]
809
+ assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
810
+ assert_in_delta(0.0, method.total_time, 0.05)
811
+ assert_in_delta(0.0, method.wait_time, 0.05)
812
+ assert_in_delta(0.0, method.self_time, 0.05)
813
+ assert_in_delta(0.0, method.children_time, 0.05)
814
+
815
+ method = methods[2]
816
+ assert_equal('Kernel#sleep', method.full_name)
817
+ assert_in_delta(0.0, method.total_time, 0.05)
818
+ assert_in_delta(0.0, method.wait_time, 0.05)
819
+ assert_in_delta(0.0, method.self_time, 0.05)
820
+ assert_in_delta(0.0, method.children_time, 0.05)
821
+ end
430
822
 
431
- def test_instance_methods_busy
432
- result = RubyProf.profile do
433
- RubyProf::C1.new.busy_wait
434
- end
823
+ def test_class_methods_sleep_threaded
824
+ result = RubyProf.profile do
825
+ background_thread = Thread.new do
826
+ RubyProf::C1.sleep_wait
827
+ end
828
+ background_thread.join
829
+ end
830
+
831
+ assert_equal(2, result.threads.count)
832
+
833
+ thread = result.threads.first
834
+ assert_in_delta(0.0, thread.total_time, 0.05)
835
+
836
+ methods = result.threads.first.methods.sort.reverse
837
+ assert_equal(4, methods.length)
838
+
839
+ # Check times
840
+ method = methods[0]
841
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
842
+ assert_in_delta(0.0, method.total_time, 0.05)
843
+ assert_in_delta(0.0, method.wait_time, 0.05)
844
+ assert_in_delta(0.0, method.self_time, 0.05)
845
+ assert_in_delta(0.0, method.children_time, 0.05)
846
+
847
+ method = methods[1]
848
+ assert_equal('Thread#join', method.full_name)
849
+ assert_in_delta(0.0, method.total_time, 0.05)
850
+ assert_in_delta(0.0, method.wait_time, 0.05)
851
+ assert_in_delta(0.0, method.self_time, 0.05)
852
+ assert_in_delta(0.0, method.children_time, 0.05)
853
+
854
+ method = methods[2]
855
+ assert_equal('<Class::Thread>#new', method.full_name)
856
+ assert_in_delta(0.0, method.total_time, 0.05)
857
+ assert_in_delta(0.0, method.wait_time, 0.05)
858
+ assert_in_delta(0.0, method.self_time, 0.05)
859
+ assert_in_delta(0.0, method.children_time, 0.05)
860
+
861
+ method = methods[3]
862
+ assert_equal('Thread#initialize', method.full_name)
863
+ assert_in_delta(0.0, method.total_time, 0.05)
864
+ assert_in_delta(0.0, method.wait_time, 0.05)
865
+ assert_in_delta(0.0, method.self_time, 0.05)
866
+ assert_in_delta(0.0, method.children_time, 0.05)
867
+
868
+ thread = result.threads.last
869
+ assert_in_delta(0.0, thread.total_time, 0.05)
870
+
871
+ methods = result.threads.first.methods.sort.reverse
872
+ assert_equal(4, methods.length)
873
+
874
+ methods = result.threads.last.methods.sort.reverse
875
+ assert_equal(3, methods.length)
876
+
877
+ # Check times
878
+ method = methods[0]
879
+ assert_equal('MeasureProcessTimeTest#test_class_methods_sleep_threaded', method.full_name)
880
+ assert_in_delta(0.0, method.total_time, 0.05)
881
+ assert_in_delta(0.0, method.wait_time, 0.05)
882
+ assert_in_delta(0.0, method.self_time, 0.05)
883
+ assert_in_delta(0.0, method.children_time, 0.05)
884
+
885
+ method = methods[1]
886
+ assert_equal('<Class::RubyProf::C1>#sleep_wait', method.full_name)
887
+ assert_in_delta(0.0, method.total_time, 0.05)
888
+ assert_in_delta(0.0, method.wait_time, 0.05)
889
+ assert_in_delta(0.0, method.self_time, 0.05)
890
+ assert_in_delta(0.0, method.children_time, 0.05)
891
+
892
+ method = methods[2]
893
+ assert_equal('Kernel#sleep', method.full_name)
894
+ assert_in_delta(0.0, method.total_time, 0.05)
895
+ assert_in_delta(0.0, method.wait_time, 0.05)
896
+ assert_in_delta(0.0, method.self_time, 0.05)
897
+ assert_in_delta(0.0, method.children_time, 0.05)
898
+ end
435
899
 
436
- thread = result.threads.first
437
- assert_in_delta(0.2, thread.total_time, 0.05)
438
-
439
- methods = result.threads.first.methods.sort.reverse
440
- assert_equal(5, methods.length)
441
-
442
- # Check times
443
- method = methods[0]
444
- assert_equal('MeasureProcessTimeTest#test_instance_methods_busy', method.full_name)
445
- assert_in_delta(0.2, method.total_time, 0.05)
446
- assert_in_delta(0.0, method.wait_time, 0.05)
447
- assert_in_delta(0.0, method.self_time, 0.05)
448
- assert_in_delta(0.2, method.children_time, 0.05)
449
-
450
- method = methods[1]
451
- assert_equal('RubyProf::C1#busy_wait', method.full_name)
452
- assert_in_delta(0.2, method.total_time, 0.05)
453
- assert_in_delta(0.0, method.wait_time, 0.05)
454
- assert_in_delta(0.09, method.self_time, 0.05)
455
- assert_in_delta(0.11, method.children_time, 0.05)
456
-
457
- method = methods[2]
458
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
459
- assert_in_delta(0.11, method.total_time, 0.05)
460
- assert_in_delta(0.0, method.wait_time, 0.05)
461
- assert_in_delta(0.11, method.self_time, 0.05)
462
- assert_in_delta(0.0, method.children_time, 0.05)
463
-
464
- method = methods[3]
465
- assert_equal('Class#new', method.full_name)
466
- assert_in_delta(0.0, method.total_time, 0.05)
467
- assert_in_delta(0.0, method.wait_time, 0.05)
468
- assert_in_delta(0.0, method.self_time, 0.05)
469
- assert_in_delta(0.0, method.children_time, 0.05)
470
-
471
- method = methods[4]
472
- assert_equal('BasicObject#initialize', method.full_name)
473
- assert_in_delta(0.0, method.total_time, 0.05)
474
- assert_in_delta(0.0, method.wait_time, 0.05)
475
- assert_in_delta(0.0, method.self_time, 0.05)
476
- assert_in_delta(0.0, method.children_time, 0.05)
477
- end
900
+ def test_class_methods_busy
901
+ result = RubyProf.profile do
902
+ RubyProf::C1.busy_wait
903
+ end
904
+
905
+ thread = result.threads.first
906
+ assert_in_delta(0.08, thread.total_time, 0.05)
907
+
908
+ methods = result.threads.first.methods.sort.reverse
909
+ assert_equal(5, methods.length)
910
+
911
+ # Check times
912
+ method = methods[0]
913
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy', method.full_name)
914
+ assert_in_delta(0.1, method.total_time, 0.05)
915
+ assert_in_delta(0.0, method.wait_time, 0.05)
916
+ assert_in_delta(0.0, method.self_time, 0.05)
917
+ assert_in_delta(0.1, method.children_time, 0.05)
918
+
919
+ method = methods[1]
920
+ assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
921
+ assert_in_delta(0.1, method.total_time, 0.05)
922
+ assert_in_delta(0.0, method.wait_time, 0.05)
923
+ assert_in_delta(0.06, method.self_time, 0.05)
924
+ assert_in_delta(0.07, method.children_time, 0.05)
925
+
926
+ method = methods[2]
927
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
928
+ assert_in_delta(0.05, method.total_time, 0.05)
929
+ assert_in_delta(0.0, method.wait_time, 0.05)
930
+ assert_in_delta(0.05, method.self_time, 0.05)
931
+ assert_in_delta(0.0, method.children_time, 0.05)
932
+ end
478
933
 
479
- def test_instance_methods_busy_block
480
- result = RubyProf.profile do
481
- 1.times { RubyProf::C1.new.busy_wait }
482
- end
934
+ def test_class_methods_busy_threaded
935
+ result = RubyProf.profile do
936
+ background_thread = Thread.new do
937
+ RubyProf::C1.busy_wait
938
+ end
939
+ background_thread.join
940
+ end
941
+
942
+ assert_equal(2, result.threads.count)
943
+
944
+ thread = result.threads.first
945
+ assert_in_delta(0.1, thread.total_time, 0.05)
946
+
947
+ methods = result.threads.first.methods.sort.reverse
948
+ assert_equal(4, methods.length)
949
+
950
+ # Check times
951
+ method = methods[0]
952
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
953
+ assert_in_delta(0.1, method.total_time, 0.05)
954
+ assert_in_delta(0.0, method.wait_time, 0.05)
955
+ assert_in_delta(0.0, method.self_time, 0.05)
956
+ assert_in_delta(0.1, method.children_time, 0.05)
957
+
958
+ method = methods[1]
959
+ assert_equal('Thread#join', method.full_name)
960
+ assert_in_delta(0.1, method.total_time, 0.05)
961
+ assert_in_delta(0.1, method.wait_time, 0.05)
962
+ assert_in_delta(0.0, method.self_time, 0.05)
963
+ assert_in_delta(0.0, method.children_time, 0.05)
964
+
965
+ method = methods[2]
966
+ assert_equal('<Class::Thread>#new', method.full_name)
967
+ assert_in_delta(0.0, method.total_time, 0.05)
968
+ assert_in_delta(0.0, method.wait_time, 0.05)
969
+ assert_in_delta(0.0, method.self_time, 0.05)
970
+ assert_in_delta(0.0, method.children_time, 0.05)
971
+
972
+ method = methods[3]
973
+ assert_equal('Thread#initialize', method.full_name)
974
+ assert_in_delta(0.0, method.total_time, 0.05)
975
+ assert_in_delta(0.0, method.wait_time, 0.05)
976
+ assert_in_delta(0.0, method.self_time, 0.05)
977
+ assert_in_delta(0.0, method.children_time, 0.05)
978
+
979
+ thread = result.threads.last
980
+ assert_in_delta(0.1, thread.total_time, 0.05)
981
+
982
+ methods = result.threads.first.methods.sort.reverse
983
+ assert_equal(4, methods.length)
984
+
985
+ methods = result.threads.last.methods.sort.reverse
986
+ assert_equal(5, methods.length)
987
+
988
+ # Check times
989
+ method = methods[0]
990
+ assert_equal('MeasureProcessTimeTest#test_class_methods_busy_threaded', method.full_name)
991
+ assert_in_delta(0.1, method.total_time, 0.05)
992
+ assert_in_delta(0.0, method.wait_time, 0.05)
993
+ assert_in_delta(0.0, method.self_time, 0.05)
994
+ assert_in_delta(0.1, method.children_time, 0.05)
995
+
996
+ method = methods[1]
997
+ assert_equal('<Class::RubyProf::C1>#busy_wait', method.full_name)
998
+ assert_in_delta(0.1, method.total_time, 0.05)
999
+ assert_in_delta(0.0, method.wait_time, 0.05)
1000
+ assert_in_delta(0.05, method.self_time, 0.05)
1001
+ assert_in_delta(0.05, method.children_time, 0.05)
1002
+
1003
+ method = methods[2]
1004
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1005
+ assert_in_delta(0.05, method.total_time, 0.05)
1006
+ assert_in_delta(0.0, method.wait_time, 0.05)
1007
+ assert_in_delta(0.05, method.self_time, 0.05)
1008
+ assert_in_delta(0.0, method.children_time, 0.05)
1009
+ end
483
1010
 
484
- methods = result.threads.first.methods.sort.reverse
485
- assert_equal(6, methods.length)
486
-
487
- # Check times
488
- method = methods[0]
489
- assert_equal("MeasureProcessTimeTest#test_instance_methods_busy_block", method.full_name)
490
- assert_in_delta(0.2, method.total_time, 0.05)
491
- assert_in_delta(0.0, method.wait_time, 0.05)
492
- assert_in_delta(0.0, method.self_time, 0.05)
493
- assert_in_delta(0.2, method.children_time, 0.05)
494
-
495
- method = methods[1]
496
- assert_equal('Integer#times', method.full_name)
497
- assert_in_delta(0.2, method.total_time, 0.05)
498
- assert_in_delta(0.0, method.wait_time, 0.05)
499
- assert_in_delta(0.0, method.self_time, 0.05)
500
- assert_in_delta(0.2, method.children_time, 0.05)
501
-
502
- method = methods[2]
503
- assert_equal('RubyProf::C1#busy_wait', method.full_name)
504
- assert_in_delta(0.2, method.total_time, 0.05)
505
- assert_in_delta(0.0, method.wait_time, 0.05)
506
- assert_in_delta(0.09, method.self_time, 0.05)
507
- assert_in_delta(0.11, method.children_time, 0.05)
508
-
509
- method = methods[3]
510
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
511
- assert_in_delta(0.11, method.total_time, 0.05)
512
- assert_in_delta(0.0, method.wait_time, 0.05)
513
- assert_in_delta(0.11, method.self_time, 0.05)
514
- assert_in_delta(0.0, method.children_time, 0.05)
515
-
516
- method = methods[4]
517
- assert_equal('Class#new', method.full_name)
518
- assert_in_delta(0.0, method.total_time, 0.05)
519
- assert_in_delta(0.0, method.wait_time, 0.05)
520
- assert_in_delta(0.0, method.self_time, 0.05)
521
- assert_in_delta(0.0, method.children_time, 0.05)
522
-
523
- method = methods[5]
524
- assert_equal('BasicObject#initialize', method.full_name)
525
- assert_in_delta(0.0, method.total_time, 0.05)
526
- assert_in_delta(0.0, method.wait_time, 0.05)
527
- assert_in_delta(0.0, method.self_time, 0.05)
528
- assert_in_delta(0.0, method.children_time, 0.05)
529
- end
1011
+ def test_instance_methods_sleep
1012
+ result = RubyProf.profile do
1013
+ RubyProf::C1.new.sleep_wait
1014
+ end
1015
+
1016
+ thread = result.threads.first
1017
+ assert_in_delta(0.0, thread.total_time, 0.05)
1018
+
1019
+ methods = result.threads.first.methods.sort.reverse
1020
+ assert_equal(5, methods.length)
1021
+
1022
+ # Check times
1023
+ method = methods[0]
1024
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep', method.full_name)
1025
+ assert_in_delta(0.0, method.total_time, 0.05)
1026
+ assert_in_delta(0.0, method.wait_time, 0.05)
1027
+ assert_in_delta(0.0, method.self_time, 0.05)
1028
+ assert_in_delta(0.0, method.children_time, 0.05)
1029
+
1030
+ method = methods[1]
1031
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
1032
+ assert_in_delta(0.0, method.total_time, 0.05)
1033
+ assert_in_delta(0.0, method.wait_time, 0.05)
1034
+ assert_in_delta(0.0, method.self_time, 0.05)
1035
+ assert_in_delta(0.0, method.children_time, 0.05)
1036
+
1037
+ method = methods[2]
1038
+ assert_equal('Kernel#sleep', method.full_name)
1039
+ assert_in_delta(0.0, method.total_time, 0.05)
1040
+ assert_in_delta(0.0, method.wait_time, 0.05)
1041
+ assert_in_delta(0.0, method.self_time, 0.05)
1042
+ assert_in_delta(0.0, method.children_time, 0.05)
1043
+
1044
+ method = methods[3]
1045
+ assert_equal('Class#new', method.full_name)
1046
+ assert_in_delta(0.0, method.total_time, 0.05)
1047
+ assert_in_delta(0.0, method.wait_time, 0.05)
1048
+ assert_in_delta(0.0, method.self_time, 0.05)
1049
+ assert_in_delta(0.0, method.children_time, 0.05)
1050
+
1051
+ method = methods[4]
1052
+ assert_equal('BasicObject#initialize', method.full_name)
1053
+ assert_in_delta(0.0, method.total_time, 0.05)
1054
+ assert_in_delta(0.0, method.wait_time, 0.05)
1055
+ assert_in_delta(0.0, method.self_time, 0.05)
1056
+ assert_in_delta(0.0, method.children_time, 0.05)
1057
+ end
530
1058
 
531
- def test_instance_methods_busy_threaded
532
- result = RubyProf.profile do
533
- background_thread = Thread.new do
534
- RubyProf::C1.new.busy_wait
1059
+ def test_instance_methods_sleep_block
1060
+ result = RubyProf.profile do
1061
+ 1.times { RubyProf::C1.new.sleep_wait }
1062
+ end
1063
+
1064
+ methods = result.threads.first.methods.sort.reverse
1065
+ assert_equal(6, methods.length)
1066
+
1067
+ # Check times
1068
+ method = methods[0]
1069
+ assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep_block", method.full_name)
1070
+ assert_in_delta(0.0, method.total_time, 0.05)
1071
+ assert_in_delta(0.0, method.wait_time, 0.05)
1072
+ assert_in_delta(0.0, method.self_time, 0.05)
1073
+ assert_in_delta(0.0, method.children_time, 0.05)
1074
+
1075
+ method = methods[1]
1076
+ assert_equal('Integer#times', method.full_name)
1077
+ assert_in_delta(0.0, method.total_time, 0.05)
1078
+ assert_in_delta(0.0, method.wait_time, 0.05)
1079
+ assert_in_delta(0.0, method.self_time, 0.05)
1080
+ assert_in_delta(0.0, method.children_time, 0.05)
1081
+
1082
+ method = methods[2]
1083
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
1084
+ assert_in_delta(0.0, method.total_time, 0.05)
1085
+ assert_in_delta(0.0, method.wait_time, 0.05)
1086
+ assert_in_delta(0.0, method.self_time, 0.05)
1087
+ assert_in_delta(0.0, method.children_time, 0.05)
1088
+
1089
+ method = methods[3]
1090
+ assert_equal('Kernel#sleep', method.full_name)
1091
+ assert_in_delta(0.0, method.total_time, 0.05)
1092
+ assert_in_delta(0.0, method.wait_time, 0.05)
1093
+ assert_in_delta(0.0, method.self_time, 0.05)
1094
+ assert_in_delta(0.0, method.children_time, 0.05)
1095
+
1096
+ method = methods[4]
1097
+ assert_equal('Class#new', method.full_name)
1098
+ assert_in_delta(0.0, method.total_time, 0.05)
1099
+ assert_in_delta(0.0, method.wait_time, 0.05)
1100
+ assert_in_delta(0.0, method.self_time, 0.05)
1101
+ assert_in_delta(0.0, method.children_time, 0.05)
1102
+
1103
+ method = methods[5]
1104
+ assert_equal('BasicObject#initialize', method.full_name)
1105
+ assert_in_delta(0.0, method.total_time, 0.05)
1106
+ assert_in_delta(0.0, method.wait_time, 0.05)
1107
+ assert_in_delta(0.0, method.self_time, 0.05)
1108
+ assert_in_delta(0.0, method.children_time, 0.05)
535
1109
  end
536
- background_thread.join
537
- end
538
1110
 
539
- assert_equal(2, result.threads.count)
540
-
541
- thread = result.threads.first
542
- assert_in_delta(0.2, thread.total_time, 0.05)
543
-
544
- methods = result.threads.first.methods.sort.reverse
545
- assert_equal(4, methods.length)
546
-
547
- # Check times
548
- method = methods[0]
549
- assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
550
- assert_in_delta(0.2, method.total_time, 0.05)
551
- assert_in_delta(0.0, method.wait_time, 0.05)
552
- assert_in_delta(0.0, method.self_time, 0.05)
553
- assert_in_delta(0.2, method.children_time, 0.05)
554
-
555
- method = methods[1]
556
- assert_equal('Thread#join', method.full_name)
557
- assert_in_delta(0.2, method.total_time, 0.05)
558
- assert_in_delta(0.2, method.wait_time, 0.05)
559
- assert_in_delta(0.0, method.self_time, 0.05)
560
- assert_in_delta(0.0, method.children_time, 0.05)
561
-
562
- method = methods[2]
563
- assert_equal('<Class::Thread>#new', method.full_name)
564
- assert_in_delta(0.0, method.total_time, 0.05)
565
- assert_in_delta(0.0, method.wait_time, 0.05)
566
- assert_in_delta(0.0, method.self_time, 0.05)
567
- assert_in_delta(0.0, method.children_time, 0.05)
568
-
569
- method = methods[3]
570
- assert_equal('Thread#initialize', method.full_name)
571
- assert_in_delta(0.0, method.total_time, 0.05)
572
- assert_in_delta(0.0, method.wait_time, 0.05)
573
- assert_in_delta(0.0, method.self_time, 0.05)
574
- assert_in_delta(0.0, method.children_time, 0.05)
575
-
576
- thread = result.threads.last
577
- assert_in_delta(0.2, thread.total_time, 0.05)
578
-
579
- methods = result.threads.first.methods.sort.reverse
580
- assert_equal(4, methods.length)
581
-
582
- methods = result.threads.last.methods.sort.reverse
583
- assert_equal(5, methods.length)
584
-
585
- # Check times
586
- method = methods[0]
587
- assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
588
- assert_in_delta(0.2, method.total_time, 0.05)
589
- assert_in_delta(0.0, method.wait_time, 0.05)
590
- assert_in_delta(0.0, method.self_time, 0.05)
591
- assert_in_delta(0.2, method.children_time, 0.05)
592
-
593
- method = methods[1]
594
- assert_equal('RubyProf::C1#busy_wait', method.full_name)
595
- assert_in_delta(0.2, method.total_time, 0.05)
596
- assert_in_delta(0.0, method.wait_time, 0.05)
597
- assert_in_delta(0.1, method.self_time, 0.05)
598
- assert_in_delta(0.1, method.children_time, 0.05)
599
-
600
- method = methods[2]
601
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
602
- assert_in_delta(0.1, method.total_time, 0.05)
603
- assert_in_delta(0.0, method.wait_time, 0.05)
604
- assert_in_delta(0.1, method.self_time, 0.05)
605
- assert_in_delta(0.0, method.children_time, 0.05)
606
-
607
- method = methods[3]
608
- assert_equal('Class#new', method.full_name)
609
- assert_in_delta(0.0, method.total_time, 0.05)
610
- assert_in_delta(0.0, method.wait_time, 0.05)
611
- assert_in_delta(0.0, method.self_time, 0.05)
612
- assert_in_delta(0.0, method.children_time, 0.05)
613
-
614
- method = methods[4]
615
- assert_equal('BasicObject#initialize', method.full_name)
616
- assert_in_delta(0.0, method.total_time, 0.05)
617
- assert_in_delta(0.0, method.wait_time, 0.05)
618
- assert_in_delta(0.0, method.self_time, 0.05)
619
- assert_in_delta(0.0, method.children_time, 0.05)
620
- end
1111
+ def test_instance_methods_sleep_threaded
1112
+ result = RubyProf.profile do
1113
+ background_thread = Thread.new do
1114
+ RubyProf::C1.new.sleep_wait
1115
+ end
1116
+ background_thread.join
1117
+ end
1118
+
1119
+ assert_equal(2, result.threads.count)
1120
+
1121
+ thread = result.threads.first
1122
+ assert_in_delta(0.0, thread.total_time, 0.05)
1123
+
1124
+ methods = result.threads.first.methods.sort.reverse
1125
+ assert_equal(4, methods.length)
1126
+
1127
+ # Check times
1128
+ method = methods[0]
1129
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
1130
+ assert_in_delta(0.0, method.total_time, 0.05)
1131
+ assert_in_delta(0.0, method.wait_time, 0.05)
1132
+ assert_in_delta(0.0, method.self_time, 0.05)
1133
+ assert_in_delta(0.0, method.children_time, 0.05)
1134
+
1135
+ method = methods[1]
1136
+ assert_equal('Thread#join', method.full_name)
1137
+ assert_in_delta(0.0, method.total_time, 0.05)
1138
+ assert_in_delta(0.0, method.wait_time, 0.05)
1139
+ assert_in_delta(0.0, method.self_time, 0.05)
1140
+ assert_in_delta(0.0, method.children_time, 0.05)
1141
+
1142
+ method = methods[2]
1143
+ assert_equal('<Class::Thread>#new', method.full_name)
1144
+ assert_in_delta(0.0, method.total_time, 0.05)
1145
+ assert_in_delta(0.0, method.wait_time, 0.05)
1146
+ assert_in_delta(0.0, method.self_time, 0.05)
1147
+ assert_in_delta(0.0, method.children_time, 0.05)
1148
+
1149
+ method = methods[3]
1150
+ assert_equal('Thread#initialize', method.full_name)
1151
+ assert_in_delta(0.0, method.total_time, 0.05)
1152
+ assert_in_delta(0.0, method.wait_time, 0.05)
1153
+ assert_in_delta(0.0, method.self_time, 0.05)
1154
+ assert_in_delta(0.0, method.children_time, 0.05)
1155
+
1156
+ thread = result.threads.last
1157
+ assert_in_delta(0.0, thread.total_time, 0.05)
1158
+
1159
+ methods = result.threads.first.methods.sort.reverse
1160
+ assert_equal(4, methods.length)
1161
+
1162
+ methods = result.threads.last.methods.sort.reverse
1163
+ assert_equal(5, methods.length)
1164
+
1165
+ # Check times
1166
+ method = methods[0]
1167
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_sleep_threaded', method.full_name)
1168
+ assert_in_delta(0.0, method.total_time, 0.05)
1169
+ assert_in_delta(0.0, method.wait_time, 0.05)
1170
+ assert_in_delta(0.0, method.self_time, 0.05)
1171
+ assert_in_delta(0.0, method.children_time, 0.05)
1172
+
1173
+ method = methods[1]
1174
+ assert_equal('RubyProf::C1#sleep_wait', method.full_name)
1175
+ assert_in_delta(0.0, method.total_time, 0.05)
1176
+ assert_in_delta(0.0, method.wait_time, 0.05)
1177
+ assert_in_delta(0.0, method.self_time, 0.05)
1178
+ assert_in_delta(0.0, method.children_time, 0.05)
1179
+
1180
+ method = methods[2]
1181
+ assert_equal('Kernel#sleep', method.full_name)
1182
+ assert_in_delta(0.0, method.total_time, 0.05)
1183
+ assert_in_delta(0.0, method.wait_time, 0.05)
1184
+ assert_in_delta(0.0, method.self_time, 0.05)
1185
+ assert_in_delta(0.0, method.children_time, 0.05)
1186
+
1187
+ method = methods[3]
1188
+ assert_equal('Class#new', method.full_name)
1189
+ assert_in_delta(0.0, method.total_time, 0.05)
1190
+ assert_in_delta(0.0, method.wait_time, 0.05)
1191
+ assert_in_delta(0.0, method.self_time, 0.05)
1192
+ assert_in_delta(0.0, method.children_time, 0.05)
1193
+
1194
+ method = methods[4]
1195
+ assert_equal('BasicObject#initialize', method.full_name)
1196
+ assert_in_delta(0.0, method.total_time, 0.05)
1197
+ assert_in_delta(0.0, method.wait_time, 0.05)
1198
+ assert_in_delta(0.0, method.self_time, 0.05)
1199
+ assert_in_delta(0.0, method.children_time, 0.05)
1200
+ end
621
1201
 
622
- def test_module_methods_sleep
623
- result = RubyProf.profile do
624
- RubyProf::C2.sleep_wait
625
- end
1202
+ def test_instance_methods_busy
1203
+ result = RubyProf.profile do
1204
+ RubyProf::C1.new.busy_wait
1205
+ end
1206
+
1207
+ thread = result.threads.first
1208
+ assert_in_delta(0.2, thread.total_time, 0.05)
1209
+
1210
+ methods = result.threads.first.methods.sort.reverse
1211
+ assert_equal(7, methods.length)
1212
+
1213
+ # Check times
1214
+ method = methods[0]
1215
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy', method.full_name)
1216
+ assert_in_delta(0.2, method.total_time, 0.05)
1217
+ assert_in_delta(0.0, method.wait_time, 0.05)
1218
+ assert_in_delta(0.0, method.self_time, 0.05)
1219
+ assert_in_delta(0.2, method.children_time, 0.05)
1220
+
1221
+ method = methods[1]
1222
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
1223
+ assert_in_delta(0.2, method.total_time, 0.05)
1224
+ assert_in_delta(0.0, method.wait_time, 0.05)
1225
+ assert_in_delta(0.09, method.self_time, 0.05)
1226
+ assert_in_delta(0.11, method.children_time, 0.05)
1227
+
1228
+ method = methods[2]
1229
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1230
+ assert_in_delta(0.033, method.total_time, 0.05)
1231
+ assert_in_delta(0.0, method.wait_time, 0.05)
1232
+ assert_in_delta(0.033, method.self_time, 0.05)
1233
+ assert_in_delta(0.0, method.children_time, 0.05)
1234
+
1235
+ method = methods[3]
1236
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1237
+ assert_in_delta(0.0, method.total_time, 0.05)
1238
+ assert_in_delta(0.0, method.wait_time, 0.05)
1239
+ assert_in_delta(0.0, method.self_time, 0.05)
1240
+ assert_in_delta(0.0, method.children_time, 0.05)
1241
+
1242
+ method = methods[4]
1243
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1244
+ assert_in_delta(0.0, method.total_time, 0.05)
1245
+ assert_in_delta(0.0, method.wait_time, 0.05)
1246
+ assert_in_delta(0.0, method.self_time, 0.05)
1247
+ assert_in_delta(0.0, method.children_time, 0.05)
1248
+
1249
+ method = methods[5]
1250
+ assert_equal('Class#new', method.full_name)
1251
+ assert_in_delta(0.0, method.total_time, 0.05)
1252
+ assert_in_delta(0.0, method.wait_time, 0.05)
1253
+ assert_in_delta(0.0, method.self_time, 0.05)
1254
+ assert_in_delta(0.0, method.children_time, 0.05)
1255
+
1256
+ method = methods[6]
1257
+ assert_equal('BasicObject#initialize', method.full_name)
1258
+ assert_in_delta(0.0, method.total_time, 0.05)
1259
+ assert_in_delta(0.0, method.wait_time, 0.05)
1260
+ assert_in_delta(0.0, method.self_time, 0.05)
1261
+ assert_in_delta(0.0, method.children_time, 0.05)
1262
+ end
626
1263
 
627
- thread = result.threads.first
628
- assert_in_delta(0.0, thread.total_time, 0.05)
629
-
630
- methods = result.threads.first.methods.sort.reverse
631
- assert_equal(3, methods.length)
632
-
633
- # Check times
634
- method = methods[0]
635
- assert_equal('MeasureProcessTimeTest#test_module_methods_sleep', method.full_name)
636
- assert_in_delta(0.0, method.total_time, 0.05)
637
- assert_in_delta(0.0, method.wait_time, 0.05)
638
- assert_in_delta(0.0, method.self_time, 0.05)
639
- assert_in_delta(0.0, method.children_time, 0.05)
640
-
641
- method = methods[1]
642
- assert_equal('RubyProf::M1#sleep_wait', method.full_name)
643
- assert_in_delta(0.0, method.total_time, 0.05)
644
- assert_in_delta(0.0, method.wait_time, 0.05)
645
- assert_in_delta(0.0, method.self_time, 0.05)
646
- assert_in_delta(0.0, method.children_time, 0.05)
647
-
648
- method = methods[2]
649
- assert_equal('Kernel#sleep', method.full_name)
650
- assert_in_delta(0.0, method.total_time, 0.05)
651
- assert_in_delta(0.0, method.wait_time, 0.05)
652
- assert_in_delta(0.0, method.self_time, 0.05)
653
- assert_in_delta(0.0, method.children_time, 0.05)
654
- end
1264
+ def test_instance_methods_busy_block
1265
+ result = RubyProf.profile do
1266
+ 1.times { RubyProf::C1.new.busy_wait }
1267
+ end
1268
+
1269
+ methods = result.threads.first.methods.sort.reverse
1270
+ assert_equal(8, methods.length)
1271
+
1272
+ # Check times
1273
+ method = methods[0]
1274
+ assert_equal("MeasureProcessTimeTest#test_instance_methods_busy_block", method.full_name)
1275
+ assert_in_delta(0.2, method.total_time, 0.05)
1276
+ assert_in_delta(0.0, method.wait_time, 0.05)
1277
+ assert_in_delta(0.0, method.self_time, 0.05)
1278
+ assert_in_delta(0.2, method.children_time, 0.05)
1279
+
1280
+ method = methods[1]
1281
+ assert_equal('Integer#times', method.full_name)
1282
+ assert_in_delta(0.2, method.total_time, 0.05)
1283
+ assert_in_delta(0.0, method.wait_time, 0.05)
1284
+ assert_in_delta(0.0, method.self_time, 0.05)
1285
+ assert_in_delta(0.2, method.children_time, 0.05)
1286
+
1287
+ method = methods[2]
1288
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
1289
+ assert_in_delta(0.2, method.total_time, 0.05)
1290
+ assert_in_delta(0.0, method.wait_time, 0.05)
1291
+ assert_in_delta(0.09, method.self_time, 0.05)
1292
+ assert_in_delta(0.11, method.children_time, 0.05)
1293
+
1294
+ method = methods[3]
1295
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1296
+ assert_in_delta(0.033, method.total_time, 0.05)
1297
+ assert_in_delta(0.0, method.wait_time, 0.05)
1298
+ assert_in_delta(0.033, method.self_time, 0.05)
1299
+ assert_in_delta(0.0, method.children_time, 0.05)
1300
+
1301
+ method = methods[4]
1302
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1303
+ assert_in_delta(0.03, method.total_time, 0.03)
1304
+ assert_in_delta(0.03, method.wait_time, 0.03)
1305
+ assert_in_delta(0.03, method.self_time, 0.03)
1306
+ assert_in_delta(0.03, method.children_time, 0.03)
1307
+
1308
+ method = methods[5]
1309
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1310
+ assert_in_delta(0.03, method.total_time, 0.03)
1311
+ assert_in_delta(0.03, method.wait_time, 0.03)
1312
+ assert_in_delta(0.03, method.self_time, 0.03)
1313
+ assert_in_delta(0.03, method.children_time, 0.03)
1314
+
1315
+ method = methods[6]
1316
+ assert_equal('Class#new', method.full_name)
1317
+ assert_in_delta(0.0, method.total_time, 0.01)
1318
+ assert_in_delta(0.0, method.wait_time, 0.01)
1319
+ assert_in_delta(0.0, method.self_time, 0.01)
1320
+ assert_in_delta(0.0, method.children_time, 0.01)
1321
+
1322
+ method = methods[7]
1323
+ assert_equal('BasicObject#initialize', method.full_name)
1324
+ assert_in_delta(0.0, method.total_time, 0.05)
1325
+ assert_in_delta(0.0, method.wait_time, 0.05)
1326
+ assert_in_delta(0.0, method.self_time, 0.05)
1327
+ assert_in_delta(0.0, method.children_time, 0.05)
1328
+ end
655
1329
 
656
- def test_module_methods_busy
657
- result = RubyProf.profile do
658
- RubyProf::C2.busy_wait
659
- end
1330
+ def test_instance_methods_busy_threaded
1331
+ result = RubyProf.profile do
1332
+ background_thread = Thread.new do
1333
+ RubyProf::C1.new.busy_wait
1334
+ end
1335
+ background_thread.join
1336
+ end
1337
+
1338
+ assert_equal(2, result.threads.count)
1339
+
1340
+ thread = result.threads.first
1341
+ assert_in_delta(0.2, thread.total_time, 0.05)
1342
+
1343
+ methods = result.threads.first.methods.sort.reverse
1344
+ assert_equal(4, methods.length)
1345
+
1346
+ # Check times
1347
+ method = methods[0]
1348
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
1349
+ assert_in_delta(0.2, method.total_time, 0.05)
1350
+ assert_in_delta(0.0, method.wait_time, 0.05)
1351
+ assert_in_delta(0.0, method.self_time, 0.05)
1352
+ assert_in_delta(0.2, method.children_time, 0.05)
1353
+
1354
+ method = methods[1]
1355
+ assert_equal('Thread#join', method.full_name)
1356
+ assert_in_delta(0.2, method.total_time, 0.05)
1357
+ assert_in_delta(0.2, method.wait_time, 0.05)
1358
+ assert_in_delta(0.0, method.self_time, 0.05)
1359
+ assert_in_delta(0.0, method.children_time, 0.05)
1360
+
1361
+ method = methods[2]
1362
+ assert_equal('<Class::Thread>#new', method.full_name)
1363
+ assert_in_delta(0.0, method.total_time, 0.05)
1364
+ assert_in_delta(0.0, method.wait_time, 0.05)
1365
+ assert_in_delta(0.0, method.self_time, 0.05)
1366
+ assert_in_delta(0.0, method.children_time, 0.05)
1367
+
1368
+ method = methods[3]
1369
+ assert_equal('Thread#initialize', method.full_name)
1370
+ assert_in_delta(0.0, method.total_time, 0.05)
1371
+ assert_in_delta(0.0, method.wait_time, 0.05)
1372
+ assert_in_delta(0.0, method.self_time, 0.05)
1373
+ assert_in_delta(0.0, method.children_time, 0.05)
1374
+
1375
+ thread = result.threads.last
1376
+ assert_in_delta(0.2, thread.total_time, 0.05)
1377
+
1378
+ methods = result.threads.first.methods.sort.reverse
1379
+ assert_equal(4, methods.length)
1380
+
1381
+ methods = result.threads.last.methods.sort.reverse
1382
+ assert_equal(7, methods.length)
1383
+
1384
+ # Check times
1385
+ method = methods[0]
1386
+ assert_equal('MeasureProcessTimeTest#test_instance_methods_busy_threaded', method.full_name)
1387
+ assert_in_delta(0.2, method.total_time, 0.05)
1388
+ assert_in_delta(0.0, method.wait_time, 0.05)
1389
+ assert_in_delta(0.0, method.self_time, 0.05)
1390
+ assert_in_delta(0.2, method.children_time, 0.05)
1391
+
1392
+ method = methods[1]
1393
+ assert_equal('RubyProf::C1#busy_wait', method.full_name)
1394
+ assert_in_delta(0.2, method.total_time, 0.05)
1395
+ assert_in_delta(0.0, method.wait_time, 0.05)
1396
+ assert_in_delta(0.1, method.self_time, 0.05)
1397
+ assert_in_delta(0.1, method.children_time, 0.05)
1398
+
1399
+ method = methods[2]
1400
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1401
+ assert_in_delta(0.03, method.total_time, 0.05)
1402
+ assert_in_delta(0.0, method.wait_time, 0.05)
1403
+ assert_in_delta(0.03, method.self_time, 0.05)
1404
+ assert_in_delta(0.0, method.children_time, 0.05)
1405
+
1406
+ method = methods[3]
1407
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1408
+ assert_in_delta(0.0, method.total_time, 0.05)
1409
+ assert_in_delta(0.0, method.wait_time, 0.05)
1410
+ assert_in_delta(0.0, method.self_time, 0.05)
1411
+ assert_in_delta(0.0, method.children_time, 0.05)
1412
+
1413
+ method = methods[4]
1414
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1415
+ assert_in_delta(0.0, method.total_time, 0.05)
1416
+ assert_in_delta(0.0, method.wait_time, 0.05)
1417
+ assert_in_delta(0.0, method.self_time, 0.05)
1418
+ assert_in_delta(0.0, method.children_time, 0.05)
1419
+
1420
+ method = methods[5]
1421
+ assert_equal('Class#new', method.full_name)
1422
+ assert_in_delta(0.0, method.total_time, 0.05)
1423
+ assert_in_delta(0.0, method.wait_time, 0.05)
1424
+ assert_in_delta(0.0, method.self_time, 0.05)
1425
+ assert_in_delta(0.0, method.children_time, 0.05)
1426
+
1427
+ method = methods[6]
1428
+ assert_equal('BasicObject#initialize', method.full_name)
1429
+ assert_in_delta(0.0, method.total_time, 0.05)
1430
+ assert_in_delta(0.0, method.wait_time, 0.05)
1431
+ assert_in_delta(0.0, method.self_time, 0.05)
1432
+ assert_in_delta(0.0, method.children_time, 0.05)
1433
+ end
660
1434
 
661
- thread = result.threads.first
662
- assert_in_delta(0.3, thread.total_time, 0.05)
663
-
664
- methods = result.threads.first.methods.sort.reverse
665
- assert_equal(3, methods.length)
666
-
667
- # Check times
668
- method = methods[0]
669
- assert_equal('MeasureProcessTimeTest#test_module_methods_busy', method.full_name)
670
- assert_in_delta(0.3, method.total_time, 0.05)
671
- assert_in_delta(0.0, method.wait_time, 0.05)
672
- assert_in_delta(0.0, method.self_time, 0.05)
673
- assert_in_delta(0.3, method.children_time, 0.05)
674
-
675
- method = methods[1]
676
- assert_equal('RubyProf::M1#busy_wait', method.full_name)
677
- assert_in_delta(0.3, method.total_time, 0.05)
678
- assert_in_delta(0.0, method.wait_time, 0.05)
679
- assert_in_delta(0.15, method.self_time, 0.05)
680
- assert_in_delta(0.15, method.children_time, 0.05)
681
-
682
- method = methods[2]
683
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
684
- assert_in_delta(0.15, method.total_time, 0.05)
685
- assert_in_delta(0.0, method.wait_time, 0.05)
686
- assert_in_delta(0.15, method.self_time, 0.05)
687
- assert_in_delta(0.0, method.children_time, 0.05)
688
- end
1435
+ def test_module_methods_sleep
1436
+ result = RubyProf.profile do
1437
+ RubyProf::C2.sleep_wait
1438
+ end
1439
+
1440
+ thread = result.threads.first
1441
+ assert_in_delta(0.0, thread.total_time, 0.05)
1442
+
1443
+ methods = result.threads.first.methods.sort.reverse
1444
+ assert_equal(3, methods.length)
1445
+
1446
+ # Check times
1447
+ method = methods[0]
1448
+ assert_equal('MeasureProcessTimeTest#test_module_methods_sleep', method.full_name)
1449
+ assert_in_delta(0.0, method.total_time, 0.05)
1450
+ assert_in_delta(0.0, method.wait_time, 0.05)
1451
+ assert_in_delta(0.0, method.self_time, 0.05)
1452
+ assert_in_delta(0.0, method.children_time, 0.05)
1453
+
1454
+ method = methods[1]
1455
+ assert_equal('RubyProf::M1#sleep_wait', method.full_name)
1456
+ assert_in_delta(0.0, method.total_time, 0.05)
1457
+ assert_in_delta(0.0, method.wait_time, 0.05)
1458
+ assert_in_delta(0.0, method.self_time, 0.05)
1459
+ assert_in_delta(0.0, method.children_time, 0.05)
1460
+
1461
+ method = methods[2]
1462
+ assert_equal('Kernel#sleep', method.full_name)
1463
+ assert_in_delta(0.0, method.total_time, 0.05)
1464
+ assert_in_delta(0.0, method.wait_time, 0.05)
1465
+ assert_in_delta(0.0, method.self_time, 0.05)
1466
+ assert_in_delta(0.0, method.children_time, 0.05)
1467
+ end
689
1468
 
690
- def test_module_instance_methods_sleep
691
- result = RubyProf.profile do
692
- RubyProf::C2.new.sleep_wait
693
- end
1469
+ def test_module_methods_busy
1470
+ result = RubyProf.profile do
1471
+ RubyProf::C2.busy_wait
1472
+ end
1473
+
1474
+ thread = result.threads.first
1475
+ assert_in_delta(0.3, thread.total_time, 0.05)
1476
+
1477
+ methods = result.threads.first.methods.sort.reverse
1478
+ assert_equal(5, methods.length)
1479
+
1480
+ # Check times
1481
+ method = methods[0]
1482
+ assert_equal('MeasureProcessTimeTest#test_module_methods_busy', method.full_name)
1483
+ assert_in_delta(0.3, method.total_time, 0.05)
1484
+ assert_in_delta(0.0, method.wait_time, 0.05)
1485
+ assert_in_delta(0.0, method.self_time, 0.05)
1486
+ assert_in_delta(0.3, method.children_time, 0.05)
1487
+
1488
+ method = methods[1]
1489
+ assert_equal('RubyProf::M1#busy_wait', method.full_name)
1490
+ assert_in_delta(0.3, method.total_time, 0.05)
1491
+ assert_in_delta(0.0, method.wait_time, 0.05)
1492
+ assert_in_delta(0.15, method.self_time, 0.05)
1493
+ assert_in_delta(0.15, method.children_time, 0.05)
1494
+
1495
+ method = methods[2]
1496
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1497
+ assert_in_delta(0.05, method.total_time, 0.05)
1498
+ assert_in_delta(0.0, method.wait_time, 0.05)
1499
+ assert_in_delta(0.05, method.self_time, 0.05)
1500
+ assert_in_delta(0.0, method.children_time, 0.05)
1501
+ end
694
1502
 
695
- thread = result.threads.first
696
- assert_in_delta(0.0, thread.total_time, 0.05)
697
-
698
- methods = result.threads.first.methods.sort.reverse
699
- assert_equal(5, methods.length)
700
-
701
- # Check times
702
- method = methods[0]
703
- assert_equal('MeasureProcessTimeTest#test_module_instance_methods_sleep', method.full_name)
704
- assert_in_delta(0.0, method.total_time, 0.05)
705
- assert_in_delta(0.0, method.wait_time, 0.05)
706
- assert_in_delta(0.0, method.self_time, 0.05)
707
- assert_in_delta(0.0, method.children_time, 0.05)
708
-
709
- method = methods[1]
710
- assert_equal('RubyProf::M1#sleep_wait', method.full_name)
711
- assert_in_delta(0.0, method.total_time, 0.05)
712
- assert_in_delta(0.0, method.wait_time, 0.05)
713
- assert_in_delta(0.0, method.self_time, 0.05)
714
- assert_in_delta(0.0, method.children_time, 0.05)
715
-
716
- method = methods[2]
717
- assert_equal('Kernel#sleep', method.full_name)
718
- assert_in_delta(0.0, method.total_time, 0.05)
719
- assert_in_delta(0.0, method.wait_time, 0.05)
720
- assert_in_delta(0.0, method.self_time, 0.05)
721
- assert_in_delta(0.0, method.children_time, 0.05)
722
-
723
- method = methods[3]
724
- assert_equal('Class#new', method.full_name)
725
- assert_in_delta(0.0, method.total_time, 0.05)
726
- assert_in_delta(0.0, method.wait_time, 0.05)
727
- assert_in_delta(0.0, method.self_time, 0.05)
728
- assert_in_delta(0.0, method.children_time, 0.05)
729
-
730
- method = methods[4]
731
- assert_equal('BasicObject#initialize', method.full_name)
732
- assert_in_delta(0.0, method.total_time, 0.05)
733
- assert_in_delta(0.0, method.wait_time, 0.05)
734
- assert_in_delta(0.0, method.self_time, 0.05)
735
- assert_in_delta(0.0, method.children_time, 0.05)
736
- end
1503
+ def test_module_instance_methods_sleep
1504
+ result = RubyProf.profile do
1505
+ RubyProf::C2.new.sleep_wait
1506
+ end
1507
+
1508
+ thread = result.threads.first
1509
+ assert_in_delta(0.0, thread.total_time, 0.05)
1510
+
1511
+ methods = result.threads.first.methods.sort.reverse
1512
+ assert_equal(5, methods.length)
1513
+
1514
+ # Check times
1515
+ method = methods[0]
1516
+ assert_equal('MeasureProcessTimeTest#test_module_instance_methods_sleep', method.full_name)
1517
+ assert_in_delta(0.0, method.total_time, 0.05)
1518
+ assert_in_delta(0.0, method.wait_time, 0.05)
1519
+ assert_in_delta(0.0, method.self_time, 0.05)
1520
+ assert_in_delta(0.0, method.children_time, 0.05)
1521
+
1522
+ method = methods[1]
1523
+ assert_equal('RubyProf::M1#sleep_wait', method.full_name)
1524
+ assert_in_delta(0.0, method.total_time, 0.05)
1525
+ assert_in_delta(0.0, method.wait_time, 0.05)
1526
+ assert_in_delta(0.0, method.self_time, 0.05)
1527
+ assert_in_delta(0.0, method.children_time, 0.05)
1528
+
1529
+ method = methods[2]
1530
+ assert_equal('Kernel#sleep', method.full_name)
1531
+ assert_in_delta(0.0, method.total_time, 0.05)
1532
+ assert_in_delta(0.0, method.wait_time, 0.05)
1533
+ assert_in_delta(0.0, method.self_time, 0.05)
1534
+ assert_in_delta(0.0, method.children_time, 0.05)
1535
+
1536
+ method = methods[3]
1537
+ assert_equal('Class#new', method.full_name)
1538
+ assert_in_delta(0.0, method.total_time, 0.05)
1539
+ assert_in_delta(0.0, method.wait_time, 0.05)
1540
+ assert_in_delta(0.0, method.self_time, 0.05)
1541
+ assert_in_delta(0.0, method.children_time, 0.05)
1542
+
1543
+ method = methods[4]
1544
+ assert_equal('BasicObject#initialize', method.full_name)
1545
+ assert_in_delta(0.0, method.total_time, 0.05)
1546
+ assert_in_delta(0.0, method.wait_time, 0.05)
1547
+ assert_in_delta(0.0, method.self_time, 0.05)
1548
+ assert_in_delta(0.0, method.children_time, 0.05)
1549
+ end
737
1550
 
738
- def test_module_instance_methods_busy
739
- result = RubyProf.profile do
740
- RubyProf::C2.new.busy_wait
1551
+ def test_module_instance_methods_busy
1552
+ result = RubyProf.profile do
1553
+ RubyProf::C2.new.busy_wait
1554
+ end
1555
+
1556
+ thread = result.threads.first
1557
+ assert_in_delta(0.3, thread.total_time, 0.05)
1558
+
1559
+ methods = result.threads.first.methods.sort.reverse
1560
+ assert_equal(7, methods.length)
1561
+
1562
+ # Check times
1563
+ method = methods[0]
1564
+ assert_equal('MeasureProcessTimeTest#test_module_instance_methods_busy', method.full_name)
1565
+ assert_in_delta(0.3, method.total_time, 0.05)
1566
+ assert_in_delta(0.0, method.wait_time, 0.05)
1567
+ assert_in_delta(0.0, method.self_time, 0.05)
1568
+ assert_in_delta(0.3, method.children_time, 0.05)
1569
+
1570
+ method = methods[1]
1571
+ assert_equal('RubyProf::M1#busy_wait', method.full_name)
1572
+ assert_in_delta(0.3, method.total_time, 0.05)
1573
+ assert_in_delta(0.0, method.wait_time, 0.05)
1574
+ assert_in_delta(0.15, method.self_time, 0.05)
1575
+ assert_in_delta(0.15, method.children_time, 0.05)
1576
+
1577
+ method = methods[2]
1578
+ assert_equal('<Module::Process>#clock_gettime', method.full_name)
1579
+ assert_in_delta(0.05, method.total_time, 0.05)
1580
+ assert_in_delta(0.0, method.wait_time, 0.05)
1581
+ assert_in_delta(0.05, method.self_time, 0.05)
1582
+ assert_in_delta(0.0, method.children_time, 0.05)
1583
+
1584
+ method = methods[3]
1585
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1586
+ assert_in_delta(0.0, method.total_time, 0.05)
1587
+ assert_in_delta(0.0, method.wait_time, 0.05)
1588
+ assert_in_delta(0.0, method.self_time, 0.05)
1589
+ assert_in_delta(0.0, method.children_time, 0.05)
1590
+
1591
+ method = methods[4]
1592
+ assert_includes(['Float#<', 'Float#-'], method.full_name)
1593
+ assert_in_delta(0.0, method.total_time, 0.05)
1594
+ assert_in_delta(0.0, method.wait_time, 0.05)
1595
+ assert_in_delta(0.0, method.self_time, 0.05)
1596
+ assert_in_delta(0.0, method.children_time, 0.05)
1597
+
1598
+ method = methods[5]
1599
+ assert_equal('Class#new', method.full_name)
1600
+ assert_in_delta(0.0, method.total_time, 0.05)
1601
+ assert_in_delta(0.0, method.wait_time, 0.05)
1602
+ assert_in_delta(0.0, method.self_time, 0.05)
1603
+ assert_in_delta(0.0, method.children_time, 0.05)
1604
+
1605
+ method = methods[6]
1606
+ assert_equal('BasicObject#initialize', method.full_name)
1607
+ assert_in_delta(0.0, method.total_time, 0.05)
1608
+ assert_in_delta(0.0, method.wait_time, 0.05)
1609
+ assert_in_delta(0.0, method.self_time, 0.05)
1610
+ assert_in_delta(0.0, method.children_time, 0.05)
1611
+ end
741
1612
  end
742
-
743
- thread = result.threads.first
744
- assert_in_delta(0.3, thread.total_time, 0.05)
745
-
746
- methods = result.threads.first.methods.sort.reverse
747
- assert_equal(5, methods.length)
748
-
749
- # Check times
750
- method = methods[0]
751
- assert_equal('MeasureProcessTimeTest#test_module_instance_methods_busy', method.full_name)
752
- assert_in_delta(0.3, method.total_time, 0.05)
753
- assert_in_delta(0.0, method.wait_time, 0.05)
754
- assert_in_delta(0.0, method.self_time, 0.05)
755
- assert_in_delta(0.3, method.children_time, 0.05)
756
-
757
- method = methods[1]
758
- assert_equal('RubyProf::M1#busy_wait', method.full_name)
759
- assert_in_delta(0.3, method.total_time, 0.05)
760
- assert_in_delta(0.0, method.wait_time, 0.05)
761
- assert_in_delta(0.15, method.self_time, 0.05)
762
- assert_in_delta(0.15, method.children_time, 0.05)
763
-
764
- method = methods[2]
765
- assert_equal('<Module::Process>#clock_gettime', method.full_name)
766
- assert_in_delta(0.15, method.total_time, 0.05)
767
- assert_in_delta(0.0, method.wait_time, 0.05)
768
- assert_in_delta(0.15, method.self_time, 0.05)
769
- assert_in_delta(0.0, method.children_time, 0.05)
770
-
771
- method = methods[3]
772
- assert_equal('Class#new', method.full_name)
773
- assert_in_delta(0.0, method.total_time, 0.05)
774
- assert_in_delta(0.0, method.wait_time, 0.05)
775
- assert_in_delta(0.0, method.self_time, 0.05)
776
- assert_in_delta(0.0, method.children_time, 0.05)
777
-
778
- method = methods[4]
779
- assert_equal('BasicObject#initialize', method.full_name)
780
- assert_in_delta(0.0, method.total_time, 0.05)
781
- assert_in_delta(0.0, method.wait_time, 0.05)
782
- assert_in_delta(0.0, method.self_time, 0.05)
783
- assert_in_delta(0.0, method.children_time, 0.05)
784
1613
  end
785
1614
  end