Move RDoc tests out of lib/

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@14757 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,7 @@
+Fri Dec 28 15:12:05 2007  Eric Hodel  <drbrain@segment7.net>
+
+	* lib/rdoc, test/rdoc: Move RDoc tests out of lib/.
+
 Fri Dec 28 15:10:47 2007  Nobuyoshi Nakada  <nobu@ruby-lang.org>
 
 	* encoding.c (set_base_encoding, enc_base_encoding): renamed

lib/rdoc/markup/simple_markup/inline.rb

@@ -81,7 +81,12 @@ module SM
     end
 
     def to_s
-      "Special: type=#{type}, text=#{text.dump}"
+      "Special: type=#{type}, name=#{SM::Attribute.as_string type}, text=#{text.dump}"
+    end
+
+    def inspect
+      "#<SM::Special:0x%x @type=%p, name=%p @text=%p>" % [
+        object_id, @type, SM::Attribute.as_string(type), text.dump]
     end
   end
   

test/rdoc/test_simple_markup.rb

@@ -1,17 +1,13 @@
 require 'test/unit'
-
-$:.unshift "../../.."
-
 require 'rdoc/markup/simple_markup'
 
-include SM
+class TestSimpleMarkup < Test::Unit::TestCase
-
-class TestParse < Test::Unit::TestCase
 
   class MockOutput
+
     def start_accepting
       @res = []
-      end
+    end
 
     def end_accepting
       @res
@@ -52,21 +48,14 @@ class TestParse < Test::Unit::TestCase
   end
 
   def basic_conv(str)
-    sm = SimpleMarkup.new
+    sm = SM::SimpleMarkup.new
     mock = MockOutput.new
     sm.convert(str, mock)
     sm.content
   end
 
-  def line_types(str, expected)
-    p = SimpleMarkup.new
-    mock = MockOutput.new
-    p.convert(str, mock)
-    assert_equal(expected, p.get_line_types.map{|type| type.to_s[0,1]}.join(''))
-  end
-
   def line_groups(str, expected)
-    p = SimpleMarkup.new
+    p = SM::SimpleMarkup.new
     mock = MockOutput.new
 
     block = p.convert(str, mock)
@@ -82,120 +71,11 @@ class TestParse < Test::Unit::TestCase
     assert_equal(expected, block)
   end
 
-  def test_tabs
+  def line_types(str, expected)
-    str = "hello\n  dave"
+    p = SM::SimpleMarkup.new
-    assert_equal(str, basic_conv(str))
+    mock = MockOutput.new
-    str = "hello\n\tdave"
+    p.convert(str, mock)
-    assert_equal("hello\n        dave", basic_conv(str))
+    assert_equal(expected, p.get_line_types.map{|type| type.to_s[0,1]}.join(''))
-    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_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
-
-  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_groups
@@ -347,8 +227,165 @@ class TestParse < Test::Unit::TestCase
                   "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_split
+    str = %{\
+       now is
+       * l1
+       1. n1
+       2. n2
+       * l2
+       the time}
+    line_groups(str,
+                [ "L0: Paragraph\nnow is",
+                  "L1: ListStart\n",
+                  "L1: ListItem\nl1",
+                  "L1: ListEnd\n",
+                  "L1: ListStart\n",
+                  "L1: ListItem\nn1",
+                  "L1: ListItem\nn2",
+                  "L1: ListEnd\n",
+                  "L1: ListStart\n",
+                  "L1: ListItem\nl2",
+                  "L1: ListEnd\n",
+                  "L0: Paragraph\nthe time"
+                ])
+
+  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_merge
@@ -441,63 +478,19 @@ class TestParse < Test::Unit::TestCase
 
   end
 
-  def test_list_split
+  def test_whitespace
-    str = %{\
+    assert_equal("hello", basic_conv("hello"))
-       now is
+    assert_equal("hello", basic_conv(" hello "))
-       * l1
+    assert_equal("hello", basic_conv(" \t \t hello\t\t"))
-       1. n1
-       2. n2
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: ListItem\nl1",
-                  "L1: ListEnd\n",
-                  "L1: ListStart\n",
-                  "L1: ListItem\nn1",
-                  "L1: ListItem\nn2",
-                  "L1: ListEnd\n",
-                  "L1: ListStart\n",
-                  "L1: ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
 
+    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
 
-
-  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
-
-  
 end
+

test/rdoc/test_simple_markup_attribute_manager.rb

@@ -1,11 +1,7 @@
 require "test/unit"
-
-$:.unshift "../../.."
-
 require "rdoc/markup/simple_markup/inline"
 
-class TestInline < Test::Unit::TestCase
+class TestSimpleMarkupAttributeManager < Test::Unit::TestCase
-
 
   def setup
     @am = SM::AttributeManager.new
@@ -32,8 +28,11 @@ class TestInline < Test::Unit::TestCase
   end
 
   def crossref(text)
+    crossref_bitmap = SM::Attribute.bitmap_for(:_SPECIAL_) |
+                      SM::Attribute.bitmap_for(:CROSSREF)
+
     [ @am.changed_attribute_by_name([], [:CROSSREF] | [:_SPECIAL_]),
-      SM::Special.new(33, text),
+      SM::Special.new(crossref_bitmap, text),
       @am.changed_attribute_by_name([:CROSSREF] | [:_SPECIAL_], [])
     ]
   end
@@ -128,8 +127,6 @@ class TestInline < Test::Unit::TestCase
 
     assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"],
                   @am.flow("cat <i><b>and</b></i> dog"))
-    
-    
   end
 
   def test_protect
@@ -151,4 +148,6 @@ class TestInline < Test::Unit::TestCase
                   @am.flow("cat {and} dog"))
 #    assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog"))
   end
+
 end
+