1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
require_relative '../spec_helper'
require_relative 'fixtures/rescue'
class SpecificExampleException < StandardError
end
class OtherCustomException < StandardError
end
class ArbitraryException < StandardError
end
exception_list = [SpecificExampleException, ArbitraryException]
describe "The rescue keyword" do
before :each do
ScratchPad.record []
end
it "can be used to handle a specific exception" do
begin
raise SpecificExampleException, "Raising this to be handled below"
rescue SpecificExampleException
:caught
end.should == :caught
end
it "can capture the raised exception in a local variable" do
begin
raise SpecificExampleException, "some text"
rescue SpecificExampleException => e
e.message.should == "some text"
end
end
it "returns value from `rescue` if an exception was raised" do
begin
raise
rescue
:caught
end.should == :caught
end
it "returns value from `else` section if no exceptions were raised" do
result = begin
:begin
rescue
:rescue
else
:else
ensure
:ensure
end
result.should == :else
end
it "can rescue multiple raised exceptions with a single rescue block" do
[lambda{raise ArbitraryException}, lambda{raise SpecificExampleException}].map do |block|
begin
block.call
rescue SpecificExampleException, ArbitraryException
:caught
end
end.should == [:caught, :caught]
end
it "can rescue a splatted list of exceptions" do
caught_it = false
begin
raise SpecificExampleException, "not important"
rescue *exception_list
caught_it = true
end
caught_it.should be_true
caught = []
[lambda{raise ArbitraryException}, lambda{raise SpecificExampleException}].each do |block|
begin
block.call
rescue *exception_list
caught << $!
end
end
caught.size.should == 2
exception_list.each do |exception_class|
caught.map{|e| e.class}.should include(exception_class)
end
end
it "can combine a splatted list of exceptions with a literal list of exceptions" do
caught_it = false
begin
raise SpecificExampleException, "not important"
rescue ArbitraryException, *exception_list
caught_it = true
end
caught_it.should be_true
caught = []
[lambda{raise ArbitraryException}, lambda{raise SpecificExampleException}].each do |block|
begin
block.call
rescue ArbitraryException, *exception_list
caught << $!
end
end
caught.size.should == 2
exception_list.each do |exception_class|
caught.map{|e| e.class}.should include(exception_class)
end
end
it "will only rescue the specified exceptions when doing a splat rescue" do
lambda do
begin
raise OtherCustomException, "not rescued!"
rescue *exception_list
end
end.should raise_error(OtherCustomException)
end
it "can rescue different types of exceptions in different ways" do
begin
raise Exception
rescue RuntimeError
rescue StandardError
rescue Exception
ScratchPad << :exception
end
ScratchPad.recorded.should == [:exception]
end
it "rescues exception within the first suitable section in order of declaration" do
begin
raise StandardError
rescue RuntimeError
ScratchPad << :runtime_error
rescue StandardError
ScratchPad << :standard_error
rescue Exception
ScratchPad << :exception
end
ScratchPad.recorded.should == [:standard_error]
end
it "will execute an else block only if no exceptions were raised" do
result = begin
ScratchPad << :one
rescue
ScratchPad << :does_not_run
else
ScratchPad << :two
:val
end
result.should == :val
ScratchPad.recorded.should == [:one, :two]
end
it "will execute an else block with ensure only if no exceptions were raised" do
result = begin
ScratchPad << :one
rescue
ScratchPad << :does_not_run
else
ScratchPad << :two
:val
ensure
ScratchPad << :ensure
:ensure_val
end
result.should == :val
ScratchPad.recorded.should == [:one, :two, :ensure]
end
it "will execute an else block only if no exceptions were raised in a method" do
result = RescueSpecs.begin_else(false)
result.should == :val
ScratchPad.recorded.should == [:one, :else_ran]
end
it "will execute an else block with ensure only if no exceptions were raised in a method" do
result = RescueSpecs.begin_else_ensure(false)
result.should == :val
ScratchPad.recorded.should == [:one, :else_ran, :ensure_ran]
end
it "will execute an else block but use the outer scope return value in a method" do
result = RescueSpecs.begin_else_return(false)
result.should == :return_val
ScratchPad.recorded.should == [:one, :else_ran, :outside_begin]
end
it "will execute an else block with ensure but use the outer scope return value in a method" do
result = RescueSpecs.begin_else_return_ensure(false)
result.should == :return_val
ScratchPad.recorded.should == [:one, :else_ran, :ensure_ran, :outside_begin]
end
else_without_rescue = lambda {
eval <<-ruby
begin
ScratchPad << :begin
else
ScratchPad << :else
end
ruby
}
ruby_version_is ""..."2.6" do
it "will execute an else block even without rescue and ensure" do
else_without_rescue.should complain(/else without rescue is useless/)
ScratchPad.recorded.should == [:begin, :else]
end
end
ruby_version_is "2.6" do
else_without_rescue.should raise_error(SyntaxError)
end
it "will not execute an else block if an exception was raised" do
result = begin
ScratchPad << :one
raise "an error occurred"
rescue
ScratchPad << :two
:val
else
ScratchPad << :does_not_run
end
result.should == :val
ScratchPad.recorded.should == [:one, :two]
end
it "will not execute an else block with ensure if an exception was raised" do
result = begin
ScratchPad << :one
raise "an error occurred"
rescue
ScratchPad << :two
:val
else
ScratchPad << :does_not_run
ensure
ScratchPad << :ensure
:ensure_val
end
result.should == :val
ScratchPad.recorded.should == [:one, :two, :ensure]
end
it "will not execute an else block if an exception was raised in a method" do
result = RescueSpecs.begin_else(true)
result.should == :rescue_val
ScratchPad.recorded.should == [:one, :rescue_ran]
end
it "will not execute an else block with ensure if an exception was raised in a method" do
result = RescueSpecs.begin_else_ensure(true)
result.should == :rescue_val
ScratchPad.recorded.should == [:one, :rescue_ran, :ensure_ran]
end
it "will not execute an else block but use the outer scope return value in a method" do
result = RescueSpecs.begin_else_return(true)
result.should == :return_val
ScratchPad.recorded.should == [:one, :rescue_ran, :outside_begin]
end
it "will not execute an else block with ensure but use the outer scope return value in a method" do
result = RescueSpecs.begin_else_return_ensure(true)
result.should == :return_val
ScratchPad.recorded.should == [:one, :rescue_ran, :ensure_ran, :outside_begin]
end
it "will not rescue errors raised in an else block in the rescue block above it" do
lambda do
begin
ScratchPad << :one
rescue Exception
ScratchPad << :does_not_run
else
ScratchPad << :two
raise SpecificExampleException, "an error from else"
end
end.should raise_error(SpecificExampleException)
ScratchPad.recorded.should == [:one, :two]
end
it "parses 'a += b rescue c' as 'a += (b rescue c)'" do
a = 'a'
c = 'c'
a += b rescue c
a.should == 'ac'
end
context "without rescue expression" do
it "will rescue only StandardError and its subclasses" do
begin
raise StandardError
rescue
ScratchPad << :caught
end
ScratchPad.recorded.should == [:caught]
end
it "will not rescue exceptions except StandardError" do
[ Exception.new, NoMemoryError.new, ScriptError.new, SecurityError.new,
SignalException.new('INT'), SystemExit.new, SystemStackError.new
].each do |exception|
lambda {
begin
raise exception
rescue
ScratchPad << :caught
end
}.should raise_error(exception.class)
end
ScratchPad.recorded.should == []
end
end
it "uses === to compare against rescued classes" do
rescuer = Class.new
def rescuer.===(exception)
true
end
begin
raise Exception
rescue rescuer
rescued = :success
rescue Exception
rescued = :failure
end
rescued.should == :success
end
it "only accepts Module or Class in rescue clauses" do
rescuer = 42
lambda {
begin
raise "error"
rescue rescuer
end
}.should raise_error(TypeError) { |e|
e.message.should =~ /class or module required for rescue clause/
}
end
it "only accepts Module or Class in splatted rescue clauses" do
rescuer = [42]
lambda {
begin
raise "error"
rescue *rescuer
end
}.should raise_error(TypeError) { |e|
e.message.should =~ /class or module required for rescue clause/
}
end
it "evaluates rescue expressions only when needed" do
invalid_rescuer = Object.new
begin
:foo
rescue invalid_rescuer
end.should == :foo
end
it "should splat the handling Error classes" do
begin
raise "raise"
rescue *(RuntimeError) => e
:expected
end.should == :expected
end
it "allows rescue in class" do
eval <<-ruby
class RescueInClassExample
raise SpecificExampleException
rescue SpecificExampleException
ScratchPad << :caught
end
ruby
ScratchPad.recorded.should == [:caught]
end
it "does not allow rescue in {} block" do
lambda {
eval <<-ruby
lambda {
raise SpecificExampleException
rescue SpecificExampleException
:caught
}
ruby
}.should raise_error(SyntaxError)
end
ruby_version_is "2.5" do
it "allows rescue in 'do end' block" do
lambda = eval <<-ruby
lambda do
raise SpecificExampleException
rescue SpecificExampleException
ScratchPad << :caught
end.call
ruby
ScratchPad.recorded.should == [:caught]
end
end
ruby_version_is ""..."2.4" do
it "fails when using 'rescue' in method arguments" do
lambda { eval '1.+ (1 rescue 1)' }.should raise_error(SyntaxError)
end
end
ruby_version_is "2.4" do
it "allows 'rescue' in method arguments" do
two = eval '1.+ (raise("Error") rescue 1)'
two.should == 2
end
it "requires the 'rescue' in method arguments to be wrapped in parens" do
lambda { eval '1.+(1 rescue 1)' }.should raise_error(SyntaxError)
eval('1.+((1 rescue 1))').should == 2
end
end
describe "inline form" do
it "can be inlined" do
a = 1/0 rescue 1
a.should == 1
end
it "doesn't except rescue expression" do
lambda {
eval <<-ruby
a = 1 rescue RuntimeError 2
ruby
}.should raise_error(SyntaxError)
end
it "rescues only StandardError and its subclasses" do
a = raise(StandardError) rescue 1
a.should == 1
lambda {
a = raise(Exception) rescue 1
}.should raise_error(Exception)
end
end
end
|