1 | ##
|
---|
2 | # Kernel ISO Test
|
---|
3 |
|
---|
4 | assert('Kernel', '15.3.1') do
|
---|
5 | assert_equal Module, Kernel.class
|
---|
6 | end
|
---|
7 |
|
---|
8 | assert('Kernel.block_given?', '15.3.1.2.2') do
|
---|
9 | def bg_try(&b)
|
---|
10 | if Kernel.block_given?
|
---|
11 | yield
|
---|
12 | else
|
---|
13 | "no block"
|
---|
14 | end
|
---|
15 | end
|
---|
16 |
|
---|
17 | assert_false Kernel.block_given?
|
---|
18 | # test without block
|
---|
19 | assert_equal "no block", bg_try
|
---|
20 | # test with block
|
---|
21 | assert_equal "block" do
|
---|
22 | bg_try { "block" }
|
---|
23 | end
|
---|
24 | # test with block
|
---|
25 | assert_equal "block" do
|
---|
26 | bg_try do
|
---|
27 | "block"
|
---|
28 | end
|
---|
29 | end
|
---|
30 | end
|
---|
31 |
|
---|
32 | # Kernel.eval is provided by the mruby-gem mrbgem. '15.3.1.2.3'
|
---|
33 |
|
---|
34 | assert('Kernel.iterator?', '15.3.1.2.5') do
|
---|
35 | assert_false Kernel.iterator?
|
---|
36 | end
|
---|
37 |
|
---|
38 | assert('Kernel.lambda', '15.3.1.2.6') do
|
---|
39 | l = Kernel.lambda do
|
---|
40 | true
|
---|
41 | end
|
---|
42 |
|
---|
43 | m = Kernel.lambda(&l)
|
---|
44 |
|
---|
45 | assert_true l.call
|
---|
46 | assert_equal Proc, l.class
|
---|
47 | assert_true m.call
|
---|
48 | assert_equal Proc, m.class
|
---|
49 | end
|
---|
50 |
|
---|
51 | assert('Kernel.loop', '15.3.1.2.8') do
|
---|
52 | i = 0
|
---|
53 |
|
---|
54 | Kernel.loop do
|
---|
55 | i += 1
|
---|
56 | break if i == 100
|
---|
57 | end
|
---|
58 |
|
---|
59 | assert_equal 100, i
|
---|
60 | end
|
---|
61 |
|
---|
62 | assert('Kernel.p', '15.3.1.2.9') do
|
---|
63 | # TODO search for a way to test p to stdio
|
---|
64 | assert_true true
|
---|
65 | end
|
---|
66 |
|
---|
67 | assert('Kernel.print', '15.3.1.2.10') do
|
---|
68 | # TODO search for a way to test print to stdio
|
---|
69 | assert_true true
|
---|
70 | end
|
---|
71 |
|
---|
72 | assert('Kernel.puts', '15.3.1.2.11') do
|
---|
73 | # TODO search for a way to test puts to stdio
|
---|
74 | assert_true true
|
---|
75 | end
|
---|
76 |
|
---|
77 | assert('Kernel.raise', '15.3.1.2.12') do
|
---|
78 | assert_raise RuntimeError do
|
---|
79 | Kernel.raise
|
---|
80 | end
|
---|
81 |
|
---|
82 | assert_raise RuntimeError do
|
---|
83 | Kernel.raise RuntimeError.new
|
---|
84 | end
|
---|
85 | end
|
---|
86 |
|
---|
87 | assert('Kernel#__id__', '15.3.1.3.3') do
|
---|
88 | assert_equal Fixnum, __id__.class
|
---|
89 | end
|
---|
90 |
|
---|
91 | assert('Kernel#__send__', '15.3.1.3.4') do
|
---|
92 | # test with block
|
---|
93 | l = __send__(:lambda) do
|
---|
94 | true
|
---|
95 | end
|
---|
96 |
|
---|
97 | assert_true l.call
|
---|
98 | assert_equal Proc, l.class
|
---|
99 | # test with argument
|
---|
100 | assert_true __send__(:respond_to?, :nil?)
|
---|
101 | # test without argument and without block
|
---|
102 | assert_equal String, __send__(:to_s).class
|
---|
103 | end
|
---|
104 |
|
---|
105 | assert('Kernel#block_given?', '15.3.1.3.6') do
|
---|
106 | def bg_try(&b)
|
---|
107 | if block_given?
|
---|
108 | yield
|
---|
109 | else
|
---|
110 | "no block"
|
---|
111 | end
|
---|
112 | end
|
---|
113 |
|
---|
114 | assert_false block_given?
|
---|
115 | assert_equal "no block", bg_try
|
---|
116 | assert_equal "block" do
|
---|
117 | bg_try { "block" }
|
---|
118 | end
|
---|
119 | assert_equal "block" do
|
---|
120 | bg_try do
|
---|
121 | "block"
|
---|
122 | end
|
---|
123 | end
|
---|
124 | end
|
---|
125 |
|
---|
126 | assert('Kernel#class', '15.3.1.3.7') do
|
---|
127 | assert_equal Module, Kernel.class
|
---|
128 | end
|
---|
129 |
|
---|
130 | assert('Kernel#clone', '15.3.1.3.8') do
|
---|
131 | class KernelCloneTest
|
---|
132 | def initialize
|
---|
133 | @v = 0
|
---|
134 | end
|
---|
135 |
|
---|
136 | def get
|
---|
137 | @v
|
---|
138 | end
|
---|
139 |
|
---|
140 | def set(v)
|
---|
141 | @v = v
|
---|
142 | end
|
---|
143 | end
|
---|
144 |
|
---|
145 | a = KernelCloneTest.new
|
---|
146 | a.set(1)
|
---|
147 | b = a.clone
|
---|
148 |
|
---|
149 | def a.test
|
---|
150 | end
|
---|
151 | a.set(2)
|
---|
152 | c = a.clone
|
---|
153 |
|
---|
154 | immutables = [ 1, :foo, true, false, nil ]
|
---|
155 | error_count = 0
|
---|
156 | immutables.each do |i|
|
---|
157 | begin
|
---|
158 | i.clone
|
---|
159 | rescue TypeError
|
---|
160 | error_count += 1
|
---|
161 | end
|
---|
162 | end
|
---|
163 |
|
---|
164 | assert_equal 2, a.get
|
---|
165 | assert_equal 1, b.get
|
---|
166 | assert_equal 2, c.get
|
---|
167 | assert_true a.respond_to?(:test)
|
---|
168 | assert_false b.respond_to?(:test)
|
---|
169 | assert_true c.respond_to?(:test)
|
---|
170 |
|
---|
171 | a.freeze
|
---|
172 | d = a.clone
|
---|
173 | assert_true d.frozen?
|
---|
174 | end
|
---|
175 |
|
---|
176 | assert('Kernel#dup', '15.3.1.3.9') do
|
---|
177 | class KernelDupTest
|
---|
178 | def initialize
|
---|
179 | @v = 0
|
---|
180 | end
|
---|
181 |
|
---|
182 | def get
|
---|
183 | @v
|
---|
184 | end
|
---|
185 |
|
---|
186 | def set(v)
|
---|
187 | @v = v
|
---|
188 | end
|
---|
189 | end
|
---|
190 |
|
---|
191 | a = KernelDupTest.new
|
---|
192 | a.set(1)
|
---|
193 | b = a.dup
|
---|
194 |
|
---|
195 | def a.test
|
---|
196 | end
|
---|
197 | a.set(2)
|
---|
198 | c = a.dup
|
---|
199 |
|
---|
200 | immutables = [ 1, :foo, true, false, nil ]
|
---|
201 | error_count = 0
|
---|
202 | immutables.each do |i|
|
---|
203 | begin
|
---|
204 | i.dup
|
---|
205 | rescue TypeError
|
---|
206 | error_count += 1
|
---|
207 | end
|
---|
208 | end
|
---|
209 |
|
---|
210 | assert_equal immutables.size, error_count
|
---|
211 | assert_equal 2, a.get
|
---|
212 | assert_equal 1, b.get
|
---|
213 | assert_equal 2, c.get
|
---|
214 | assert_true a.respond_to?(:test)
|
---|
215 | assert_false b.respond_to?(:test)
|
---|
216 | assert_false c.respond_to?(:test)
|
---|
217 | end
|
---|
218 |
|
---|
219 | assert('Kernel#dup class') do
|
---|
220 | assert_nothing_raised do
|
---|
221 | Array.dup.new(200)
|
---|
222 | Range.dup.new(2, 3)
|
---|
223 | String.dup.new("a"*50)
|
---|
224 | end
|
---|
225 | end
|
---|
226 |
|
---|
227 | # Kernel#eval is provided by mruby-eval mrbgem '15.3.1.3.12'
|
---|
228 |
|
---|
229 | assert('Kernel#extend', '15.3.1.3.13') do
|
---|
230 | class Test4ExtendClass
|
---|
231 | end
|
---|
232 |
|
---|
233 | module Test4ExtendModule
|
---|
234 | def test_method; end
|
---|
235 | end
|
---|
236 |
|
---|
237 | a = Test4ExtendClass.new
|
---|
238 | a.extend(Test4ExtendModule)
|
---|
239 | b = Test4ExtendClass.new
|
---|
240 |
|
---|
241 | assert_true a.respond_to?(:test_method)
|
---|
242 | assert_false b.respond_to?(:test_method)
|
---|
243 |
|
---|
244 | assert_raise(FrozenError) { Object.new.freeze.extend(Test4ExtendModule) }
|
---|
245 | assert_raise(FrozenError, TypeError) { :sym.extend(Test4ExtendModule) }
|
---|
246 | end
|
---|
247 |
|
---|
248 | assert('Kernel#extend works on toplevel', '15.3.1.3.13') do
|
---|
249 | module Test4ExtendModule
|
---|
250 | def test_method; end
|
---|
251 | end
|
---|
252 | # This would crash...
|
---|
253 | extend(Test4ExtendModule)
|
---|
254 |
|
---|
255 | assert_true respond_to?(:test_method)
|
---|
256 | end
|
---|
257 |
|
---|
258 | assert('Kernel#freeze') do
|
---|
259 | obj = Object.new
|
---|
260 | assert_equal obj, obj.freeze
|
---|
261 | assert_equal 0, 0.freeze
|
---|
262 | assert_equal :a, :a.freeze
|
---|
263 | assert_equal true, true.freeze
|
---|
264 | assert_equal false, false.freeze
|
---|
265 | assert_equal nil, nil.freeze
|
---|
266 | skip unless Object.const_defined?(:Float)
|
---|
267 | assert_equal 0.0, 0.0.freeze
|
---|
268 | end
|
---|
269 |
|
---|
270 | assert('Kernel#frozen?') do
|
---|
271 | assert_false "".frozen?
|
---|
272 | assert_true "".freeze.frozen?
|
---|
273 | assert_true 0.frozen?
|
---|
274 | assert_true :a.frozen?
|
---|
275 | assert_true true.frozen?
|
---|
276 | assert_true false.frozen?
|
---|
277 | assert_true nil.frozen?
|
---|
278 | skip unless Object.const_defined?(:Float)
|
---|
279 | assert_true 0.0.frozen?
|
---|
280 | end
|
---|
281 |
|
---|
282 | assert('Kernel#hash', '15.3.1.3.15') do
|
---|
283 | assert_equal hash, hash
|
---|
284 | end
|
---|
285 |
|
---|
286 | assert('Kernel#inspect', '15.3.1.3.17') do
|
---|
287 | s = inspect
|
---|
288 |
|
---|
289 | assert_equal String, s.class
|
---|
290 | assert_equal "main", s
|
---|
291 | end
|
---|
292 |
|
---|
293 | assert('Kernel#is_a?', '15.3.1.3.24') do
|
---|
294 | assert_true is_a?(Kernel)
|
---|
295 | assert_false is_a?(Array)
|
---|
296 |
|
---|
297 | assert_raise TypeError do
|
---|
298 | 42.is_a?(42)
|
---|
299 | end
|
---|
300 | end
|
---|
301 |
|
---|
302 | assert('Kernel#iterator?', '15.3.1.3.25') do
|
---|
303 | assert_false iterator?
|
---|
304 | end
|
---|
305 |
|
---|
306 | assert('Kernel#kind_of?', '15.3.1.3.26') do
|
---|
307 | assert_true kind_of?(Kernel)
|
---|
308 | assert_false kind_of?(Array)
|
---|
309 | end
|
---|
310 |
|
---|
311 | assert('Kernel#lambda', '15.3.1.3.27') do
|
---|
312 | l = lambda do
|
---|
313 | true
|
---|
314 | end
|
---|
315 |
|
---|
316 | m = lambda(&l)
|
---|
317 |
|
---|
318 | assert_true l.call
|
---|
319 | assert_equal Proc, l.class
|
---|
320 | assert_true m.call
|
---|
321 | assert_equal Proc, m.class
|
---|
322 | end
|
---|
323 |
|
---|
324 | assert('Kernel#loop', '15.3.1.3.29') do
|
---|
325 | i = 0
|
---|
326 |
|
---|
327 | loop do
|
---|
328 | i += 1
|
---|
329 | break if i == 100
|
---|
330 | end
|
---|
331 |
|
---|
332 | assert_equal i, 100
|
---|
333 | end
|
---|
334 |
|
---|
335 | assert('Kernel#method_missing', '15.3.1.3.30') do
|
---|
336 | class MMTestClass
|
---|
337 | def method_missing(sym)
|
---|
338 | "A call to #{sym}"
|
---|
339 | end
|
---|
340 | end
|
---|
341 | mm_test = MMTestClass.new
|
---|
342 | assert_equal 'A call to no_method_named_this', mm_test.no_method_named_this
|
---|
343 |
|
---|
344 | class SuperMMTestClass < MMTestClass
|
---|
345 | def no_super_method_named_this
|
---|
346 | super
|
---|
347 | end
|
---|
348 | end
|
---|
349 | super_mm_test = SuperMMTestClass.new
|
---|
350 | assert_equal 'A call to no_super_method_named_this', super_mm_test.no_super_method_named_this
|
---|
351 |
|
---|
352 | class NoSuperMethodTestClass
|
---|
353 | def no_super_method_named_this
|
---|
354 | super
|
---|
355 | end
|
---|
356 | end
|
---|
357 | no_super_test = NoSuperMethodTestClass.new
|
---|
358 | msg = "undefined method 'no_super_method_named_this'"
|
---|
359 | assert_raise_with_message(NoMethodError, msg) do
|
---|
360 | no_super_test.no_super_method_named_this
|
---|
361 | end
|
---|
362 |
|
---|
363 | a = String.new
|
---|
364 | msg = "undefined method 'no_method_named_this'"
|
---|
365 | assert_raise_with_message(NoMethodError, msg) do
|
---|
366 | a.no_method_named_this
|
---|
367 | end
|
---|
368 | end
|
---|
369 |
|
---|
370 | assert('Kernel#nil?', '15.3.1.3.32') do
|
---|
371 | assert_false nil?
|
---|
372 | end
|
---|
373 |
|
---|
374 | assert('Kernel#object_id', '15.3.1.3.33') do
|
---|
375 | a = ""
|
---|
376 | b = ""
|
---|
377 | assert_not_equal a.object_id, b.object_id
|
---|
378 |
|
---|
379 | assert_kind_of Numeric, object_id
|
---|
380 | assert_kind_of Numeric, "".object_id
|
---|
381 | assert_kind_of Numeric, true.object_id
|
---|
382 | assert_kind_of Numeric, false.object_id
|
---|
383 | assert_kind_of Numeric, nil.object_id
|
---|
384 | assert_kind_of Numeric, :no.object_id
|
---|
385 | assert_kind_of Numeric, 1.object_id
|
---|
386 | assert_kind_of Numeric, 1.0.object_id
|
---|
387 | end
|
---|
388 |
|
---|
389 | # Kernel#p is defined in mruby-print mrbgem. '15.3.1.3.34'
|
---|
390 |
|
---|
391 | # Kernel#print is defined in mruby-print mrbgem. '15.3.1.3.35'
|
---|
392 |
|
---|
393 | # Kernel#puts is defined in mruby-print mrbgem. '15.3.1.3.39'
|
---|
394 |
|
---|
395 | assert('Kernel#raise', '15.3.1.3.40') do
|
---|
396 | assert_raise RuntimeError do
|
---|
397 | raise
|
---|
398 | end
|
---|
399 |
|
---|
400 | assert_raise RuntimeError do
|
---|
401 | raise RuntimeError.new
|
---|
402 | end
|
---|
403 | end
|
---|
404 |
|
---|
405 | assert('Kernel#remove_instance_variable', '15.3.1.3.41') do
|
---|
406 | class Test4RemoveInstanceVar
|
---|
407 | attr_reader :var
|
---|
408 | def initialize
|
---|
409 | @var = 99
|
---|
410 | end
|
---|
411 | def remove
|
---|
412 | remove_instance_variable(:@var)
|
---|
413 | end
|
---|
414 | end
|
---|
415 |
|
---|
416 | tri = Test4RemoveInstanceVar.new
|
---|
417 | assert_equal 99, tri.var
|
---|
418 | assert_equal 99, tri.remove
|
---|
419 | assert_equal nil, tri.var
|
---|
420 | assert_raise(NameError) { tri.remove }
|
---|
421 | assert_raise(NameError) { tri.remove_instance_variable(:var) }
|
---|
422 | assert_raise(FrozenError) { tri.freeze.remove }
|
---|
423 | assert_raise(FrozenError, NameError) { :a.remove_instance_variable(:@v) }
|
---|
424 | end
|
---|
425 |
|
---|
426 | # Kernel#require is defined in mruby-require. '15.3.1.3.42'
|
---|
427 |
|
---|
428 | assert('Kernel#respond_to?', '15.3.1.3.43') do
|
---|
429 | class Test4RespondTo
|
---|
430 | def valid_method; end
|
---|
431 |
|
---|
432 | def test_method; end
|
---|
433 | undef test_method
|
---|
434 | end
|
---|
435 |
|
---|
436 | assert_raise TypeError do
|
---|
437 | Test4RespondTo.new.respond_to?(1)
|
---|
438 | end
|
---|
439 |
|
---|
440 | assert_raise ArgumentError do
|
---|
441 | Test4RespondTo.new.respond_to?
|
---|
442 | end
|
---|
443 |
|
---|
444 | assert_raise ArgumentError do
|
---|
445 | Test4RespondTo.new.respond_to? :a, true, :aa
|
---|
446 | end
|
---|
447 |
|
---|
448 | assert_true respond_to?(:nil?)
|
---|
449 | assert_true Test4RespondTo.new.respond_to?(:valid_method)
|
---|
450 | assert_true Test4RespondTo.new.respond_to?('valid_method')
|
---|
451 | assert_false Test4RespondTo.new.respond_to?(:test_method)
|
---|
452 | end
|
---|
453 |
|
---|
454 | assert('Kernel#to_s', '15.3.1.3.46') do
|
---|
455 | assert_equal to_s.class, String
|
---|
456 | end
|
---|
457 |
|
---|
458 | assert('Kernel#!=') do
|
---|
459 | str1 = "hello"
|
---|
460 | str2 = str1
|
---|
461 | str3 = "world"
|
---|
462 |
|
---|
463 | assert_false (str1[1] != 'e')
|
---|
464 | assert_true (str1 != str3)
|
---|
465 | assert_false (str2 != str1)
|
---|
466 | end
|
---|
467 |
|
---|
468 | # operator "!~" is defined in ISO Ruby 11.4.4.
|
---|
469 | assert('Kernel#!~') do
|
---|
470 | x = "x"
|
---|
471 | def x.=~(other)
|
---|
472 | other == "x"
|
---|
473 | end
|
---|
474 | assert_false x !~ "x"
|
---|
475 | assert_true x !~ "z"
|
---|
476 |
|
---|
477 | y = "y"
|
---|
478 | def y.=~(other)
|
---|
479 | other == "y"
|
---|
480 | end
|
---|
481 | def y.!~(other)
|
---|
482 | other == "not y"
|
---|
483 | end
|
---|
484 | assert_false y !~ "y"
|
---|
485 | assert_false y !~ "z"
|
---|
486 | assert_true y !~ "not y"
|
---|
487 | end
|
---|
488 |
|
---|
489 | assert('Kernel#respond_to_missing?') do
|
---|
490 | class Test4RespondToMissing
|
---|
491 | def respond_to_missing?(method_name, include_private = false)
|
---|
492 | method_name == :a_method
|
---|
493 | end
|
---|
494 | end
|
---|
495 |
|
---|
496 | assert_true Test4RespondToMissing.new.respond_to?(:a_method)
|
---|
497 | assert_false Test4RespondToMissing.new.respond_to?(:no_method)
|
---|
498 | end
|
---|
499 |
|
---|
500 | assert('stack extend') do
|
---|
501 | def recurse(count, stop)
|
---|
502 | return count if count > stop
|
---|
503 | recurse(count+1, stop)
|
---|
504 | end
|
---|
505 |
|
---|
506 | assert_equal 6, recurse(0, 5)
|
---|
507 | end
|
---|