From 46c9c8a119263e5667f779d045b742bf281816e2 Mon Sep 17 00:00:00 2001
From: inglorion <voodoo@inglorion.net>
Date: Fri, 18 Mar 2011 08:01:19 +0100
Subject: [PATCH] Merged validator tests with compiler tests

---
 test/test              | 236 ++++++++++------
 test/test_validator.rb | 753 +++++++++++++++++++++++--------------------------
 2 files changed, 495 insertions(+), 494 deletions(-)
 rewrite test/test (93%)
 rewrite test/test_validator.rb (96%)

diff --git a/test/test b/test/test
dissimilarity index 93%
index a67efc8..062a2c7 100755
--- a/test/test
+++ b/test/test
@@ -1,93 +1,143 @@
-#! /bin/sh
-
-### Run tests
-
-errors=0
-
-[ -n "$RUBY" ] || RUBY=ruby
-
-# run_test program expected_output
-run_test() {
-    printf '%s...' "$1"
-    output=`$2`
-    s=$?
-    if [ $s -ne 0 ]
-    then
-        echo "FAIL: exit status is $s"
-        errors=$((errors + 1))
-    elif [ "$output" != "$3" ]
-    then
-        echo "FAIL: wrong output"
-        errors=$((errors + 1))
-    else
-	echo pass
-    fi
-}
-
-run_test2() {
-    run_test "$1" "./$1" "$2"
-}
-
-run_test1() {
-    run_test2 "$1" "`cat $1.out`"
-}
-
-run_test2 hello "Hello, world!"
-
-run_test1 bytes
-
-run_test1 call
-
-run_test1 at
-
-run_test1 block
-
-run_test1 else-if
-
-run_test1 if
-
-run_test1 goto
-
-run_test2 fact 479001600
-
-run_test1 bitwise
-
-run_test1 plusminus
-
-run_test1 many-vars
-
-run_test1 mul
-
-run_test1 div
-
-run_test1 mod
-
-run_test1 raw
-
-run_test1 rotate
-
-run_test1 set-byte
-
-run_test1 set-word
-
-run_test1 shift
-
-run_test1 vtable
-
-run_test2 tail-calls ''
-
-run_test1 99bottles
-
-run_test1 gcd
-
-printf 'test_output_name...'
-$RUBY test_output_name.rb
-[ $? -eq 0 ] || errors=$((errors + 1))
-
-if [ $errors -eq 0 ]
-then
-    echo All tests passed
-else
-    echo "$errors tests failed"
-    exit 1
-fi
+#! /usr/bin/env ruby
+
+require 'test_validator'
+
+$errors = 0
+
+# Runs block and verifies that it returns the given value.
+# If it doesn't, prints an error message and increments $errors.
+def expect name, value, &block
+  begin
+    print "#{name}..."
+    result = yield
+    if result == value
+      puts "pass"
+      true
+    else
+      puts "FAIL: expected #{value.inspect}, but got #{result.inspect}"
+      $errors = $errors + 1
+    end
+  rescue Exception => e
+    puts "FAIL: Unexpected #{e.class}\n#{e.message}"
+    $errors = $errors + 1
+  end
+end
+
+# Runs block and verifies that it returns true.
+# If it doesn't, prints an error message and increments $errors.
+def expect_true name, &block
+  expect name, true, &block
+end
+
+# Runs block and verifies that it throws an exception of type
+# +exception_type+. If the block doesn't throw such an exception,
+# prints an error message and increments $errors.
+def expect_exception name, exception_type, &block
+  begin
+    print "#{name}..."
+    yield
+    puts "FAIL: Expected exception of type #{exception_type}," +
+      " but no exception was raised"
+    $errors = $errors + 1
+  rescue Exception => e
+    if e.kind_of? exception_type
+      puts "pass"
+      true
+    else
+      puts "FAIL: Expected #{exception_type}, but got #{e.class}"
+      $errors = $errors + 1
+    end
+  end
+end
+
+# Runs block and verifies that it throws a ValidationError.
+# If the block doesn't throw such an exception,
+# prints an error message and increments $errors.
+def expect_ValidationError name, &block
+  expect_exception name, ValidationError, &block
+end
+
+$RUBY = ENV['RUBY'] || 'ruby'
+
+def run_test program, command, expected_output
+  print "#{program}..."
+  output=`#{command}`
+  status=$?
+  if status != 0
+    puts "FAIL: exit status is #{status}"
+    $errors = $errors + 1
+  elsif output != expected_output
+    puts "FAIL: wrong output"
+    $errors = $errors + 1
+  else
+    puts 'pass'
+  end
+end
+
+def run_test2 program, expected_output
+  run_test program, "./#{program}", expected_output
+end
+
+def run_test1 program
+  run_test2 program, `cat #{program}.out`
+end
+
+test_validator
+
+run_test2 'hello', "Hello, world!\n"
+
+run_test1 'bytes'
+
+run_test1 'call'
+
+run_test1 'at'
+
+run_test1 'block'
+
+run_test1 'else-if'
+
+run_test1 'if'
+
+run_test1 'goto'
+
+run_test2 'fact', "479001600\n"
+
+run_test1 'bitwise'
+
+run_test1 'plusminus'
+
+run_test1 'many-vars'
+
+run_test1 'mul'
+
+run_test1 'div'
+
+run_test1 'mod'
+
+run_test1 'raw'
+
+run_test1 'rotate'
+
+run_test1 'set-byte'
+
+run_test1 'set-word'
+
+run_test1 'shift'
+
+run_test1 'vtable'
+
+run_test2 'tail-calls', ''
+
+run_test1 '99bottles'
+
+run_test1 'gcd'
+
+printf 'test_output_name...'
+$errors = $errors + 1 unless system("$RUBY test_output_name.rb")
+
+if $errors == 0
+  puts "All tests passed"
+else
+  puts "#{$errors} tests failed"
+  exit 1
+end
diff --git a/test/test_validator.rb b/test/test_validator.rb
dissimilarity index 96%
index 529dfde..9cc15c2 100755
--- a/test/test_validator.rb
+++ b/test/test_validator.rb
@@ -1,401 +1,352 @@
-#! /usr/bin/env ruby
-
-require 'voodoo/validator'
-
-include Voodoo::Validator
-
-$errors = 0
-
-# Runs block and verifies that it returns true.
-# If it doesn't, prints an error message and increments $errors.
-def expect_true name, &block
-  begin
-    print "#{name}..."
-    result = yield
-    if result
-      puts "pass"
-      true
-    else
-      puts "FAIL: expected true, but got #{result.inspect}"
-      $errors = $errors + 1
-    end
-  rescue Exception => e
-    puts "FAIL: Unexpected #{e.class}\n#{e.message}"
-    $errors = $errors + 1
-  end
-end
-
-def expect_exception name, exception_type, &block
-  begin
-    print "#{name}..."
-    yield
-    puts "FAIL: Expected exception of type #{exception_type}," +
-      " but no exception was raised"
-    $errors = $errors + 1
-  rescue Exception => e
-    if e.kind_of? exception_type
-      puts "pass"
-      true
-    else
-      puts "FAIL: Expected #{exception_type}, but got #{e.class}"
-      $errors = $errors + 1
-    end
-  end
-end
-
-def expect_ValidationError name, &block
-  expect_exception name, ValidationError, &block
-end
-
-[:add, :and, :asr, :bsr, :div, :mod, :mul,
- :or, :rol, :ror, :shl, :shr, :sub, :xor].each do |binop|
-  expect_true("#{binop}_ints") {
-    validate_expression [binop, -14, 3]
-  }
-
-  expect_ValidationError("#{binop}_missing_arg") {
-    validate_expression [binop, 3]
-  }
-
-  expect_ValidationError("#{binop}_no_args") {
-    validate_expression [binop]
-  }
-
-  expect_ValidationError("#{binop}_too_many_args") {
-    validate_expression [binop, -14, 3, 28]
-  }
-end
-
-expect_true("align_no_parameters") {
-  validate_toplevel [:align]
-}
-
-expect_ValidationError("align_no_integer") {
-  validate_toplevel [:align, "wrong"]
-}
-
-expect_true("align_with_parameter") {
-  validate_toplevel [:align, 16]
-}
-
-expect_ValidationError("align_too_many_parameters") {
-  validate_toplevel [:align, 16, "wrong"]
-}
-
-expect_true("at_number_expression") {
-  validate_expression [:'@', 40]
-}
-
-expect_ValidationError("at_string_expression") {
-  validate_expression [:'@', "foo"]
-}
-
-expect_true("at_symbol_expression") {
-  validate_expression [:'@', :foo]
-}
-
-expect_ValidationError("block_expression") {
-  validate_expression [:block, [:call, :foo]]
-}
-
-expect_true("block_statement") {
-  validate_statement [:block, [:call, :foo]]
-}
-
-expect_true("block_level") {
-  validate_toplevel [:block, [:call, :foo]]
-}
-
-expect_true("byte_toplevel") {
-  validate_toplevel [:byte, 42]
-}
-
-expect_ValidationError("byte_toplevel_no_integer") {
-  validate_toplevel [:byte, "wrong"]
-}
-
-[:call, :"tail-call"].each do |call|
-  expect_true("#{call}_expression") {
-    validate_expression [call, :foo]
-  }
-
-  expect_true("#{call}_expression_multiple_parameters") {
-    validate_expression [call, :foo, :bar, 42]
-  }
-
-  expect_true("#{call}_statement") {
-    validate_statement [call, :foo]
-  }
-
-  expect_true("#{call}_toplevel") {
-    validate_toplevel [call, :foo]
-  }
-
-  expect_ValidationError("#{call}_without_parameters") {
-    validate_expression [call]
-  }
-end
-
-expect_ValidationError("function_as_expression") {
-  validate_expression [:function, [:x, :y], [:return, [:add, :x, :y]]]
-}
-
-expect_ValidationError("function_as_statement") {
-  validate_statement [:function, [:x, :y], [:return, [:add, :x, :y]]]
-}
-
-expect_ValidationError("function_missing_formals") {
-  validate_toplevel [:function]
-}
-
-expect_true("function_ok") {
-  validate_toplevel [:function, [:x, :y], [:return, [:add, :x, :y]]]
-}
-
-[:byte, :word].each do |thing|
-  expect_true("get-#{thing}_expression") {
-    validate_expression [:"get-#{thing}", :foo, 12]
-  }
-
-  expect_ValidationError("get-#{thing}_expression_missing_parameter") {
-    validate_expression [:"get-#{thing}", :foo]
-  }
-
-  expect_ValidationError("get-#{thing}_expression_no_parameters") {
-    validate_expression [:"get-#{thing}"]
-  }
-
-  expect_ValidationError("get-#{thing}_expression_too_many_parameters") {
-    validate_expression [:"get-#{thing}", :foo, 12, 13]
-  }
-
-  expect_ValidationError("get-#{thing}_statement") {
-    validate_statement [:"get-#{thing}", :foo, 12]
-  }
-
-  expect_ValidationError("set-#{thing}_expression") {
-    validate_expression [:"set-#{thing}", :foo, 12, 18]
-  }
-
-  expect_true("set-#{thing}_statement") {
-    validate_statement [:"set-#{thing}", :foo, 12, 18]
-  }
-
-  expect_ValidationError("set-#{thing}_statement_missing_parameters") {
-    validate_statement [:"set-#{thing}", :foo]
-  }
-
-  expect_ValidationError("set-#{thing}_statement_no_parameters") {
-    validate_statement [:"set-#{thing}"]
-  }
-
-  expect_ValidationError("set-#{thing}_statement_too_many_parameters") {
-    validate_statement [:"set-#{thing}", :foo, 12, 18, 19]
-  }
-end
-
-expect_ValidationError("goto_expression") {
-  validate_expression [:goto, 8888]
-}
-
-expect_true("goto_statement_int") {
-  validate_statement [:goto, 8888]
-}
-
-expect_true("goto_statement_label") {
-  validate_statement [:goto, :foo]
-}
-
-expect_ValidationError("goto_statement_no_parameters") {
-  validate_statement [:goto]
-}
-
-expect_ValidationError("goto_statement_too_many_parameters") {
-  validate_statement [:goto, :foo, 42]
-}
-
-expect_true("goto_toplevel") {
-  validate_toplevel [:goto, :foo]
-}
-
-[:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].each do |cnd|
-  expect_ValidationError("#{cnd}_expression") {
-    validate_expression [cnd, [:x, :y], [[:call, :foo]]]
-  }
-
-  expect_true("#{cnd}_else_statement") {
-    validate_statement [cnd, [:x, :y], [[:call, :foo]], [[:call, :bar]]]
-  }
-
-  expect_true("#{cnd}_statement") {
-    validate_statement [cnd, [:x, :y], [[:call, :foo]]]
-  }
-
-  expect_true("#{cnd}_toplevel") {
-    validate_toplevel [cnd, [:x, :y], [[:call, :foo]]]
-  }
-
-  expect_ValidationError("let_inside_#{cnd}_statement") {
-    validate_statement [cnd, [:x, :y], [[:let, :foo, 42]]]
-  }
-
-  expect_true("let_inside_block_inside_#{cnd}_statement") {
-    validate_statement [cnd, [:x, :y], [[:block, [:let, :foo, 42]]]]
-  }
-end
-
-[:export, :import].each do |directive|
-  expect_true("#{directive}_toplevel") {
-    validate_toplevel [directive, :foo]
-  }
-
-  expect_true("#{directive}_toplevel_multiple_parameters") {
-    validate_toplevel [directive, :foo, :bar, :baz]
-  }
-
-  expect_ValidationError("#{directive}_toplevel_no_parameters") {
-    validate_toplevel [directive]
-  }
-
-  expect_ValidationError("#{directive}_statement") {
-    validate_statement [directive, :foo]
-  }
-end
-
-expect_true("label_statement") {
-  validate_statement [:label, :foo]
-}
-
-expect_ValidationError("label_statement_no_parameters") {
-  validate_statement [:label]
-}
-
-expect_ValidationError("label_statement_too_many_parameters") {
-  validate_statement [:label, :foo, 18]
-}
-
-expect_ValidationError("label_statement_parameter_no_symbol") {
-  validate_statement [:label, 18]
-}
-
-expect_true("label_toplevel") {
-  validate_toplevel [:label, :foo]
-}
-
-expect_true("let_inside_block") {
-  validate_toplevel [:block, [:let, :foo, 42], [:call, :foo]]
-}
-
-expect_true("let_inside_function") {
-  validate_toplevel [:function, [:n],
-                     [:let, :foo, [:mul, :n, :n]],
-                     [:call, :foo]]
-}
-
-expect_true("let_statement_int") {
-  validate_statement [:let, :x, 12]
-}
-
-expect_true("let_statement_expression") {
-  validate_statement [:let, :x, [:add, 12, 3]]
-}
-
-expect_ValidationError("let_statement_no_symbol") {
-  validate_statement [:let, 12, 12]
-}
-
-expect_ValidationError("let_statement_without_parameters") {
-  validate_statement [:let]
-}
-
-expect_true("int_is_expression") {
-  validate_expression 12
-}
-
-expect_ValidationError("no_symbol_expression") {
-  validate_expression ["wrong"]
-}
-
-expect_ValidationError("no_symbol_statement") {
-  validate_statement ["wrong"]
-}
-
-expect_ValidationError("no_symbol_toplevel") {
-  validate_toplevel ["wrong"]
-}
-
-expect_ValidationError("no_array_statement") {
-  validate_statement :wrong
-}
-
-expect_ValidationError("no_array_toplevel") {
-  validate_toplevel :wrong
-}
-
-expect_true("not_expression") {
-  validate_expression [:not, :x]
-}
-
-expect_ValidationError("not_expression_no_parameters") {
-  validate_expression [:not]
-}
-
-expect_ValidationError("not_expression_too_many_parameters") {
-  validate_expression [:not, :x, :y]
-}
-
-expect_ValidationError("section_missing_name") {
-  validate_toplevel [:section]
-}
-
-expect_ValidationError("section_number") {
-  validate_toplevel [:section, 12]
-}
-
-expect_true("section_string") { validate_toplevel [:section, :code] }
-
-expect_true("section_symbol") { validate_toplevel [:section, :code] }
-
-expect_true("set_statement_int") {
-  validate_statement [:set, :x, 12]
-}
-
-expect_ValidationError("set_statement_no_symbol") {
-  validate_statement [:set, 12, 12]
-}
-
-expect_true("set_statement_expression") {
-  validate_statement [:set, :x, [:add, 12, 3]]
-}
-
-expect_ValidationError("set_statement_without_parameters") {
-  validate_statement [:set]
-}
-
-expect_true("string_toplevel") {
-  validate_toplevel [:string, "test"]
-}
-
-expect_ValidationError("string_toplevel_no_string") {
-  validate_toplevel [:string, 42]
-}
-
-expect_true("symbol_is_expression") {
-  validate_expression :foo
-}
-
-expect_true("word_toplevel") {
-  validate_toplevel [:word, 42]
-}
-
-expect_ValidationError("word_toplevel_no_integer") {
-  validate_toplevel [:word, "wrong"]
-}
-
-if $errors == 0
-  puts "All tests passed"
-  exit
-else
-  puts "#{$errors} tests failed"
-  exit 1
-end
+#! /usr/bin/env ruby
+
+require 'voodoo/validator'
+
+include Voodoo::Validator
+
+def test_validator
+  [:add, :and, :asr, :bsr, :div, :mod, :mul,
+   :or, :rol, :ror, :shl, :shr, :sub, :xor].each do |binop|
+    expect_true("#{binop}_ints") {
+      validate_expression [binop, -14, 3]
+    }
+
+    expect_ValidationError("#{binop}_missing_arg") {
+      validate_expression [binop, 3]
+    }
+
+    expect_ValidationError("#{binop}_no_args") {
+      validate_expression [binop]
+    }
+
+    expect_ValidationError("#{binop}_too_many_args") {
+      validate_expression [binop, -14, 3, 28]
+    }
+  end
+
+  expect_true("align_no_parameters") {
+    validate_toplevel [:align]
+  }
+
+  expect_ValidationError("align_no_integer") {
+    validate_toplevel [:align, "wrong"]
+  }
+
+  expect_true("align_with_parameter") {
+    validate_toplevel [:align, 16]
+  }
+
+  expect_ValidationError("align_too_many_parameters") {
+    validate_toplevel [:align, 16, "wrong"]
+  }
+
+  expect_true("at_number_expression") {
+    validate_expression [:'@', 40]
+  }
+
+  expect_ValidationError("at_string_expression") {
+    validate_expression [:'@', "foo"]
+  }
+
+  expect_true("at_symbol_expression") {
+    validate_expression [:'@', :foo]
+  }
+
+  expect_ValidationError("block_expression") {
+    validate_expression [:block, [:call, :foo]]
+  }
+
+  expect_true("block_statement") {
+    validate_statement [:block, [:call, :foo]]
+  }
+
+  expect_true("block_level") {
+    validate_toplevel [:block, [:call, :foo]]
+  }
+
+  expect_true("byte_toplevel") {
+    validate_toplevel [:byte, 42]
+  }
+
+  expect_ValidationError("byte_toplevel_no_integer") {
+    validate_toplevel [:byte, "wrong"]
+  }
+
+  [:call, :"tail-call"].each do |call|
+    expect_true("#{call}_expression") {
+      validate_expression [call, :foo]
+    }
+
+    expect_true("#{call}_expression_multiple_parameters") {
+      validate_expression [call, :foo, :bar, 42]
+    }
+
+    expect_true("#{call}_statement") {
+      validate_statement [call, :foo]
+    }
+
+    expect_true("#{call}_toplevel") {
+      validate_toplevel [call, :foo]
+    }
+
+    expect_ValidationError("#{call}_without_parameters") {
+      validate_expression [call]
+    }
+  end
+
+  expect_ValidationError("function_as_expression") {
+    validate_expression [:function, [:x, :y], [:return, [:add, :x, :y]]]
+  }
+
+  expect_ValidationError("function_as_statement") {
+    validate_statement [:function, [:x, :y], [:return, [:add, :x, :y]]]
+  }
+
+  expect_ValidationError("function_missing_formals") {
+    validate_toplevel [:function]
+  }
+
+  expect_true("function_ok") {
+    validate_toplevel [:function, [:x, :y], [:return, [:add, :x, :y]]]
+  }
+
+  [:byte, :word].each do |thing|
+    expect_true("get-#{thing}_expression") {
+      validate_expression [:"get-#{thing}", :foo, 12]
+    }
+
+    expect_ValidationError("get-#{thing}_expression_missing_parameter") {
+      validate_expression [:"get-#{thing}", :foo]
+    }
+
+    expect_ValidationError("get-#{thing}_expression_no_parameters") {
+      validate_expression [:"get-#{thing}"]
+    }
+
+    expect_ValidationError("get-#{thing}_expression_too_many_parameters") {
+      validate_expression [:"get-#{thing}", :foo, 12, 13]
+    }
+
+    expect_ValidationError("get-#{thing}_statement") {
+      validate_statement [:"get-#{thing}", :foo, 12]
+    }
+
+    expect_ValidationError("set-#{thing}_expression") {
+      validate_expression [:"set-#{thing}", :foo, 12, 18]
+    }
+
+    expect_true("set-#{thing}_statement") {
+      validate_statement [:"set-#{thing}", :foo, 12, 18]
+    }
+
+    expect_ValidationError("set-#{thing}_statement_missing_parameters") {
+      validate_statement [:"set-#{thing}", :foo]
+    }
+
+    expect_ValidationError("set-#{thing}_statement_no_parameters") {
+      validate_statement [:"set-#{thing}"]
+    }
+
+    expect_ValidationError("set-#{thing}_statement_too_many_parameters") {
+      validate_statement [:"set-#{thing}", :foo, 12, 18, 19]
+    }
+  end
+
+  expect_ValidationError("goto_expression") {
+    validate_expression [:goto, 8888]
+  }
+
+  expect_true("goto_statement_int") {
+    validate_statement [:goto, 8888]
+  }
+
+  expect_true("goto_statement_label") {
+    validate_statement [:goto, :foo]
+  }
+
+  expect_ValidationError("goto_statement_no_parameters") {
+    validate_statement [:goto]
+  }
+
+  expect_ValidationError("goto_statement_too_many_parameters") {
+    validate_statement [:goto, :foo, 42]
+  }
+
+  expect_true("goto_toplevel") {
+    validate_toplevel [:goto, :foo]
+  }
+
+  [:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].each do |cnd|
+    expect_ValidationError("#{cnd}_expression") {
+      validate_expression [cnd, [:x, :y], [[:call, :foo]]]
+    }
+
+    expect_true("#{cnd}_else_statement") {
+      validate_statement [cnd, [:x, :y], [[:call, :foo]], [[:call, :bar]]]
+    }
+
+    expect_true("#{cnd}_statement") {
+      validate_statement [cnd, [:x, :y], [[:call, :foo]]]
+    }
+
+    expect_true("#{cnd}_toplevel") {
+      validate_toplevel [cnd, [:x, :y], [[:call, :foo]]]
+    }
+
+    expect_ValidationError("let_inside_#{cnd}_statement") {
+      validate_statement [cnd, [:x, :y], [[:let, :foo, 42]]]
+    }
+
+    expect_true("let_inside_block_inside_#{cnd}_statement") {
+      validate_statement [cnd, [:x, :y], [[:block, [:let, :foo, 42]]]]
+    }
+  end
+
+  [:export, :import].each do |directive|
+    expect_true("#{directive}_toplevel") {
+      validate_toplevel [directive, :foo]
+    }
+
+    expect_true("#{directive}_toplevel_multiple_parameters") {
+      validate_toplevel [directive, :foo, :bar, :baz]
+    }
+
+    expect_ValidationError("#{directive}_toplevel_no_parameters") {
+      validate_toplevel [directive]
+    }
+
+    expect_ValidationError("#{directive}_statement") {
+      validate_statement [directive, :foo]
+    }
+  end
+
+  expect_true("label_statement") {
+    validate_statement [:label, :foo]
+  }
+
+  expect_ValidationError("label_statement_no_parameters") {
+    validate_statement [:label]
+  }
+
+  expect_ValidationError("label_statement_too_many_parameters") {
+    validate_statement [:label, :foo, 18]
+  }
+
+  expect_ValidationError("label_statement_parameter_no_symbol") {
+    validate_statement [:label, 18]
+  }
+
+  expect_true("label_toplevel") {
+    validate_toplevel [:label, :foo]
+  }
+
+  expect_true("let_inside_block") {
+    validate_toplevel [:block, [:let, :foo, 42], [:call, :foo]]
+  }
+
+  expect_true("let_inside_function") {
+    validate_toplevel [:function, [:n],
+                       [:let, :foo, [:mul, :n, :n]],
+                       [:call, :foo]]
+  }
+
+  expect_true("let_statement_int") {
+    validate_statement [:let, :x, 12]
+  }
+
+  expect_true("let_statement_expression") {
+    validate_statement [:let, :x, [:add, 12, 3]]
+  }
+
+  expect_ValidationError("let_statement_no_symbol") {
+    validate_statement [:let, 12, 12]
+  }
+
+  expect_ValidationError("let_statement_without_parameters") {
+    validate_statement [:let]
+  }
+
+  expect_true("int_is_expression") {
+    validate_expression 12
+  }
+
+  expect_ValidationError("no_symbol_expression") {
+    validate_expression ["wrong"]
+  }
+
+  expect_ValidationError("no_symbol_statement") {
+    validate_statement ["wrong"]
+  }
+
+  expect_ValidationError("no_symbol_toplevel") {
+    validate_toplevel ["wrong"]
+  }
+
+  expect_ValidationError("no_array_statement") {
+    validate_statement :wrong
+  }
+
+  expect_ValidationError("no_array_toplevel") {
+    validate_toplevel :wrong
+  }
+
+  expect_true("not_expression") {
+    validate_expression [:not, :x]
+  }
+
+  expect_ValidationError("not_expression_no_parameters") {
+    validate_expression [:not]
+  }
+
+  expect_ValidationError("not_expression_too_many_parameters") {
+    validate_expression [:not, :x, :y]
+  }
+
+  expect_ValidationError("section_missing_name") {
+    validate_toplevel [:section]
+  }
+
+  expect_ValidationError("section_number") {
+    validate_toplevel [:section, 12]
+  }
+
+  expect_true("section_string") { validate_toplevel [:section, :code] }
+
+  expect_true("section_symbol") { validate_toplevel [:section, :code] }
+
+  expect_true("set_statement_int") {
+    validate_statement [:set, :x, 12]
+  }
+
+  expect_ValidationError("set_statement_no_symbol") {
+    validate_statement [:set, 12, 12]
+  }
+
+  expect_true("set_statement_expression") {
+    validate_statement [:set, :x, [:add, 12, 3]]
+  }
+
+  expect_ValidationError("set_statement_without_parameters") {
+    validate_statement [:set]
+  }
+
+  expect_true("string_toplevel") {
+    validate_toplevel [:string, "test"]
+  }
+
+  expect_ValidationError("string_toplevel_no_string") {
+    validate_toplevel [:string, 42]
+  }
+
+  expect_true("symbol_is_expression") {
+    validate_expression :foo
+  }
+
+  expect_true("word_toplevel") {
+    validate_toplevel [:word, 42]
+  }
+
+  expect_ValidationError("word_toplevel_no_integer") {
+    validate_toplevel [:word, "wrong"]
+  }
+end
-- 
2.11.4.GIT