[270] | 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
|
---|
[439] | 102 | assert_equal String, __send__(:to_s).class
|
---|
[270] | 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)
|
---|
[439] | 170 |
|
---|
| 171 | a.freeze
|
---|
| 172 | d = a.clone
|
---|
| 173 | assert_true d.frozen?
|
---|
[270] | 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 |
|
---|
[331] | 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 |
|
---|
[270] | 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)
|
---|
[439] | 243 |
|
---|
| 244 | assert_raise(FrozenError) { Object.new.freeze.extend(Test4ExtendModule) }
|
---|
| 245 | assert_raise(FrozenError, TypeError) { :sym.extend(Test4ExtendModule) }
|
---|
[270] | 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 |
|
---|
[331] | 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
|
---|
[439] | 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
|
---|
[331] | 268 | end
|
---|
| 269 |
|
---|
[439] | 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?
|
---|
[270] | 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 |
|
---|
[439] | 344 | class SuperMMTestClass < MMTestClass
|
---|
| 345 | def no_super_method_named_this
|
---|
| 346 | super
|
---|
[270] | 347 | end
|
---|
| 348 | end
|
---|
[439] | 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
|
---|
[270] | 351 |
|
---|
[439] | 352 | class NoSuperMethodTestClass
|
---|
| 353 | def no_super_method_named_this
|
---|
| 354 | super
|
---|
[270] | 355 | end
|
---|
| 356 | end
|
---|
[439] | 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
|
---|
[270] | 361 | end
|
---|
| 362 |
|
---|
[439] | 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
|
---|
[270] | 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
|
---|
[439] | 418 | assert_equal 99, tri.remove
|
---|
[270] | 419 | assert_equal nil, tri.var
|
---|
[439] | 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) }
|
---|
[270] | 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
|
---|