xref: /external/antlr/antlr-3.4/runtime/Python/tests/t059debug.py

import unittest
import textwrap
import antlr3
import antlr3.tree
import antlr3.debug
import testbase
import sys
import threading
import socket
import errno
import time

class Debugger(threading.Thread):
    def __init__(self, port):
        super(Debugger, self).__init__()
        self.events = []
        self.success = False
        self.port = port

    def run(self):
        # create listening socket
        s = None
        tstart = time.time()
        while time.time() - tstart < 10:
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.connect(('127.0.0.1', self.port))
                break
            except socket.error, exc:
                if exc.args[0] != errno.ECONNREFUSED:
                    raise
                time.sleep(0.1)

        if s is None:
            self.events.append(['nosocket'])
            return

        s.setblocking(1)
        s.settimeout(10.0)

        output = s.makefile('w', 0)
        input = s.makefile('r', 0)

        try:
            # handshake
            l = input.readline().strip()
            assert l == 'ANTLR 2'
            l = input.readline().strip()
            assert l.startswith('grammar "')

            output.write('ACK\n')
            output.flush()

            while True:
                event = input.readline().strip()
                self.events.append(event.split('\t'))

                output.write('ACK\n')
                output.flush()

                if event == 'terminate':
                    self.success = True
                    break

        except socket.timeout:
            self.events.append(['timeout'])
        except socket.error, exc:
            self.events.append(['socketerror', exc.args])

        s.close()


class T(testbase.ANTLRTest):
    def execParser(self, grammar, grammarEntry, input, listener,
                   parser_args={}):
        if listener is None:
            port = 49100
            debugger = Debugger(port)
            debugger.start()
            # TODO(pink): install alarm, so it doesn't hang forever in case of a bug

        else:
            port = None

        try:
            lexerCls, parserCls = self.compileInlineGrammar(
                grammar, options='-debug')

            cStream = antlr3.StringStream(input)
            lexer = lexerCls(cStream)
            tStream = antlr3.CommonTokenStream(lexer)
            parser = parserCls(tStream, dbg=listener, port=port, **parser_args)
            getattr(parser, grammarEntry)()

        finally:
            if listener is None:
                debugger.join()
                return debugger

    def testBasicParser(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID EOF;
        ID : 'a'..'z'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        listener = antlr3.debug.RecordDebugEventListener()

        self.execParser(
            grammar, 'a',
            input="a",
            listener=listener)

        # We only check that some LT events are present. How many is subject
        # to change (at the time of writing there are two, which is one too
        # many).
        lt_events = [event for event in listener.events
                     if event.startswith("LT ")]
        self.assertNotEqual(lt_events, [])

        # For the rest, filter out LT events to get a reliable test.
        expected = ["enterRule a",
                    "location 6:1",
                    "location 6:5",
                    "location 6:8",
                    "location 6:11",
                    "exitRule a"]
        found = [event for event in listener.events
                 if not event.startswith("LT ")]
        self.assertListEqual(found, expected)

    def testSocketProxy(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID EOF;
        ID : 'a'..'z'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['location', '6', '8'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['location', '6', '11'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)

    def testRecognitionException(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID EOF;
        ID : 'a'..'z'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a b",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['consumeHiddenToken', '1', '5', '99', '1', '1', '"'],
                    ['location', '6', '8'],
                    ['LT', '1', '2', '4', '0', '1', '2', '"b'],
                    ['LT', '1', '2', '4', '0', '1', '2', '"b'],
                    ['LT', '2', '-1', '-1', '0', '1', '3', '"<EOF>'],
                    ['LT', '1', '2', '4', '0', '1', '2', '"b'],
                    ['LT', '1', '2', '4', '0', '1', '2', '"b'],
                    ['beginResync'],
                    ['consumeToken', '2', '4', '0', '1', '2', '"b'],
                    ['endResync'],
                    ['exception', 'UnwantedTokenException', '2', '1', '2'],
                    ['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '3', '"<EOF>'],
                    ['location', '6', '11'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testSemPred(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : {True}? ID EOF;
        ID : 'a'..'z'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['semanticPredicate', '1', 'True'],
                    ['location', '6', '13'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['location', '6', '16'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['location', '6', '19'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testPositiveClosureBlock(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID ( ID | INT )+ EOF;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a 1 b c 3",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
                    ['location', '6', '8'],
                    ['enterSubRule', '1'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                    ['consumeToken', '2', '5', '0', '1', '2', '"1'],
                    ['consumeHiddenToken', '3', '6', '99', '1', '3', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '4', '4', '0', '1', '4', '"b'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '4', '4', '0', '1', '4', '"b'],
                    ['consumeToken', '4', '4', '0', '1', '4', '"b'],
                    ['consumeHiddenToken', '5', '6', '99', '1', '5', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '6', '4', '0', '1', '6', '"c'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '6', '4', '0', '1', '6', '"c'],
                    ['consumeToken', '6', '4', '0', '1', '6', '"c'],
                    ['consumeHiddenToken', '7', '6', '99', '1', '7', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '8', '5', '0', '1', '8', '"3'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '8', '5', '0', '1', '8', '"3'],
                    ['consumeToken', '8', '5', '0', '1', '8', '"3'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['exitDecision', '1'],
                    ['exitSubRule', '1'],
                    ['location', '6', '22'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['location', '6', '25'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testClosureBlock(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID ( ID | INT )* EOF;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a 1 b c 3",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
                    ['location', '6', '8'],
                    ['enterSubRule', '1'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                    ['consumeToken', '2', '5', '0', '1', '2', '"1'],
                    ['consumeHiddenToken', '3', '6', '99', '1', '3', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '4', '4', '0', '1', '4', '"b'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '4', '4', '0', '1', '4', '"b'],
                    ['consumeToken', '4', '4', '0', '1', '4', '"b'],
                    ['consumeHiddenToken', '5', '6', '99', '1', '5', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '6', '4', '0', '1', '6', '"c'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '6', '4', '0', '1', '6', '"c'],
                    ['consumeToken', '6', '4', '0', '1', '6', '"c'],
                    ['consumeHiddenToken', '7', '6', '99', '1', '7', '"'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '8', '5', '0', '1', '8', '"3'],
                    ['exitDecision', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '8'],
                    ['LT', '1', '8', '5', '0', '1', '8', '"3'],
                    ['consumeToken', '8', '5', '0', '1', '8', '"3'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['exitDecision', '1'],
                    ['exitSubRule', '1'],
                    ['location', '6', '22'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '9', '"<EOF>'],
                    ['location', '6', '25'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testMismatchedSetException(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID ( ID | INT ) EOF;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['location', '6', '8'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['exception', 'MismatchedSetException', '1', '1', '1'],
                    ['exception', 'MismatchedSetException', '1', '1', '1'],
                    ['beginResync'],
                    ['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
                    ['endResync'],
                    ['location', '6', '24'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testBlock(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID ( b | c ) EOF;
        b : ID;
        c : INT;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a 1",
            listener=None)

        self.assertTrue(debugger.success)
        expected =  [['enterRule', 'T.g', 'a'],
                     ['location', '6', '1'],
                     ['enterAlt', '1'],
                     ['location', '6', '5'],
                     ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                     ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                     ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                     ['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
                     ['location', '6', '8'],
                     ['enterSubRule', '1'],
                     ['enterDecision', '1', '0'],
                     ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                     ['exitDecision', '1'],
                     ['enterAlt', '2'],
                     ['location', '6', '14'],
                     ['enterRule', 'T.g', 'c'],
                     ['location', '8', '1'],
                     ['enterAlt', '1'],
                     ['location', '8', '5'],
                     ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                     ['LT', '1', '2', '5', '0', '1', '2', '"1'],
                     ['consumeToken', '2', '5', '0', '1', '2', '"1'],
                     ['location', '8', '8'],
                     ['exitRule', 'T.g', 'c'],
                     ['exitSubRule', '1'],
                     ['location', '6', '18'],
                     ['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
                     ['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
                     ['consumeToken', '-1', '-1', '0', '1', '3', '"<EOF>'],
                     ['location', '6', '21'],
                     ['exitRule', 'T.g', 'a'],
                     ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testNoViableAlt(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ID ( b | c ) EOF;
        b : ID;
        c : INT;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        BANG : '!' ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a !",
            listener=None)

        self.assertTrue(debugger.success)
        expected =  [['enterRule', 'T.g', 'a'],
                     ['location', '6', '1'],
                     ['enterAlt', '1'],
                     ['location', '6', '5'],
                     ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                     ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                     ['consumeToken', '0', '5', '0', '1', '0', '"a'],
                     ['consumeHiddenToken', '1', '7', '99', '1', '1', '"'],
                     ['location', '6', '8'],
                     ['enterSubRule', '1'],
                     ['enterDecision', '1', '0'],
                     ['LT', '1', '2', '4', '0', '1', '2', '"!'],
                     ['LT', '1', '2', '4', '0', '1', '2', '"!'],
                     ['LT', '1', '2', '4', '0', '1', '2', '"!'],
                     ['exception', 'NoViableAltException', '2', '1', '2'],
                     ['exitDecision', '1'],
                     ['exitSubRule', '1'],
                     ['exception', 'NoViableAltException', '2', '1', '2'],
                     ['beginResync'],
                     ['LT', '1', '2', '4', '0', '1', '2', '"!'],
                     ['consumeToken', '2', '4', '0', '1', '2', '"!'],
                     ['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
                     ['endResync'],
                     ['location', '6', '21'],
                     ['exitRule', 'T.g', 'a'],
                     ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testRuleBlock(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : b | c;
        b : ID;
        c : INT;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="1",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterDecision', '1', '0'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"1'],
                    ['exitDecision', '1'],
                    ['enterAlt', '2'],
                    ['location', '6', '9'],
                    ['enterRule', 'T.g', 'c'],
                    ['location', '8', '1'],
                    ['enterAlt', '1'],
                    ['location', '8', '5'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"1'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"1'],
                    ['consumeToken', '0', '5', '0', '1', '0', '"1'],
                    ['location', '8', '8'],
                    ['exitRule', 'T.g', 'c'],
                    ['location', '6', '10'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testRuleBlockSingleAlt(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : b;
        b : ID;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['enterRule', 'T.g', 'b'],
                    ['location', '7', '1'],
                    ['enterAlt', '1'],
                    ['location', '7', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['location', '7', '7'],
                    ['exitRule', 'T.g', 'b'],
                    ['location', '6', '6'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testBlockSingleAlt(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ( b );
        b : ID;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['enterAlt', '1'],
                    ['location', '6', '7'],
                    ['enterRule', 'T.g', 'b'],
                    ['location', '7', '1'],
                    ['enterAlt', '1'],
                    ['location', '7', '5'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '4', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '4', '0', '1', '0', '"a'],
                    ['location', '7', '7'],
                    ['exitRule', 'T.g', 'b'],
                    ['location', '6', '10'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testDFA(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
        }
        a : ( b | c ) EOF;
        b : ID* INT;
        c : ID+ BANG;
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        BANG : '!';
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        debugger = self.execParser(
            grammar, 'a',
            input="a!",
            listener=None)

        self.assertTrue(debugger.success)
        expected = [['enterRule', 'T.g', 'a'],
                    ['location', '6', '1'],
                    ['enterAlt', '1'],
                    ['location', '6', '5'],
                    ['enterSubRule', '1'],
                    ['enterDecision', '1', '0'],
                    ['mark', '0'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '5', '0', '1', '0', '"a'],
                    ['LT', '1', '1', '4', '0', '1', '1', '"!'],
                    ['consumeToken', '1', '4', '0', '1', '1', '"!'],
                    ['rewind', '0'],
                    ['exitDecision', '1'],
                    ['enterAlt', '2'],
                    ['location', '6', '11'],
                    ['enterRule', 'T.g', 'c'],
                    ['location', '8', '1'],
                    ['enterAlt', '1'],
                    ['location', '8', '5'],
                    ['enterSubRule', '3'],
                    ['enterDecision', '3', '0'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                    ['exitDecision', '3'],
                    ['enterAlt', '1'],
                    ['location', '8', '5'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                    ['LT', '1', '0', '5', '0', '1', '0', '"a'],
                    ['consumeToken', '0', '5', '0', '1', '0', '"a'],
                    ['enterDecision', '3', '0'],
                    ['LT', '1', '1', '4', '0', '1', '1', '"!'],
                    ['exitDecision', '3'],
                    ['exitSubRule', '3'],
                    ['location', '8', '9'],
                    ['LT', '1', '1', '4', '0', '1', '1', '"!'],
                    ['LT', '1', '1', '4', '0', '1', '1', '"!'],
                    ['consumeToken', '1', '4', '0', '1', '1', '"!'],
                    ['location', '8', '13'],
                    ['exitRule', 'T.g', 'c'],
                    ['exitSubRule', '1'],
                    ['location', '6', '15'],
                    ['LT', '1', '-1', '-1', '0', '1', '2', '"<EOF>'],
                    ['LT', '1', '-1', '-1', '0', '1', '2', '"<EOF>'],
                    ['consumeToken', '-1', '-1', '0', '1', '2', '"<EOF>'],
                    ['location', '6', '18'],
                    ['exitRule', 'T.g', 'a'],
                    ['terminate']]

        self.assertListEqual(debugger.events, expected)


    def testBasicAST(self):
        grammar = textwrap.dedent(
        r'''
        grammar T;
        options {
            language=Python;
            output=AST;
        }
        a : ( b | c ) EOF!;
        b : ID* INT -> ^(INT ID*);
        c : ID+ BANG -> ^(BANG ID+);
        ID : 'a'..'z'+ ;
        INT : '0'..'9'+ ;
        BANG : '!';
        WS : (' '|'\n') {$channel=HIDDEN;} ;
        ''')

        listener = antlr3.debug.RecordDebugEventListener()

        self.execParser(
            grammar, 'a',
            input="a!",
            listener=listener)

        # don't check output for now (too dynamic), I'm satisfied if it
        # doesn't crash


if __name__ == '__main__':
    unittest.main()