test/test_validator.rb

   1 #! /usr/bin/env ruby
   2
   3 require 'voodoo/validator'
   4
   5 include Voodoo::Validator
   6
   7 $errors = 0
   8
   9 # Runs block and verifies that it returns true.
  10 # If it doesn't, prints an error message and increments $errors.
  11 def expect_true name, &block
  12   begin
  13     print "#{name}..."
  14     result = yield
  15     if result
  16       puts "pass"
  17       true
  18     else
  19       puts "FAIL: expected true, but got #{result.inspect}"
  20       $errors = $errors + 1
  21     end
  22   rescue Exception => e
  23     puts "FAIL: Unexpected #{e.class}\n#{e.message}"
  24     $errors = $errors + 1
  25   end
  26 end
  27
  28 def expect_exception name, exception_type, &block
  29   begin
  30     print "#{name}..."
  31     yield
  32     puts "FAIL: Expected exception of type #{exception_type}," +
  33       " but no exception was raised"
  34     $errors = $errors + 1
  35   rescue Exception => e
  36     if e.kind_of? exception_type
  37       puts "pass"
  38       true
  39     else
  40       puts "FAIL: Expected #{exception_type}, but got #{e.class}"
  41       $errors = $errors + 1
  42     end
  43   end
  44 end
  45
  46 def expect_ValidationError name, &block
  47   expect_exception name, ValidationError, &block
  48 end
  49
  50 [:add, :and, :asr, :bsr, :div, :mod, :mul,
  51  :or, :rol, :ror, :shl, :shr, :sub, :xor].each do |binop|
  52   expect_true("#{binop}_ints") {
  53     validate_expression [binop, -14, 3]
  54   }
  55
  56   expect_ValidationError("#{binop}_missing_arg") {
  57     validate_expression [binop, 3]
  58   }
  59
  60   expect_ValidationError("#{binop}_no_args") {
  61     validate_expression [binop]
  62   }
  63
  64   expect_ValidationError("#{binop}_too_many_args") {
  65     validate_expression [binop, -14, 3, 28]
  66   }
  67 end
  68
  69 expect_true("align_no_parameters") {
  70   validate_toplevel [:align]
  71 }
  72
  73 expect_ValidationError("align_no_integer") {
  74   validate_toplevel [:align, "wrong"]
  75 }
  76
  77 expect_true("align_with_parameter") {
  78   validate_toplevel [:align, 16]
  79 }
  80
  81 expect_ValidationError("align_too_many_parameters") {
  82   validate_toplevel [:align, 16, "wrong"]
  83 }
  84
  85 expect_true("at_number_expression") {
  86   validate_expression [:'@', 40]
  87 }
  88
  89 expect_ValidationError("at_string_expression") {
  90   validate_expression [:'@', "foo"]
  91 }
  92
  93 expect_true("at_symbol_expression") {
  94   validate_expression [:'@', :foo]
  95 }
  96
  97 expect_ValidationError("block_expression") {
  98   validate_expression [:block, [:call, :foo]]
  99 }
 100
 101 expect_true("block_statement") {
 102   validate_statement [:block, [:call, :foo]]
 103 }
 104
 105 expect_true("block_level") {
 106   validate_toplevel [:block, [:call, :foo]]
 107 }
 108
 109 expect_true("byte_toplevel") {
 110   validate_toplevel [:byte, 42]
 111 }
 112
 113 expect_ValidationError("byte_toplevel_no_integer") {
 114   validate_toplevel [:byte, "wrong"]
 115 }
 116
 117 [:call, :"tail-call"].each do |call|
 118   expect_true("#{call}_expression") {
 119     validate_expression [call, :foo]
 120   }
 121
 122   expect_true("#{call}_expression_multiple_parameters") {
 123     validate_expression [call, :foo, :bar, 42]
 124   }
 125
 126   expect_true("#{call}_statement") {
 127     validate_statement [call, :foo]
 128   }
 129
 130   expect_true("#{call}_toplevel") {
 131     validate_toplevel [call, :foo]
 132   }
 133
 134   expect_ValidationError("#{call}_without_parameters") {
 135     validate_expression [call]
 136   }
 137 end
 138
 139 expect_ValidationError("function_as_expression") {
 140   validate_expression [:function, [:x, :y], [:return, [:add, :x, :y]]]
 141 }
 142
 143 expect_ValidationError("function_as_statement") {
 144   validate_statement [:function, [:x, :y], [:return, [:add, :x, :y]]]
 145 }
 146
 147 expect_ValidationError("function_missing_formals") {
 148   validate_toplevel [:function]
 149 }
 150
 151 expect_true("function_ok") {
 152   validate_toplevel [:function, [:x, :y], [:return, [:add, :x, :y]]]
 153 }
 154
 155 [:byte, :word].each do |thing|
 156   expect_true("get-#{thing}_expression") {
 157     validate_expression [:"get-#{thing}", :foo, 12]
 158   }
 159
 160   expect_ValidationError("get-#{thing}_expression_missing_parameter") {
 161     validate_expression [:"get-#{thing}", :foo]
 162   }
 163
 164   expect_ValidationError("get-#{thing}_expression_no_parameters") {
 165     validate_expression [:"get-#{thing}"]
 166   }
 167
 168   expect_ValidationError("get-#{thing}_expression_too_many_parameters") {
 169     validate_expression [:"get-#{thing}", :foo, 12, 13]
 170   }
 171
 172   expect_ValidationError("get-#{thing}_statement") {
 173     validate_statement [:"get-#{thing}", :foo, 12]
 174   }
 175
 176   expect_ValidationError("set-#{thing}_expression") {
 177     validate_expression [:"set-#{thing}", :foo, 12, 18]
 178   }
 179
 180   expect_true("set-#{thing}_statement") {
 181     validate_statement [:"set-#{thing}", :foo, 12, 18]
 182   }
 183
 184   expect_ValidationError("set-#{thing}_statement_missing_parameters") {
 185     validate_statement [:"set-#{thing}", :foo]
 186   }
 187
 188   expect_ValidationError("set-#{thing}_statement_no_parameters") {
 189     validate_statement [:"set-#{thing}"]
 190   }
 191
 192   expect_ValidationError("set-#{thing}_statement_too_many_parameters") {
 193     validate_statement [:"set-#{thing}", :foo, 12, 18, 19]
 194   }
 195 end
 196
 197 expect_ValidationError("goto_expression") {
 198   validate_expression [:goto, 8888]
 199 }
 200
 201 expect_true("goto_statement_int") {
 202   validate_statement [:goto, 8888]
 203 }
 204
 205 expect_true("goto_statement_label") {
 206   validate_statement [:goto, :foo]
 207 }
 208
 209 expect_ValidationError("goto_statement_no_parameters") {
 210   validate_statement [:goto]
 211 }
 212
 213 expect_ValidationError("goto_statement_too_many_parameters") {
 214   validate_statement [:goto, :foo, 42]
 215 }
 216
 217 expect_true("goto_toplevel") {
 218   validate_toplevel [:goto, :foo]
 219 }
 220
 221 [:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].each do |cnd|
 222   expect_ValidationError("#{cnd}_expression") {
 223     validate_expression [cnd, [:x, :y], [[:call, :foo]]]
 224   }
 225
 226   expect_true("#{cnd}_else_statement") {
 227     validate_statement [cnd, [:x, :y], [[:call, :foo]], [[:call, :bar]]]
 228   }
 229
 230   expect_true("#{cnd}_statement") {
 231     validate_statement [cnd, [:x, :y], [[:call, :foo]]]
 232   }
 233
 234   expect_true("#{cnd}_toplevel") {
 235     validate_toplevel [cnd, [:x, :y], [[:call, :foo]]]
 236   }
 237
 238   expect_ValidationError("let_inside_#{cnd}_statement") {
 239     validate_statement [cnd, [:x, :y], [[:let, :foo, 42]]]
 240   }
 241
 242   expect_true("let_inside_block_inside_#{cnd}_statement") {
 243     validate_statement [cnd, [:x, :y], [[:block, [:let, :foo, 42]]]]
 244   }
 245 end
 246
 247 [:export, :import].each do |directive|
 248   expect_true("#{directive}_toplevel") {
 249     validate_toplevel [directive, :foo]
 250   }
 251
 252   expect_true("#{directive}_toplevel_multiple_parameters") {
 253     validate_toplevel [directive, :foo, :bar, :baz]
 254   }
 255
 256   expect_ValidationError("#{directive}_toplevel_no_parameters") {
 257     validate_toplevel [directive]
 258   }
 259
 260   expect_ValidationError("#{directive}_statement") {
 261     validate_statement [directive, :foo]
 262   }
 263 end
 264
 265 expect_true("label_statement") {
 266   validate_statement [:label, :foo]
 267 }
 268
 269 expect_ValidationError("label_statement_no_parameters") {
 270   validate_statement [:label]
 271 }
 272
 273 expect_ValidationError("label_statement_too_many_parameters") {
 274   validate_statement [:label, :foo, 18]
 275 }
 276
 277 expect_ValidationError("label_statement_parameter_no_symbol") {
 278   validate_statement [:label, 18]
 279 }
 280
 281 expect_true("label_toplevel") {
 282   validate_toplevel [:label, :foo]
 283 }
 284
 285 expect_true("let_inside_block") {
 286   validate_toplevel [:block, [:let, :foo, 42], [:call, :foo]]
 287 }
 288
 289 expect_true("let_inside_function") {
 290   validate_toplevel [:function, [:n],
 291                      [:let, :foo, [:mul, :n, :n]],
 292                      [:call, :foo]]
 293 }
 294
 295 expect_true("let_statement_int") {
 296   validate_statement [:let, :x, 12]
 297 }
 298
 299 expect_true("let_statement_expression") {
 300   validate_statement [:let, :x, [:add, 12, 3]]
 301 }
 302
 303 expect_ValidationError("let_statement_no_symbol") {
 304   validate_statement [:let, 12, 12]
 305 }
 306
 307 expect_ValidationError("let_statement_without_parameters") {
 308   validate_statement [:let]
 309 }
 310
 311 expect_true("int_is_expression") {
 312   validate_expression 12
 313 }
 314
 315 expect_ValidationError("no_symbol_expression") {
 316   validate_expression ["wrong"]
 317 }
 318
 319 expect_ValidationError("no_symbol_statement") {
 320   validate_statement ["wrong"]
 321 }
 322
 323 expect_ValidationError("no_symbol_toplevel") {
 324   validate_toplevel ["wrong"]
 325 }
 326
 327 expect_ValidationError("no_array_statement") {
 328   validate_statement :wrong
 329 }
 330
 331 expect_ValidationError("no_array_toplevel") {
 332   validate_toplevel :wrong
 333 }
 334
 335 expect_true("not_expression") {
 336   validate_expression [:not, :x]
 337 }
 338
 339 expect_ValidationError("not_expression_no_parameters") {
 340   validate_expression [:not]
 341 }
 342
 343 expect_ValidationError("not_expression_too_many_parameters") {
 344   validate_expression [:not, :x, :y]
 345 }
 346
 347 expect_ValidationError("section_missing_name") {
 348   validate_toplevel [:section]
 349 }
 350
 351 expect_ValidationError("section_number") {
 352   validate_toplevel [:section, 12]
 353 }
 354
 355 expect_true("section_string") { validate_toplevel [:section, :code] }
 356
 357 expect_true("section_symbol") { validate_toplevel [:section, :code] }
 358
 359 expect_true("set_statement_int") {
 360   validate_statement [:set, :x, 12]
 361 }
 362
 363 expect_ValidationError("set_statement_no_symbol") {
 364   validate_statement [:set, 12, 12]
 365 }
 366
 367 expect_true("set_statement_expression") {
 368   validate_statement [:set, :x, [:add, 12, 3]]
 369 }
 370
 371 expect_ValidationError("set_statement_without_parameters") {
 372   validate_statement [:set]
 373 }
 374
 375 expect_true("string_toplevel") {
 376   validate_toplevel [:string, "test"]
 377 }
 378
 379 expect_ValidationError("string_toplevel_no_string") {
 380   validate_toplevel [:string, 42]
 381 }
 382
 383 expect_true("symbol_is_expression") {
 384   validate_expression :foo
 385 }
 386
 387 expect_true("word_toplevel") {
 388   validate_toplevel [:word, 42]
 389 }
 390
 391 expect_ValidationError("word_toplevel_no_integer") {
 392   validate_toplevel [:word, "wrong"]
 393 }
 394
 395 if $errors == 0
 396   puts "All tests passed"
 397   exit
 398 else
 399   puts "#{$errors} tests failed"
 400   exit 1
 401 end