From 101671ae44e1686680c80cd07b452aabeb88fb63 Mon Sep 17 00:00:00 2001 From: goodger Date: Sat, 20 Apr 2002 03:01:52 +0000 Subject: Initial revision git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@18 929543f6-e4f2-0310-98a6-ba3bd3dd1d04 --- test/test_statemachine.py | 296 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100755 test/test_statemachine.py (limited to 'test/test_statemachine.py') diff --git a/test/test_statemachine.py b/test/test_statemachine.py new file mode 100755 index 000000000..a73a17197 --- /dev/null +++ b/test/test_statemachine.py @@ -0,0 +1,296 @@ +#! /usr/bin/env python + +""" +:Author: David Goodger +:Contact: goodger@users.sourceforge.net +:Revision: $Revision$ +:Date: $Date$ +:Copyright: This module has been placed in the public domain. + +Test module for statemachine.py. +""" + +import unittest, sys, re +from DocutilsTestSupport import statemachine +try: + import mypdb as pdb +except: + import pdb +pdb.tracenow = 0 + +debug = 0 +testtext = statemachine.string2lines("""\ +First paragraph. + +- This is a bullet list. First list item. + Second line of first para. + + Second para. + + block quote + +- Second list item. Example:: + + a + literal + block + +Last paragraph.""") +expected = ('StateMachine1 text1 blank1 bullet1 knownindent1 ' + 'StateMachine2 text2 text2 blank2 text2 blank2 indent2 ' + 'StateMachine3 text3 blank3 finished3 finished2 ' + 'bullet1 knownindent1 ' + 'StateMachine2 text2 blank2 literalblock2(4) finished2 ' + 'text1 finished1').split() +para1 = testtext[:2] +item1 = [line[2:] for line in testtext[2:9]] +item2 = [line[2:] for line in testtext[9:-1]] +lbindent = 6 +literalblock = [line[lbindent:] for line in testtext[11:-1]] +para2 = testtext[-1] + + +class MockState(statemachine.StateWS): + + patterns = {'bullet': re.compile(r'- '), + 'text': ''} + initialtransitions = ['bullet', ['text']] + levelholder = [0] + + def bof(self, context): + self.levelholder[0] += 1 + self.level = self.levelholder[0] + if self.debug: print >>sys.stderr, 'StateMachine%s' % self.level + return [], ['StateMachine%s' % self.level] + + def blank(self, match, context, nextstate): + result = ['blank%s' % self.level] + if self.debug: print >>sys.stderr, 'blank%s' % self.level + if context and context[-1] and context[-1][-2:] == '::': + result.extend(self.literalblock()) + return [], None, result + + def indent(self, match, context, nextstate): + if self.debug: print >>sys.stderr, 'indent%s' % self.level + context, nextstate, result = statemachine.StateWS.indent( + self, match, context, nextstate) + return context, nextstate, ['indent%s' % self.level] + result + + def knownindent(self, match, context, nextstate): + if self.debug: print >>sys.stderr, 'knownindent%s' % self.level + context, nextstate, result = statemachine.StateWS.knownindent( + self, match, context, nextstate) + return context, nextstate, ['knownindent%s' % self.level] + result + + def bullet(self, match, context, nextstate): + if self.debug: print >>sys.stderr, 'bullet%s' % self.level + context, nextstate, result \ + = self.knownindent(match, context, nextstate) + return [], nextstate, ['bullet%s' % self.level] + result + + def text(self, match, context, nextstate): + if self.debug: print >>sys.stderr, 'text%s' % self.level + return [match.string], nextstate, ['text%s' % self.level] + + def literalblock(self): + indented, indent, offset, good = self.statemachine.getindented() + if self.debug: print >>sys.stderr, 'literalblock%s(%s)' % (self.level, + indent) + return ['literalblock%s(%s)' % (self.level, indent)] + + def eof(self, context): + self.levelholder[0] -= 1 + if self.debug: print >>sys.stderr, 'finished%s' % self.level + return ['finished%s' % self.level] + + +class EmptySMTests(unittest.TestCase): + + def setUp(self): + self.sm = statemachine.StateMachine( + stateclasses=[], initialstate='State') + self.sm.debug = debug + + def test_addstate(self): + self.sm.addstate(statemachine.State) + self.assert_(len(self.sm.states) == 1) + self.assertRaises(statemachine.DuplicateStateError, self.sm.addstate, + statemachine.State) + self.sm.addstate(statemachine.StateWS) + self.assert_(len(self.sm.states) == 2) + + def test_addstates(self): + self.sm.addstates((statemachine.State, statemachine.StateWS)) + self.assertEqual(len(self.sm.states), 2) + + def test_getstate(self): + self.assertRaises(statemachine.UnknownStateError, self.sm.getstate) + self.sm.addstates((statemachine.State, statemachine.StateWS)) + self.assertRaises(statemachine.UnknownStateError, self.sm.getstate, + 'unknownState') + self.assert_(isinstance(self.sm.getstate('State'), + statemachine.State)) + self.assert_(isinstance(self.sm.getstate('StateWS'), + statemachine.State)) + self.assertEqual(self.sm.currentstate, 'StateWS') + + +class EmptySMWSTests(EmptySMTests): + + def setUp(self): + self.sm = statemachine.StateMachineWS( + stateclasses=[], initialstate='State') + self.sm.debug = debug + + +class SMWSTests(unittest.TestCase): + + def setUp(self): + self.sm = statemachine.StateMachineWS([MockState], 'MockState', + debug=debug) + self.sm.debug = debug + self.sm.states['MockState'].levelholder[0] = 0 + + def tearDown(self): + self.sm.unlink() + + def test___init__(self): + self.assertEquals(self.sm.states.keys(), ['MockState']) + self.assertEquals(len(self.sm.states['MockState'].transitions), 2) + + def test_getindented(self): + self.sm.inputlines = testtext + self.sm.lineoffset = -1 + self.sm.nextline(3) + indented, offset, good = self.sm.getknownindented(2) + self.assertEquals(indented, item1) + self.assertEquals(offset, len(para1)) + self.failUnless(good) + self.sm.nextline() + indented, offset, good = self.sm.getknownindented(2) + self.assertEquals(indented, item2) + self.assertEquals(offset, len(para1) + len(item1)) + self.failUnless(good) + self.sm.previousline(3) + if self.sm.debug: + print '\ntest_getindented: self.sm.line:\n', self.sm.line + indented, indent, offset, good = self.sm.getindented() + if self.sm.debug: + print '\ntest_getindented: indented:\n', indented + self.assertEquals(indent, lbindent) + self.assertEquals(indented, literalblock) + self.assertEquals(offset, (len(para1) + len(item1) + len(item2) + - len(literalblock))) + self.failUnless(good) + + def test_gettextblock(self): + self.sm.inputlines = testtext + self.sm.lineoffset = -1 + self.sm.nextline() + textblock = self.sm.gettextblock() + self.assertEquals(textblock, testtext[:1]) + self.sm.nextline(2) + textblock = self.sm.gettextblock() + self.assertEquals(textblock, testtext[2:4]) + + def test_getunindented(self): + self.sm.inputlines = testtext + self.sm.lineoffset = -1 + self.sm.nextline() + textblock = self.sm.getunindented() + self.assertEquals(textblock, testtext[:1]) + self.sm.nextline() + self.assertRaises(statemachine.UnexpectedIndentationError, + self.sm.getunindented) + + def test_run(self): + self.assertEquals(self.sm.run(testtext), expected) + + +class EmptyClass: + pass + + +class EmptyStateTests(unittest.TestCase): + + def setUp(self): + self.state = statemachine.State(EmptyClass(), debug=debug) + self.state.patterns = {'nop': 'dummy', + 'nop2': 'dummy', + 'nop3': 'dummy', + 'bogus': 'dummy'} + self.state.nop2 = self.state.nop3 = self.state.nop + + def test_addtransitions(self): + self.assertEquals(len(self.state.transitions), 0) + self.state.addtransitions(['None'], {'None': None}) + self.assertEquals(len(self.state.transitions), 1) + self.assertRaises(statemachine.UnknownTransitionError, + self.state.addtransitions, ['bogus'], {}) + self.assertRaises(statemachine.DuplicateTransitionError, + self.state.addtransitions, ['None'], {'None': None}) + + def test_addtransition(self): + self.assertEquals(len(self.state.transitions), 0) + self.state.addtransition('None', None) + self.assertEquals(len(self.state.transitions), 1) + self.assertRaises(statemachine.DuplicateTransitionError, + self.state.addtransition, 'None', None) + + def test_removetransition(self): + self.assertEquals(len(self.state.transitions), 0) + self.state.addtransition('None', None) + self.assertEquals(len(self.state.transitions), 1) + self.state.removetransition('None') + self.assertEquals(len(self.state.transitions), 0) + self.assertRaises(statemachine.UnknownTransitionError, + self.state.removetransition, 'None') + + def test_maketransition(self): + dummy = re.compile('dummy') + self.assertEquals(self.state.maketransition('nop', 'bogus'), + (dummy, self.state.nop, 'bogus')) + self.assertEquals(self.state.maketransition('nop'), + (dummy, self.state.nop, + self.state.__class__.__name__)) + self.assertRaises(statemachine.TransitionPatternNotFound, + self.state.maketransition, 'None') + self.assertRaises(statemachine.TransitionMethodNotFound, + self.state.maketransition, 'bogus') + + def test_maketransitions(self): + dummy = re.compile('dummy') + self.assertEquals(self.state.maketransitions(('nop', ['nop2'], + ('nop3', 'bogus'))), + (['nop', 'nop2', 'nop3'], + {'nop': (dummy, self.state.nop, + self.state.__class__.__name__), + 'nop2': (dummy, self.state.nop2, + self.state.__class__.__name__), + 'nop3': (dummy, self.state.nop3, 'bogus')})) + + +class MiscTests(unittest.TestCase): + + s2l_string = "hello\tthere\thow are\tyou?\n\tI'm fine\tthanks.\n" + s2l_expected = ['hello there how are you?', + " I'm fine thanks."] + indented_string = """\ + a + literal + block""" + + def test_string2lines(self): + self.assertEquals(statemachine.string2lines(self.s2l_string), + self.s2l_expected) + + def test_extractindented(self): + block = statemachine.string2lines(self.indented_string) + self.assertEquals(statemachine.extractindented(block), + ([s[6:] for s in block], 6, 1)) + self.assertEquals(statemachine.extractindented(self.s2l_expected), + ([], 0, 0)) + + +if __name__ == '__main__': + unittest.main() -- cgit v1.2.1 From 34f7a6d1ac6f52cf920a933aba804f54c7be5525 Mon Sep 17 00:00:00 2001 From: goodger Date: Sun, 5 May 2002 15:49:41 +0000 Subject: updated git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@91 929543f6-e4f2-0310-98a6-ba3bd3dd1d04 --- test/test_statemachine.py | 171 +++++++++++++++++++++++----------------------- 1 file changed, 84 insertions(+), 87 deletions(-) (limited to 'test/test_statemachine.py') diff --git a/test/test_statemachine.py b/test/test_statemachine.py index a73a17197..02dd1e69b 100755 --- a/test/test_statemachine.py +++ b/test/test_statemachine.py @@ -12,11 +12,7 @@ Test module for statemachine.py. import unittest, sys, re from DocutilsTestSupport import statemachine -try: - import mypdb as pdb -except: - import pdb -pdb.tracenow = 0 + debug = 0 testtext = statemachine.string2lines("""\ @@ -36,10 +32,10 @@ First paragraph. block Last paragraph.""") -expected = ('StateMachine1 text1 blank1 bullet1 knownindent1 ' +expected = ('StateMachine1 text1 blank1 bullet1 known_indent1 ' 'StateMachine2 text2 text2 blank2 text2 blank2 indent2 ' 'StateMachine3 text3 blank3 finished3 finished2 ' - 'bullet1 knownindent1 ' + 'bullet1 known_indent1 ' 'StateMachine2 text2 blank2 literalblock2(4) finished2 ' 'text1 finished1').split() para1 = testtext[:2] @@ -54,7 +50,7 @@ class MockState(statemachine.StateWS): patterns = {'bullet': re.compile(r'- '), 'text': ''} - initialtransitions = ['bullet', ['text']] + initial_transitions = ['bullet', ['text']] levelholder = [0] def bof(self, context): @@ -63,37 +59,37 @@ class MockState(statemachine.StateWS): if self.debug: print >>sys.stderr, 'StateMachine%s' % self.level return [], ['StateMachine%s' % self.level] - def blank(self, match, context, nextstate): + def blank(self, match, context, next_state): result = ['blank%s' % self.level] if self.debug: print >>sys.stderr, 'blank%s' % self.level if context and context[-1] and context[-1][-2:] == '::': result.extend(self.literalblock()) return [], None, result - def indent(self, match, context, nextstate): + def indent(self, match, context, next_state): if self.debug: print >>sys.stderr, 'indent%s' % self.level - context, nextstate, result = statemachine.StateWS.indent( - self, match, context, nextstate) - return context, nextstate, ['indent%s' % self.level] + result + context, next_state, result = statemachine.StateWS.indent( + self, match, context, next_state) + return context, next_state, ['indent%s' % self.level] + result - def knownindent(self, match, context, nextstate): - if self.debug: print >>sys.stderr, 'knownindent%s' % self.level - context, nextstate, result = statemachine.StateWS.knownindent( - self, match, context, nextstate) - return context, nextstate, ['knownindent%s' % self.level] + result + def known_indent(self, match, context, next_state): + if self.debug: print >>sys.stderr, 'known_indent%s' % self.level + context, next_state, result = statemachine.StateWS.known_indent( + self, match, context, next_state) + return context, next_state, ['known_indent%s' % self.level] + result - def bullet(self, match, context, nextstate): + def bullet(self, match, context, next_state): if self.debug: print >>sys.stderr, 'bullet%s' % self.level - context, nextstate, result \ - = self.knownindent(match, context, nextstate) - return [], nextstate, ['bullet%s' % self.level] + result + context, next_state, result \ + = self.known_indent(match, context, next_state) + return [], next_state, ['bullet%s' % self.level] + result - def text(self, match, context, nextstate): + def text(self, match, context, next_state): if self.debug: print >>sys.stderr, 'text%s' % self.level - return [match.string], nextstate, ['text%s' % self.level] + return [match.string], next_state, ['text%s' % self.level] def literalblock(self): - indented, indent, offset, good = self.statemachine.getindented() + indented, indent, offset, good = self.state_machine.get_indented() if self.debug: print >>sys.stderr, 'literalblock%s(%s)' % (self.level, indent) return ['literalblock%s(%s)' % (self.level, indent)] @@ -108,38 +104,38 @@ class EmptySMTests(unittest.TestCase): def setUp(self): self.sm = statemachine.StateMachine( - stateclasses=[], initialstate='State') + state_classes=[], initial_state='State') self.sm.debug = debug - def test_addstate(self): - self.sm.addstate(statemachine.State) + def test_add_state(self): + self.sm.add_state(statemachine.State) self.assert_(len(self.sm.states) == 1) - self.assertRaises(statemachine.DuplicateStateError, self.sm.addstate, + self.assertRaises(statemachine.DuplicateStateError, self.sm.add_state, statemachine.State) - self.sm.addstate(statemachine.StateWS) + self.sm.add_state(statemachine.StateWS) self.assert_(len(self.sm.states) == 2) - def test_addstates(self): - self.sm.addstates((statemachine.State, statemachine.StateWS)) + def test_add_states(self): + self.sm.add_states((statemachine.State, statemachine.StateWS)) self.assertEqual(len(self.sm.states), 2) - def test_getstate(self): - self.assertRaises(statemachine.UnknownStateError, self.sm.getstate) - self.sm.addstates((statemachine.State, statemachine.StateWS)) - self.assertRaises(statemachine.UnknownStateError, self.sm.getstate, + def test_get_state(self): + self.assertRaises(statemachine.UnknownStateError, self.sm.get_state) + self.sm.add_states((statemachine.State, statemachine.StateWS)) + self.assertRaises(statemachine.UnknownStateError, self.sm.get_state, 'unknownState') - self.assert_(isinstance(self.sm.getstate('State'), + self.assert_(isinstance(self.sm.get_state('State'), statemachine.State)) - self.assert_(isinstance(self.sm.getstate('StateWS'), + self.assert_(isinstance(self.sm.get_state('StateWS'), statemachine.State)) - self.assertEqual(self.sm.currentstate, 'StateWS') + self.assertEqual(self.sm.current_state, 'StateWS') class EmptySMWSTests(EmptySMTests): def setUp(self): self.sm = statemachine.StateMachineWS( - stateclasses=[], initialstate='State') + state_classes=[], initial_state='State') self.sm.debug = debug @@ -158,50 +154,50 @@ class SMWSTests(unittest.TestCase): self.assertEquals(self.sm.states.keys(), ['MockState']) self.assertEquals(len(self.sm.states['MockState'].transitions), 2) - def test_getindented(self): - self.sm.inputlines = testtext - self.sm.lineoffset = -1 - self.sm.nextline(3) - indented, offset, good = self.sm.getknownindented(2) + def test_get_indented(self): + self.sm.input_lines = testtext + self.sm.line_offset = -1 + self.sm.next_line(3) + indented, offset, good = self.sm.get_known_indented(2) self.assertEquals(indented, item1) self.assertEquals(offset, len(para1)) self.failUnless(good) - self.sm.nextline() - indented, offset, good = self.sm.getknownindented(2) + self.sm.next_line() + indented, offset, good = self.sm.get_known_indented(2) self.assertEquals(indented, item2) self.assertEquals(offset, len(para1) + len(item1)) self.failUnless(good) - self.sm.previousline(3) + self.sm.previous_line(3) if self.sm.debug: - print '\ntest_getindented: self.sm.line:\n', self.sm.line - indented, indent, offset, good = self.sm.getindented() + print '\ntest_get_indented: self.sm.line:\n', self.sm.line + indented, indent, offset, good = self.sm.get_indented() if self.sm.debug: - print '\ntest_getindented: indented:\n', indented + print '\ntest_get_indented: indented:\n', indented self.assertEquals(indent, lbindent) self.assertEquals(indented, literalblock) self.assertEquals(offset, (len(para1) + len(item1) + len(item2) - len(literalblock))) self.failUnless(good) - def test_gettextblock(self): - self.sm.inputlines = testtext - self.sm.lineoffset = -1 - self.sm.nextline() - textblock = self.sm.gettextblock() + def test_get_text_block(self): + self.sm.input_lines = testtext + self.sm.line_offset = -1 + self.sm.next_line() + textblock = self.sm.get_text_block() self.assertEquals(textblock, testtext[:1]) - self.sm.nextline(2) - textblock = self.sm.gettextblock() + self.sm.next_line(2) + textblock = self.sm.get_text_block() self.assertEquals(textblock, testtext[2:4]) - def test_getunindented(self): - self.sm.inputlines = testtext - self.sm.lineoffset = -1 - self.sm.nextline() - textblock = self.sm.getunindented() + def test_get_text_block_flush_left(self): + self.sm.input_lines = testtext + self.sm.line_offset = -1 + self.sm.next_line() + textblock = self.sm.get_text_block(flush_left=1) self.assertEquals(textblock, testtext[:1]) - self.sm.nextline() + self.sm.next_line(2) self.assertRaises(statemachine.UnexpectedIndentationError, - self.sm.getunindented) + self.sm.get_text_block, flush_left=1) def test_run(self): self.assertEquals(self.sm.run(testtext), expected) @@ -221,47 +217,48 @@ class EmptyStateTests(unittest.TestCase): 'bogus': 'dummy'} self.state.nop2 = self.state.nop3 = self.state.nop - def test_addtransitions(self): + def test_add_transitions(self): self.assertEquals(len(self.state.transitions), 0) - self.state.addtransitions(['None'], {'None': None}) + self.state.add_transitions(['None'], {'None': None}) self.assertEquals(len(self.state.transitions), 1) self.assertRaises(statemachine.UnknownTransitionError, - self.state.addtransitions, ['bogus'], {}) + self.state.add_transitions, ['bogus'], {}) self.assertRaises(statemachine.DuplicateTransitionError, - self.state.addtransitions, ['None'], {'None': None}) + self.state.add_transitions, ['None'], + {'None': None}) - def test_addtransition(self): + def test_add_transition(self): self.assertEquals(len(self.state.transitions), 0) - self.state.addtransition('None', None) + self.state.add_transition('None', None) self.assertEquals(len(self.state.transitions), 1) self.assertRaises(statemachine.DuplicateTransitionError, - self.state.addtransition, 'None', None) + self.state.add_transition, 'None', None) - def test_removetransition(self): + def test_remove_transition(self): self.assertEquals(len(self.state.transitions), 0) - self.state.addtransition('None', None) + self.state.add_transition('None', None) self.assertEquals(len(self.state.transitions), 1) - self.state.removetransition('None') + self.state.remove_transition('None') self.assertEquals(len(self.state.transitions), 0) self.assertRaises(statemachine.UnknownTransitionError, - self.state.removetransition, 'None') + self.state.remove_transition, 'None') - def test_maketransition(self): + def test_make_transition(self): dummy = re.compile('dummy') - self.assertEquals(self.state.maketransition('nop', 'bogus'), + self.assertEquals(self.state.make_transition('nop', 'bogus'), (dummy, self.state.nop, 'bogus')) - self.assertEquals(self.state.maketransition('nop'), + self.assertEquals(self.state.make_transition('nop'), (dummy, self.state.nop, self.state.__class__.__name__)) self.assertRaises(statemachine.TransitionPatternNotFound, - self.state.maketransition, 'None') + self.state.make_transition, 'None') self.assertRaises(statemachine.TransitionMethodNotFound, - self.state.maketransition, 'bogus') + self.state.make_transition, 'bogus') - def test_maketransitions(self): + def test_make_transitions(self): dummy = re.compile('dummy') - self.assertEquals(self.state.maketransitions(('nop', ['nop2'], - ('nop3', 'bogus'))), + self.assertEquals(self.state.make_transitions(('nop', ['nop2'], + ('nop3', 'bogus'))), (['nop', 'nop2', 'nop3'], {'nop': (dummy, self.state.nop, self.state.__class__.__name__), @@ -284,11 +281,11 @@ class MiscTests(unittest.TestCase): self.assertEquals(statemachine.string2lines(self.s2l_string), self.s2l_expected) - def test_extractindented(self): + def test_extract_indented(self): block = statemachine.string2lines(self.indented_string) - self.assertEquals(statemachine.extractindented(block), + self.assertEquals(statemachine.extract_indented(block), ([s[6:] for s in block], 6, 1)) - self.assertEquals(statemachine.extractindented(self.s2l_expected), + self.assertEquals(statemachine.extract_indented(self.s2l_expected), ([], 0, 0)) -- cgit v1.2.1 From 1be17ead1d6e210c5a8d76cd44a283879f932d69 Mon Sep 17 00:00:00 2001 From: goodger Date: Thu, 30 May 2002 02:29:07 +0000 Subject: updated git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@158 929543f6-e4f2-0310-98a6-ba3bd3dd1d04 --- test/test_statemachine.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'test/test_statemachine.py') diff --git a/test/test_statemachine.py b/test/test_statemachine.py index 02dd1e69b..8c336ca78 100755 --- a/test/test_statemachine.py +++ b/test/test_statemachine.py @@ -10,7 +10,9 @@ Test module for statemachine.py. """ -import unittest, sys, re +import unittest +import sys +import re from DocutilsTestSupport import statemachine -- cgit v1.2.1 From c2291595af5c117f10061fd9bf68fa0ff69d74fa Mon Sep 17 00:00:00 2001 From: goodger Date: Thu, 19 Sep 2002 00:51:03 +0000 Subject: updated git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@695 929543f6-e4f2-0310-98a6-ba3bd3dd1d04 --- test/test_statemachine.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'test/test_statemachine.py') diff --git a/test/test_statemachine.py b/test/test_statemachine.py index 8c336ca78..4ff5993fb 100755 --- a/test/test_statemachine.py +++ b/test/test_statemachine.py @@ -1,12 +1,12 @@ #! /usr/bin/env python -""" -:Author: David Goodger -:Contact: goodger@users.sourceforge.net -:Revision: $Revision$ -:Date: $Date$ -:Copyright: This module has been placed in the public domain. +# Author: David Goodger +# Contact: goodger@users.sourceforge.net +# Revision: $Revision$ +# Date: $Date$ +# Copyright: This module has been placed in the public domain. +""" Test module for statemachine.py. """ @@ -154,7 +154,7 @@ class SMWSTests(unittest.TestCase): def test___init__(self): self.assertEquals(self.sm.states.keys(), ['MockState']) - self.assertEquals(len(self.sm.states['MockState'].transitions), 2) + self.assertEquals(len(self.sm.states['MockState'].transitions), 4) def test_get_indented(self): self.sm.input_lines = testtext -- cgit v1.2.1 From 47e460c659b1e295d43604762eff2e9147d7df6c Mon Sep 17 00:00:00 2001 From: goodger Date: Fri, 8 Nov 2002 01:38:11 +0000 Subject: updated git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk/docutils@917 929543f6-e4f2-0310-98a6-ba3bd3dd1d04 --- test/test_statemachine.py | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) (limited to 'test/test_statemachine.py') diff --git a/test/test_statemachine.py b/test/test_statemachine.py index 4ff5993fb..4ca2a0144 100755 --- a/test/test_statemachine.py +++ b/test/test_statemachine.py @@ -157,7 +157,7 @@ class SMWSTests(unittest.TestCase): self.assertEquals(len(self.sm.states['MockState'].transitions), 4) def test_get_indented(self): - self.sm.input_lines = testtext + self.sm.input_lines = statemachine.StringList(testtext) self.sm.line_offset = -1 self.sm.next_line(3) indented, offset, good = self.sm.get_known_indented(2) @@ -182,7 +182,7 @@ class SMWSTests(unittest.TestCase): self.failUnless(good) def test_get_text_block(self): - self.sm.input_lines = testtext + self.sm.input_lines = statemachine.StringList(testtext) self.sm.line_offset = -1 self.sm.next_line() textblock = self.sm.get_text_block() @@ -192,7 +192,7 @@ class SMWSTests(unittest.TestCase): self.assertEquals(textblock, testtext[2:4]) def test_get_text_block_flush_left(self): - self.sm.input_lines = testtext + self.sm.input_lines = statemachine.StringList(testtext) self.sm.line_offset = -1 self.sm.next_line() textblock = self.sm.get_text_block(flush_left=1) @@ -274,22 +274,10 @@ class MiscTests(unittest.TestCase): s2l_string = "hello\tthere\thow are\tyou?\n\tI'm fine\tthanks.\n" s2l_expected = ['hello there how are you?', " I'm fine thanks."] - indented_string = """\ - a - literal - block""" - def test_string2lines(self): self.assertEquals(statemachine.string2lines(self.s2l_string), self.s2l_expected) - def test_extract_indented(self): - block = statemachine.string2lines(self.indented_string) - self.assertEquals(statemachine.extract_indented(block), - ([s[6:] for s in block], 6, 1)) - self.assertEquals(statemachine.extract_indented(self.s2l_expected), - ([], 0, 0)) - if __name__ == '__main__': unittest.main() -- cgit v1.2.1