[270] | 1 | assert('Kernel.fail, Kernel#fail') do
|
---|
| 2 | assert_raise(RuntimeError) { fail }
|
---|
| 3 | assert_raise(RuntimeError) { Kernel.fail }
|
---|
| 4 | end
|
---|
| 5 |
|
---|
[331] | 6 | assert('Kernel.caller, Kernel#caller') do
|
---|
| 7 | skip "backtrace isn't available" if caller(0).empty?
|
---|
| 8 |
|
---|
| 9 | caller_lineno = __LINE__ + 3
|
---|
| 10 | c = Class.new do
|
---|
| 11 | def foo(*args)
|
---|
| 12 | caller(*args)
|
---|
| 13 | end
|
---|
| 14 |
|
---|
| 15 | def bar(*args)
|
---|
| 16 | foo(*args)
|
---|
| 17 | end
|
---|
| 18 |
|
---|
| 19 | def baz(*args)
|
---|
| 20 | bar(*args)
|
---|
| 21 | end
|
---|
| 22 | end
|
---|
| 23 | assert_equal "kernel.rb:#{caller_lineno}:in foo", c.new.baz(0)[0][-19..-1]
|
---|
| 24 | assert_equal "bar", c.new.baz[0][-3..-1]
|
---|
| 25 | assert_equal "foo", c.new.baz(0)[0][-3..-1]
|
---|
| 26 | assert_equal "bar", c.new.baz(1)[0][-3..-1]
|
---|
| 27 | assert_equal "baz", c.new.baz(2)[0][-3..-1]
|
---|
| 28 | assert_equal ["foo", "bar"], c.new.baz(0, 2).map { |i| i[-3..-1] }
|
---|
| 29 | assert_equal ["bar", "baz"], c.new.baz(1..2).map { |i| i[-3..-1] }
|
---|
| 30 | assert_nil c.new.baz(10..20)
|
---|
| 31 | assert_raise(ArgumentError) { c.new.baz(-1) }
|
---|
| 32 | assert_raise(ArgumentError) { c.new.baz(-1, 1) }
|
---|
| 33 | assert_raise(ArgumentError) { c.new.baz(1, -1) }
|
---|
| 34 | assert_raise(TypeError) { c.new.baz(nil) }
|
---|
| 35 | end
|
---|
| 36 |
|
---|
[270] | 37 | assert('Kernel#__method__') do
|
---|
| 38 | assert_equal(:m, Class.new {def m; __method__; end}.new.m)
|
---|
| 39 | assert_equal(:m, Class.new {define_method(:m) {__method__}}.new.m)
|
---|
| 40 | c = Class.new do
|
---|
| 41 | [:m1, :m2].each do |m|
|
---|
| 42 | define_method(m) do
|
---|
| 43 | __method__
|
---|
| 44 | end
|
---|
| 45 | end
|
---|
| 46 | end
|
---|
| 47 | assert_equal(:m1, c.new.m1)
|
---|
| 48 | assert_equal(:m2, c.new.m2)
|
---|
| 49 | end
|
---|
| 50 |
|
---|
| 51 | assert('Kernel#Integer') do
|
---|
[439] | 52 | assert_operator(26, :eql?, Integer("0x1a"))
|
---|
| 53 | assert_operator(930, :eql?, Integer("0930", 10))
|
---|
| 54 | assert_operator(7, :eql?, Integer("111", 2))
|
---|
| 55 | assert_operator(0, :eql?, Integer("0"))
|
---|
| 56 | assert_operator(0, :eql?, Integer("00000"))
|
---|
| 57 | assert_operator(123, :eql?, Integer('1_2_3'))
|
---|
| 58 | assert_operator(123, :eql?, Integer("\t\r\n\f\v 123 \t\r\n\f\v"))
|
---|
[270] | 59 | assert_raise(TypeError) { Integer(nil) }
|
---|
[439] | 60 | assert_raise(ArgumentError) { Integer('a') }
|
---|
| 61 | assert_raise(ArgumentError) { Integer('4a5') }
|
---|
| 62 | assert_raise(ArgumentError) { Integer('1_2__3') }
|
---|
| 63 | assert_raise(ArgumentError) { Integer('68_') }
|
---|
| 64 | assert_raise(ArgumentError) { Integer('68_ ') }
|
---|
| 65 | assert_raise(ArgumentError) { Integer('_68') }
|
---|
| 66 | assert_raise(ArgumentError) { Integer(' _68') }
|
---|
| 67 | assert_raise(ArgumentError) { Integer('6 8') }
|
---|
| 68 | assert_raise(ArgumentError) { Integer("15\0") }
|
---|
| 69 | assert_raise(ArgumentError) { Integer("15.0") }
|
---|
| 70 | skip unless Object.const_defined?(:Float)
|
---|
| 71 | assert_operator(123, :eql?, Integer(123.999))
|
---|
[270] | 72 | end
|
---|
| 73 |
|
---|
| 74 | assert('Kernel#Float') do
|
---|
[439] | 75 | skip unless Object.const_defined?(:Float)
|
---|
| 76 | assert_operator(1.0, :eql?, Float(1))
|
---|
| 77 | assert_operator(123.456, :eql?, Float(123.456))
|
---|
| 78 | assert_operator(123.456, :eql?, Float("123.456"))
|
---|
| 79 | assert_operator(123.0, :eql?, Float('1_2_3'))
|
---|
| 80 | assert_operator(12.34, :eql?, Float('1_2.3_4'))
|
---|
| 81 | assert_operator(0.9, :eql?, Float('.9'))
|
---|
| 82 | assert_operator(0.9, :eql?, Float(" \t\r\n\f\v.9 \t\r\n\f\v"))
|
---|
| 83 | assert_operator(16.0, :eql?, Float("0x10"))
|
---|
[270] | 84 | assert_raise(TypeError) { Float(nil) }
|
---|
[439] | 85 | assert_raise(ArgumentError) { Float("1. 5") }
|
---|
| 86 | assert_raise(ArgumentError) { Float("1.5a") }
|
---|
| 87 | assert_raise(ArgumentError) { Float("1.5\0") }
|
---|
| 88 | assert_raise(ArgumentError) { Float('a') }
|
---|
| 89 | assert_raise(ArgumentError) { Float('4a5') }
|
---|
| 90 | assert_raise(ArgumentError) { Float('1_2__3') }
|
---|
| 91 | assert_raise(ArgumentError) { Float('68_') }
|
---|
| 92 | assert_raise(ArgumentError) { Float('68._7') }
|
---|
| 93 | assert_raise(ArgumentError) { Float('68.7_') }
|
---|
| 94 | assert_raise(ArgumentError) { Float('68.7_ ') }
|
---|
| 95 | assert_raise(ArgumentError) { Float('_68') }
|
---|
| 96 | assert_raise(ArgumentError) { Float(' _68') }
|
---|
| 97 | assert_raise(ArgumentError) { Float('1_2.3__4') }
|
---|
[270] | 98 | end
|
---|
| 99 |
|
---|
| 100 | assert('Kernel#String') do
|
---|
| 101 | assert_equal("main", String(self))
|
---|
| 102 | assert_equal("Object", String(self.class))
|
---|
| 103 | assert_equal("123456", String(123456))
|
---|
| 104 | end
|
---|
| 105 |
|
---|
| 106 | assert('Kernel#Array') do
|
---|
| 107 | assert_equal([1], Kernel.Array(1))
|
---|
| 108 | assert_equal([1, 2, 3, 4, 5], Kernel.Array([1, 2, 3, 4, 5]))
|
---|
| 109 | assert_equal([1, 2, 3, 4, 5], Kernel.Array(1..5))
|
---|
| 110 | assert_equal([[:a, 1], [:b, 2], [:c, 3]], Kernel.Array({a:1, b:2, c:3}))
|
---|
| 111 | end
|
---|
| 112 |
|
---|
| 113 | assert('Kernel#Hash') do
|
---|
| 114 | assert_equal({}, Hash([]))
|
---|
| 115 | assert_equal({}, Hash(nil))
|
---|
| 116 | assert_equal({:key => :value}, Hash(key: :value))
|
---|
| 117 | assert_raise(TypeError) { Hash([1, 2, 3]) }
|
---|
| 118 | end
|
---|