cast 0.0.1 → 0.3.1

data/test/common.rb

@@ -1,174 +0,0 @@
-$: << File.expand_path('../lib')
-require 'cast'
-require 'test/unit'
-
-if true
-  class C::Node
-    def pretty_print q
-      q.text self.to_debug
-    end
-  end
-end
-
-class Array
-  def same_list? other
-    self.length == other.length or
-      return false
-    self.zip(other).all? do |mine, yours|
-      mine.equal? yours or
-        return false
-    end
-  end
-end
-
-class Integer
-  ###
-  ### Return a `self'-element array containing the result of the given
-  ### block.
-  ###
-  def of &blk
-    Array.new(self, &blk)
-  end
-end
-
-module Test::Unit::Assertions
-  ###
-  ### Assert that the given ast's nodes' parents are correct, and
-  ### there aren't non-Nodes where there shouldn't be.
-  ###
-  def assert_tree ast
-    meth = 'unknown method'
-    caller.each do |line|
-      if line =~ /in `(test_.*?)'/  #`
-        meth = $1
-        break
-      end
-    end
-    filename = "#{self.class}_#{meth}.out"
-    begin
-      assert_tree1(ast, nil)
-      assert(true)
-    rescue BadTreeError => e
-      require 'pp'
-      open("#{filename}", 'w'){|f| PP.pp(ast, f)}
-      flunk("#{e.message}.  Output dumped to `#{filename}'.")
-    end
-  end
-  ###
-  def assert_tree1 x, parent
-    if x.is_a? C::Node
-      parent.equal? x.parent or
-        raise BadTreeError, "#{x.class}:0x#{(x.id << 1).to_s(16)} has #{x.parent ? 'wrong' : 'no'} parent"
-      x.fields.each do |field|
-        next if !field.child?
-        val = x.send(field.reader)
-        next if val.nil?
-        val.is_a? C::Node or
-          raise BadTreeError, "#{x.class}:0x#{(x.id << 1).to_s(16)} is a non-Node child"
-        assert_tree1(val, x)
-      end
-    end
-  end
-  class BadTreeError < StandardError; end
-  ###
-  ### Assert that `arg' is a C::NodeList.
-  ###
-  def assert_list arg
-    assert_kind_of(C::NodeList, arg)
-  end
-  ###
-  ### Assert that `arg' is an empty C::NodeList.
-  ###
-  def assert_empty_list arg
-    assert_list arg
-    assert(arg.empty?)
-  end
-  ###
-  ### Assert that the elements of exp are the same as those of out,
-  ### and are in the same order.
-  ###
-  def assert_same_list exp, out
-    assert_equal(exp.length, out.length, "Checking length")
-    (0...exp.length).each do |i|
-      assert_same(exp[i], out[i], "At index #{i} (of 0...#{exp.length})")
-    end
-  end
-  ###
-  ### Assert that out is ==, but not the same as exp (i.e., it is a
-  ### copy).
-  ###
-  def assert_copy exp, out
-    assert_not_same exp, out
-    assert_equal exp, out
-  end
-  ###
-  ### Assert the invariants of `node'.
-  ###
-  def assert_invariants node
-    node.assert_invariants(self)
-  end
-  ###
-  ### Return a not-too-trivial C program string.
-  ###
-  def prog
-    return <<EOS
-int main(int argc, char **argv) {
-  struct S {
-    int i, j;
-    float f, g;
-  } x;
-  x.i = (int)argv[2][5];
-  return 0;
-}
-EOS
-  end
-end
-
-module CheckAst
-  INDENT = '    '
-
-  ParseError = C::ParseError
-
-  def check_ast test_data
-    inp, exp = test_data.split(/^----+\n/)
-    ast = yield(inp)
-    assert_tree(ast)
-    assert ast.is_a?(C::Node)
-    out = ast.to_debug
-    assert_equal_debug_strs(exp, out)
-  end
-
-  def assert_equal_debug_strs exp, out
-    ## remove EOL space
-    out = out.gsub(/ *$/, '')
-    exp = exp.gsub(/ *$/, '')
-
-    ## normalize BOL space
-    exp.gsub!(%r'^#{INDENT}*') do |s|
-      levels = s.length / INDENT.length
-      C::Node::TO_DEBUG_TAB*levels
-    end
-
-    ## compare
-    meth = 'unknown method'
-    caller.each do |line|
-      if line =~ /in `(test_.*?)'/  #`
-        meth = $1
-        break
-      end
-    end
-
-    filename_prefix = "#{self.class}_#{meth}"
-
-    assert_block("Debug strings unequal.  Output dumped to #{filename_prefix}.{exp,out}") do
-      if out == exp
-        true
-      else
-        classname = self.class.name.split(/::/)[-1]
-        open("#{filename_prefix}.out", 'w'){|f| f.print(out)}
-        open("#{filename_prefix}.exp", 'w'){|f| f.print(exp)}
-        false
-      end
-    end
-  end
-end

data/test/run.rb

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.new(Dir.pwd).grep(/^test_/) do |filename|
-  require "#{Dir.pwd}/#{filename}"
-end

data/test/test_c_nodes.rb

@@ -1,160 +0,0 @@
-require 'common'
-
-###
-### ##################################################################
-###
-### Tests for miscellaneous methods specific to individual Node
-### classes.
-###
-### ##################################################################
-###
-class MiscTests < Test::Unit::TestCase
-  include CheckAst
-
-  ###
-  ### ----------------------------------------------------------------
-  ###                           Declarator#
-  ###                         declaration type
-  ### ----------------------------------------------------------------
-  ###
-
-  def test_declarator_declaration
-    tor = C::Declarator.new(nil, 'x')
-    assert_nil(tor.declaration)
-
-    list = C::NodeArray[tor]
-    assert_nil(tor.declaration)
-
-    tion = C::Declaration.new(C::Int.new, list)
-    assert_same(tion, tor.declaration)
-
-    list.detach
-    assert_nil(tor.declaration)
-  end
-
-  def test_declarator_type
-    ## int i, *j, k[], l(), *m[10];
-    decl = C::Declaration.new(C::Int.new)
-    decl.declarators << C::Declarator.new(nil, 'i')
-    decl.declarators << C::Declarator.new(C::Pointer.new, 'j')
-    decl.declarators << C::Declarator.new(C::Array.new, 'k')
-    decl.declarators << C::Declarator.new(C::Function.new, 'l')
-    arr = C::Array.new(C::Pointer.new, C::IntLiteral.new(10))
-    decl.declarators << C::Declarator.new(arr, 'm')
-
-    assert_equal_debug_strs(decl.declarators[0].type.to_debug, <<EOS)
-Int
-EOS
-    assert_equal_debug_strs(decl.declarators[1].type.to_debug, <<EOS)
-Pointer
-    type: Int
-EOS
-    assert_equal_debug_strs(decl.declarators[2].type.to_debug, <<EOS)
-Array
-    type: Int
-EOS
-    assert_equal_debug_strs(decl.declarators[3].type.to_debug, <<EOS)
-Function
-    type: Int
-EOS
-    assert_equal_debug_strs(decl.declarators[4].type.to_debug, <<EOS)
-Array
-    type: Pointer
-        type: Int
-    length: IntLiteral
-        val: 10
-EOS
-  end
-
-  ###
-  ### ----------------------------------------------------------------
-  ###                           DirectType#
-  ###                    direct_type indirect_type
-  ###                          IndirectType#
-  ###              direct_type indirect_type direct_type=
-  ### ----------------------------------------------------------------
-  ###
-
-  def test_type_direct_type
-    d = C::Int.new
-    t = C::Pointer.new(d)
-    assert_same(d, t.direct_type)
-
-    d = C::Float.new
-    t = C::Pointer.new(C::Pointer.new(d))
-    assert_same(d, t.direct_type)
-
-    d = C::Struct.new('S')
-    t = C::Array.new(d)
-    assert_same(d, t.direct_type)
-
-    d = C::CustomType.new('T')
-    t = C::Function.new(d)
-    assert_same(d, t.direct_type)
-
-    t = C::Pointer.new(nil)
-    assert_nil(t.direct_type)
-
-    t = C::Int.new
-    assert_same(t, t.direct_type)
-  end
-
-  def test_type_indirect_type
-    d = C::Int.new
-    t = C::Pointer.new(d)
-    assert_equal(C::Pointer.new, t.indirect_type)
-
-    d = C::Float.new
-    t = C::Pointer.new(C::Pointer.new(d))
-    assert_equal(C::Pointer.new(C::Pointer.new), t.indirect_type)
-
-    d = C::Struct.new('S')
-    t = C::Array.new(d, C::IntLiteral.new(10))
-    assert_equal(C::Array.new(nil, C::IntLiteral.new(10)), t.indirect_type)
-
-    d = C::CustomType.new('T')
-    t = C::Function.new(d)
-    assert_equal(C::Function.new, t.indirect_type)
-
-    t = C::Pointer.new(nil)
-    assert_copy(t, t.indirect_type)
-
-    t = C::Int.new
-    assert_nil(t.indirect_type)
-  end
-
-  def test_type_set_direct_type
-    d = C::Int.new
-    t = C::Pointer.new(d)
-    x = C::Int.new
-    t.direct_type = x
-    assert_same(x, t.type)
-
-    d = C::Float.new
-    t = C::Pointer.new(C::Pointer.new(d))
-    x = C::Float.new
-    t.direct_type = x
-    assert_same(x, t.type.type)
-
-    d = C::Struct.new('S')
-    t = C::Array.new(d)
-    x = C::Struct.new('T')
-    t.direct_type = x
-    assert_same(x, t.type)
-
-    d = C::CustomType.new('T')
-    t = C::Function.new(d)
-    x = C::Void.new
-    t.direct_type = x
-    assert_same(x, t.type)
-
-    t = C::Pointer.new(nil)
-    x = C::Imaginary.new
-    t.direct_type = x
-    assert_same(x, t.type)
-
-    t = C::Int.new
-    x = C::Void.new
-    assert_raise(NoMethodError){t.direct_type = x}
-  end
-end

data/test/test_parse.rb

@@ -1,2014 +0,0 @@
-###
-### ##################################################################
-###
-### Tests for the parse methods.
-###
-### ##################################################################
-###
-
-require 'common'
-
-class MatchTest < Test::Unit::TestCase
-  def setup
-    C.default_parser = C::Parser.new
-  end
-  def test_node_matches
-    i = C::Int.new
-    assert_same(true, i.match?(i))
-    assert_same(true, i.match?('int'))
-
-    l = C::IntLiteral.new(10)
-    assert_same(true, l.match?(l))
-    assert_same(true, l.match?(10))
-
-    i = C::Int.new
-    assert_same(false, i.match?('unsigned int'))
-    assert_same(false, i.match?('long int'))
-    assert_same(false, i.match?('no int here'))  # shouldn't raise!
-
-    l = C::IntLiteral.new(10)
-    assert_same(false, i.match?(10.0))
-
-    t = C::CustomType.new('T')
-    ##
-    assert_same(false, t.match?('T'))
-    ##
-    parser = C::Parser.new
-    parser.type_names << 'T'
-    assert_same(true, t.match?('T', parser))
-    ##
-    assert_same(false, t.match?('T'))
-    ##
-    C.default_parser.type_names << 'T'
-    assert_same(true, t.match?('T'))
-  end
-
-  def test_nodelist_match
-    list = C::NodeArray[]
-    assert_same(true, list.match?(list))
-    assert_same(true, list.match?([]))
-
-    list = C::NodeArray[C::Int.new, C::IntLiteral.new(10)]
-    list2 = C::NodeChain[C::Int.new, C::IntLiteral.new(10)]
-    assert_same(true, list.match?(list))
-    assert_same(true, list.match?(list2))
-    assert_same(true, list.match?(['int', 10]))
-
-    list = C::NodeArray[C::NodeArray[C::Int.new], C::NodeChain[]]
-    list2 = C::NodeChain[C::NodeChain[C::Int.new], C::NodeArray[]]
-    assert_same(true, list.match?(list))
-    assert_same(true, list.match?(list2))
-    assert_same(true, list.match?([['int'], []]))
-    assert_same(false, list.match?([[], ['int']]))
-    assert_same(false, list.match?(['int']))
-    assert_same(false, list.match?([['int']]))
-
-    t = C::NodeArray[C::CustomType.new('T')]
-    ##
-    assert_same(false, t.match?(['T']))
-    ##
-    parser = C::Parser.new
-    parser.type_names << 'T'
-    assert_same(true, t.match?(['T'], parser))
-    ##
-    assert_same(false, t.match?(['T']))
-    ##
-    C.default_parser.type_names << 'T'
-    assert_same(true, t.match?(['T']))
-  end
-end
-
-class ParseTests < Test::Unit::TestCase
-  include CheckAst
-  def check klass, s
-    check_ast(s){|inp| klass.parse(inp)}
-  end
-
-  def test_translation_unit
-    check C::TranslationUnit, <<EOS
-int i;
-void (*f)(void *);
-----
-TranslationUnit
-    entities:
-        - Declaration
-            type: Int
-            declarators:
-                - Declarator
-                    name: "i"
-        - Declaration
-            type: Void
-            declarators:
-                - Declarator
-                    indirect_type: Pointer
-                        type: Function
-                            params:
-                                - Parameter
-                                    type: Pointer
-                                        type: Void
-                    name: "f"
-EOS
-    assert_raise(ParseError){C::TranslationUnit.parse('')}
-  end
-
-  def test_declaration
-    check C::Declaration, <<EOS
-int i;
-----
-Declaration
-    type: Int
-    declarators:
-        - Declarator
-            name: "i"
-EOS
-    check C::Declaration, <<EOS
-int i, j;
-----
-Declaration
-    type: Int
-    declarators:
-        - Declarator
-            name: "i"
-        - Declarator
-            name: "j"
-EOS
-    assert_raise(ParseError){C::Declaration.parse('int i; int j;')}
-    assert_raise(ParseError){C::Declaration.parse('int f() {}')}
-    assert_raise(ParseError){C::Declaration.parse('')}
-  end
-
-  def test_parameter
-    check C::Parameter, <<EOS
-int i
-----
-Parameter
-    type: Int
-    name: "i"
-EOS
-    check C::Parameter, <<EOS
-int
-----
-Parameter
-    type: Int
-EOS
-    check C::Parameter, <<EOS
-i
-----
-Parameter
-    name: "i"
-EOS
-    check C::Parameter, <<EOS
-void
-----
-Parameter
-    type: Void
-EOS
-    assert_raise(ParseError){C::Parameter.parse('...')}
-    assert_raise(ParseError){C::Parameter.parse(') {} void (')}
-    assert_raise(ParseError){C::Parameter.parse('); void(')}
-    assert_raise(ParseError){C::Parameter.parse('i,j')}
-    assert_raise(ParseError){C::Parameter.parse('int,float')}
-    assert_raise(ParseError){C::Parameter.parse('')}
-  end
-
-  def test_declarator
-    check C::Declarator, <<EOS
-x
-----
-Declarator
-    name: "x"
-EOS
-    check C::Declarator, <<EOS
-*x
-----
-Declarator
-    indirect_type: Pointer
-    name: "x"
-EOS
-    check C::Declarator, <<EOS
-x[10]
-----
-Declarator
-    indirect_type: Array
-        length: IntLiteral
-            val: 10
-    name: "x"
-EOS
-    check C::Declarator, <<EOS
-*x(int argc, char **argv)
-----
-Declarator
-    indirect_type: Function
-        type: Pointer
-        params:
-            - Parameter
-                type: Int
-                name: "argc"
-            - Parameter
-                type: Pointer
-                    type: Pointer
-                        type: Char
-                name: "argv"
-    name: "x"
-EOS
-    assert_raise(ParseError){C::Declarator.parse('f; int f;')}
-    assert_raise(ParseError){C::Declarator.parse('i,j')}
-    assert_raise(ParseError){C::Declarator.parse(';')}
-    assert_raise(ParseError){C::Declarator.parse('')}
-  end
-
-  def test_function_def
-    check C::FunctionDef, <<EOS
-int f() {}
-----
-FunctionDef
-    type: Function
-        type: Int
-    name: "f"
-EOS
-    check C::FunctionDef, <<EOS
-void *f(void *) {}
-----
-FunctionDef
-    type: Function
-        type: Pointer
-            type: Void
-        params:
-            - Parameter
-                type: Pointer
-                    type: Void
-    name: "f"
-EOS
-    assert_raise(ParseError){C::FunctionDef.parse('void f(); void g();')}
-    assert_raise(ParseError){C::FunctionDef.parse('int i;')}
-    assert_raise(ParseError){C::FunctionDef.parse('void f();')}
-    assert_raise(ParseError){C::FunctionDef.parse(';')}
-    assert_raise(ParseError){C::FunctionDef.parse('')}
-  end
-
-  def test_enumerator
-    check C::Enumerator, <<EOS
-X
-----
-Enumerator
-    name: "X"
-EOS
-    check C::Enumerator, <<EOS
-X=10
-----
-Enumerator
-    name: "X"
-    val: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Enumerator.parse('} enum {')}
-    assert_raise(ParseError){C::Enumerator.parse('} f() {')}
-    assert_raise(ParseError){C::Enumerator.parse('X, Y')}
-    assert_raise(ParseError){C::Enumerator.parse('')}
-  end
-
-  def test_member_initializer
-    check C::MemberInit, <<EOS
-1
-----
-MemberInit
-    init: IntLiteral
-        val: 1
-EOS
-    check C::MemberInit, <<EOS
-1,
-----
-MemberInit
-    init: IntLiteral
-        val: 1
-EOS
-    check C::MemberInit, <<EOS
-i
-----
-MemberInit
-    init: Variable
-        name: "i"
-EOS
-    check C::MemberInit, <<EOS
-.i = i
-----
-MemberInit
-    member:
-        - Member
-            name: "i"
-    init: Variable
-        name: "i"
-EOS
-    check C::MemberInit, <<EOS
-.i [5] = 10.0
-----
-MemberInit
-    member:
-        - Member
-            name: "i"
-        - IntLiteral
-            val: 5
-    init: FloatLiteral
-        val: 10.0
-EOS
-    assert_raise(ParseError){C::MemberInit.parse('} int f() {')}
-    assert_raise(ParseError){C::MemberInit.parse('}} f() {{')}
-    assert_raise(ParseError){C::MemberInit.parse('1}; x = {1')}
-    assert_raise(ParseError){C::MemberInit.parse('1}, y')}
-    assert_raise(ParseError){C::MemberInit.parse('1, 2')}
-    assert_raise(ParseError){C::MemberInit.parse('')}
-  end
-
-  def test_block
-    check C::Block, <<EOS
-{}
-----
-Block
-EOS
-    check C::Block, <<EOS
-{{}}
-----
-Block
-    stmts:
-        - Block
-EOS
-    assert_raise(ParseError){C::Block.parse('} void f() {')}
-    assert_raise(ParseError){C::Block.parse(';;')}
-    assert_raise(ParseError){C::Block.parse('int i;')}
-    assert_raise(ParseError){C::Block.parse(';')}
-    assert_raise(ParseError){C::Block.parse('')}
-  end
-
-  def test_if
-    check C::If, <<EOS
-if (1) 10;
-----
-If
-    cond: IntLiteral
-        val: 1
-    then: ExpressionStatement
-        expr: IntLiteral
-            val: 10
-EOS
-    check C::If, <<EOS
-if (1) 10; else 20;
-----
-If
-    cond: IntLiteral
-        val: 1
-    then: ExpressionStatement
-        expr: IntLiteral
-            val: 10
-    else: ExpressionStatement
-        expr: IntLiteral
-            val: 20
-EOS
-    assert_raise(ParseError){C::If.parse('} void f() {')}
-    assert_raise(ParseError){C::If.parse(';;')}
-    assert_raise(ParseError){C::If.parse('int i;')}
-    assert_raise(ParseError){C::If.parse(';')}
-    assert_raise(ParseError){C::If.parse('')}
-  end
-
-  def test_switch
-    check C::Switch, <<EOS
-switch (x);
-----
-Switch
-    cond: Variable
-        name: "x"
-    stmt: ExpressionStatement
-EOS
-    assert_raise(ParseError){C::Switch.parse('} void f() {')}
-    assert_raise(ParseError){C::Switch.parse(';;')}
-    assert_raise(ParseError){C::Switch.parse('int i;')}
-    assert_raise(ParseError){C::Switch.parse(';')}
-    assert_raise(ParseError){C::Switch.parse('')}
-  end
-
-  def test_while
-    check C::While, <<EOS
-while (1);
-----
-While
-    cond: IntLiteral
-        val: 1
-    stmt: ExpressionStatement
-EOS
-    check C::While, <<EOS
-do ; while (1);
-----
-While (do)
-    cond: IntLiteral
-        val: 1
-    stmt: ExpressionStatement
-EOS
-    assert_raise(ParseError){C::While.parse('} void f() {')}
-    assert_raise(ParseError){C::While.parse(';;')}
-    assert_raise(ParseError){C::While.parse('int i;')}
-    assert_raise(ParseError){C::While.parse(';')}
-    assert_raise(ParseError){C::While.parse('')}
-  end
-
-  def test_for
-    check C::For, <<EOS
-for (;;);
-----
-For
-    stmt: ExpressionStatement
-EOS
-    check C::For, <<EOS
-for (int i; ; );
-----
-For
-    init: Declaration
-        type: Int
-        declarators:
-            - Declarator
-                name: "i"
-    stmt: ExpressionStatement
-EOS
-    assert_raise(ParseError){C::For.parse('} void f() {')}
-    assert_raise(ParseError){C::For.parse(';;')}
-    assert_raise(ParseError){C::For.parse('int i;')}
-    assert_raise(ParseError){C::For.parse(';')}
-    assert_raise(ParseError){C::For.parse('')}
-  end
-
-  def test_goto
-    check C::Goto, <<EOS
-goto x;
-----
-Goto
-    target: "x"
-EOS
-    assert_raise(ParseError){C::Goto.parse('} void f() {')}
-    assert_raise(ParseError){C::Goto.parse(';;')}
-    assert_raise(ParseError){C::Goto.parse('int i;')}
-    assert_raise(ParseError){C::Goto.parse(';')}
-    assert_raise(ParseError){C::Goto.parse('')}
-  end
-
-  def test_continue
-    check C::Continue, <<EOS
-continue;
-----
-Continue
-EOS
-    assert_raise(ParseError){C::Continue.parse('} void f() {')}
-    assert_raise(ParseError){C::Continue.parse(';;')}
-    assert_raise(ParseError){C::Continue.parse('int i;')}
-    assert_raise(ParseError){C::Continue.parse(';')}
-    assert_raise(ParseError){C::Continue.parse('')}
-  end
-
-  def test_break
-    check C::Break, <<EOS
-break;
-----
-Break
-EOS
-    assert_raise(ParseError){C::Break.parse('} void f() {')}
-    assert_raise(ParseError){C::Break.parse(';;')}
-    assert_raise(ParseError){C::Break.parse('int i;')}
-    assert_raise(ParseError){C::Break.parse(';')}
-    assert_raise(ParseError){C::Break.parse('')}
-  end
-
-  def test_return
-    check C::Return, <<EOS
-return;
-----
-Return
-EOS
-    check C::Return, <<EOS
-return 10;
-----
-Return
-    expr: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Return.parse('} void f() {')}
-    assert_raise(ParseError){C::Return.parse(';;')}
-    assert_raise(ParseError){C::Return.parse('int i;')}
-    assert_raise(ParseError){C::Return.parse(';')}
-    assert_raise(ParseError){C::Return.parse('')}
-  end
-
-  def test_expression_statement
-    check C::ExpressionStatement, <<EOS
-;
-----
-ExpressionStatement
-EOS
-    check C::ExpressionStatement, <<EOS
-10;
-----
-ExpressionStatement
-    expr: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ExpressionStatement.parse('} void f() {')}
-    assert_raise(ParseError){C::ExpressionStatement.parse(';;')}
-    assert_raise(ParseError){C::ExpressionStatement.parse('int i;')}
-    assert_raise(ParseError){C::ExpressionStatement.parse('return;')}
-    assert_raise(ParseError){C::ExpressionStatement.parse('')}
-  end
-
-  def test_statement
-    check C::Statement, <<EOS
-{}
-----
-Block
-EOS
-    check C::Statement, <<EOS
-if (1) 10; else 20;
-----
-If
-    cond: IntLiteral
-        val: 1
-    then: ExpressionStatement
-        expr: IntLiteral
-            val: 10
-    else: ExpressionStatement
-        expr: IntLiteral
-            val: 20
-EOS
-    check C::Statement, <<EOS
-switch (x);
-----
-Switch
-    cond: Variable
-        name: "x"
-    stmt: ExpressionStatement
-EOS
-    check C::Statement, <<EOS
-while (1) ;
-----
-While
-    cond: IntLiteral
-        val: 1
-    stmt: ExpressionStatement
-EOS
-    check C::Statement, <<EOS
-do ; while (1);
-----
-While (do)
-    cond: IntLiteral
-        val: 1
-    stmt: ExpressionStatement
-EOS
-    check C::Statement, <<EOS
-for (;;) ;
-----
-For
-    stmt: ExpressionStatement
-EOS
-    check C::Statement, <<EOS
-goto x;
-----
-Goto
-    target: "x"
-EOS
-    check C::Statement, <<EOS
-continue;
-----
-Continue
-EOS
-    check C::Statement, <<EOS
-break;
-----
-Break
-EOS
-    check C::Statement, <<EOS
-return;
-----
-Return
-EOS
-    check C::Statement, <<EOS
-;
-----
-ExpressionStatement
-EOS
-    assert_raise(ParseError){C::Statement.parse('} void f() {')}
-    assert_raise(ParseError){C::Statement.parse(';;')}
-    assert_raise(ParseError){C::Statement.parse('int i;')}
-    assert_raise(ParseError){C::Statement.parse('')}
-  end
-
-  def test_plain_label
-    check C::PlainLabel, <<EOS
-x:
-----
-PlainLabel
-    name: "x"
-EOS
-    assert_raise(ParseError){C::PlainLabel.parse('} void f() {')}
-    assert_raise(ParseError){C::PlainLabel.parse(';')}
-    assert_raise(ParseError){C::PlainLabel.parse('')}
-    assert_raise(ParseError){C::PlainLabel.parse('x')}
-    assert_raise(ParseError){C::PlainLabel.parse('case 1:')}
-    assert_raise(ParseError){C::PlainLabel.parse('default:')}
-  end
-
-  def test_default
-    check C::Default, <<EOS
-default:
-----
-Default
-EOS
-    assert_raise(ParseError){C::Default.parse('} void f() {')}
-    assert_raise(ParseError){C::Default.parse(';')}
-    assert_raise(ParseError){C::Default.parse('')}
-    assert_raise(ParseError){C::Default.parse('x')}
-    assert_raise(ParseError){C::Default.parse('x:')}
-    assert_raise(ParseError){C::Default.parse('case 1:')}
-  end
-
-  def test_case
-    check C::Case, <<EOS
-case 1:
-----
-Case
-    expr: IntLiteral
-        val: 1
-EOS
-    assert_raise(ParseError){C::Case.parse('} void f() {')}
-    assert_raise(ParseError){C::Case.parse(';')}
-    assert_raise(ParseError){C::Case.parse('')}
-    assert_raise(ParseError){C::Case.parse('x:')}
-    assert_raise(ParseError){C::Case.parse('default:')}
-  end
-
-  def test_label
-    check C::Label, <<EOS
-x:
-----
-PlainLabel
-    name: "x"
-EOS
-    check C::Label, <<EOS
-default:
-----
-Default
-EOS
-    check C::Label, <<EOS
-case 1:
-----
-Case
-    expr: IntLiteral
-        val: 1
-EOS
-    assert_raise(ParseError){C::Label.parse('} void f() {')}
-    assert_raise(ParseError){C::Label.parse(';')}
-    assert_raise(ParseError){C::Label.parse('')}
-    assert_raise(ParseError){C::Label.parse('x')}
-  end
-
-  def test_comma
-    check C::Comma, <<EOS
-++i, ++j
-----
-Comma
-    exprs:
-        - PreInc
-            expr: Variable
-                name: "i"
-        - PreInc
-            expr: Variable
-                name: "j"
-EOS
-    check C::Comma, <<EOS
-(++i, ++j)
-----
-Comma
-    exprs:
-        - PreInc
-            expr: Variable
-                name: "i"
-        - PreInc
-            expr: Variable
-                name: "j"
-EOS
-    assert_raise(ParseError){C::Comma.parse('} void f() {')}
-    assert_raise(ParseError){C::Comma.parse(';')}
-    assert_raise(ParseError){C::Comma.parse('int i')}
-    assert_raise(ParseError){C::Comma.parse('int')}
-    assert_raise(ParseError){C::Comma.parse('if (0)')}
-    assert_raise(ParseError){C::Comma.parse('switch (0)')}
-    assert_raise(ParseError){C::Comma.parse('for (;;)')}
-    assert_raise(ParseError){C::Comma.parse('goto')}
-    assert_raise(ParseError){C::Comma.parse('return')}
-  end
-
-  def test_conditional
-    check C::Conditional, <<EOS
-1 ? 10 : 20
-----
-Conditional
-    cond: IntLiteral
-        val: 1
-    then: IntLiteral
-        val: 10
-    else: IntLiteral
-        val: 20
-EOS
-    assert_raise(ParseError){C::Conditional.parse('} void f() {')}
-    assert_raise(ParseError){C::Conditional.parse(';')}
-    assert_raise(ParseError){C::Conditional.parse('int i')}
-    assert_raise(ParseError){C::Conditional.parse('int')}
-    assert_raise(ParseError){C::Conditional.parse('if (0)')}
-    assert_raise(ParseError){C::Conditional.parse('switch (0)')}
-    assert_raise(ParseError){C::Conditional.parse('for (;;)')}
-    assert_raise(ParseError){C::Conditional.parse('goto')}
-    assert_raise(ParseError){C::Conditional.parse('return')}
-  end
-
-  def test_cast
-    check C::Cast, <<EOS
-(int)10.0
-----
-Cast
-    type: Int
-    expr: FloatLiteral
-        val: 10.0
-EOS
-    assert_raise(ParseError){C::Cast.parse('} void f() {')}
-    assert_raise(ParseError){C::Cast.parse(';')}
-    assert_raise(ParseError){C::Cast.parse('int i')}
-    assert_raise(ParseError){C::Cast.parse('int')}
-    assert_raise(ParseError){C::Cast.parse('if (0)')}
-    assert_raise(ParseError){C::Cast.parse('switch (0)')}
-    assert_raise(ParseError){C::Cast.parse('for (;;)')}
-    assert_raise(ParseError){C::Cast.parse('goto')}
-    assert_raise(ParseError){C::Cast.parse('return')}
-  end
-
-  def test_address
-    check C::Address, <<EOS
-&x
-----
-Address
-    expr: Variable
-        name: "x"
-EOS
-    assert_raise(ParseError){C::Address.parse('} void f() {')}
-    assert_raise(ParseError){C::Address.parse(';')}
-    assert_raise(ParseError){C::Address.parse('int i')}
-    assert_raise(ParseError){C::Address.parse('int')}
-    assert_raise(ParseError){C::Address.parse('if (0)')}
-    assert_raise(ParseError){C::Address.parse('switch (0)')}
-    assert_raise(ParseError){C::Address.parse('for (;;)')}
-    assert_raise(ParseError){C::Address.parse('goto')}
-    assert_raise(ParseError){C::Address.parse('return')}
-  end
-
-  def test_dereference
-    check C::Dereference, <<EOS
-*x
-----
-Dereference
-    expr: Variable
-        name: "x"
-EOS
-    assert_raise(ParseError){C::Dereference.parse('} void f() {')}
-    assert_raise(ParseError){C::Dereference.parse(';')}
-    assert_raise(ParseError){C::Dereference.parse('int i')}
-    assert_raise(ParseError){C::Dereference.parse('int')}
-    assert_raise(ParseError){C::Dereference.parse('if (0)')}
-    assert_raise(ParseError){C::Dereference.parse('switch (0)')}
-    assert_raise(ParseError){C::Dereference.parse('for (;;)')}
-    assert_raise(ParseError){C::Dereference.parse('goto')}
-    assert_raise(ParseError){C::Dereference.parse('return')}
-  end
-
-  def test_sizeof
-    check C::Sizeof, <<EOS
-sizeof i
-----
-Sizeof
-    expr: Variable
-        name: "i"
-EOS
-    check C::Sizeof, <<EOS
-sizeof(int)
-----
-Sizeof
-    expr: Int
-EOS
-    assert_raise(ParseError){C::Sizeof.parse('} void f() {')}
-    assert_raise(ParseError){C::Sizeof.parse(';')}
-    assert_raise(ParseError){C::Sizeof.parse('int i')}
-    assert_raise(ParseError){C::Sizeof.parse('int')}
-    assert_raise(ParseError){C::Sizeof.parse('if (0)')}
-    assert_raise(ParseError){C::Sizeof.parse('switch (0)')}
-    assert_raise(ParseError){C::Sizeof.parse('for (;;)')}
-    assert_raise(ParseError){C::Sizeof.parse('goto')}
-    assert_raise(ParseError){C::Sizeof.parse('return')}
-  end
-
-  def test_index
-    check C::Index, <<EOS
-x[10][20]
-----
-Index
-    expr: Index
-        expr: Variable
-            name: "x"
-        index: IntLiteral
-            val: 10
-    index: IntLiteral
-        val: 20
-EOS
-    assert_raise(ParseError){C::Index.parse('} void f() {')}
-    assert_raise(ParseError){C::Index.parse(';')}
-    assert_raise(ParseError){C::Index.parse('int i')}
-    assert_raise(ParseError){C::Index.parse('int')}
-    assert_raise(ParseError){C::Index.parse('if (0)')}
-    assert_raise(ParseError){C::Index.parse('switch (0)')}
-    assert_raise(ParseError){C::Index.parse('for (;;)')}
-    assert_raise(ParseError){C::Index.parse('goto')}
-    assert_raise(ParseError){C::Index.parse('return')}
-  end
-
-  def test_call
-    check C::Call, <<EOS
-x(10, 20)()
-----
-Call
-    expr: Call
-        expr: Variable
-            name: "x"
-        args:
-            - IntLiteral
-                val: 10
-            - IntLiteral
-                val: 20
-EOS
-    assert_raise(ParseError){C::Call.parse('} void f() {')}
-    assert_raise(ParseError){C::Call.parse(';')}
-    assert_raise(ParseError){C::Call.parse('int i')}
-    assert_raise(ParseError){C::Call.parse('int')}
-    assert_raise(ParseError){C::Call.parse('if (0)')}
-    assert_raise(ParseError){C::Call.parse('switch (0)')}
-    assert_raise(ParseError){C::Call.parse('for (;;)')}
-    assert_raise(ParseError){C::Call.parse('goto')}
-    assert_raise(ParseError){C::Call.parse('return')}
-  end
-
-  def test_arrow
-    check C::Arrow, <<EOS
-x->y
-----
-Arrow
-    expr: Variable
-        name: "x"
-    member: Member
-        name: "y"
-EOS
-    assert_raise(ParseError){C::Arrow.parse('} void f() {')}
-    assert_raise(ParseError){C::Arrow.parse(';')}
-    assert_raise(ParseError){C::Arrow.parse('int i')}
-    assert_raise(ParseError){C::Arrow.parse('int')}
-    assert_raise(ParseError){C::Arrow.parse('if (0)')}
-    assert_raise(ParseError){C::Arrow.parse('switch (0)')}
-    assert_raise(ParseError){C::Arrow.parse('for (;;)')}
-    assert_raise(ParseError){C::Arrow.parse('goto')}
-    assert_raise(ParseError){C::Arrow.parse('return')}
-  end
-
-  def test_dot
-    check C::Dot, <<EOS
-x.y
-----
-Dot
-    expr: Variable
-        name: "x"
-    member: Member
-        name: "y"
-EOS
-    assert_raise(ParseError){C::Dot.parse('} void f() {')}
-    assert_raise(ParseError){C::Dot.parse(';')}
-    assert_raise(ParseError){C::Dot.parse('int i')}
-    assert_raise(ParseError){C::Dot.parse('int')}
-    assert_raise(ParseError){C::Dot.parse('if (0)')}
-    assert_raise(ParseError){C::Dot.parse('switch (0)')}
-    assert_raise(ParseError){C::Dot.parse('for (;;)')}
-    assert_raise(ParseError){C::Dot.parse('goto')}
-    assert_raise(ParseError){C::Dot.parse('return')}
-  end
-
-  def test_positive
-    check C::Positive, <<EOS
-+1
-----
-Positive
-    expr: IntLiteral
-        val: 1
-EOS
-    assert_raise(ParseError){C::Positive.parse('} void f() {')}
-    assert_raise(ParseError){C::Positive.parse(';')}
-    assert_raise(ParseError){C::Positive.parse('int i')}
-    assert_raise(ParseError){C::Positive.parse('int')}
-    assert_raise(ParseError){C::Positive.parse('if (0)')}
-    assert_raise(ParseError){C::Positive.parse('switch (0)')}
-    assert_raise(ParseError){C::Positive.parse('for (;;)')}
-    assert_raise(ParseError){C::Positive.parse('goto')}
-    assert_raise(ParseError){C::Positive.parse('return')}
-  end
-
-  def test_negative
-    check C::Negative, <<EOS
--1
-----
-Negative
-    expr: IntLiteral
-        val: 1
-EOS
-    assert_raise(ParseError){C::Negative.parse('} void f() {')}
-    assert_raise(ParseError){C::Negative.parse(';')}
-    assert_raise(ParseError){C::Negative.parse('int i')}
-    assert_raise(ParseError){C::Negative.parse('int')}
-    assert_raise(ParseError){C::Negative.parse('if (0)')}
-    assert_raise(ParseError){C::Negative.parse('switch (0)')}
-    assert_raise(ParseError){C::Negative.parse('for (;;)')}
-    assert_raise(ParseError){C::Negative.parse('goto')}
-    assert_raise(ParseError){C::Negative.parse('return')}
-  end
-
-  def test_add
-    check C::Add, <<EOS
-1 + 10
-----
-Add
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Add.parse('} void f() {')}
-    assert_raise(ParseError){C::Add.parse(';')}
-    assert_raise(ParseError){C::Add.parse('int i')}
-    assert_raise(ParseError){C::Add.parse('int')}
-    assert_raise(ParseError){C::Add.parse('if (0)')}
-    assert_raise(ParseError){C::Add.parse('switch (0)')}
-    assert_raise(ParseError){C::Add.parse('for (;;)')}
-    assert_raise(ParseError){C::Add.parse('goto')}
-    assert_raise(ParseError){C::Add.parse('return')}
-  end
-
-  def test_subtract
-    check C::Subtract, <<EOS
-1 - 10
-----
-Subtract
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Subtract.parse('} void f() {')}
-    assert_raise(ParseError){C::Subtract.parse(';')}
-    assert_raise(ParseError){C::Subtract.parse('int i')}
-    assert_raise(ParseError){C::Subtract.parse('int')}
-    assert_raise(ParseError){C::Subtract.parse('if (0)')}
-    assert_raise(ParseError){C::Subtract.parse('switch (0)')}
-    assert_raise(ParseError){C::Subtract.parse('for (;;)')}
-    assert_raise(ParseError){C::Subtract.parse('goto')}
-    assert_raise(ParseError){C::Subtract.parse('return')}
-  end
-
-  def test_multiply
-    check C::Multiply, <<EOS
-1 * 10
-----
-Multiply
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Multiply.parse('} void f() {')}
-    assert_raise(ParseError){C::Multiply.parse(';')}
-    assert_raise(ParseError){C::Multiply.parse('int i')}
-    assert_raise(ParseError){C::Multiply.parse('int')}
-    assert_raise(ParseError){C::Multiply.parse('if (0)')}
-    assert_raise(ParseError){C::Multiply.parse('switch (0)')}
-    assert_raise(ParseError){C::Multiply.parse('for (;;)')}
-    assert_raise(ParseError){C::Multiply.parse('goto')}
-    assert_raise(ParseError){C::Multiply.parse('return')}
-  end
-
-  def test_divide
-    check C::Divide, <<EOS
-1 / 10
-----
-Divide
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Divide.parse('} void f() {')}
-    assert_raise(ParseError){C::Divide.parse(';')}
-    assert_raise(ParseError){C::Divide.parse('int i')}
-    assert_raise(ParseError){C::Divide.parse('int')}
-    assert_raise(ParseError){C::Divide.parse('if (0)')}
-    assert_raise(ParseError){C::Divide.parse('switch (0)')}
-    assert_raise(ParseError){C::Divide.parse('for (;;)')}
-    assert_raise(ParseError){C::Divide.parse('goto')}
-    assert_raise(ParseError){C::Divide.parse('return')}
-  end
-
-  def test_mod
-    check C::Mod, <<EOS
-1 % 10
-----
-Mod
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Mod.parse('} void f() {')}
-    assert_raise(ParseError){C::Mod.parse(';')}
-    assert_raise(ParseError){C::Mod.parse('int i')}
-    assert_raise(ParseError){C::Mod.parse('int')}
-    assert_raise(ParseError){C::Mod.parse('if (0)')}
-    assert_raise(ParseError){C::Mod.parse('switch (0)')}
-    assert_raise(ParseError){C::Mod.parse('for (;;)')}
-    assert_raise(ParseError){C::Mod.parse('goto')}
-    assert_raise(ParseError){C::Mod.parse('return')}
-  end
-
-  def test_pre_inc
-    check C::PreInc, <<EOS
-++i
-----
-PreInc
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::PreInc.parse('} void f() {')}
-    assert_raise(ParseError){C::PreInc.parse(';')}
-    assert_raise(ParseError){C::PreInc.parse('int i')}
-    assert_raise(ParseError){C::PreInc.parse('int')}
-    assert_raise(ParseError){C::PreInc.parse('if (0)')}
-    assert_raise(ParseError){C::PreInc.parse('switch (0)')}
-    assert_raise(ParseError){C::PreInc.parse('for (;;)')}
-    assert_raise(ParseError){C::PreInc.parse('goto')}
-    assert_raise(ParseError){C::PreInc.parse('return')}
-  end
-
-  def test_post_inc
-    check C::PostInc, <<EOS
-i++
-----
-PostInc
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::PostInc.parse('} void f() {')}
-    assert_raise(ParseError){C::PostInc.parse(';')}
-    assert_raise(ParseError){C::PostInc.parse('int i')}
-    assert_raise(ParseError){C::PostInc.parse('int')}
-    assert_raise(ParseError){C::PostInc.parse('if (0)')}
-    assert_raise(ParseError){C::PostInc.parse('switch (0)')}
-    assert_raise(ParseError){C::PostInc.parse('for (;;)')}
-    assert_raise(ParseError){C::PostInc.parse('goto')}
-    assert_raise(ParseError){C::PostInc.parse('return')}
-  end
-
-  def test_pre_dec
-    check C::PreDec, <<EOS
---i
-----
-PreDec
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::PreDec.parse('} void f() {')}
-    assert_raise(ParseError){C::PreDec.parse(';')}
-    assert_raise(ParseError){C::PreDec.parse('int i')}
-    assert_raise(ParseError){C::PreDec.parse('int')}
-    assert_raise(ParseError){C::PreDec.parse('if (0)')}
-    assert_raise(ParseError){C::PreDec.parse('switch (0)')}
-    assert_raise(ParseError){C::PreDec.parse('for (;;)')}
-    assert_raise(ParseError){C::PreDec.parse('goto')}
-    assert_raise(ParseError){C::PreDec.parse('return')}
-  end
-
-  def test_post_dec
-    check C::PostDec, <<EOS
-i--
-----
-PostDec
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::PostDec.parse('} void f() {')}
-    assert_raise(ParseError){C::PostDec.parse(';')}
-    assert_raise(ParseError){C::PostDec.parse('int i')}
-    assert_raise(ParseError){C::PostDec.parse('int')}
-    assert_raise(ParseError){C::PostDec.parse('if (0)')}
-    assert_raise(ParseError){C::PostDec.parse('switch (0)')}
-    assert_raise(ParseError){C::PostDec.parse('for (;;)')}
-    assert_raise(ParseError){C::PostDec.parse('goto')}
-    assert_raise(ParseError){C::PostDec.parse('return')}
-  end
-
-  def test_equal
-    check C::Equal, <<EOS
-1 == 10
-----
-Equal
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Equal.parse('} void f() {')}
-    assert_raise(ParseError){C::Equal.parse(';')}
-    assert_raise(ParseError){C::Equal.parse('int i')}
-    assert_raise(ParseError){C::Equal.parse('int')}
-    assert_raise(ParseError){C::Equal.parse('if (0)')}
-    assert_raise(ParseError){C::Equal.parse('switch (0)')}
-    assert_raise(ParseError){C::Equal.parse('for (;;)')}
-    assert_raise(ParseError){C::Equal.parse('goto')}
-    assert_raise(ParseError){C::Equal.parse('return')}
-  end
-
-  def test_not_equal
-    check C::NotEqual, <<EOS
-1 != 10
-----
-NotEqual
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::NotEqual.parse('} void f() {')}
-    assert_raise(ParseError){C::NotEqual.parse(';')}
-    assert_raise(ParseError){C::NotEqual.parse('int i')}
-    assert_raise(ParseError){C::NotEqual.parse('int')}
-    assert_raise(ParseError){C::NotEqual.parse('if (0)')}
-    assert_raise(ParseError){C::NotEqual.parse('switch (0)')}
-    assert_raise(ParseError){C::NotEqual.parse('for (;;)')}
-    assert_raise(ParseError){C::NotEqual.parse('goto')}
-    assert_raise(ParseError){C::NotEqual.parse('return')}
-  end
-
-  def test_less
-    check C::Less, <<EOS
-1 < 10
-----
-Less
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Less.parse('} void f() {')}
-    assert_raise(ParseError){C::Less.parse(';')}
-    assert_raise(ParseError){C::Less.parse('int i')}
-    assert_raise(ParseError){C::Less.parse('int')}
-    assert_raise(ParseError){C::Less.parse('if (0)')}
-    assert_raise(ParseError){C::Less.parse('switch (0)')}
-    assert_raise(ParseError){C::Less.parse('for (;;)')}
-    assert_raise(ParseError){C::Less.parse('goto')}
-    assert_raise(ParseError){C::Less.parse('return')}
-  end
-
-  def test_more
-    check C::More, <<EOS
-1 > 10
-----
-More
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::More.parse('} void f() {')}
-    assert_raise(ParseError){C::More.parse(';')}
-    assert_raise(ParseError){C::More.parse('int i')}
-    assert_raise(ParseError){C::More.parse('int')}
-    assert_raise(ParseError){C::More.parse('if (0)')}
-    assert_raise(ParseError){C::More.parse('switch (0)')}
-    assert_raise(ParseError){C::More.parse('for (;;)')}
-    assert_raise(ParseError){C::More.parse('goto')}
-    assert_raise(ParseError){C::More.parse('return')}
-  end
-
-  def test_less_or_equal
-    check C::LessOrEqual, <<EOS
-1 <= 10
-----
-LessOrEqual
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::LessOrEqual.parse('} void f() {')}
-    assert_raise(ParseError){C::LessOrEqual.parse(';')}
-    assert_raise(ParseError){C::LessOrEqual.parse('int i')}
-    assert_raise(ParseError){C::LessOrEqual.parse('int')}
-    assert_raise(ParseError){C::LessOrEqual.parse('if (0)')}
-    assert_raise(ParseError){C::LessOrEqual.parse('switch (0)')}
-    assert_raise(ParseError){C::LessOrEqual.parse('for (;;)')}
-    assert_raise(ParseError){C::LessOrEqual.parse('goto')}
-    assert_raise(ParseError){C::LessOrEqual.parse('return')}
-  end
-
-  def test_more_or_equal
-    check C::MoreOrEqual, <<EOS
-1 >= 10
-----
-MoreOrEqual
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::MoreOrEqual.parse('} void f() {')}
-    assert_raise(ParseError){C::MoreOrEqual.parse(';')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('int i')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('int')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('if (0)')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('switch (0)')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('for (;;)')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('goto')}
-    assert_raise(ParseError){C::MoreOrEqual.parse('return')}
-  end
-
-  def test_bit_and
-    check C::BitAnd, <<EOS
-1 & 10
-----
-BitAnd
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitAnd.parse('} void f() {')}
-    assert_raise(ParseError){C::BitAnd.parse(';')}
-    assert_raise(ParseError){C::BitAnd.parse('int i')}
-    assert_raise(ParseError){C::BitAnd.parse('int')}
-    assert_raise(ParseError){C::BitAnd.parse('if (0)')}
-    assert_raise(ParseError){C::BitAnd.parse('switch (0)')}
-    assert_raise(ParseError){C::BitAnd.parse('for (;;)')}
-    assert_raise(ParseError){C::BitAnd.parse('goto')}
-    assert_raise(ParseError){C::BitAnd.parse('return')}
-  end
-
-  def test_bit_or
-    check C::BitOr, <<EOS
-1 | 10
-----
-BitOr
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitOr.parse('} void f() {')}
-    assert_raise(ParseError){C::BitOr.parse(';')}
-    assert_raise(ParseError){C::BitOr.parse('int i')}
-    assert_raise(ParseError){C::BitOr.parse('int')}
-    assert_raise(ParseError){C::BitOr.parse('if (0)')}
-    assert_raise(ParseError){C::BitOr.parse('switch (0)')}
-    assert_raise(ParseError){C::BitOr.parse('for (;;)')}
-    assert_raise(ParseError){C::BitOr.parse('goto')}
-    assert_raise(ParseError){C::BitOr.parse('return')}
-  end
-
-  def test_bit_xor
-    check C::BitXor, <<EOS
-1 ^ 10
-----
-BitXor
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitXor.parse('} void f() {')}
-    assert_raise(ParseError){C::BitXor.parse(';')}
-    assert_raise(ParseError){C::BitXor.parse('int i')}
-    assert_raise(ParseError){C::BitXor.parse('int')}
-    assert_raise(ParseError){C::BitXor.parse('if (0)')}
-    assert_raise(ParseError){C::BitXor.parse('switch (0)')}
-    assert_raise(ParseError){C::BitXor.parse('for (;;)')}
-    assert_raise(ParseError){C::BitXor.parse('goto')}
-    assert_raise(ParseError){C::BitXor.parse('return')}
-  end
-
-  def test_bit_not
-    check C::BitNot, <<EOS
-~i
-----
-BitNot
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::BitNot.parse('} void f() {')}
-    assert_raise(ParseError){C::BitNot.parse(';')}
-    assert_raise(ParseError){C::BitNot.parse('int i')}
-    assert_raise(ParseError){C::BitNot.parse('int')}
-    assert_raise(ParseError){C::BitNot.parse('if (0)')}
-    assert_raise(ParseError){C::BitNot.parse('switch (0)')}
-    assert_raise(ParseError){C::BitNot.parse('for (;;)')}
-    assert_raise(ParseError){C::BitNot.parse('goto')}
-    assert_raise(ParseError){C::BitNot.parse('return')}
-  end
-
-  def test_shift_left
-    check C::ShiftLeft, <<EOS
-1 << 10
-----
-ShiftLeft
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ShiftLeft.parse('} void f() {')}
-    assert_raise(ParseError){C::ShiftLeft.parse(';')}
-    assert_raise(ParseError){C::ShiftLeft.parse('int i')}
-    assert_raise(ParseError){C::ShiftLeft.parse('int')}
-    assert_raise(ParseError){C::ShiftLeft.parse('if (0)')}
-    assert_raise(ParseError){C::ShiftLeft.parse('switch (0)')}
-    assert_raise(ParseError){C::ShiftLeft.parse('for (;;)')}
-    assert_raise(ParseError){C::ShiftLeft.parse('goto')}
-    assert_raise(ParseError){C::ShiftLeft.parse('return')}
-  end
-
-  def test_shift_right
-    check C::ShiftRight, <<EOS
-1 >> 10
-----
-ShiftRight
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ShiftRight.parse('} void f() {')}
-    assert_raise(ParseError){C::ShiftRight.parse(';')}
-    assert_raise(ParseError){C::ShiftRight.parse('int i')}
-    assert_raise(ParseError){C::ShiftRight.parse('int')}
-    assert_raise(ParseError){C::ShiftRight.parse('if (0)')}
-    assert_raise(ParseError){C::ShiftRight.parse('switch (0)')}
-    assert_raise(ParseError){C::ShiftRight.parse('for (;;)')}
-    assert_raise(ParseError){C::ShiftRight.parse('goto')}
-    assert_raise(ParseError){C::ShiftRight.parse('return')}
-  end
-
-  def test_and
-    check C::And, <<EOS
-1 && 10
-----
-And
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::And.parse('} void f() {')}
-    assert_raise(ParseError){C::And.parse(';')}
-    assert_raise(ParseError){C::And.parse('int i')}
-    assert_raise(ParseError){C::And.parse('int')}
-    assert_raise(ParseError){C::And.parse('if (0)')}
-    assert_raise(ParseError){C::And.parse('switch (0)')}
-    assert_raise(ParseError){C::And.parse('for (;;)')}
-    assert_raise(ParseError){C::And.parse('goto')}
-    assert_raise(ParseError){C::And.parse('return')}
-  end
-
-  def test_or
-    check C::Or, <<EOS
-1 || 10
-----
-Or
-    expr1: IntLiteral
-        val: 1
-    expr2: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Or.parse('} void f() {')}
-    assert_raise(ParseError){C::Or.parse(';')}
-    assert_raise(ParseError){C::Or.parse('int i')}
-    assert_raise(ParseError){C::Or.parse('int')}
-    assert_raise(ParseError){C::Or.parse('if (0)')}
-    assert_raise(ParseError){C::Or.parse('switch (0)')}
-    assert_raise(ParseError){C::Or.parse('for (;;)')}
-    assert_raise(ParseError){C::Or.parse('goto')}
-    assert_raise(ParseError){C::Or.parse('return')}
-  end
-
-  def test_not
-    check C::Not, <<EOS
-!i
-----
-Not
-    expr: Variable
-        name: "i"
-EOS
-    assert_raise(ParseError){C::Not.parse('} void f() {')}
-    assert_raise(ParseError){C::Not.parse(';')}
-    assert_raise(ParseError){C::Not.parse('int i')}
-    assert_raise(ParseError){C::Not.parse('int')}
-    assert_raise(ParseError){C::Not.parse('if (0)')}
-    assert_raise(ParseError){C::Not.parse('switch (0)')}
-    assert_raise(ParseError){C::Not.parse('for (;;)')}
-    assert_raise(ParseError){C::Not.parse('goto')}
-    assert_raise(ParseError){C::Not.parse('return')}
-  end
-
-  def test_assign
-    check C::Assign, <<EOS
-x = 10
-----
-Assign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Assign.parse('} void f() {')}
-    assert_raise(ParseError){C::Assign.parse(';')}
-    assert_raise(ParseError){C::Assign.parse('int i')}
-    assert_raise(ParseError){C::Assign.parse('int')}
-    assert_raise(ParseError){C::Assign.parse('if (0)')}
-    assert_raise(ParseError){C::Assign.parse('switch (0)')}
-    assert_raise(ParseError){C::Assign.parse('for (;;)')}
-    assert_raise(ParseError){C::Assign.parse('goto')}
-    assert_raise(ParseError){C::Assign.parse('return')}
-  end
-
-  def test_multiply_assign
-    check C::MultiplyAssign, <<EOS
-x *= 10
-----
-MultiplyAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::MultiplyAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::MultiplyAssign.parse(';')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('int i')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('int')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('if (0)')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('goto')}
-    assert_raise(ParseError){C::MultiplyAssign.parse('return')}
-  end
-
-  def test_divide_assign
-    check C::DivideAssign, <<EOS
-x /= 10
-----
-DivideAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::DivideAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::DivideAssign.parse(';')}
-    assert_raise(ParseError){C::DivideAssign.parse('int i')}
-    assert_raise(ParseError){C::DivideAssign.parse('int')}
-    assert_raise(ParseError){C::DivideAssign.parse('if (0)')}
-    assert_raise(ParseError){C::DivideAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::DivideAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::DivideAssign.parse('goto')}
-    assert_raise(ParseError){C::DivideAssign.parse('return')}
-  end
-
-  def test_mod_assign
-    check C::ModAssign, <<EOS
-x %= 10
-----
-ModAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ModAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::ModAssign.parse(';')}
-    assert_raise(ParseError){C::ModAssign.parse('int i')}
-    assert_raise(ParseError){C::ModAssign.parse('int')}
-    assert_raise(ParseError){C::ModAssign.parse('if (0)')}
-    assert_raise(ParseError){C::ModAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::ModAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::ModAssign.parse('goto')}
-    assert_raise(ParseError){C::ModAssign.parse('return')}
-  end
-
-  def test_add_assign
-    check C::AddAssign, <<EOS
-x += 10
-----
-AddAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::AddAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::AddAssign.parse(';')}
-    assert_raise(ParseError){C::AddAssign.parse('int i')}
-    assert_raise(ParseError){C::AddAssign.parse('int')}
-    assert_raise(ParseError){C::AddAssign.parse('if (0)')}
-    assert_raise(ParseError){C::AddAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::AddAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::AddAssign.parse('goto')}
-    assert_raise(ParseError){C::AddAssign.parse('return')}
-  end
-
-  def test_subtract_assign
-    check C::SubtractAssign, <<EOS
-x -= 10
-----
-SubtractAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::SubtractAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::SubtractAssign.parse(';')}
-    assert_raise(ParseError){C::SubtractAssign.parse('int i')}
-    assert_raise(ParseError){C::SubtractAssign.parse('int')}
-    assert_raise(ParseError){C::SubtractAssign.parse('if (0)')}
-    assert_raise(ParseError){C::SubtractAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::SubtractAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::SubtractAssign.parse('goto')}
-    assert_raise(ParseError){C::SubtractAssign.parse('return')}
-  end
-
-  def test_shift_left_assign
-    check C::ShiftLeftAssign, <<EOS
-x <<= 10
-----
-ShiftLeftAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse(';')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('int i')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('int')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('if (0)')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('goto')}
-    assert_raise(ParseError){C::ShiftLeftAssign.parse('return')}
-  end
-
-  def test_shift_right_assign
-    check C::ShiftRightAssign, <<EOS
-x >>= 10
-----
-ShiftRightAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::ShiftRightAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse(';')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('int i')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('int')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('if (0)')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('goto')}
-    assert_raise(ParseError){C::ShiftRightAssign.parse('return')}
-  end
-
-  def test_bit_and_assign
-    check C::BitAndAssign, <<EOS
-x &= 10
-----
-BitAndAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitAndAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::BitAndAssign.parse(';')}
-    assert_raise(ParseError){C::BitAndAssign.parse('int i')}
-    assert_raise(ParseError){C::BitAndAssign.parse('int')}
-    assert_raise(ParseError){C::BitAndAssign.parse('if (0)')}
-    assert_raise(ParseError){C::BitAndAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::BitAndAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::BitAndAssign.parse('goto')}
-    assert_raise(ParseError){C::BitAndAssign.parse('return')}
-  end
-
-  def test_bit_xor_assign
-    check C::BitXorAssign, <<EOS
-x ^= 10
-----
-BitXorAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitXorAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::BitXorAssign.parse(';')}
-    assert_raise(ParseError){C::BitXorAssign.parse('int i')}
-    assert_raise(ParseError){C::BitXorAssign.parse('int')}
-    assert_raise(ParseError){C::BitXorAssign.parse('if (0)')}
-    assert_raise(ParseError){C::BitXorAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::BitXorAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::BitXorAssign.parse('goto')}
-    assert_raise(ParseError){C::BitXorAssign.parse('return')}
-  end
-
-  def test_bit_or_assign
-    check C::BitOrAssign, <<EOS
-x |= 10
-----
-BitOrAssign
-    lval: Variable
-        name: "x"
-    rval: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::BitOrAssign.parse('} void f() {')}
-    assert_raise(ParseError){C::BitOrAssign.parse(';')}
-    assert_raise(ParseError){C::BitOrAssign.parse('int i')}
-    assert_raise(ParseError){C::BitOrAssign.parse('int')}
-    assert_raise(ParseError){C::BitOrAssign.parse('if (0)')}
-    assert_raise(ParseError){C::BitOrAssign.parse('switch (0)')}
-    assert_raise(ParseError){C::BitOrAssign.parse('for (;;)')}
-    assert_raise(ParseError){C::BitOrAssign.parse('goto')}
-    assert_raise(ParseError){C::BitOrAssign.parse('return')}
-  end
-
-  def test_pointer
-    check C::Pointer, <<EOS
-int *
-----
-Pointer
-    type: Int
-EOS
-    check C::Pointer, <<EOS
-const volatile unsigned int*
-----
-Pointer
-    type: Int (const volatile unsigned)
-EOS
-    assert_raise(ParseError){C::Pointer.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Pointer.parse('1); (int')}
-    assert_raise(ParseError){C::Pointer.parse('void')}
-  end
-
-  def test_array
-    check C::Array, <<EOS
-int[]
-----
-Array
-    type: Int
-EOS
-    check C::Array, <<EOS
-const volatile unsigned int[10]
-----
-Array
-    type: Int (const volatile unsigned)
-    length: IntLiteral
-        val: 10
-EOS
-    assert_raise(ParseError){C::Array.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Array.parse('1); (int')}
-    assert_raise(ParseError){C::Array.parse('void')}
-  end
-
-  def test_function
-    check C::Function, <<EOS
-void()
-----
-Function
-    type: Void
-EOS
-    check C::Function, <<EOS
-const volatile unsigned int(int x, int y)
-----
-Function
-    type: Int (const volatile unsigned)
-    params:
-        - Parameter
-            type: Int
-            name: "x"
-        - Parameter
-            type: Int
-            name: "y"
-EOS
-    assert_raise(ParseError){C::Function.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Function.parse('1); (int')}
-    assert_raise(ParseError){C::Function.parse('void')}
-  end
-
-  def test_struct
-    check C::Struct, <<EOS
-struct s
-----
-Struct
-    name: "s"
-EOS
-    check C::Struct, <<EOS
-const struct {int i, j : 4;}
-----
-Struct (const)
-    members:
-        - Declaration
-            type: Int
-            declarators:
-                - Declarator
-                    name: "i"
-                - Declarator
-                    name: "j"
-                    num_bits: IntLiteral
-                        val: 4
-EOS
-    assert_raise(ParseError){C::Struct.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Struct.parse('1); (int')}
-    assert_raise(ParseError){C::Struct.parse('void')}
-  end
-
-  def test_union
-    check C::Union, <<EOS
-union s
-----
-Union
-    name: "s"
-EOS
-    check C::Union, <<EOS
-const union {int i, j : 4;}
-----
-Union (const)
-    members:
-        - Declaration
-            type: Int
-            declarators:
-                - Declarator
-                    name: "i"
-                - Declarator
-                    name: "j"
-                    num_bits: IntLiteral
-                        val: 4
-EOS
-    assert_raise(ParseError){C::Union.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Union.parse('1); (int')}
-    assert_raise(ParseError){C::Union.parse('void')}
-  end
-
-  def test_enum
-    check C::Enum, <<EOS
-enum s
-----
-Enum
-    name: "s"
-EOS
-    check C::Enum, <<EOS
-const enum {X = 10, Y, Z}
-----
-Enum (const)
-    members:
-        - Enumerator
-            name: "X"
-            val: IntLiteral
-                val: 10
-        - Enumerator
-            name: "Y"
-        - Enumerator
-            name: "Z"
-EOS
-    assert_raise(ParseError){C::Enum.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Enum.parse('1); (int')}
-    assert_raise(ParseError){C::Enum.parse('void')}
-  end
-
-  def test_custom_type
-    assert_raise(ParseError){C::CustomType.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::CustomType.parse('1); (int')}
-    assert_raise(ParseError){C::CustomType.parse('void')}
-  end
-
-  def test_void
-    check C::Void, <<EOS
-const void
-----
-Void (const)
-EOS
-    assert_raise(ParseError){C::Void.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Void.parse('1); (int')}
-    assert_raise(ParseError){C::Void.parse('int')}
-  end
-
-  def test_int
-    check C::Int, <<EOS
-const int
-----
-Int (const)
-EOS
-    assert_raise(ParseError){C::Int.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Int.parse('1); (int')}
-    assert_raise(ParseError){C::Int.parse('void')}
-  end
-
-  def test_float
-    check C::Float, <<EOS
-const float
-----
-Float (const)
-EOS
-    assert_raise(ParseError){C::Float.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Float.parse('1); (int')}
-    assert_raise(ParseError){C::Float.parse('void')}
-  end
-
-  def test_char
-    check C::Char, <<EOS
-const char
-----
-Char (const)
-EOS
-    assert_raise(ParseError){C::Char.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Char.parse('1); (int')}
-    assert_raise(ParseError){C::Char.parse('void')}
-  end
-
-  def test_bool
-    check C::Bool, <<EOS
-const _Bool
-----
-Bool (const)
-EOS
-    assert_raise(ParseError){C::Bool.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Bool.parse('1); (int')}
-    assert_raise(ParseError){C::Bool.parse('void')}
-  end
-
-  def test_complex
-    check C::Complex, <<EOS
-const _Complex float
-----
-Complex (const)
-EOS
-    assert_raise(ParseError){C::Complex.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Complex.parse('1); (int')}
-    assert_raise(ParseError){C::Complex.parse('void')}
-  end
-
-  def test_imaginary
-    check C::Imaginary, <<EOS
-const _Imaginary float
-----
-Imaginary (const)
-EOS
-    assert_raise(ParseError){C::Imaginary.parse('1);} void f() {(int')}
-    assert_raise(ParseError){C::Imaginary.parse('1); (int')}
-    assert_raise(ParseError){C::Imaginary.parse('void')}
-  end
-
-  def test_string_literal
-    check C::StringLiteral, <<EOS
-"hello"
-----
-StringLiteral
-    val: "hello"
-EOS
-    assert_raise(ParseError){C::StringLiteral.parse('} void f() {')}
-    assert_raise(ParseError){C::StringLiteral.parse(';')}
-    assert_raise(ParseError){C::StringLiteral.parse('int i')}
-    assert_raise(ParseError){C::StringLiteral.parse('int')}
-    assert_raise(ParseError){C::StringLiteral.parse('if (0)')}
-    assert_raise(ParseError){C::StringLiteral.parse('switch (0)')}
-    assert_raise(ParseError){C::StringLiteral.parse('for (;;)')}
-    assert_raise(ParseError){C::StringLiteral.parse('goto')}
-    assert_raise(ParseError){C::StringLiteral.parse('return')}
-  end
-
-  def test_char_literal
-    check C::CharLiteral, <<EOS
-'x'
-----
-CharLiteral
-    val: "x"
-EOS
-    assert_raise(ParseError){C::CharLiteral.parse('} void f() {')}
-    assert_raise(ParseError){C::CharLiteral.parse(';')}
-    assert_raise(ParseError){C::CharLiteral.parse('int i')}
-    assert_raise(ParseError){C::CharLiteral.parse('int')}
-    assert_raise(ParseError){C::CharLiteral.parse('if (0)')}
-    assert_raise(ParseError){C::CharLiteral.parse('switch (0)')}
-    assert_raise(ParseError){C::CharLiteral.parse('for (;;)')}
-    assert_raise(ParseError){C::CharLiteral.parse('goto')}
-    assert_raise(ParseError){C::CharLiteral.parse('return')}
-  end
-
-  def test_compound_literal
-    check C::CompoundLiteral, <<EOS
-(struct s){.x [0] = 10, .y = 20, 30}
-----
-CompoundLiteral
-    type: Struct
-        name: "s"
-    member_inits:
-        - MemberInit
-            member:
-                - Member
-                    name: "x"
-                - IntLiteral
-                    val: 0
-            init: IntLiteral
-                val: 10
-        - MemberInit
-            member:
-                - Member
-                    name: "y"
-            init: IntLiteral
-                val: 20
-        - MemberInit
-            init: IntLiteral
-                val: 30
-EOS
-    assert_raise(ParseError){C::CompoundLiteral.parse('} void f() {')}
-    assert_raise(ParseError){C::CompoundLiteral.parse(';')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('int i')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('int')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('if (0)')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('switch (0)')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('for (;;)')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('goto')}
-    assert_raise(ParseError){C::CompoundLiteral.parse('return')}
-  end
-
-  def test_int_literal
-    check C::IntLiteral, <<EOS
-1
-----
-IntLiteral
-    val: 1
-EOS
-    assert_raise(ParseError){C::IntLiteral.parse('} void f() {')}
-    assert_raise(ParseError){C::IntLiteral.parse(';')}
-    assert_raise(ParseError){C::IntLiteral.parse('int i')}
-    assert_raise(ParseError){C::IntLiteral.parse('int')}
-    assert_raise(ParseError){C::IntLiteral.parse('if (0)')}
-    assert_raise(ParseError){C::IntLiteral.parse('switch (0)')}
-    assert_raise(ParseError){C::IntLiteral.parse('for (;;)')}
-    assert_raise(ParseError){C::IntLiteral.parse('goto')}
-    assert_raise(ParseError){C::IntLiteral.parse('return')}
-  end
-
-  def test_float_literal
-    check C::FloatLiteral, <<EOS
-1.0
-----
-FloatLiteral
-    val: 1.0
-EOS
-    assert_raise(ParseError){C::FloatLiteral.parse('} void f() {')}
-    assert_raise(ParseError){C::FloatLiteral.parse(';')}
-    assert_raise(ParseError){C::FloatLiteral.parse('int i')}
-    assert_raise(ParseError){C::FloatLiteral.parse('int')}
-    assert_raise(ParseError){C::FloatLiteral.parse('if (0)')}
-    assert_raise(ParseError){C::FloatLiteral.parse('switch (0)')}
-    assert_raise(ParseError){C::FloatLiteral.parse('for (;;)')}
-    assert_raise(ParseError){C::FloatLiteral.parse('goto')}
-    assert_raise(ParseError){C::FloatLiteral.parse('return')}
-  end
-
-  def test_variable
-    check C::Variable, <<EOS
-x
-----
-Variable
-    name: "x"
-EOS
-    assert_raise(ParseError){C::Variable.parse('} void f() {')}
-    assert_raise(ParseError){C::Variable.parse(';')}
-    assert_raise(ParseError){C::Variable.parse('int i')}
-    assert_raise(ParseError){C::Variable.parse('int')}
-    assert_raise(ParseError){C::Variable.parse('if (0)')}
-    assert_raise(ParseError){C::Variable.parse('switch (0)')}
-    assert_raise(ParseError){C::Variable.parse('for (;;)')}
-    assert_raise(ParseError){C::Variable.parse('goto')}
-    assert_raise(ParseError){C::Variable.parse('return')}
-  end
-end