baby/old_tests.rb

   1    def test_math
   2       t = Context.new
   3       do_test t, %{
   4          puts 5 + 6
   5          puts 5 * 5
   6          puts 15 % 10
   7          puts 15 / 10
   8       }, "11\n25\n5\n1\n"
   9    end
  10
  11    def test_typing
  12       t = Context.new
  13       do_test t, %{
  14          a = true
  15          puts typeof(typeof(a))
  16          puts typeof(true)
  17          puts typeof(5)
  18          puts typeof(typeof(true))
  19          b = 5
  20          puts typeof(b)
  21       }, "3\n1\n2\n3\n2\n"
  22    end
  23
  24    def __test_reallocate_byte_array # FIXME
  25       do_test t, %{
  26          t = VByteArray.new
  27          t.realloc 2*4
  28          t.set_element(0, 10)
  29          puts t.get_element(0)
  30          t.set_element(1, 20)
  31          puts t.get_element(1)
  32       }, "10\n20\n"
  33    end
  34
  35    def test_new_byte_array
  36       # note - its not yet a byte array its an array of ints so must allocate * 4!
  37       t = Context.new
  38       do_test t, %{
  39          t = VByteArray.new
  40          t.alloc 2*4
  41          t.set_element(0, 10)
  42          puts t.get_element(0)
  43          t.set_element(1, 20)
  44          puts t.get_element(1)
  45       }, "10\n20\n"
  46       do_test t, %{
  47          t = VByteArray.new
  48          t.alloc 2*4
  49          a = 0
  50          t.set_element(a, ?h)
  51          a += 1
  52          t.set_element(a, ?i)
  53          a = 0
  54          putchar t.get_element(a)
  55          a += 1
  56          putchar t.get_element(a)
  57          putchar ?\\n
  58       }, "hi\n"
  59    end
  60
  61    def test_string_constant
  62       t = Context.new
  63       do_test t, %{
  64          t = "this is a string"
  65          puts typeof(VByteArray.new)
  66          puts typeof(t) # TODO - for the moment the string is a VByteArray we need to wrap it in RString or so!
  67          size = t.get_element(0)
  68          n = 1 # pos 0 is the length
  69          while n < (size + 1)
  70             putchar t.get_element(n)
  71             n += 1
  72          end
  73       }, "5\n5\nthis is a string"
  74    end
  75
  76    def test_instance_variable
  77       t = Context.new
  78       do_test t, %{
  79          #{$stdlib_member_vars}
  80          class Blah
  81             def init
  82                @a = 800
  83                @b = 900
  84             end
  85             def print_a
  86                puts @a
  87                puts @b
  88             end
  89          end
  90          blah = Blah.new
  91          blah.init
  92          blah.print_a
  93       }, "800\n900\n"
  94    end
  95
  96    def __test_global_variable # FIXME
  97       t = Context.new
  98       do_test t, %{
  99          class Blah
 100             def init
 101                $a = 5
 102             end
 103          end
 104          blah = Blah.new
 105          blah.init
 106          puts $a
 107          $a = 4
 108          blah.init
 109          puts $a
 110       }, "5\n4\n4\n"
 111    end
 112
 113    def test_multiple_custom_class_empty_initializer_instance_method_same_method_names
 114       t = Context.new
 115       do_test t, %{
 116          class Test1
 117             def do_something
 118                puts 120
 119             end
 120          end
 121          class Test2
 122             def do_something a
 123                puts 150 + a
 124             end
 125          end
 126          test1 = Test1.new
 127          test1.do_something
 128          test2 = Test2.new
 129          test2.do_something 5
 130       }, "120\n155\n"
 131    end
 132
 133    def test_custom_class_empty_initializer_instance_methods
 134       t = Context.new
 135       do_test t, %{
 136          class Test
 137             def do_something
 138                puts 120
 139             end
 140             def do_something_2
 141                puts 150
 142             end
 143          end
 144          test = Test.new
 145          test.do_something
 146          test.do_something_2
 147       }, "120\n150\n"
 148    end
 149
 150    def test_stdlib_string
 151       t = Context.new
 152       do_test t, %{
 153        #{$stdlib}
 154        putstr "blah"
 155        putstr num_to_s(214)
 156        # fixme - puts is a builtin that currently just prints an int, should be removed
 157        puts 214
 158        puts strlen(concat("foo", "bar"))
 159        putstr concat("foo", "bar")
 160       }, "blah214214\n6\nfoobar"
 161    end
 162
 163    def __test_method_operator # FIXME
 164       t = Context.new
 165       # BROKEN
 166       do_test t, %{
 167          t = VByteArray.new
 168          a = 0
 169          t[a] = ?a
 170          puts typeof(t)
 171       }, "4\n"
 172    end
 173
 174    def test_static_methods
 175       t = Context.new
 176       do_test t, %{
 177          class A
 178             def A.do_it
 179                putchar ?a
 180             end
 181          end
 182          class B
 183             def B.do_it
 184                putchar ?b
 185             end
 186          end
 187          A.do_it
 188          B.do_it
 189       }, "ab"
 190    end
 191
 192    def test_putchar
 193       t = Context.new
 194       do_test t, %{
 195          dummy = false # another dummy!!! why??? because we don't assign any variables? :|
 196          putchar ?a
 197       }, "a"
 198       do_test t, %{
 199          n = 15
 200          last_digit = n % 10
 201          putchar ?0 + last_digit
 202       }, "5"
 203       do_test t, %{
 204          n = 15
 205          while n > 0
 206             ch = ?0 + n % 10
 207             putchar ch
 208             n /= 10
 209          end
 210       }, "51"
 211    end
 212
 213    def test_def
 214       t = Context.new
 215       do_test t, %{
 216          def my_function
 217             puts 1 != 2
 218          end
 219          my_function}, "1\n"
 220       do_test t, %{
 221          def my_second_function
 222             puts 5
 223          end
 224          my_second_function}, "5\n"
 225       do_test t, %{
 226          def my_other_function2 a
 227             puts a
 228          end
 229          my_other_function2 800}, "800\n"
 230       do_test t, %{
 231          def my_other_function3 a, b
 232             puts a
 233             puts b + 8
 234          end
 235          my_other_function3 700, 800}, "700\n808\n"
 236       do_test t, %{
 237          def my_fourth_function a
 238             puts a
 239             puts a
 240          end
 241          t = 800
 242          my_fourth_function t}, "800\n800\n"
 243       do_test t, %{
 244          def funky
 245             5
 246          end
 247          puts funky}, "5\n"
 248       do_test t, %{
 249          def funky2
 250             return 8
 251             5
 252          end
 253          puts funky2}, "8\n"
 254    end
 255
 256    def test_blah
 257       t = Context.new
 258       do_test t, %{
 259          # test out not
 260          puts 1 != 2
 261       }, "1\n"
 262       do_test t, %{
 263          # test out puts of bools
 264          dummy = false # FIXME - this is required???
 265          puts false
 266          puts true
 267       }, "0\n1\n"
 268       do_test t, %{
 269          # test out equality operators
 270          puts (1 == 1)
 271          puts (1 == 2)
 272       }, "1\n0\n"
 273       do_test t, %{
 274          # test out >
 275          puts (5 > 10)
 276          puts (5 > 4)
 277       }, "0\n1\n"
 278       do_test t, %{
 279          # test out eq on local vars
 280          a = 3
 281          puts a == 3
 282          puts a == 2
 283       }, "1\n0\n"
 284       do_test t, %{
 285          # while loop
 286          a = 130
 287          while a > 120
 288             puts a
 289             a += -1
 290          end
 291       }, "130\n129\n128\n127\n126\n125\n124\n123\n122\n121\n"
 292       do_test t, %{
 293          # if conditional
 294          a = 100
 295          if a == 100
 296             puts 100
 297          else
 298             puts -1
 299          end
 300          a = 200
 301          if a == 100
 302             puts 100
 303          else
 304             puts -1
 305          end
 306       }, "100\n-1\n"
 307       do_test t, %{
 308          # test that a src = dest does a copy of dest
 309          x = 1
 310          y = x
 311          puts x
 312          puts y
 313          x += 1
 314          puts x
 315          puts y
 316       }, "1\n1\n2\n1\n"
 317       do_test t, %{
 318          # setting/puts of local var
 319          a = 5
 320          puts a
 321       }, "5\n"
 322       do_test t, %{
 323          # setting an addition of constant and constant
 324          y = 6 + 4
 325          puts y
 326       }, "10\n"
 327       do_test t, %{
 328          # puts of addition of constant and constant
 329          puts 2 + 2
 330       }, "4\n"
 331       do_test t, %{
 332          # test of localvar += constant construct
 333          a = 10
 334          h = 6
 335          h += 1
 336          h += a
 337          puts h
 338       }, "17\n"
 339    end
 340
 341    def test_complex_mult_table
 342       t = Context.new
 343       do_test t, %{
 344          #{$stdlib}
 345          def mul_line sx, sy, y
 346             max_num_len = strlen(num_to_s(sx * sy))
 347             alignment = max_num_len + 1
 348             x = 1
 349             while x < (sy + 1)
 350                num_str = num_to_s(x * y)
 351                num_spaces = alignment - strlen(num_str)
 352                c = 0
 353                while c < num_spaces
 354                   putstr " "
 355                   c += 1
 356                end
 357                putstr num_str
 358                x += 1
 359             end
 360          end
 361          def mul_table sx, sy
 362             y = 1
 363             while y < (sy + 1)
 364                mul_line sx, sy, y
 365                putstr "\\n"
 366                y += 1
 367             end
 368          end
 369          mul_table 12, 12
 370       }, "   1   2   3   4   5   6   7   8   9  10  11  12\n   2   4   6   8  10  12  14  16  18  20  22  24\n   3   6   9  12  15  18  21  24  27  30  33  36\n   4   8  12  16  20  24  28  32  36  40  44  48\n   5  10  15  20  25  30  35  40  45  50  55  60\n   6  12  18  24  30  36  42  48  54  60  66  72\n   7  14  21  28  35  42  49  56  63  70  77  84\n   8  16  24  32  40  48  56  64  72  80  88  96\n   9  18  27  36  45  54  63  72  81  90  99 108\n  10  20  30  40  50  60  70  80  90 100 110 120\n  11  22  33  44  55  66  77  88  99 110 121 132\n  12  24  36  48  60  72  84  96 108 120 132 144\n"
 371    end
 372
 373    def test_many_nested_function_calls
 374       t = Context.new
 375       do_test t, %{
 376          def blah2 y
 377             x = 0
 378             while x < 100
 379                blah3 x
 380                x += 1
 381             end
 382          end
 383          def blah3 y
 384             x = 0
 385             while x < 100
 386                x += 1
 387             end
 388          end
 389          blah2 1
 390       }, ""
 391    end