def testUnwrapMixedQuoted( self ):
flow = flowtext.parser()
testText = ( "This line is \n" +
"quoted and has a couple of soft \n" +
"breaks in it.\n\n" +
">This line is also \n" +
">quoted and has an \n" +
">example of embaressing wrap\n")
expectedText = ( "This line is " +
"quoted and has a couple of soft " +
"breaks in it.\n\n" +
">This line is also " +
"quoted and has an " +
"example of embaressing wrap\n")
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testUnwrapIllegalQuoteChange( self ):
flow = flowtext.parser()
testText = ( ">>This line is quoted \n"
">>to a depth of 2 \n"
">but this line it wraps to is only 1 and fixed\n"
">>>This line is quoted to \n"
">>>a depth of 3 \n"
">>but this line it wraps to \n"
">>is flowed and quoted to a \n"
">>depth of 2.\n")
expectedText = ( ">>This line is quoted to a depth of 2\n"
">but this line it wraps to is only 1 and fixed\n"
">>>This line is quoted to a depth of 3\n"
">>but this line it wraps to is flowed and quoted to a "
"depth of 2.\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testUnwrapUsenetSignature(self):
flow = flowtext.parser()
testText = ( "This line is \n"
"quoted and has a couple of soft \n"
"breaks in it.\n\n"
">This line is also \n"
">quoted and has an \n"
">example of embaressing wrap\n"
"-- \n"
"And this is a usenet signature\n")
expectedText = ( "This line is "
"quoted and has a couple of soft "
"breaks in it.\n\n"
">This line is also "
"quoted and has an "
"example of embaressing wrap\n"
"-- \n"
"And this is a usenet signature\n")
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testSetMaxWidth( self ):
flow = flowtext.parser()
flow.setMaxWidth( 40 )
self.assertEqual( 40, flow.getMaxWidth() )
def setOverWide():
flow.setMaxWidth( 99 )
self.assertRaises( ValueError, setOverWide )
def testUnwrapQuotedWithSoftWrapAndQuoted(self):
flow = flowtext.parser()
testText = ( ">This line is \n" +
"quoted and has a couple of soft \n" +
">breaks in it.\n")
expectedText = ( ">This line is " +
"quoted and has a couple of soft " +
"breaks in it.\n")
self.assertEqual( expectedText, flow.unwrap( testText ) )
def testStandardiseNewlines(self):
flow = flowtext.parser()
testText = ("This is a basic newline\n" +
"And another type\r" +
"And another\n\r" +
"And yet another\r\n")
expectedText = ("This is a basic newline\n" +
"And another type\n" +
"And another\n" +
"And yet another\n")
self.assertEqual( expectedText, flow.standardiseNewlines(testText))
def testUnwrapTwoParagraphs( self ):
flow = flowtext.parser()
testText = ( "This line spans a few \n" +
"lines and has a couple of soft \n" +
"breaks in it.\n\n" +
"and sneakily has a second \n" +
"paragraph\n" )
expectedText = ( "This line spans a few " +
"lines and has a couple of soft " +
"breaks in it.\n\n" +
"and sneakily has a second " +
"paragraph\n" )
self.assertEqual( expectedText, flow.unwrap( testText ) )
def testUnwrapTwoGTQuotedLines( self ):
flow = flowtext.parser()
testText = ( ">This line is \n" +
">quoted and has a couple of soft \n" +
">breaks in it.\n\n" +
">This line is also \n" +
">quoted\n" )
expectedText = ( ">This line is " +
"quoted and has a couple of soft " +
"breaks in it.\n\n" +
">This line is also " +
"quoted\n" )
self.assertEqual( expectedText, flow.unwrap( testText ) )
def testUnwrapMixedNormalAndQuoted( self ):
flow = flowtext.parser()
testText = ( ">This line is \n" +
">quoted and has a couple of soft \n" +
">breaks in it.\n\n" +
"This line is not \n" +
"quoted\n" )
expectedText = ( ">This line is " +
"quoted and has a couple of soft " +
"breaks in it.\n\n" +
"This line is not " +
"quoted\n" )
self.assertEqual( expectedText, flow.unwrap( testText ) )
def testGenerateMessage(self):
flow = flowtext.parser()
msg = flow.generateMessage(">This line is very, very long \nindeed and will go on and on and on "
"and will be over 66 characters long hopefully \nforcing the wrapping "
"mechanism into action. Of course we then \nneed to investigate real word "
"boundary wrapping, not merely character \nsplitting\n")
expectedText = (">This line is very, very long indeed and will go on and on and on \n"
">and will be over 66 characters long hopefully forcing the \n"
">wrapping mechanism into action. Of course we then need to \n"
">investigate real word boundary wrapping, not merely character \n"
">splitting\n" )
self.assertEqual(msg.get_content_type(), "text/plain")
self.assertEqual(msg.get_param("format"), "flowed")
self.assertEqual(msg.get_payload(), expectedText)
def testUnwrapEndingWithCr(self):
flow = flowtext.parser()
testText = ( "This line ends with a CR which should be untouched\n")
expectedText = ( "This line ends with a CR which should be untouched\n")
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testASimpleUnwrapQuotedWithGt( self ):
flow = flowtext.parser()
testText = ( ">This line is \n>quoted\n" )
expectedText = ( ">This line is quoted\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testNegativeUnwrap( self ):
flow = flowtext.parser()
testText = ( "This line spans a few \n" +
"lines and has a couple of soft \n" +
"breaks in it. \n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertNotEqual( testText, outputText )
def testParsesMessage(self):
flow = flowtext.parser()
msg = Message()
def test():
flow.parseMessage(msg)
self.assertRaises(ValueError, test)
msg = flow.generateMessage(">This line is very, very long \nindeed and will go on and on and on "
"and will be over 66 characters long hopefully \nforcing the wrapping "
"mechanism into action. Of course we then \nneed to investigate real word "
"boundary wrapping, not merely character \nsplitting\n")
expectedText = (">This line is very, very long indeed and will go on and on and on \n"
">and will be over 66 characters long hopefully forcing the \n"
">wrapping mechanism into action. Of course we then need to \n"
">investigate real word boundary wrapping, not merely character \n"
">splitting\n" )
self.assertEqual(flow.parseMessage(msg), expectedText)
def testUnwrapSpaceStuffed(self):
flow = flowtext.parser()
testText = ( " >This is a special line, and although it is more than 66 characters, \n"
" it is space stuffed, and therefore the > should be ignored\n" )
expectedText = (" >This is a special line, and although it is more than 66 characters, "
"it is space stuffed, and therefore the > should be ignored\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testWrapLongestLine(self):
flow = flowtext.parser()
testText = ( "ThisIsAllOneWordAndWillNotBeWrappedThislineisvery,verylongindeedandwillgoonandonandon"
"andwillbeover66characterslonghopefullyforcingthewrapping"
"mechanismintoaction.Ofcoursewethenneedtoinvestigaterealword"
"boundarywrapping,notmerelycharactersplitting\n" )
expectedText = testText
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.wrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testWrapQuotedLongQuote(self):
flow = flowtext.parser()
testText = ( ">>>>>This line is very, very long indeed and will go on and on and on "
"and will be over 66 characters long hopefully forcing the wrapping "
"mechanism into action. Of course we then need to investigate real word "
"boundary wrapping, not merely character splitting\n" )
expectedText = (">>>>>This line is very, very long indeed and will go on and on \n"
">>>>>and on and will be over 66 characters long hopefully forcing \n"
">>>>>the wrapping mechanism into action. Of course we then need \n"
">>>>>to investigate real word boundary wrapping, not merely \n"
">>>>>character splitting\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.wrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
def testUnwrapAll( self ):
flow = flowtext.parser()
testText = ( "This line spans a few \n"
"lines and has a couple of soft \n"
"breaks in it. It also has a very, very long line which spans a little "
"too long and therefore needs to be well wrapped.\n"
"\nAfter which there is a new paragraph. This new paragraph has only "
"one long line\n"
" And now an indented (therefore space stuffed) section \n"
" which also spans a few lines, with soft line breaks (using the space "
"then crlf convention)\n\n"
">Another quoted test using the greater than sign \n"
">but its otherwise nothing special.\n\n"
">And here I am going to give a soft break \n"
">>And change the quoting depth - this is an illegal operation\n" )
expectedText = ( "This line spans a few "
"lines and has a couple of soft "
"breaks in it. It also has a very, very long line which spans a little "
"too long and therefore needs to be well wrapped.\n"
"\nAfter which there is a new paragraph. This new paragraph has only "
"one long line\n"
" And now an indented (therefore space stuffed) section "
"which also spans a few lines, with soft line breaks (using the space "
"then crlf convention)\n\n"
">Another quoted test using the greater than sign "
"but its otherwise nothing special.\n\n"
">And here I am going to give a soft break\n"
">>And change the quoting depth - this is an illegal operation\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.unwrap( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testPrepare(self):
flow = flowtext.parser()
testText = ( "This small document needs to be space stuffed\n"
">It contains this line which is not quoted\n"
" And this line with an intentional space\n"
"From here to infinity\n" )
expectedText = ("This small document needs to be space stuffed\n"
" >It contains this line which is not quoted\n"
" And this line with an intentional space\n"
" From here to infinity\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.prepNonQuotedText( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testFlow79(self):
flow = flowtext.parser(79)
testText = ( ">This line is very, very long \nindeed and will go on and on and on "
"and will be over 79 characters long hopefully \nforcing the wrapping "
"mechanism into action. Of course we then \nneed to investigate real word "
"boundary wrapping, not merely character \nsplitting\n" )
expectedText = (">This line is very, very long indeed and will go on and on and on and will be \n"
">over 79 characters long hopefully forcing the wrapping mechanism into action. \n"
">Of course we then need to investigate real word boundary wrapping, not merely \n"
">character splitting\n" )
debug = False
if(debug):
print "\n---------------------------\ninput text\n"
print testText
outputText = flow.flow( testText, debug )
if(debug):
print "\n---------------------------\nExpected text\n"
print expectedText
print "\n---------------------------\noutput text\n"
print outputText
self.assertEqual( expectedText, outputText )
def testConstruction( self ):
flow = flowtext.parser()
self.assertEqual( 66, flow.getMaxWidth() )
#Try constructing again
flow = flowtext.parser( 23 )
self.assertEqual( 23, flow.getMaxWidth() )
def setUp( self ):
self.flow = flowtext.parser()
