docutils/test/test_statemachine.py

   1 #! /usr/bin/env python
   2
   3 # $Id$
   4 # Author: David Goodger <goodger@python.org>
   5 # Copyright: This module has been placed in the public domain.
   6
   7 """
   8 Test module for statemachine.py.
   9 """
  10
  11 import unittest
  12 import sys
  13 import re
  14 from DocutilsTestSupport import statemachine
  15
  16 # python 2.3
  17 if not hasattr(unittest.TestCase, "assertTrue"):
  18     # HACK? this changes TestCase, fixes the problem for tests executing afterwards.
  19     # this tests break if run alone
  20     unittest.TestCase.assertTrue = unittest.TestCase.failUnless
  21
  22 debug = False
  23 testtext = statemachine.string2lines("""\
  24 First paragraph.
  25
  26 - This is a bullet list. First list item.
  27   Second line of first para.
  28
  29   Second para.
  30
  31       block quote
  32
  33 - Second list item. Example::
  34
  35         a
  36       literal
  37            block
  38
  39 Last paragraph.""")
  40 expected = ('StateMachine1 text1 blank1 bullet1 known_indent1 '
  41             'StateMachine2 text2 text2 blank2 text2 blank2 indent2 '
  42             'StateMachine3 text3 blank3 finished3 finished2 '
  43             'bullet1 known_indent1 '
  44             'StateMachine2 text2 blank2 literalblock2(4) finished2 '
  45             'text1 finished1').split()
  46 para1 = testtext[:2]
  47 item1 = [line[2:] for line in testtext[2:9]]
  48 item2 = [line[2:] for line in testtext[9:-1]]
  49 lbindent = 6
  50 literalblock = [line[lbindent:] for line in testtext[11:-1]]
  51 para2 = testtext[-1]
  52
  53
  54 class MockState(statemachine.StateWS):
  55
  56     patterns = {'bullet': re.compile(r'- '),
  57                 'text': ''}
  58     initial_transitions = ['bullet', ['text']]
  59     levelholder = [0]
  60
  61     def bof(self, context):
  62         self.levelholder[0] += 1
  63         self.level = self.levelholder[0]
  64         if self.debug: print >>sys.stderr, 'StateMachine%s' % self.level
  65         return [], ['StateMachine%s' % self.level]
  66
  67     def blank(self, match, context, next_state):
  68         result = ['blank%s' % self.level]
  69         if self.debug: print >>sys.stderr, 'blank%s' % self.level
  70         if context and context[-1] and context[-1][-2:] == '::':
  71             result.extend(self.literalblock())
  72         return [], None, result
  73
  74     def indent(self, match, context, next_state):
  75         if self.debug: print >>sys.stderr, 'indent%s' % self.level
  76         context, next_state, result = statemachine.StateWS.indent(
  77               self, match, context, next_state)
  78         return context, next_state, ['indent%s' % self.level] + result
  79
  80     def known_indent(self, match, context, next_state):
  81         if self.debug: print >>sys.stderr, 'known_indent%s' % self.level
  82         context, next_state, result = statemachine.StateWS.known_indent(
  83               self, match, context, next_state)
  84         return context, next_state, ['known_indent%s' % self.level] + result
  85
  86     def bullet(self, match, context, next_state):
  87         if self.debug: print >>sys.stderr, 'bullet%s' % self.level
  88         context, next_state, result \
  89               = self.known_indent(match, context, next_state)
  90         return [], next_state, ['bullet%s' % self.level] + result
  91
  92     def text(self, match, context, next_state):
  93         if self.debug: print >>sys.stderr, 'text%s' % self.level
  94         return [match.string], next_state, ['text%s' % self.level]
  95
  96     def literalblock(self):
  97         indented, indent, offset, good = self.state_machine.get_indented()
  98         if self.debug: print >>sys.stderr, 'literalblock%s(%s)' % (self.level,
  99                                                                    indent)
 100         return ['literalblock%s(%s)' % (self.level, indent)]
 101
 102     def eof(self, context):
 103         self.levelholder[0] -= 1
 104         if self.debug: print >>sys.stderr, 'finished%s' % self.level
 105         return ['finished%s' % self.level]
 106
 107
 108 class EmptySMTests(unittest.TestCase):
 109
 110     def setUp(self):
 111         self.sm = statemachine.StateMachine(
 112               state_classes=[], initial_state='State')
 113         self.sm.debug = debug
 114
 115     def test_add_state(self):
 116         self.sm.add_state(statemachine.State)
 117         self.assertTrue(len(self.sm.states) == 1)
 118         self.assertRaises(statemachine.DuplicateStateError, self.sm.add_state,
 119                           statemachine.State)
 120         self.sm.add_state(statemachine.StateWS)
 121         self.assertTrue(len(self.sm.states) == 2)
 122
 123     def test_add_states(self):
 124         self.sm.add_states((statemachine.State, statemachine.StateWS))
 125         self.assertEqual(len(self.sm.states), 2)
 126
 127     def test_get_state(self):
 128         self.assertRaises(statemachine.UnknownStateError, self.sm.get_state)
 129         self.sm.add_states((statemachine.State, statemachine.StateWS))
 130         self.assertRaises(statemachine.UnknownStateError, self.sm.get_state,
 131                           'unknownState')
 132         self.assertTrue(isinstance(self.sm.get_state('State'),
 133                                 statemachine.State))
 134         self.assertTrue(isinstance(self.sm.get_state('StateWS'),
 135                                 statemachine.State))
 136         self.assertEqual(self.sm.current_state, 'StateWS')
 137
 138
 139 class EmptySMWSTests(EmptySMTests):
 140
 141     def setUp(self):
 142         self.sm = statemachine.StateMachineWS(
 143               state_classes=[], initial_state='State')
 144         self.sm.debug = debug
 145
 146
 147 class SMWSTests(unittest.TestCase):
 148
 149     def setUp(self):
 150         self.sm = statemachine.StateMachineWS([MockState], 'MockState',
 151                                               debug=debug)
 152         self.sm.debug = debug
 153         self.sm.states['MockState'].levelholder[0] = 0
 154
 155     def tearDown(self):
 156         self.sm.unlink()
 157
 158     def test___init__(self):
 159         self.assertEqual(self.sm.states.keys(), ['MockState'])
 160         self.assertEqual(len(self.sm.states['MockState'].transitions), 4)
 161
 162     def test_get_indented(self):
 163         self.sm.input_lines = statemachine.StringList(testtext)
 164         self.sm.line_offset = -1
 165         self.sm.next_line(3)
 166         indented, offset, good = self.sm.get_known_indented(2)
 167         self.assertEqual(indented, item1)
 168         self.assertEqual(offset, len(para1))
 169         self.assertTrue(good)
 170         self.sm.next_line()
 171         indented, offset, good = self.sm.get_known_indented(2)
 172         self.assertEqual(indented, item2)
 173         self.assertEqual(offset, len(para1) + len(item1))
 174         self.assertTrue(good)
 175         self.sm.previous_line(3)
 176         if self.sm.debug:
 177             print '\ntest_get_indented: self.sm.line:\n', self.sm.line
 178         indented, indent, offset, good = self.sm.get_indented()
 179         if self.sm.debug:
 180             print '\ntest_get_indented: indented:\n', indented
 181         self.assertEqual(indent, lbindent)
 182         self.assertEqual(indented, literalblock)
 183         self.assertEqual(offset, (len(para1) + len(item1) + len(item2)
 184                                    - len(literalblock)))
 185         self.assertTrue(good)
 186
 187     def test_get_text_block(self):
 188         self.sm.input_lines = statemachine.StringList(testtext)
 189         self.sm.line_offset = -1
 190         self.sm.next_line()
 191         textblock = self.sm.get_text_block()
 192         self.assertEqual(textblock, testtext[:1])
 193         self.sm.next_line(2)
 194         textblock = self.sm.get_text_block()
 195         self.assertEqual(textblock, testtext[2:4])
 196
 197     def test_get_text_block_flush_left(self):
 198         self.sm.input_lines = statemachine.StringList(testtext)
 199         self.sm.line_offset = -1
 200         self.sm.next_line()
 201         textblock = self.sm.get_text_block(flush_left=1)
 202         self.assertEqual(textblock, testtext[:1])
 203         self.sm.next_line(2)
 204         self.assertRaises(statemachine.UnexpectedIndentationError,
 205                           self.sm.get_text_block, flush_left=1)
 206
 207     def test_run(self):
 208         self.assertEqual(self.sm.run(testtext), expected)
 209
 210
 211 class EmptyClass:
 212     pass
 213
 214
 215 class EmptyStateTests(unittest.TestCase):
 216
 217     def setUp(self):
 218         self.state = statemachine.State(EmptyClass(), debug=debug)
 219         self.state.patterns = {'nop': 'dummy',
 220                                'nop2': 'dummy',
 221                                'nop3': 'dummy',
 222                                'bogus': 'dummy'}
 223         self.state.nop2 = self.state.nop3 = self.state.nop
 224
 225     def test_add_transitions(self):
 226         self.assertEqual(len(self.state.transitions), 0)
 227         self.state.add_transitions(['None'], {'None': None})
 228         self.assertEqual(len(self.state.transitions), 1)
 229         self.assertRaises(statemachine.UnknownTransitionError,
 230                           self.state.add_transitions, ['bogus'], {})
 231         self.assertRaises(statemachine.DuplicateTransitionError,
 232                           self.state.add_transitions, ['None'],
 233                           {'None': None})
 234
 235     def test_add_transition(self):
 236         self.assertEqual(len(self.state.transitions), 0)
 237         self.state.add_transition('None', None)
 238         self.assertEqual(len(self.state.transitions), 1)
 239         self.assertRaises(statemachine.DuplicateTransitionError,
 240                           self.state.add_transition, 'None', None)
 241
 242     def test_remove_transition(self):
 243         self.assertEqual(len(self.state.transitions), 0)
 244         self.state.add_transition('None', None)
 245         self.assertEqual(len(self.state.transitions), 1)
 246         self.state.remove_transition('None')
 247         self.assertEqual(len(self.state.transitions), 0)
 248         self.assertRaises(statemachine.UnknownTransitionError,
 249                           self.state.remove_transition, 'None')
 250
 251     def test_make_transition(self):
 252         dummy = re.compile('dummy')
 253         self.assertEqual(self.state.make_transition('nop', 'bogus'),
 254                           (dummy, self.state.nop, 'bogus'))
 255         self.assertEqual(self.state.make_transition('nop'),
 256                           (dummy, self.state.nop,
 257                            self.state.__class__.__name__))
 258         self.assertRaises(statemachine.TransitionPatternNotFound,
 259                           self.state.make_transition, 'None')
 260         self.assertRaises(statemachine.TransitionMethodNotFound,
 261                           self.state.make_transition, 'bogus')
 262
 263     def test_make_transitions(self):
 264         dummy = re.compile('dummy')
 265         self.assertEqual(self.state.make_transitions(('nop', ['nop2'],
 266                                                        ('nop3', 'bogus'))),
 267                           (['nop', 'nop2', 'nop3'],
 268                            {'nop': (dummy, self.state.nop,
 269                                     self.state.__class__.__name__),
 270                             'nop2': (dummy, self.state.nop2,
 271                                      self.state.__class__.__name__),
 272                             'nop3': (dummy, self.state.nop3, 'bogus')}))
 273
 274
 275 class MiscTests(unittest.TestCase):
 276
 277     s2l_string = "hello\tthere\thow are\tyou?\n\tI'm fine\tthanks.\n"
 278     s2l_expected = ['hello   there   how are you?',
 279                     "        I'm fine        thanks."]
 280     def test_string2lines(self):
 281         self.assertEqual(statemachine.string2lines(self.s2l_string),
 282                           self.s2l_expected)
 283
 284
 285 if __name__ == '__main__':
 286     unittest.main()