Class TestParse
In: markup/test/TestParse.rb
Parent: Test::Unit::TestCase

Methods

Classes and Modules

Class TestParse::MockOutput

Public Instance methods

[Source]

    # File markup/test/TestParse.rb, line 54
54:   def basic_conv(str)
55:     sm = SimpleMarkup.new
56:     mock = MockOutput.new
57:     sm.convert(str, mock)
58:     sm.content
59:   end

[Source]

    # File markup/test/TestParse.rb, line 68
68:   def line_groups(str, expected)
69:     p = SimpleMarkup.new
70:     mock = MockOutput.new
71: 
72:     block = p.convert(str, mock)
73: 
74:     if block != expected
75:       rows = (0...([expected.size, block.size].max)).collect{|i|
76:         [expected[i]||"nil", block[i]||"nil"] 
77:       }
78:       printf "\n\n%35s %35s\n", "Expected", "Got"
79:       rows.each {|e,g| printf "%35s %35s\n", e.dump, g.dump }
80:     end
81: 
82:     assert_equal(expected, block)
83:   end

[Source]

    # File markup/test/TestParse.rb, line 61
61:   def line_types(str, expected)
62:     p = SimpleMarkup.new
63:     mock = MockOutput.new
64:     p.convert(str, mock)
65:     assert_equal(expected, p.get_line_types.map{|type| type.to_s[0,1]}.join(''))
66:   end

[Source]

     # File markup/test/TestParse.rb, line 201
201:   def test_groups
202:     str = "now is the time"
203:     line_groups(str, ["L0: Paragraph\nnow is the time"] )
204: 
205:     str = "now is the time\nfor all good men"
206:     line_groups(str, ["L0: Paragraph\nnow is the time for all good men"] )
207: 
208:     str = %{\
209:       now is the time
210:         code _line_ here
211:       for all good men}
212: 
213:     line_groups(str,
214:                 [ "L0: Paragraph\nnow is the time",
215:                   "L0: Verbatim\n  code _line_ here\n",
216:                   "L0: Paragraph\nfor all good men"
217:                 ] )
218: 
219:     str = "now is the time\n  code\n more code\nfor all good men"
220:     line_groups(str,
221:                 [ "L0: Paragraph\nnow is the time",
222:                   "L0: Verbatim\n  code\n more code\n",
223:                   "L0: Paragraph\nfor all good men"
224:                 ] )
225: 
226:     str = %{\
227:        now is
228:        * l1
229:        * l2
230:        the time}
231:     line_groups(str,
232:                 [ "L0: Paragraph\nnow is",
233:                   "L1: ListStart\n",
234:                   "L1: ListItem\nl1",
235:                   "L1: ListItem\nl2",
236:                   "L1: ListEnd\n",
237:                   "L0: Paragraph\nthe time"
238:                 ])
239: 
240:     str = %{\
241:        now is
242:        * l1
243:          l1+
244:        * l2
245:        the time}
246:     line_groups(str,
247:                 [ "L0: Paragraph\nnow is",
248:                   "L1: ListStart\n",
249:                   "L1: ListItem\nl1 l1+",
250:                   "L1: ListItem\nl2",
251:                   "L1: ListEnd\n",
252:                   "L0: Paragraph\nthe time"
253:                 ])
254: 
255:     str = %{\
256:        now is
257:        * l1
258:          * l1.1
259:        * l2
260:        the time}
261:     line_groups(str,
262:                 [ "L0: Paragraph\nnow is",
263:                   "L1: ListStart\n",
264:                   "L1: ListItem\nl1",
265:                   "L2: ListStart\n",
266:                   "L2: ListItem\nl1.1",
267:                   "L2: ListEnd\n",
268:                   "L1: ListItem\nl2",
269:                   "L1: ListEnd\n",
270:                   "L0: Paragraph\nthe time"
271:                 ])
272: 
273: 
274:     str = %{\
275:        now is
276:        * l1
277:          * l1.1
278:            text
279:              code
280:                code
281: 
282:            text
283:        * l2
284:        the time}
285:     line_groups(str,
286:                 [ "L0: Paragraph\nnow is",
287:                   "L1: ListStart\n",
288:                   "L1: ListItem\nl1",
289:                   "L2: ListStart\n",
290:                   "L2: ListItem\nl1.1 text",
291:                   "L2: Verbatim\n  code\n    code\n",
292:                   "L2: Paragraph\ntext",
293:                   "L2: ListEnd\n",
294:                   "L1: ListItem\nl2",
295:                   "L1: ListEnd\n",
296:                   "L0: Paragraph\nthe time"
297:                 ])
298: 
299: 
300:     str = %{\
301:        now is
302:        1. l1
303:           * l1.1
304:        2. l2
305:        the time}
306:     line_groups(str,
307:                 [ "L0: Paragraph\nnow is",
308:                   "L1: ListStart\n",
309:                   "L1: ListItem\nl1",
310:                   "L2: ListStart\n",
311:                   "L2: ListItem\nl1.1",
312:                   "L2: ListEnd\n",
313:                   "L1: ListItem\nl2",
314:                   "L1: ListEnd\n",
315:                   "L0: Paragraph\nthe time"
316:                 ])
317: 
318:     str = %{\
319:        now is
320:        [cat] l1
321:              * l1.1
322:        [dog] l2
323:        the time}
324:     line_groups(str,
325:                 [ "L0: Paragraph\nnow is",
326:                   "L1: ListStart\n",
327:                   "L1: ListItem\nl1",
328:                   "L2: ListStart\n",
329:                   "L2: ListItem\nl1.1",
330:                   "L2: ListEnd\n",
331:                   "L1: ListItem\nl2",
332:                   "L1: ListEnd\n",
333:                   "L0: Paragraph\nthe time"
334:                 ])
335: 
336:     str = %{\
337:        now is
338:        [cat] l1
339:              continuation
340:        [dog] l2
341:        the time}
342:     line_groups(str,
343:                 [ "L0: Paragraph\nnow is",
344:                   "L1: ListStart\n",
345:                   "L1: ListItem\nl1 continuation",
346:                   "L1: ListItem\nl2",
347:                   "L1: ListEnd\n",
348:                   "L0: Paragraph\nthe time"
349:                 ])
350: 
351:     
352:   end

[Source]

     # File markup/test/TestParse.rb, line 470
470:   def test_headings
471:     str = "= heading one"
472:     line_groups(str, 
473:                 [ "L0: Heading\nheading one"
474:                 ])
475: 
476:     str = "=== heading three"
477:     line_groups(str, 
478:                 [ "L0: Heading\nheading three"
479:                 ])
480: 
481:     str = "text\n   === heading three"
482:     line_groups(str, 
483:                 [ "L0: Paragraph\ntext",
484:                   "L0: Verbatim\n   === heading three\n"
485:                 ])
486: 
487:     str = "text\n   code\n   === heading three"
488:     line_groups(str, 
489:                 [ "L0: Paragraph\ntext",
490:                   "L0: Verbatim\n   code\n   === heading three\n"
491:                 ])
492: 
493:     str = "text\n   code\n=== heading three"
494:     line_groups(str, 
495:                 [ "L0: Paragraph\ntext",
496:                   "L0: Verbatim\n   code\n",
497:                   "L0: Heading\nheading three"
498:                 ])
499: 
500:   end

[Source]

     # File markup/test/TestParse.rb, line 444
444:   def test_list_split
445:     str = %{\
446:        now is
447:        * l1
448:        1. n1
449:        2. n2
450:        * l2
451:        the time}
452:     line_groups(str,
453:                 [ "L0: Paragraph\nnow is",
454:                   "L1: ListStart\n",
455:                   "L1: ListItem\nl1",
456:                   "L1: ListEnd\n",
457:                   "L1: ListStart\n",
458:                   "L1: ListItem\nn1",
459:                   "L1: ListItem\nn2",
460:                   "L1: ListEnd\n",
461:                   "L1: ListStart\n",
462:                   "L1: ListItem\nl2",
463:                   "L1: ListEnd\n",
464:                   "L0: Paragraph\nthe time"
465:                 ])
466: 
467:   end

[Source]

     # File markup/test/TestParse.rb, line 85
 85:   def test_tabs
 86:     str = "hello\n  dave"
 87:     assert_equal(str, basic_conv(str))
 88:     str = "hello\n\tdave"
 89:     assert_equal("hello\n        dave", basic_conv(str))
 90:     str = "hello\n \tdave"
 91:     assert_equal("hello\n        dave", basic_conv(str))
 92:     str = "hello\n  \tdave"
 93:     assert_equal("hello\n        dave", basic_conv(str))
 94:     str = "hello\n   \tdave"
 95:     assert_equal("hello\n        dave", basic_conv(str))
 96:     str = "hello\n    \tdave"
 97:     assert_equal("hello\n        dave", basic_conv(str))
 98:     str = "hello\n     \tdave"
 99:     assert_equal("hello\n        dave", basic_conv(str))
100:     str = "hello\n      \tdave"
101:     assert_equal("hello\n        dave", basic_conv(str))
102:     str = "hello\n       \tdave"
103:     assert_equal("hello\n        dave", basic_conv(str))
104:     str = "hello\n        \tdave"
105:     assert_equal("hello\n                dave", basic_conv(str))
106:     str = ".\t\t."
107:     assert_equal(".               .", basic_conv(str))
108:   end

[Source]

     # File markup/test/TestParse.rb, line 124
124:   def test_types
125:     str = "now is the time"
126:     line_types(str, 'P')
127: 
128:     str = "now is the time\nfor all good men"
129:     line_types(str, 'PP')
130: 
131:     str = "now is the time\n  code\nfor all good men"
132:     line_types(str, 'PVP')
133: 
134:     str = "now is the time\n  code\n more code\nfor all good men"
135:     line_types(str, 'PVVP')
136: 
137:     str = "now is\n---\nthe time"
138:     line_types(str, 'PRP')
139: 
140:     str = %{\
141:        now is
142:        * l1
143:        * l2
144:        the time}
145:     line_types(str, 'PLLP')
146: 
147:     str = %{\
148:        now is
149:        * l1
150:          l1+
151:        * l2
152:        the time}
153:     line_types(str, 'PLPLP')
154: 
155:     str = %{\
156:        now is
157:        * l1
158:          * l1.1
159:        * l2
160:        the time}
161:     line_types(str, 'PLLLP')
162: 
163:     str = %{\
164:        now is
165:        * l1
166:          * l1.1
167:            text
168:              code
169:              code
170: 
171:            text
172:        * l2
173:        the time}
174:     line_types(str, 'PLLPVVBPLP')
175: 
176:     str = %{\
177:        now is
178:        1. l1
179:           * l1.1
180:        2. l2
181:        the time}
182:     line_types(str, 'PLLLP')
183: 
184:     str = %{\
185:        now is
186:        [cat] l1
187:              * l1.1
188:        [dog] l2
189:        the time}
190:     line_types(str, 'PLLLP')
191: 
192:     str = %{\
193:        now is
194:        [cat] l1
195:              continuation
196:        [dog] l2
197:        the time}
198:     line_types(str, 'PLPLP')
199:   end

[Source]

     # File markup/test/TestParse.rb, line 354
354:   def test_verbatim_merge
355:     str = %{\
356:        now is
357:           code
358:        the time}
359: 
360:     line_groups(str,
361:                 [ "L0: Paragraph\nnow is",
362:                   "L0: Verbatim\n   code\n",
363:                   "L0: Paragraph\nthe time"
364:                 ])
365: 
366: 
367:     str = %{\
368:        now is
369:           code
370:           code1
371:        the time}
372: 
373:     line_groups(str,
374:                 [ "L0: Paragraph\nnow is",
375:                   "L0: Verbatim\n   code\n   code1\n",
376:                   "L0: Paragraph\nthe time"
377:                 ])
378: 
379: 
380:     str = %{\
381:        now is
382:           code
383: 
384:           code1
385:        the time}
386: 
387:     line_groups(str,
388:                 [ "L0: Paragraph\nnow is",
389:                   "L0: Verbatim\n   code\n\n   code1\n",
390:                   "L0: Paragraph\nthe time"
391:                 ])
392: 
393: 
394:     str = %{\
395:        now is
396:           code
397: 
398:           code1
399: 
400:        the time}
401: 
402:     line_groups(str,
403:                 [ "L0: Paragraph\nnow is",
404:                   "L0: Verbatim\n   code\n\n   code1\n",
405:                   "L0: Paragraph\nthe time"
406:                 ])
407: 
408: 
409:     str = %{\
410:        now is
411:           code
412: 
413:           code1
414: 
415:           code2
416:        the time}
417: 
418:     line_groups(str,
419:                 [ "L0: Paragraph\nnow is",
420:                   "L0: Verbatim\n   code\n\n   code1\n\n   code2\n",
421:                   "L0: Paragraph\nthe time"
422:                 ])
423: 
424: 
425:     # Folds multiple blank lines
426:     str = %{\
427:        now is
428:           code
429: 
430: 
431:           code1
432: 
433:        the time}
434: 
435:     line_groups(str,
436:                 [ "L0: Paragraph\nnow is",
437:                   "L0: Verbatim\n   code\n\n   code1\n",
438:                   "L0: Paragraph\nthe time"
439:                 ])
440: 
441: 
442:   end

[Source]

     # File markup/test/TestParse.rb, line 110
110:   def test_whitespace
111:     assert_equal("hello", basic_conv("hello"))
112:     assert_equal("hello", basic_conv(" hello "))
113:     assert_equal("hello", basic_conv(" \t \t hello\t\t"))
114: 
115:     assert_equal("1\n 2\n  3", basic_conv("1\n 2\n  3"))
116:     assert_equal("1\n 2\n  3", basic_conv("  1\n   2\n    3"))
117: 
118:     assert_equal("1\n 2\n  3\n1\n 2", basic_conv("1\n 2\n  3\n1\n 2"))
119:     assert_equal("1\n 2\n  3\n1\n 2", basic_conv("  1\n   2\n    3\n  1\n   2"))
120: 
121:     assert_equal("1\n 2\n\n  3", basic_conv("  1\n   2\n\n    3"))
122:   end

[Validate]