rdoc 2.0.0

data/lib/rdoc/tokenstream.rb

@@ -0,0 +1,33 @@
+module RDoc; end
+
+##
+# A TokenStream is a list of tokens, gathered during the parse of some entity
+# (say a method). Entities populate these streams by being registered with the
+# lexer. Any class can collect tokens by including TokenStream. From the
+# outside, you use such an object by calling the start_collecting_tokens
+# method, followed by calls to add_token and pop_token.
+
+module RDoc::TokenStream
+
+  def token_stream
+    @token_stream
+  end
+
+  def start_collecting_tokens
+    @token_stream = []
+  end
+
+  def add_token(tk)
+    @token_stream << tk
+  end
+
+  def add_tokens(tks)
+    tks.each  {|tk| add_token(tk)}
+  end
+
+  def pop_token
+    @token_stream.pop
+  end
+
+end
+

data/test/test_rdoc_c_parser.rb

@@ -0,0 +1,261 @@
+require 'stringio'
+require 'tempfile'
+require 'test/unit'
+require 'rdoc/parsers/parse_c'
+
+class RDoc::C_Parser
+  attr_accessor :classes
+
+  public :do_classes, :do_constants
+end
+
+class TestRdocC_Parser < Test::Unit::TestCase
+
+  def setup
+    @tempfile = Tempfile.new self.class.name
+    filename = @tempfile.path
+
+    @top_level = RDoc::TopLevel.new filename
+    @fn = filename
+    @options = RDoc::Options.new Hash.new
+    @stats = RDoc::Stats.new
+
+    @progress = StringIO.new
+  end
+
+  def teardown
+    @tempfile.unlink
+  end
+
+  def test_do_classes_boot_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo boot class
+ */
+VALUE cFoo = boot_defclass("Foo", 0);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo boot class\n   ", klass.comment
+  end
+
+  def test_do_classes_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo class
+ */
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo class\n   ", klass.comment
+  end
+
+  def test_do_classes_class_under
+    content = <<-EOF
+/* Document-class: Kernel::Foo
+ * this is the Foo class under Kernel
+ */
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo class under Kernel\n   ", klass.comment
+  end
+
+  def test_do_classes_module
+    content = <<-EOF
+/* Document-module: Foo
+ * this is the Foo module
+ */
+VALUE mFoo = rb_define_module("Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "   this is the Foo module\n   ", klass.comment
+  end
+
+  def test_do_classes_module_under
+    content = <<-EOF
+/* Document-module: Kernel::Foo
+ * this is the Foo module under Kernel
+ */
+VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "   this is the Foo module under Kernel\n   ", klass.comment
+  end
+
+  def test_do_constants
+    content = <<-EOF
+#include <ruby.h>
+
+void Init_foo(){
+   VALUE cFoo = rb_define_class("Foo", rb_cObject);
+
+   /* 300: The highest possible score in bowling */
+   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
+
+   /* Huzzah!: What you cheer when you roll a perfect game */
+   rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!"));
+
+   /* TEST\:TEST: Checking to see if escaped semicolon works */
+   rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST"));
+
+   /* \\: The file separator on MS Windows */
+   rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\"));
+
+   /* /: The file separator on Unix */
+   rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/"));
+
+   /* C:\\Program Files\\Stuff: A directory on MS Windows */
+   rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff"));
+
+   /* Default definition */
+   rb_define_const(cFoo, "NOSEMI", INT2FIX(99));
+
+   rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment"));
+
+   /*
+    * Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE", INT2FIX(1));
+
+   /*
+    * 1: Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1));
+
+   /* Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1));
+
+}
+    EOF
+
+    parser = util_parser content
+
+    parser.do_classes
+    parser.do_constants
+
+    klass = parser.classes['cFoo']
+    assert klass
+
+    constants = klass.constants
+    assert !klass.constants.empty?
+
+    constants = constants.map { |c| [c.name, c.value, c.comment] }
+
+    assert_equal ['PERFECT', '300',
+                  "\n      The highest possible score in bowling   \n   "],
+                 constants.shift
+    assert_equal ['CHEER', 'Huzzah!',
+                  "\n      What you cheer when you roll a perfect game   \n   "],
+                 constants.shift
+    assert_equal ['TEST', 'TEST:TEST',
+                  "\n      Checking to see if escaped semicolon works   \n   "],
+                 constants.shift
+    assert_equal ['MSEPARATOR', '\\',
+                  "\n      The file separator on MS Windows   \n   "],
+                 constants.shift
+    assert_equal ['SEPARATOR', '/',
+                  "\n      The file separator on Unix   \n   "],
+                 constants.shift
+    assert_equal ['STUFF', 'C:\\Program Files\\Stuff',
+                  "\n      A directory on MS Windows   \n   "],
+                 constants.shift
+    assert_equal ['NOSEMI', 'INT2FIX(99)',
+                  "\n      Default definition   \n   "],
+                 constants.shift
+    assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', nil],
+                 constants.shift
+
+    comment = <<-EOF.chomp
+
+     
+      Multiline comment goes here because this comment spans multiple lines.
+      Multiline comment goes here because this comment spans multiple lines.
+      
+   
+    EOF
+    assert_equal ['MULTILINE', 'INT2FIX(1)', comment], constants.shift
+    assert_equal ['MULTILINE_VALUE', '1', comment], constants.shift
+
+    comment = <<-EOF.chomp
+
+      Multiline comment goes here because this comment spans multiple lines.
+      Multiline comment goes here because this comment spans multiple lines.
+      
+   
+    EOF
+    assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift
+
+    assert constants.empty?, constants.inspect
+  end
+
+  def test_find_class_comment_init
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+void
+Init_Foo(void) {
+  VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo\n   \n", klass.comment
+  end
+
+  def test_find_class_comment_define_class
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+VALUE foo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo\n   ", klass.comment
+  end
+
+  def test_find_class_comment_define_class_Init_Foo
+    content = <<-EOF
+/*
+ * a comment for class Foo on Init
+ */
+void
+Init_Foo(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo on Init\n   \n", klass.comment
+  end
+
+  def util_get_class(content, name)
+    parser = util_parser content
+    parser.do_classes
+    parser.classes[name]
+  end
+
+  def util_parser(content)
+    parser = RDoc::C_Parser.new @top_level, @fn, content, @options, @stats
+    parser.progress = @progress
+    parser
+  end
+
+end
+

data/test/test_rdoc_markup.rb

@@ -0,0 +1,613 @@
+require 'test/unit'
+require 'rdoc/markup'
+require 'rdoc/markup/to_test'
+
+class TestRDocMarkup < Test::Unit::TestCase
+
+  def basic_conv(str)
+    sm = RDoc::Markup.new
+    mock = RDoc::Markup::ToTest.new
+    sm.convert(str, mock)
+    sm.content
+  end
+
+  def line_groups(str, expected)
+    m = RDoc::Markup.new
+    mock = RDoc::Markup::ToTest.new
+
+    block = m.convert(str, mock)
+
+    if block != expected
+      rows = (0...([expected.size, block.size].max)).collect{|i|
+        [expected[i]||"nil", block[i]||"nil"]
+      }
+      printf "\n\n%35s %35s\n", "Expected", "Got"
+      rows.each {|e,g| printf "%35s %35s\n", e.dump, g.dump }
+    end
+
+    assert_equal(expected, block)
+  end
+
+  def line_types(str, expected)
+    m = RDoc::Markup.new
+    mock = RDoc::Markup::ToTest.new
+    m.convert(str, mock)
+    assert_equal(expected, m.get_line_types.map{|type| type.to_s[0,1]}.join(''))
+  end
+
+  def test_groups
+    str = "now is the time"
+    line_groups(str, ["L0: Paragraph\nnow is the time"] )
+
+    str = "now is the time\nfor all good men"
+    line_groups(str, ["L0: Paragraph\nnow is the time for all good men"] )
+
+    str = %{\
+      now is the time
+        code _line_ here
+      for all good men}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is the time",
+                  "L0: Verbatim\n  code _line_ here\n",
+                  "L0: Paragraph\nfor all good men"
+                ] )
+
+    str = "now is the time\n  code\n more code\nfor all good men"
+    line_groups(str,
+                [ "L0: Paragraph\nnow is the time",
+                  "L0: Verbatim\n  code\n more code\n",
+                  "L0: Paragraph\nfor all good men"
+                ] )
+
+    str = %{\
+       now is
+       * l1
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl1",
+                  "L1: BULLET ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+    str = %{\
+       now is
+       * l1
+         l1+
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl1 l1+",
+                  "L1: BULLET ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+    str = %{\
+       now is
+       * l1
+         * l1.1
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl1",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\nl1.1",
+                  "L2: ListEnd\n",
+                  "L1: BULLET ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+       * l1
+         * l1.1
+           text
+             code
+               code
+
+           text
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl1",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\nl1.1 text",
+                  "L2: Verbatim\n  code\n    code\n",
+                  "L2: Paragraph\ntext",
+                  "L2: ListEnd\n",
+                  "L1: BULLET ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+       1. l1
+          * l1.1
+       2. l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: NUMBER ListItem\nl1",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\nl1.1",
+                  "L2: ListEnd\n",
+                  "L1: NUMBER ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+    str = %{\
+       now is
+       [cat] l1
+             * l1.1
+       [dog] l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: LABELED ListItem\ncat: l1",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\nl1.1",
+                  "L2: ListEnd\n",
+                  "L1: LABELED ListItem\ndog: l2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+    str = %{\
+       now is
+       [cat] l1
+             continuation
+       [dog] l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: LABELED ListItem\ncat: l1 continuation",
+                  "L1: LABELED ListItem\ndog: l2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+  end
+
+  def test_headings
+    str = "= heading one"
+    line_groups(str,
+                [ "L0: Heading\nheading one"
+                ])
+
+    str = "=== heading three"
+    line_groups(str,
+                [ "L0: Heading\nheading three"
+                ])
+
+    str = "text\n   === heading three"
+    line_groups(str,
+                [ "L0: Paragraph\ntext",
+                  "L0: Verbatim\n   === heading three\n"
+                ])
+
+    str = "text\n   code\n   === heading three"
+    line_groups(str,
+                [ "L0: Paragraph\ntext",
+                  "L0: Verbatim\n   code\n   === heading three\n"
+                ])
+
+    str = "text\n   code\n=== heading three"
+    line_groups(str,
+                [ "L0: Paragraph\ntext",
+                  "L0: Verbatim\n   code\n",
+                  "L0: Heading\nheading three"
+                ])
+
+  end
+
+  def test_list_alpha
+    str = "a. alpha\nb. baker\nB. ALPHA\nA. BAKER"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: LOWERALPHA ListItem\nalpha",
+                  "L1: LOWERALPHA ListItem\nbaker",
+                  "L1: ListEnd\n",
+                  "L1: ListStart\n",
+                  "L1: UPPERALPHA ListItem\nALPHA",
+                  "L1: UPPERALPHA ListItem\nBAKER",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_bullet_dash
+    str = "- one\n- two\n"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: BULLET ListItem\none",
+                  "L1: BULLET ListItem\ntwo",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_bullet_star
+    str = "* one\n* two\n"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: BULLET ListItem\none",
+                  "L1: BULLET ListItem\ntwo",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_labeled_bracket
+    str = "[one] item one\n[two] item two"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: LABELED ListItem\none: item one",
+                  "L1: LABELED ListItem\ntwo: item two",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_labeled_bracket_continued
+    str = "[one]\n  item one\n[two]\n  item two"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: LABELED ListItem\none: item one",
+                  "L1: LABELED ListItem\ntwo: item two",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_labeled_colon
+    str = "one:: item one\ntwo:: item two"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: NOTE ListItem\none:: item one",
+                  "L1: NOTE ListItem\ntwo:: item two",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_labeled_colon_continued
+    str = "one::\n  item one\ntwo::\n  item two"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: NOTE ListItem\none:: item one",
+                  "L1: NOTE ListItem\ntwo:: item two",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_nested_bullet_bullet
+    str = "* one\n* two\n  * cat\n  * dog"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: BULLET ListItem\none",
+                  "L1: BULLET ListItem\ntwo",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\ncat",
+                  "L2: BULLET ListItem\ndog",
+                  "L2: ListEnd\n",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_nested_labeled_bullet
+    str = "[one]\n  * cat\n  * dog"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: LABELED ListItem\none: ",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\ncat",
+                  "L2: BULLET ListItem\ndog",
+                  "L2: ListEnd\n",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_nested_labeled_bullet_bullet
+    str = "[one]\n  * cat\n    * dog"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: LABELED ListItem\none: ",
+                  "L2: ListStart\n",
+                  "L2: BULLET ListItem\ncat",
+                  "L3: ListStart\n",
+                  "L3: BULLET ListItem\ndog",
+                  "L3: ListEnd\n",
+                  "L2: ListEnd\n",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_nested_number_number
+    str = "1. one\n1. two\n   1. cat\n   1. dog"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: NUMBER ListItem\none",
+                  "L1: NUMBER ListItem\ntwo",
+                  "L2: ListStart\n",
+                  "L2: NUMBER ListItem\ncat",
+                  "L2: NUMBER ListItem\ndog",
+                  "L2: ListEnd\n",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_number
+    str = "1. one\n2. two\n1. three"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: NUMBER ListItem\none",
+                  "L1: NUMBER ListItem\ntwo",
+                  "L1: NUMBER ListItem\nthree",
+                  "L1: ListEnd\n" ])
+  end
+
+  def test_list_split
+    str = %{\
+       now is
+       * l1
+       1. n1
+       2. n2
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl1",
+                  "L1: ListEnd\n",
+                  "L1: ListStart\n",
+                  "L1: NUMBER ListItem\nn1",
+                  "L1: NUMBER ListItem\nn2",
+                  "L1: ListEnd\n",
+                  "L1: ListStart\n",
+                  "L1: BULLET ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+  end
+
+  def test_paragraph
+    str = "paragraph\n\n*bold* paragraph\n"
+
+    line_groups str, [
+      "L0: Paragraph\nparagraph",
+      "L0: BlankLine\n",
+      "L0: Paragraph\n*bold* paragraph"
+    ]
+  end
+
+  def test_tabs
+    str = "hello\n  dave"
+    assert_equal(str, basic_conv(str))
+    str = "hello\n\tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n  \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n   \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n    \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n     \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n      \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n       \tdave"
+    assert_equal("hello\n        dave", basic_conv(str))
+    str = "hello\n        \tdave"
+    assert_equal("hello\n                dave", basic_conv(str))
+    str = ".\t\t."
+    assert_equal(".               .", basic_conv(str))
+  end
+
+  def test_types
+    str = "now is the time"
+    line_types(str, 'P')
+
+    str = "now is the time\nfor all good men"
+    line_types(str, 'PP')
+
+    str = "now is the time\n  code\nfor all good men"
+    line_types(str, 'PVP')
+
+    str = "now is the time\n  code\n more code\nfor all good men"
+    line_types(str, 'PVVP')
+
+    str = "now is\n---\nthe time"
+    line_types(str, 'PRP')
+
+    str = %{\
+       now is
+       * l1
+       * l2
+       the time}
+    line_types(str, 'PLLP')
+
+    str = %{\
+       now is
+       * l1
+         l1+
+       * l2
+       the time}
+    line_types(str, 'PLPLP')
+
+    str = %{\
+       now is
+       * l1
+         * l1.1
+       * l2
+       the time}
+    line_types(str, 'PLLLP')
+
+    str = %{\
+       now is
+       * l1
+         * l1.1
+           text
+             code
+             code
+
+           text
+       * l2
+       the time}
+    line_types(str, 'PLLPVVBPLP')
+
+    str = %{\
+       now is
+       1. l1
+          * l1.1
+       2. l2
+       the time}
+    line_types(str, 'PLLLP')
+
+    str = %{\
+       now is
+       [cat] l1
+             * l1.1
+       [dog] l2
+       the time}
+    line_types(str, 'PLLLP')
+
+    str = %{\
+       now is
+       [cat] l1
+             continuation
+       [dog] l2
+       the time}
+    line_types(str, 'PLPLP')
+  end
+
+  def test_verbatim
+    str = "paragraph\n  *bold* verbatim\n"
+
+    line_groups str, [
+      "L0: Paragraph\nparagraph",
+      "L0: Verbatim\n  *bold* verbatim\n"
+    ]
+  end
+
+  def test_verbatim_merge
+    str = %{\
+       now is
+          code
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+          code
+          code1
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n   code1\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+          code
+
+          code1
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n\n   code1\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+          code
+
+          code1
+
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n\n   code1\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    str = %{\
+       now is
+          code
+
+          code1
+
+          code2
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n\n   code1\n\n   code2\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+    # Folds multiple blank lines
+    str = %{\
+       now is
+          code
+
+
+          code1
+
+       the time}
+
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L0: Verbatim\n   code\n\n   code1\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+
+  end
+
+  def test_whitespace
+    assert_equal("hello", basic_conv("hello"))
+    assert_equal("hello", basic_conv(" hello "))
+    assert_equal("hello", basic_conv(" \t \t hello\t\t"))
+
+    assert_equal("1\n 2\n  3", basic_conv("1\n 2\n  3"))
+    assert_equal("1\n 2\n  3", basic_conv("  1\n   2\n    3"))
+
+    assert_equal("1\n 2\n  3\n1\n 2", basic_conv("1\n 2\n  3\n1\n 2"))
+    assert_equal("1\n 2\n  3\n1\n 2", basic_conv("  1\n   2\n    3\n  1\n   2"))
+
+    assert_equal("1\n 2\n\n  3", basic_conv("  1\n   2\n\n    3"))
+  end
+
+end
+