baby/basic.rb

   1 #!/usr/bin/env ruby
   2
   3 require "testing.rb"
   4
   5 module Test_Basic
   6
   7    include TestMod
   8
   9    # DO_TESTS = [:test_46]
  10    def test_46
  11          do_blah <<SRC, "2\n2\n", [178, 477]
  12          # test top level if, requires handling of :if in handle_element, other pathways don't hit that for some reason?
  13          n = 2
  14          if n == 1
  15             pi 1
  16          end
  17          if n == 2
  18             pi 2
  19          end
  20          pi n
  21 SRC
  22    end
  23
  24    def test_44_trivial_block_arg
  25          do_blah <<SRC, "5\n1\n5\n2\n", [794, 1428]
  26          # test trivial block - no complex scopes
  27          def blah &block
  28             block.call 1
  29             block.call 2
  30          end
  31          a = 5
  32          blah {
  33             |val|
  34             pi a
  35             pi val
  36          }
  37 SRC
  38    end
  39
  40    def test_31_scoping
  41          do_blah <<SRC, "-5\n2\n5\n-5\n2\n5\n", [535, 802]
  42          # test scoping - calling a method should push a new lexical pad
  43          def inner_scope
  44             a = 2
  45             pi -5
  46             pi a
  47          end
  48          a = 5
  49          inner_scope # -5, 2
  50          pi a        # 5
  51          inner_scope # -5, 2
  52          pi a        # 5
  53 SRC
  54    end
  55
  56    def test_8_instance_method_calls_self_method
  57          do_blah <<SRC, "2\n", [635, 902]
  58          class Boo
  59             def two
  60                one + one
  61             end
  62             def one
  63                1
  64             end
  65          end
  66          t = Boo.new
  67          pi t.two
  68 SRC
  69    end
  70
  71    def test_12_instance_variable_hooks
  72          do_blah <<SRC, "25\n100\n", [1746, 3120]
  73          class Blah
  74             def init
  75                alloc_self
  76             end
  77             def callhookload a
  78                dget a
  79             end
  80             def callhook b, a
  81                dset a, b
  82             end
  83             def test_self
  84                @a = 25
  85                @b = 100
  86                pi @a
  87                pi @b
  88             end
  89          end
  90          blah = Blah.new
  91          blah.init
  92          blah.test_self
  93 SRC
  94    end
  95
  96    def test_empty_class_def
  97          do_blah <<SRC, "2\n", [85, 88]
  98          class Blah
  99             # class can't be empty!
 100          end
 101          pi 2
 102 SRC
 103    end
 104
 105    def test_1_templates_scopes
 106       do_blah <<SRC, nil, [1654, 2041]
 107          # useful for testing templated scopes
 108          def scope1 a, b
 109             b = -2
 110             c = -3
 111             pi a
 112             pi b
 113             pi c
 114          end
 115          def do_it t
 116             scope1 t, t + 1
 117          end
 118          do_it 1
 119          do_it 2
 120          do_it 3
 121          do_it 4
 122 SRC
 123    end
 124
 125    def test_2_simple_yield_instance_method
 126          do_blah <<SRC, nil, [1137, 2160]
 127          class Test
 128             def init
 129                alloc_self
 130             end
 131             def looper
 132                yield 1
 133                yield 2
 134                yield 3
 135             end
 136             def looping num
 137                looper {
 138                   |n|
 139                   pi n
 140                }
 141             end
 142          end
 143          t = Test.new
 144          t.looping 3
 145 SRC
 146    end
 147
 148    def test_3_trivial_yield
 149          do_blah <<SRC, nil, [1486, 3667]
 150       def blah
 151          yield 1
 152          yield 2
 153          yield 3
 154          yield 4
 155          yield 5
 156          yield 6
 157          pi -1
 158       end
 159       blah {
 160          |n|
 161          pi n
 162       }
 163       pi -1
 164 SRC
 165    end
 166
 167    def test_4_while_break_yield
 168          do_blah <<SRC, nil, [1637, 2487]
 169       def count_up_to top
 170          n = 0
 171          while true
 172             n += 1
 173             yield n
 174             break if n == top
 175          end
 176       end
 177       def do_this h
 178          count_up_to(h) {
 179             |h|
 180             pi h
 181          }
 182       end
 183       do_this 2
 184       do_this 2
 185 SRC
 186    end
 187
 188    def test_5_simple_yield
 189          do_blah <<SRC, nil, [1098, 2687]
 190          def thrice
 191             yield
 192             yield
 193             yield
 194             yield
 195             yield
 196          end
 197          n = 0
 198          thrice {
 199             n += 1
 200             pi n
 201          }
 202          pi -1
 203          pi n
 204 SRC
 205    end
 206
 207    def test_6_most_basic_yield
 208          do_blah <<SRC, nil, [493, 1099]
 209          def thrice
 210             pi 1
 211             yield
 212             pi 3
 213             yield
 214          end
 215          thrice {
 216             pi 1
 217          }
 218 SRC
 219    end
 220
 221    def test_7_method_calling_method
 222          do_blah <<SRC, nil, [384, 574]
 223          def seven
 224             pi 7
 225          end
 226          def six
 227             seven
 228          end
 229          def five
 230             six
 231          end
 232          five
 233 SRC
 234    end
 235
 236    def test_9_looped_instance_create_and_method_call
 237          do_blah <<SRC, nil, [1033, 903]
 238          class Blah
 239             def five
 240                5
 241             end
 242          end
 243          n = 0
 244          while true
 245             t = Blah.new
 246             pi t.five
 247             n += 1
 248             break if n > 3
 249          end
 250 SRC
 251    end
 252
 253    def test_10_trivial_math
 254          do_blah <<SRC, nil, [114, 136]
 255          t = 5 * 6
 256          pi t + 2
 257 SRC
 258    end
 259
 260    def test_11_return_from_instance_method
 261          do_blah <<SRC, nil, [525, 1036]
 262          # testcase for return values on instance methods
 263          # problem was caused as fall through to Def at end of
 264          # method happened and the return value was discarded
 265          class Blah
 266             def test2 a, b
 267                t = a + b
 268                10 + t
 269             end
 270          end
 271          blah = Blah.new
 272          pi blah.test2(5, 6)
 273 SRC
 274    end
 275
 276    def test_13_dict_get_set
 277          do_blah <<SRC, nil, [626, 1040]
 278          class Blah
 279             def init
 280                alloc_self
 281                dset ?a, 10
 282                dset ?b, 20
 283             end
 284             def test
 285                pi (dget ?a)
 286                pi (dget ?b)
 287             end
 288          end
 289          blah = Blah.new
 290          blah.init
 291          blah.test
 292 SRC
 293    end
 294
 295    def test_14_instance_method_calls_kernel_method
 296          do_blah <<SRC, nil, [541, 795]
 297          class Boo
 298             def calc
 299                pi 5
 300                doodle
 301             end
 302          end
 303          # main
 304          def doodle
 305             pi 6
 306          end
 307          boo = Boo.new
 308          boo.calc
 309          doodle
 310 SRC
 311    end
 312
 313    def test_15_trivial_while_break
 314          do_blah <<SRC, nil, [248, 420]
 315          n = 0
 316          while true
 317             pi n
 318             n += 1
 319             break if n == 2
 320          end
 321 SRC
 322    end
 323
 324    def test_16_set_get
 325          do_blah <<SRC, nil, [744, 1161]
 326          class Blah
 327             def one
 328                alloc_self
 329                set 1, 50
 330                pi 5
 331                two
 332             end
 333             def two
 334                pi get(1)
 335                pi get(1)
 336                three
 337             end
 338             def three
 339                pi 30 - 5
 340             end
 341          end
 342          blah = Blah.new
 343          blah.one
 344 SRC
 345    end
 346
 347    def test_18_trivial_yield_simple_scope
 348          do_blah <<SRC, nil, [592, 1213]
 349          # test trivial yield - no complex scopes
 350          def blah
 351             yield 1
 352             yield 2
 353          end
 354          blah {
 355             |val|
 356             pi val
 357          }
 358 SRC
 359    end
 360
 361    def test_36
 362          do_blah <<SRC, nil, [1130, 2045]
 363          # test yielding while loop with a break
 364          def blah
 365             n = 0
 366             while n < 5
 367                yield n
 368                n += 1
 369                break if n == 3
 370             end
 371             pi 8
 372          end
 373          blah {
 374             |val|
 375             pi val
 376          }
 377          pi 9
 378 SRC
 379    end
 380
 381    def test_37
 382          do_blah <<SRC, nil, [375, 545]
 383          # test while loop with a break
 384          n = 0
 385          while n < 5
 386             pi n
 387             n += 1
 388             break if n == 3
 389          end
 390          pi 9
 391 SRC
 392    end
 393
 394    def test_38
 395          do_blah <<SRC, nil, [897, 1300]
 396          # test iterators in global methods
 397          def times n
 398             ln = 0
 399             while ln < n
 400                ln += 1
 401                yield
 402             end
 403          end
 404          def test
 405             times(3) {
 406                pi 5
 407             }
 408          end
 409          test
 410 SRC
 411    end
 412
 413    def test_39
 414          do_blah <<SRC, nil, [847, 1386]
 415          # test an implementation of times method
 416          def times n
 417             ln = 0
 418             while ln < n
 419                ln += 1
 420                yield
 421             end
 422          end
 423          times(3) {
 424             pi 5
 425          }
 426 SRC
 427    end
 428
 429    def test_40
 430          do_blah <<SRC, nil, [1564, 2109]
 431          # test yielding while loop - while end condition is tested in this one, but not in the above one
 432          def blah
 433             n = 0
 434             while n < 5
 435                yield n
 436                n += 1
 437             end
 438             pi 8
 439          end
 440          blah {
 441             |val|
 442             pi val
 443          }
 444          pi 9
 445 SRC
 446    end
 447
 448    def test_41
 449          do_blah <<SRC, nil, [509, 797]
 450          # test multiple method definitions with differing prototypes
 451          def blah
 452             pi 8
 453          end
 454          def blah2 n
 455             pi 9 + n
 456          end
 457          blah
 458          blah2 10
 459          blah
 460 SRC
 461    end
 462
 463    def test_43
 464          do_blah <<SRC, nil, [705, 1479]
 465          # test trivial yield
 466          def blah
 467             yield 1
 468             yield 2
 469          end
 470          idx = 5
 471          blah {
 472             |val|
 473             idx = val
 474          }
 475          pi idx
 476 SRC
 477    end
 478
 479    def test_45
 480          do_blah <<SRC, nil, [435, 467]
 481          # test while loop
 482          n = 0
 483          while n < 5
 484             pi n
 485             n += 1
 486          end
 487          pi n
 488 SRC
 489    end
 490
 491    public_instance_methods.each {
 492       |meth|
 493       next if meth !~ /^test.*/ or DO_TESTS.include? meth.to_sym
 494       remove_method meth.to_sym
 495    } if defined? DO_TESTS
 496 end