← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to bootstraptest/test_block.rb

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-09-04 16:01:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070904160117-i15zckg2nhxe9fyw
Tags: 1.9.0+20070830-2ubuntu1
* Sync from Debian; remaining changes:
  - Add -g to CFLAGS.
* Fixes build failure on ia64.
* Fixes build failure with gcc-4.2 on lpia.
* Robustify check for target_os, fixing build failure on lpia.
* Set Ubuntu maintainer address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bootstraptest/test_block.rb
 
1
assert_equal %q{1}, %q{
 
2
  1.times{
 
3
    begin
 
4
      a = 1
 
5
    ensure
 
6
      foo = nil
 
7
    end
 
8
  }
 
9
}
 
10
assert_equal %q{2}, %q{
 
11
  [1,2,3].find{|x| x == 2}
 
12
}
 
13
assert_equal %q{2}, %q{
 
14
  class E
 
15
    include Enumerable
 
16
    def each(&block)
 
17
      [1, 2, 3].each(&block)
 
18
    end
 
19
  end
 
20
  E.new.find {|x| x == 2 }
 
21
}
 
22
assert_equal %q{6}, %q{
 
23
  sum = 0
 
24
  for x in [1, 2, 3]
 
25
    sum += x
 
26
  end
 
27
  sum
 
28
}
 
29
assert_equal %q{15}, %q{
 
30
  sum = 0
 
31
  for x in (1..5)
 
32
    sum += x
 
33
  end
 
34
  sum
 
35
}
 
36
assert_equal %q{0}, %q{
 
37
  sum = 0
 
38
  for x in []
 
39
    sum += x
 
40
  end
 
41
  sum
 
42
}
 
43
assert_equal %q{1}, %q{
 
44
  ans = []
 
45
  1.times{
 
46
    for n in 1..3
 
47
      a = n
 
48
      ans << a
 
49
    end
 
50
  }
 
51
}
 
52
assert_equal %q{1..3}, %q{
 
53
  ans = []
 
54
  for m in 1..3
 
55
    for n in 1..3
 
56
      a = [m, n]
 
57
      ans << a
 
58
    end
 
59
  end
 
60
}
 
61
assert_equal %q{[1, 2, 3]}, %q{
 
62
  (1..3).to_a
 
63
}
 
64
assert_equal %q{[4, 8, 12]}, %q{
 
65
  (1..3).map{|e|
 
66
    e * 4
 
67
  }
 
68
}
 
69
assert_equal %q{[1, 2, 3]}, %q{
 
70
  class C
 
71
    include Enumerable
 
72
    def each
 
73
      [1,2,3].each{|e|
 
74
        yield e
 
75
      }
 
76
    end
 
77
  end
 
78
  
 
79
  C.new.to_a
 
80
}
 
81
assert_equal %q{[4, 5, 6]}, %q{
 
82
  class C
 
83
    include Enumerable
 
84
    def each
 
85
      [1,2,3].each{|e|
 
86
        yield e
 
87
      }
 
88
    end
 
89
  end
 
90
  
 
91
  C.new.map{|e|
 
92
    e + 3
 
93
  }
 
94
}
 
95
assert_equal %q{100}, %q{
 
96
  def m
 
97
    yield
 
98
  end
 
99
  def n
 
100
    yield
 
101
  end
 
102
 
 
103
  m{
 
104
    n{
 
105
      100
 
106
    }
 
107
  }
 
108
}
 
109
assert_equal %q{20}, %q{
 
110
  def m
 
111
    yield 1
 
112
  end
 
113
  
 
114
  m{|ib|
 
115
    m{|jb|
 
116
      i = 20
 
117
    }
 
118
  }
 
119
}
 
120
assert_equal %q{2}, %q{
 
121
  def m
 
122
    yield 1
 
123
  end
 
124
  
 
125
  m{|ib|
 
126
    m{|jb|
 
127
      ib = 20
 
128
      kb = 2
 
129
    }
 
130
  }
 
131
}
 
132
assert_equal %q{3}, %q{
 
133
  def iter1
 
134
    iter2{
 
135
      yield
 
136
    }
 
137
  end
 
138
  
 
139
  def iter2
 
140
    yield
 
141
  end
 
142
  
 
143
  iter1{
 
144
    jb = 2
 
145
    iter1{
 
146
      jb = 3
 
147
    }
 
148
    jb
 
149
  }
 
150
}
 
151
assert_equal %q{2}, %q{
 
152
  def iter1
 
153
    iter2{
 
154
      yield
 
155
    }
 
156
  end
 
157
  
 
158
  def iter2
 
159
    yield
 
160
  end
 
161
  
 
162
  iter1{
 
163
    jb = 2
 
164
    iter1{
 
165
      jb
 
166
    }
 
167
    jb
 
168
  }
 
169
}
 
170
assert_equal %q{2}, %q{
 
171
  def m
 
172
    yield 1
 
173
  end
 
174
  m{|ib|
 
175
    ib*2
 
176
  }
 
177
}
 
178
assert_equal %q{92580}, %q{
 
179
  def m
 
180
    yield 12345, 67890
 
181
  end
 
182
  m{|ib,jb|
 
183
    ib*2+jb
 
184
  }
 
185
}
 
186
assert_equal %q{[10, nil]}, %q{
 
187
  def iter
 
188
    yield 10
 
189
  end
 
190
 
 
191
  a = nil
 
192
  [iter{|a|
 
193
    a
 
194
  }, a]
 
195
}
 
196
assert_equal %q{21}, %q{
 
197
  def iter
 
198
    yield 10
 
199
  end
 
200
 
 
201
  iter{|a|
 
202
    iter{|a|
 
203
      a + 1
 
204
    } + a
 
205
  }
 
206
}
 
207
assert_equal %q{[10, 20, 30, 40, nil, nil, nil, nil]}, %q{
 
208
  def iter
 
209
    yield 10, 20, 30, 40
 
210
  end
 
211
 
 
212
  a = b = c = d = nil
 
213
  iter{|a, b, c, d|
 
214
    [a, b, c, d]
 
215
  } + [a, b, c, d]
 
216
}
 
217
assert_equal %q{[10, 20, 30, 40, nil, nil]}, %q{
 
218
  def iter
 
219
    yield 10, 20, 30, 40
 
220
  end
 
221
 
 
222
  a = b = nil
 
223
  iter{|a, b, c, d|
 
224
    [a, b, c, d]
 
225
  } + [a, b]
 
226
}
 
227
assert_equal %q{[1]}, %q{
 
228
  $a = []
 
229
  
 
230
  def iter
 
231
    yield 1
 
232
  end
 
233
  
 
234
  def m
 
235
    x = iter{|x|
 
236
      $a << x
 
237
      y = 0
 
238
    }
 
239
  end
 
240
  m
 
241
  $a
 
242
}
 
243
assert_equal %q{[1, [2]]}, %q{
 
244
  def iter
 
245
    yield 1, 2
 
246
  end
 
247
 
 
248
  iter{|a, *b|
 
249
    [a, b]
 
250
  }
 
251
}
 
252
assert_equal %q{[[1, 2]]}, %q{
 
253
  def iter
 
254
    yield 1, 2
 
255
  end
 
256
 
 
257
  iter{|*a|
 
258
    [a]
 
259
  }
 
260
}
 
261
assert_equal %q{[1, 2, []]}, %q{
 
262
  def iter
 
263
    yield 1, 2
 
264
  end
 
265
 
 
266
  iter{|a, b, *c|
 
267
    [a, b, c]
 
268
  }
 
269
}
 
270
assert_equal %q{[1, 2, nil, []]}, %q{
 
271
  def iter
 
272
    yield 1, 2
 
273
  end
 
274
 
 
275
  iter{|a, b, c, *d|
 
276
    [a, b, c, d]
 
277
  }
 
278
}
 
279
assert_equal %q{1}, %q{
 
280
  def m
 
281
    yield
 
282
  end
 
283
  m{
 
284
    1
 
285
  }
 
286
}
 
287
assert_equal %q{15129}, %q{
 
288
  def m
 
289
    yield 123
 
290
  end
 
291
  m{|ib|
 
292
    m{|jb|
 
293
      ib*jb
 
294
    }
 
295
  }
 
296
}
 
297
assert_equal %q{2}, %q{
 
298
  def m a
 
299
    yield a
 
300
  end
 
301
  m(1){|ib|
 
302
    m(2){|jb|
 
303
      ib*jb
 
304
    }
 
305
  }
 
306
}
 
307
assert_equal %q{9}, %q{
 
308
  sum = 0
 
309
  3.times{|ib|
 
310
    2.times{|jb|
 
311
      sum += ib + jb
 
312
    }}
 
313
  sum
 
314
}
 
315
assert_equal %q{10}, %q{
 
316
  3.times{|bl|
 
317
    break 10
 
318
  }
 
319
}
 
320
assert_equal %q{[1, 2]}, %q{
 
321
  def iter
 
322
    yield 1,2,3
 
323
  end
 
324
 
 
325
  iter{|i, j|
 
326
    [i, j]
 
327
  }
 
328
}
 
329
assert_equal %q{[1, nil]}, %q{
 
330
  def iter
 
331
    yield 1
 
332
  end
 
333
 
 
334
  iter{|i, j|
 
335
    [i, j]
 
336
  }
 
337
}
 
338
 
 
339
assert_equal '0', %q{
 
340
def m()
 
341
end
 
342
m {|(v0,*,(*)),|}
 
343
m {|(*v0,(*)),|}
 
344
m {|(v0,*v1,(*)),|}
 
345
m {|((v0,*v1,v2)),|}
 
346
m {|(v0,*v1,v2),|}
 
347
m {|(v0,*v1,(v2)),|}
 
348
m {|((*),*v0,v1),|}
 
349
m {|((v0),*v1,v2),|}
 
350
m {|(v0,v1,*v2,v3),|}
 
351
m {|v0,(v1,*v2,v3),|}
 
352
m {|(v0,*v1,v2),v3,|}
 
353
m {|(v0,*v1,v2)|}
 
354
m {|(v0,*v1,v2),&v3|}
 
355
m {|(v0,*v1,v2),*|}
 
356
m {|(v0,*v1,v2),*,&v3|}
 
357
m {|*,(v0,*v1,v2)|}
 
358
m {|*,(v0,*v1,v2),&v3|}
 
359
m {|v0,*,(v1,*v2,v3)|}
 
360
m {|v0,*,(v1,*v2,v3),&v4|}
 
361
m {|(v0,*v1,v2),*,v3|}
 
362
m {|(v0,*v1,v2),*,v3,&v4|}
 
363
m {|(v0, *v1, v2)|}
 
364
m {|(*,v)|}
 
365
0
 
366
}, "block parameter (shouldn't SEGV: [ruby-dev:31143])"
 
367
 
 
368
assert_equal 'nil', %q{
 
369
  def m
 
370
    yield
 
371
  end
 
372
  m{|&b| b}.inspect
 
373
}, '[ruby-dev:31147]'
 
374
 
 
375
assert_equal 'nil', %q{
 
376
  def m()
 
377
    yield
 
378
  end
 
379
  m {|(v,(*))|}.inspect
 
380
}, '[ruby-dev:31160]'
 
381
 
 
382
assert_equal 'nil', %q{
 
383
  def m()
 
384
    yield
 
385
  end
 
386
  m {|(*,a,b)|}.inspect
 
387
}, '[ruby-dev:31153]'
 
388
 
 
389
assert_equal 'nil', %q{
 
390
  def m()
 
391
    yield
 
392
  end
 
393
  m {|((*))|}.inspect
 
394
}
 
395
 
 
396
assert_equal %q{[1, 1, [1, nil], [1, nil], [1, nil], [1, nil], [1, 1], 1, [1, nil], [1, nil], [1, nil], [1, nil], [[1, 1], [1, 1]], [1, 1], [1, 1], [1, 1], [1, nil], [1, nil], [[[1, 1], [1, 1]], [[1, 1], [1, 1]]], [[1, 1], [1, 1]], [[1, 1], [1, 1]], [[1, 1], [1, 1]], [1, 1], [1, 1], [[[[1, 1], [1, 1]], [[1, 1], [1, 1]]], [[[1, 1], [1, 1]], [[1, 1], [1, 1]]]], [[[1, 1], [1, 1]], [[1, 1], [1, 1]]], [[[1, 1], [1, 1]], [[1, 1], [1, 1]]], [[[1, 1], [1, 1]], [[1, 1], [1, 1]]], [[1, 1], [1, 1]], [[1, 1], [1, 1]]]}, %q{
 
397
def m(ary = [])
 
398
  yield(ary)
 
399
end
 
400
 
 
401
$ans = []
 
402
o = 1
 
403
5.times{
 
404
  v,(*) = o; $ans << o
 
405
  m(o){|(v,(*))| $ans << v}
 
406
  ((x, y)) = o; $ans << [x, y]
 
407
  m(o){|((x, y))| $ans << [x, y]}
 
408
  (((x, y))) = o; $ans << [x, y]
 
409
  m(o){|(((x, y)))| $ans << [x, y]}
 
410
  o = [o, o]
 
411
}; $ans
 
412
}
 
413
 
 
414
assert_equal '0', %q{
 
415
  def m()
 
416
    yield [0]
 
417
  end
 
418
  m {|*,v| v}.inspect
 
419
}, '[ruby-dev:31437]'
 
420
assert_equal '[0]', %q{
 
421
  def m
 
422
    yield [0]
 
423
  end
 
424
  m{|v, &b| v}.inspect
 
425
}, '[ruby-dev:31440]'
 
426
assert_equal 'ok', %q{
 
427
  begin
 
428
    lambda{|a|}.call(1, 2)
 
429
  rescue ArgumentError
 
430
    :ok
 
431
  else
 
432
    :ng
 
433
  end
 
434
}, '[ruby-dev:31464]'
 
435
assert_equal 'ok', %q{
 
436
  begin
 
437
    lambda{|&b|}.call(3)
 
438
  rescue ArgumentError
 
439
    :ok
 
440
  else
 
441
    :ng
 
442
  end
 
443
}, '[ruby-dev:31472]'
 
444