[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.global_variables', '15.3.1.2.4') do
|
---|
| 35 | assert_equal Array, Kernel.global_variables.class
|
---|
| 36 | end
|
---|
| 37 |
|
---|
| 38 | assert('Kernel.iterator?', '15.3.1.2.5') do
|
---|
| 39 | assert_false Kernel.iterator?
|
---|
| 40 | end
|
---|
| 41 |
|
---|
| 42 | assert('Kernel.lambda', '15.3.1.2.6') do
|
---|
| 43 | l = Kernel.lambda do
|
---|
| 44 | true
|
---|
| 45 | end
|
---|
| 46 |
|
---|
| 47 | m = Kernel.lambda(&l)
|
---|
| 48 |
|
---|
| 49 | assert_true l.call
|
---|
| 50 | assert_equal Proc, l.class
|
---|
| 51 | assert_true m.call
|
---|
| 52 | assert_equal Proc, m.class
|
---|
| 53 | end
|
---|
| 54 |
|
---|
| 55 | # Not implemented at the moment
|
---|
| 56 | #assert('Kernel.local_variables', '15.3.1.2.7') do
|
---|
| 57 | # Kernel.local_variables.class == Array
|
---|
| 58 | #end
|
---|
| 59 |
|
---|
| 60 | assert('Kernel.loop', '15.3.1.2.8') do
|
---|
| 61 | i = 0
|
---|
| 62 |
|
---|
| 63 | Kernel.loop do
|
---|
| 64 | i += 1
|
---|
| 65 | break if i == 100
|
---|
| 66 | end
|
---|
| 67 |
|
---|
| 68 | assert_equal 100, i
|
---|
| 69 | end
|
---|
| 70 |
|
---|
| 71 | assert('Kernel.p', '15.3.1.2.9') do
|
---|
| 72 | # TODO search for a way to test p to stdio
|
---|
| 73 | assert_true true
|
---|
| 74 | end
|
---|
| 75 |
|
---|
| 76 | assert('Kernel.print', '15.3.1.2.10') do
|
---|
| 77 | # TODO search for a way to test print to stdio
|
---|
| 78 | assert_true true
|
---|
| 79 | end
|
---|
| 80 |
|
---|
| 81 | assert('Kernel.puts', '15.3.1.2.11') do
|
---|
| 82 | # TODO search for a way to test puts to stdio
|
---|
| 83 | assert_true true
|
---|
| 84 | end
|
---|
| 85 |
|
---|
| 86 | assert('Kernel.raise', '15.3.1.2.12') do
|
---|
| 87 | assert_raise RuntimeError do
|
---|
| 88 | Kernel.raise
|
---|
| 89 | end
|
---|
| 90 |
|
---|
| 91 | assert_raise RuntimeError do
|
---|
| 92 | Kernel.raise RuntimeError.new
|
---|
| 93 | end
|
---|
| 94 | end
|
---|
| 95 |
|
---|
| 96 | assert('Kernel#__id__', '15.3.1.3.3') do
|
---|
| 97 | assert_equal Fixnum, __id__.class
|
---|
| 98 | end
|
---|
| 99 |
|
---|
| 100 | assert('Kernel#__send__', '15.3.1.3.4') do
|
---|
| 101 | # test with block
|
---|
| 102 | l = __send__(:lambda) do
|
---|
| 103 | true
|
---|
| 104 | end
|
---|
| 105 |
|
---|
| 106 | assert_true l.call
|
---|
| 107 | assert_equal Proc, l.class
|
---|
| 108 | # test with argument
|
---|
| 109 | assert_true __send__(:respond_to?, :nil?)
|
---|
| 110 | # test without argument and without block
|
---|
| 111 | assert_equal Array, __send__(:public_methods).class
|
---|
| 112 | end
|
---|
| 113 |
|
---|
| 114 | assert('Kernel#block_given?', '15.3.1.3.6') do
|
---|
| 115 | def bg_try(&b)
|
---|
| 116 | if block_given?
|
---|
| 117 | yield
|
---|
| 118 | else
|
---|
| 119 | "no block"
|
---|
| 120 | end
|
---|
| 121 | end
|
---|
| 122 |
|
---|
| 123 | assert_false block_given?
|
---|
| 124 | assert_equal "no block", bg_try
|
---|
| 125 | assert_equal "block" do
|
---|
| 126 | bg_try { "block" }
|
---|
| 127 | end
|
---|
| 128 | assert_equal "block" do
|
---|
| 129 | bg_try do
|
---|
| 130 | "block"
|
---|
| 131 | end
|
---|
| 132 | end
|
---|
| 133 | end
|
---|
| 134 |
|
---|
| 135 | assert('Kernel#class', '15.3.1.3.7') do
|
---|
| 136 | assert_equal Module, Kernel.class
|
---|
| 137 | end
|
---|
| 138 |
|
---|
| 139 | assert('Kernel#clone', '15.3.1.3.8') do
|
---|
| 140 | class KernelCloneTest
|
---|
| 141 | def initialize
|
---|
| 142 | @v = 0
|
---|
| 143 | end
|
---|
| 144 |
|
---|
| 145 | def get
|
---|
| 146 | @v
|
---|
| 147 | end
|
---|
| 148 |
|
---|
| 149 | def set(v)
|
---|
| 150 | @v = v
|
---|
| 151 | end
|
---|
| 152 | end
|
---|
| 153 |
|
---|
| 154 | a = KernelCloneTest.new
|
---|
| 155 | a.set(1)
|
---|
| 156 | b = a.clone
|
---|
| 157 |
|
---|
| 158 | def a.test
|
---|
| 159 | end
|
---|
| 160 | a.set(2)
|
---|
| 161 | c = a.clone
|
---|
| 162 |
|
---|
| 163 | immutables = [ 1, :foo, true, false, nil ]
|
---|
| 164 | error_count = 0
|
---|
| 165 | immutables.each do |i|
|
---|
| 166 | begin
|
---|
| 167 | i.clone
|
---|
| 168 | rescue TypeError
|
---|
| 169 | error_count += 1
|
---|
| 170 | end
|
---|
| 171 | end
|
---|
| 172 |
|
---|
| 173 | assert_equal 2, a.get
|
---|
| 174 | assert_equal 1, b.get
|
---|
| 175 | assert_equal 2, c.get
|
---|
| 176 | assert_true a.respond_to?(:test)
|
---|
| 177 | assert_false b.respond_to?(:test)
|
---|
| 178 | assert_true c.respond_to?(:test)
|
---|
| 179 | end
|
---|
| 180 |
|
---|
| 181 | assert('Kernel#dup', '15.3.1.3.9') do
|
---|
| 182 | class KernelDupTest
|
---|
| 183 | def initialize
|
---|
| 184 | @v = 0
|
---|
| 185 | end
|
---|
| 186 |
|
---|
| 187 | def get
|
---|
| 188 | @v
|
---|
| 189 | end
|
---|
| 190 |
|
---|
| 191 | def set(v)
|
---|
| 192 | @v = v
|
---|
| 193 | end
|
---|
| 194 | end
|
---|
| 195 |
|
---|
| 196 | a = KernelDupTest.new
|
---|
| 197 | a.set(1)
|
---|
| 198 | b = a.dup
|
---|
| 199 |
|
---|
| 200 | def a.test
|
---|
| 201 | end
|
---|
| 202 | a.set(2)
|
---|
| 203 | c = a.dup
|
---|
| 204 |
|
---|
| 205 | immutables = [ 1, :foo, true, false, nil ]
|
---|
| 206 | error_count = 0
|
---|
| 207 | immutables.each do |i|
|
---|
| 208 | begin
|
---|
| 209 | i.dup
|
---|
| 210 | rescue TypeError
|
---|
| 211 | error_count += 1
|
---|
| 212 | end
|
---|
| 213 | end
|
---|
| 214 |
|
---|
| 215 | assert_equal immutables.size, error_count
|
---|
| 216 | assert_equal 2, a.get
|
---|
| 217 | assert_equal 1, b.get
|
---|
| 218 | assert_equal 2, c.get
|
---|
| 219 | assert_true a.respond_to?(:test)
|
---|
| 220 | assert_false b.respond_to?(:test)
|
---|
| 221 | assert_false c.respond_to?(:test)
|
---|
| 222 | end
|
---|
| 223 |
|
---|
[331] | 224 | assert('Kernel#dup class') do
|
---|
| 225 | assert_nothing_raised do
|
---|
| 226 | Array.dup.new(200)
|
---|
| 227 | Range.dup.new(2, 3)
|
---|
| 228 | String.dup.new("a"*50)
|
---|
| 229 | end
|
---|
| 230 | end
|
---|
| 231 |
|
---|
[270] | 232 | # Kernel#eval is provided by mruby-eval mrbgem '15.3.1.3.12'
|
---|
| 233 |
|
---|
| 234 | assert('Kernel#extend', '15.3.1.3.13') do
|
---|
| 235 | class Test4ExtendClass
|
---|
| 236 | end
|
---|
| 237 |
|
---|
| 238 | module Test4ExtendModule
|
---|
| 239 | def test_method; end
|
---|
| 240 | end
|
---|
| 241 |
|
---|
| 242 | a = Test4ExtendClass.new
|
---|
| 243 | a.extend(Test4ExtendModule)
|
---|
| 244 | b = Test4ExtendClass.new
|
---|
| 245 |
|
---|
| 246 | assert_true a.respond_to?(:test_method)
|
---|
| 247 | assert_false b.respond_to?(:test_method)
|
---|
| 248 | end
|
---|
| 249 |
|
---|
| 250 | assert('Kernel#extend works on toplevel', '15.3.1.3.13') do
|
---|
| 251 | module Test4ExtendModule
|
---|
| 252 | def test_method; end
|
---|
| 253 | end
|
---|
| 254 | # This would crash...
|
---|
| 255 | extend(Test4ExtendModule)
|
---|
| 256 |
|
---|
| 257 | assert_true respond_to?(:test_method)
|
---|
| 258 | end
|
---|
| 259 |
|
---|
[331] | 260 | assert('Kernel#freeze') do
|
---|
| 261 | obj = Object.new
|
---|
| 262 | assert_equal obj, obj.freeze
|
---|
| 263 | assert_equal 0, 0.freeze
|
---|
| 264 | assert_equal :a, :a.freeze
|
---|
| 265 | end
|
---|
| 266 |
|
---|
[270] | 267 | assert('Kernel#global_variables', '15.3.1.3.14') do
|
---|
| 268 | assert_equal Array, global_variables.class
|
---|
| 269 | end
|
---|
| 270 |
|
---|
| 271 | assert('Kernel#hash', '15.3.1.3.15') do
|
---|
| 272 | assert_equal hash, hash
|
---|
| 273 | end
|
---|
| 274 |
|
---|
| 275 | assert('Kernel#inspect', '15.3.1.3.17') do
|
---|
| 276 | s = inspect
|
---|
| 277 |
|
---|
| 278 | assert_equal String, s.class
|
---|
| 279 | assert_equal "main", s
|
---|
| 280 | end
|
---|
| 281 |
|
---|
| 282 | assert('Kernel#instance_variable_defined?', '15.3.1.3.20') do
|
---|
| 283 | o = Object.new
|
---|
| 284 | o.instance_variable_set(:@a, 1)
|
---|
| 285 |
|
---|
| 286 | assert_true o.instance_variable_defined?("@a")
|
---|
| 287 | assert_false o.instance_variable_defined?("@b")
|
---|
| 288 | assert_true o.instance_variable_defined?("@a"[0,2])
|
---|
| 289 | assert_true o.instance_variable_defined?("@abc"[0,2])
|
---|
| 290 | end
|
---|
| 291 |
|
---|
| 292 | assert('Kernel#instance_variables', '15.3.1.3.23') do
|
---|
| 293 | o = Object.new
|
---|
| 294 | o.instance_eval do
|
---|
| 295 | @a = 11
|
---|
| 296 | @b = 12
|
---|
| 297 | end
|
---|
| 298 | ivars = o.instance_variables
|
---|
| 299 |
|
---|
| 300 | assert_equal Array, ivars.class,
|
---|
| 301 | assert_equal(2, ivars.size)
|
---|
| 302 | assert_true ivars.include?(:@a)
|
---|
| 303 | assert_true ivars.include?(:@b)
|
---|
| 304 | end
|
---|
| 305 |
|
---|
| 306 | assert('Kernel#is_a?', '15.3.1.3.24') do
|
---|
| 307 | assert_true is_a?(Kernel)
|
---|
| 308 | assert_false is_a?(Array)
|
---|
| 309 |
|
---|
| 310 | assert_raise TypeError do
|
---|
| 311 | 42.is_a?(42)
|
---|
| 312 | end
|
---|
| 313 | end
|
---|
| 314 |
|
---|
| 315 | assert('Kernel#iterator?', '15.3.1.3.25') do
|
---|
| 316 | assert_false iterator?
|
---|
| 317 | end
|
---|
| 318 |
|
---|
| 319 | assert('Kernel#kind_of?', '15.3.1.3.26') do
|
---|
| 320 | assert_true kind_of?(Kernel)
|
---|
| 321 | assert_false kind_of?(Array)
|
---|
| 322 | end
|
---|
| 323 |
|
---|
| 324 | assert('Kernel#lambda', '15.3.1.3.27') do
|
---|
| 325 | l = lambda do
|
---|
| 326 | true
|
---|
| 327 | end
|
---|
| 328 |
|
---|
| 329 | m = lambda(&l)
|
---|
| 330 |
|
---|
| 331 | assert_true l.call
|
---|
| 332 | assert_equal Proc, l.class
|
---|
| 333 | assert_true m.call
|
---|
| 334 | assert_equal Proc, m.class
|
---|
| 335 | end
|
---|
| 336 |
|
---|
| 337 | # Not implemented yet
|
---|
| 338 | #assert('Kernel#local_variables', '15.3.1.3.28') do
|
---|
| 339 | # local_variables.class == Array
|
---|
| 340 | #end
|
---|
| 341 |
|
---|
| 342 | assert('Kernel#loop', '15.3.1.3.29') do
|
---|
| 343 | i = 0
|
---|
| 344 |
|
---|
| 345 | loop do
|
---|
| 346 | i += 1
|
---|
| 347 | break if i == 100
|
---|
| 348 | end
|
---|
| 349 |
|
---|
| 350 | assert_equal i, 100
|
---|
| 351 | end
|
---|
| 352 |
|
---|
| 353 | assert('Kernel#method_missing', '15.3.1.3.30') do
|
---|
| 354 | class MMTestClass
|
---|
| 355 | def method_missing(sym)
|
---|
| 356 | "A call to #{sym}"
|
---|
| 357 | end
|
---|
| 358 | end
|
---|
| 359 | mm_test = MMTestClass.new
|
---|
| 360 | assert_equal 'A call to no_method_named_this', mm_test.no_method_named_this
|
---|
| 361 |
|
---|
| 362 | a = String.new
|
---|
| 363 | begin
|
---|
| 364 | a.no_method_named_this
|
---|
| 365 | rescue NoMethodError => e
|
---|
| 366 | assert_equal "undefined method 'no_method_named_this' for \"\"", e.message
|
---|
| 367 | end
|
---|
| 368 |
|
---|
| 369 | class ShortInspectClass
|
---|
| 370 | def inspect
|
---|
| 371 | 'An inspect string'
|
---|
| 372 | end
|
---|
| 373 | end
|
---|
| 374 | b = ShortInspectClass.new
|
---|
| 375 | begin
|
---|
| 376 | b.no_method_named_this
|
---|
| 377 | rescue NoMethodError => e
|
---|
| 378 | assert_equal "undefined method 'no_method_named_this' for An inspect string", e.message
|
---|
| 379 | end
|
---|
| 380 |
|
---|
| 381 | class LongInspectClass
|
---|
| 382 | def inspect
|
---|
| 383 | "A" * 70
|
---|
| 384 | end
|
---|
| 385 | end
|
---|
| 386 | c = LongInspectClass.new
|
---|
| 387 | begin
|
---|
| 388 | c.no_method_named_this
|
---|
| 389 | rescue NoMethodError => e
|
---|
| 390 | assert_equal "undefined method 'no_method_named_this' for #{c.to_s}", e.message
|
---|
| 391 | end
|
---|
| 392 |
|
---|
| 393 | class NoInspectClass
|
---|
| 394 | undef inspect
|
---|
| 395 | end
|
---|
| 396 | d = NoInspectClass.new
|
---|
| 397 | begin
|
---|
| 398 | d.no_method_named_this
|
---|
| 399 | rescue NoMethodError => e
|
---|
| 400 | assert_equal "undefined method 'no_method_named_this' for #{d.to_s}", e.message
|
---|
| 401 | end
|
---|
| 402 | end
|
---|
| 403 |
|
---|
| 404 | assert('Kernel#methods', '15.3.1.3.31') do
|
---|
| 405 | assert_equal Array, methods.class
|
---|
| 406 | end
|
---|
| 407 |
|
---|
| 408 | assert('Kernel#nil?', '15.3.1.3.32') do
|
---|
| 409 | assert_false nil?
|
---|
| 410 | end
|
---|
| 411 |
|
---|
| 412 | assert('Kernel#object_id', '15.3.1.3.33') do
|
---|
| 413 | a = ""
|
---|
| 414 | b = ""
|
---|
| 415 | assert_not_equal a.object_id, b.object_id
|
---|
| 416 |
|
---|
| 417 | assert_kind_of Numeric, object_id
|
---|
| 418 | assert_kind_of Numeric, "".object_id
|
---|
| 419 | assert_kind_of Numeric, true.object_id
|
---|
| 420 | assert_kind_of Numeric, false.object_id
|
---|
| 421 | assert_kind_of Numeric, nil.object_id
|
---|
| 422 | assert_kind_of Numeric, :no.object_id
|
---|
| 423 | assert_kind_of Numeric, 1.object_id
|
---|
| 424 | assert_kind_of Numeric, 1.0.object_id
|
---|
| 425 | end
|
---|
| 426 |
|
---|
| 427 | # Kernel#p is defined in mruby-print mrbgem. '15.3.1.3.34'
|
---|
| 428 |
|
---|
| 429 | # Kernel#print is defined in mruby-print mrbgem. '15.3.1.3.35'
|
---|
| 430 |
|
---|
| 431 | assert('Kernel#private_methods', '15.3.1.3.36') do
|
---|
| 432 | assert_equal Array, private_methods.class
|
---|
| 433 | end
|
---|
| 434 |
|
---|
| 435 | assert('Kernel#protected_methods', '15.3.1.3.37') do
|
---|
| 436 | assert_equal Array, protected_methods.class
|
---|
| 437 | end
|
---|
| 438 |
|
---|
| 439 | assert('Kernel#public_methods', '15.3.1.3.38') do
|
---|
| 440 | assert_equal Array, public_methods.class
|
---|
[331] | 441 | class Foo
|
---|
| 442 | def foo
|
---|
| 443 | end
|
---|
| 444 | end
|
---|
| 445 | assert_equal [:foo], Foo.new.public_methods(false)
|
---|
[270] | 446 | end
|
---|
| 447 |
|
---|
| 448 | # Kernel#puts is defined in mruby-print mrbgem. '15.3.1.3.39'
|
---|
| 449 |
|
---|
| 450 | assert('Kernel#raise', '15.3.1.3.40') do
|
---|
| 451 | assert_raise RuntimeError do
|
---|
| 452 | raise
|
---|
| 453 | end
|
---|
| 454 |
|
---|
| 455 | assert_raise RuntimeError do
|
---|
| 456 | raise RuntimeError.new
|
---|
| 457 | end
|
---|
| 458 | end
|
---|
| 459 |
|
---|
| 460 | assert('Kernel#remove_instance_variable', '15.3.1.3.41') do
|
---|
| 461 | class Test4RemoveInstanceVar
|
---|
| 462 | attr_reader :var
|
---|
| 463 | def initialize
|
---|
| 464 | @var = 99
|
---|
| 465 | end
|
---|
| 466 | def remove
|
---|
| 467 | remove_instance_variable(:@var)
|
---|
| 468 | end
|
---|
| 469 | end
|
---|
| 470 |
|
---|
| 471 | tri = Test4RemoveInstanceVar.new
|
---|
| 472 | assert_equal 99, tri.var
|
---|
| 473 | tri.remove
|
---|
| 474 | assert_equal nil, tri.var
|
---|
| 475 | assert_raise NameError do
|
---|
| 476 | tri.remove
|
---|
| 477 | end
|
---|
| 478 | end
|
---|
| 479 |
|
---|
| 480 | # Kernel#require is defined in mruby-require. '15.3.1.3.42'
|
---|
| 481 |
|
---|
| 482 | assert('Kernel#respond_to?', '15.3.1.3.43') do
|
---|
| 483 | class Test4RespondTo
|
---|
| 484 | def valid_method; end
|
---|
| 485 |
|
---|
| 486 | def test_method; end
|
---|
| 487 | undef test_method
|
---|
| 488 | end
|
---|
| 489 |
|
---|
| 490 | assert_raise TypeError do
|
---|
| 491 | Test4RespondTo.new.respond_to?(1)
|
---|
| 492 | end
|
---|
| 493 |
|
---|
| 494 | assert_raise ArgumentError do
|
---|
| 495 | Test4RespondTo.new.respond_to?
|
---|
| 496 | end
|
---|
| 497 |
|
---|
| 498 | assert_raise ArgumentError do
|
---|
| 499 | Test4RespondTo.new.respond_to? :a, true, :aa
|
---|
| 500 | end
|
---|
| 501 |
|
---|
| 502 | assert_true respond_to?(:nil?)
|
---|
| 503 | assert_true Test4RespondTo.new.respond_to?(:valid_method)
|
---|
| 504 | assert_true Test4RespondTo.new.respond_to?('valid_method')
|
---|
| 505 | assert_false Test4RespondTo.new.respond_to?(:test_method)
|
---|
| 506 | end
|
---|
| 507 |
|
---|
| 508 | assert('Kernel#send', '15.3.1.3.44') do
|
---|
| 509 | # test with block
|
---|
| 510 | l = send(:lambda) do
|
---|
| 511 | true
|
---|
| 512 | end
|
---|
| 513 |
|
---|
| 514 | assert_true l.call
|
---|
| 515 | assert_equal l.class, Proc
|
---|
| 516 | # test with argument
|
---|
| 517 | assert_true send(:respond_to?, :nil?)
|
---|
| 518 | # test without argument and without block
|
---|
| 519 | assert_equal send(:public_methods).class, Array
|
---|
| 520 | end
|
---|
| 521 |
|
---|
| 522 | assert('Kernel#singleton_methods', '15.3.1.3.45') do
|
---|
| 523 | assert_equal singleton_methods.class, Array
|
---|
| 524 | end
|
---|
| 525 |
|
---|
| 526 | assert('Kernel#to_s', '15.3.1.3.46') do
|
---|
| 527 | assert_equal to_s.class, String
|
---|
| 528 | end
|
---|
| 529 |
|
---|
[331] | 530 | assert('Kernel#to_s on primitives') do
|
---|
| 531 | begin
|
---|
| 532 | Fixnum.alias_method :to_s_, :to_s
|
---|
| 533 | Fixnum.remove_method :to_s
|
---|
| 534 |
|
---|
| 535 | assert_nothing_raised do
|
---|
| 536 | # segfaults if mrb_cptr is used
|
---|
| 537 | 1.to_s
|
---|
| 538 | end
|
---|
| 539 | ensure
|
---|
| 540 | Fixnum.alias_method :to_s, :to_s_
|
---|
| 541 | Fixnum.remove_method :to_s_
|
---|
| 542 | end
|
---|
| 543 | end
|
---|
| 544 |
|
---|
[270] | 545 | assert('Kernel.local_variables', '15.3.1.2.7') do
|
---|
| 546 | a, b = 0, 1
|
---|
| 547 | a += b
|
---|
| 548 |
|
---|
| 549 | vars = Kernel.local_variables.sort
|
---|
| 550 | assert_equal [:a, :b, :vars], vars
|
---|
| 551 |
|
---|
[331] | 552 | assert_equal [:a, :b, :c, :vars], Proc.new { |a, b|
|
---|
[270] | 553 | c = 2
|
---|
[331] | 554 | Kernel.local_variables.sort
|
---|
| 555 | }.call(-1, -2)
|
---|
[270] | 556 | end
|
---|
| 557 |
|
---|
| 558 | assert('Kernel#!=') do
|
---|
| 559 | str1 = "hello"
|
---|
| 560 | str2 = str1
|
---|
| 561 | str3 = "world"
|
---|
| 562 |
|
---|
| 563 | assert_false (str1[1] != 'e')
|
---|
| 564 | assert_true (str1 != str3)
|
---|
| 565 | assert_false (str2 != str1)
|
---|
| 566 | end
|
---|
| 567 |
|
---|
| 568 | # operator "!~" is defined in ISO Ruby 11.4.4.
|
---|
| 569 | assert('Kernel#!~') do
|
---|
| 570 | x = "x"
|
---|
| 571 | def x.=~(other)
|
---|
| 572 | other == "x"
|
---|
| 573 | end
|
---|
| 574 | assert_false x !~ "x"
|
---|
| 575 | assert_true x !~ "z"
|
---|
| 576 |
|
---|
| 577 | y = "y"
|
---|
| 578 | def y.=~(other)
|
---|
| 579 | other == "y"
|
---|
| 580 | end
|
---|
| 581 | def y.!~(other)
|
---|
| 582 | other == "not y"
|
---|
| 583 | end
|
---|
| 584 | assert_false y !~ "y"
|
---|
| 585 | assert_false y !~ "z"
|
---|
| 586 | assert_true y !~ "not y"
|
---|
| 587 | end
|
---|
| 588 |
|
---|
| 589 | assert('Kernel#respond_to_missing?') do
|
---|
| 590 | class Test4RespondToMissing
|
---|
| 591 | def respond_to_missing?(method_name, include_private = false)
|
---|
| 592 | method_name == :a_method
|
---|
| 593 | end
|
---|
| 594 | end
|
---|
| 595 |
|
---|
| 596 | assert_true Test4RespondToMissing.new.respond_to?(:a_method)
|
---|
| 597 | assert_false Test4RespondToMissing.new.respond_to?(:no_method)
|
---|
| 598 | end
|
---|
| 599 |
|
---|
| 600 | assert('Kernel#global_variables') do
|
---|
| 601 | variables = global_variables
|
---|
| 602 | 1.upto(9) do |i|
|
---|
| 603 | assert_equal variables.include?(:"$#{i}"), true
|
---|
| 604 | end
|
---|
| 605 | end
|
---|
| 606 |
|
---|
| 607 | assert('Kernel#define_singleton_method') do
|
---|
| 608 | o = Object.new
|
---|
| 609 | ret = o.define_singleton_method(:test_method) do
|
---|
| 610 | :singleton_method_ok
|
---|
| 611 | end
|
---|
| 612 | assert_equal :test_method, ret
|
---|
| 613 | assert_equal :singleton_method_ok, o.test_method
|
---|
| 614 | end
|
---|
| 615 |
|
---|
| 616 | assert('stack extend') do
|
---|
| 617 | def recurse(count, stop)
|
---|
| 618 | return count if count > stop
|
---|
| 619 | recurse(count+1, stop)
|
---|
| 620 | end
|
---|
| 621 |
|
---|
| 622 | assert_equal 6, recurse(0, 5)
|
---|
| 623 | end
|
---|