* test/test_pp.rb: extract from lib/pp.rb.

* test/test_prettyprint.rb: extract from lib/prettyprint.rb.

* test/test_tsort.rb: extract from lib/tsort.rb.


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

3 files changed, 0 insertions, 747 deletions

diff --git a/lib/pp.rb b/lib/pp.rb
index 41f51b0046..d7425cd5f5 100644
--- a/lib/pp.rb
+++ b/lib/pp.rb
@@ -515,186 +515,3 @@ end
     end
   }
 }
-
-# :enddoc:
-if __FILE__ == $0
-  require 'test/unit'
-
-  class PPTest < Test::Unit::TestCase
-    def test_list0123_12
-      assert_equal("[0, 1, 2, 3]\n", PP.pp([0,1,2,3], '', 12))
-    end
-
-    def test_list0123_11
-      assert_equal("[0,\n 1,\n 2,\n 3]\n", PP.pp([0,1,2,3], '', 11))
-    end
-
-    OverriddenStruct = Struct.new("OverriddenStruct", :members, :class)
-    def test_struct_override_members # [ruby-core:7865]
-      a = OverriddenStruct.new(1,2)
-      assert_equal("#<struct Struct::OverriddenStruct members=1, class=2>\n", PP.pp(a, ''))
-    end
-
-    def test_redefined_method
-      o = ""
-      def o.method
-      end
-      assert_equal(%(""\n), PP.pp(o, ""))
-    end
-  end
-
-  class HasInspect
-    def initialize(a)
-      @a = a
-    end
-
-    def inspect
-      return "<inspect:#{@a.inspect}>"
-    end
-  end
-
-  class HasPrettyPrint
-    def initialize(a)
-      @a = a
-    end
-
-    def pretty_print(q)
-      q.text "<pretty_print:"
-      q.pp @a
-      q.text ">"
-    end
-  end
-
-  class HasBoth
-    def initialize(a)
-      @a = a
-    end
-
-    def inspect
-      return "<inspect:#{@a.inspect}>"
-    end
-
-    def pretty_print(q)
-      q.text "<pretty_print:"
-      q.pp @a
-      q.text ">"
-    end
-  end
-
-  class PrettyPrintInspect < HasPrettyPrint
-    alias inspect pretty_print_inspect
-  end
-
-  class PrettyPrintInspectWithoutPrettyPrint
-    alias inspect pretty_print_inspect
-  end
-
-  class PPInspectTest < Test::Unit::TestCase
-    def test_hasinspect
-      a = HasInspect.new(1)
-      assert_equal("<inspect:1>\n", PP.pp(a, ''))
-    end
-
-    def test_hasprettyprint
-      a = HasPrettyPrint.new(1)
-      assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
-    end
-
-    def test_hasboth
-      a = HasBoth.new(1)
-      assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
-    end
-
-    def test_pretty_print_inspect
-      a = PrettyPrintInspect.new(1)
-      assert_equal("<pretty_print:1>", a.inspect)
-      a = PrettyPrintInspectWithoutPrettyPrint.new
-      assert_raise(RuntimeError) { a.inspect }
-    end
-
-    def test_proc
-      a = proc {1}
-      assert_equal("#{a.inspect}\n", PP.pp(a, ''))
-    end
-
-    def test_to_s_with_iv
-      a = Object.new
-      def a.to_s() "aaa" end
-      a.instance_eval { @a = nil }
-      result = PP.pp(a, '')
-      assert_equal("#{a.inspect}\n", result)
-      assert_match(/\A#<Object.*>\n\z/m, result)
-      a = 1.0
-      a.instance_eval { @a = nil }
-      result = PP.pp(a, '')
-      assert_equal("#{a.inspect}\n", result)
-    end
-
-    def test_to_s_without_iv
-      a = Object.new
-      def a.to_s() "aaa" end
-      result = PP.pp(a, '')
-      assert_equal("#{a.inspect}\n", result)
-      assert_equal("aaa\n", result)
-    end
-  end
-
-  class PPCycleTest < Test::Unit::TestCase
-    def test_array
-      a = []
-      a << a
-      assert_equal("[[...]]\n", PP.pp(a, ''))
-      assert_equal("#{a.inspect}\n", PP.pp(a, ''))
-    end
-
-    def test_hash
-      a = {}
-      a[0] = a
-      assert_equal("{0=>{...}}\n", PP.pp(a, ''))
-      assert_equal("#{a.inspect}\n", PP.pp(a, ''))
-    end
-
-    S = Struct.new("S", :a, :b)
-    def test_struct
-      a = S.new(1,2)
-      a.b = a
-      assert_equal("#<struct Struct::S a=1, b=#<struct Struct::S:...>>\n", PP.pp(a, ''))
-      assert_equal("#{a.inspect}\n", PP.pp(a, ''))
-    end
-
-    def test_object
-      a = Object.new
-      a.instance_eval {@a = a}
-      assert_equal(a.inspect + "\n", PP.pp(a, ''))
-    end
-
-    def test_anonymous
-      a = Class.new.new
-      assert_equal(a.inspect + "\n", PP.pp(a, ''))
-    end
-
-    def test_withinspect
-      a = []
-      a << HasInspect.new(a)
-      assert_equal("[<inspect:[...]>]\n", PP.pp(a, ''))
-      assert_equal("#{a.inspect}\n", PP.pp(a, ''))
-    end
-
-    def test_share_nil
-      begin
-        PP.sharing_detection = true
-        a = [nil, nil]
-        assert_equal("[nil, nil]\n", PP.pp(a, ''))
-      ensure
-        PP.sharing_detection = false
-      end
-    end
-  end
-
-  class PPSingleLineTest < Test::Unit::TestCase
-    def test_hash
-      assert_equal("{1=>1}", PP.singleline_pp({ 1 => 1}, '')) # [ruby-core:02699]
-      assert_equal("[1#{', 1'*99}]", PP.singleline_pp([1]*100, ''))
-    end
-  end
-end
diff --git a/lib/prettyprint.rb b/lib/prettyprint.rb
index 911565392d..2c1fff3258 100644
--- a/lib/prettyprint.rb
+++ b/lib/prettyprint.rb
@@ -375,520 +375,3 @@ class PrettyPrint
     end
   end
 end
-
-if __FILE__ == $0
-  require 'test/unit'
-
-  class WadlerExample < Test::Unit::TestCase # :nodoc:
-    def setup
-      @tree = Tree.new("aaaa", Tree.new("bbbbb", Tree.new("ccc"),
-                                                 Tree.new("dd")),
-                               Tree.new("eee"),
-                               Tree.new("ffff", Tree.new("gg"),
-                                                Tree.new("hhh"),
-                                                Tree.new("ii")))
-    end
-
-    def hello(width)
-      PrettyPrint.format('', width) {|hello|
-        hello.group {
-          hello.group {
-            hello.group {
-              hello.group {
-                hello.text 'hello'
-                hello.breakable; hello.text 'a'
-              }
-              hello.breakable; hello.text 'b'
-            }
-            hello.breakable; hello.text 'c'
-          }
-          hello.breakable; hello.text 'd'
-        }
-      }
-    end
-
-    def test_hello_00_06
-      expected = <<'End'.chomp
-hello
-a
-b
-c
-d
-End
-      assert_equal(expected, hello(0))
-      assert_equal(expected, hello(6))
-    end
-
-    def test_hello_07_08
-      expected = <<'End'.chomp
-hello a
-b
-c
-d
-End
-      assert_equal(expected, hello(7))
-      assert_equal(expected, hello(8))
-    end
-
-    def test_hello_09_10
-      expected = <<'End'.chomp
-hello a b
-c
-d
-End
-      out = hello(9); assert_equal(expected, out)
-      out = hello(10); assert_equal(expected, out)
-    end
-
-    def test_hello_11_12
-      expected = <<'End'.chomp
-hello a b c
-d
-End
-      assert_equal(expected, hello(11))
-      assert_equal(expected, hello(12))
-    end
-
-    def test_hello_13
-      expected = <<'End'.chomp
-hello a b c d
-End
-      assert_equal(expected, hello(13))
-    end
-
-    def tree(width)
-      PrettyPrint.format('', width) {|q| @tree.show(q)}
-    end
-
-    def test_tree_00_19
-      expected = <<'End'.chomp
-aaaa[bbbbb[ccc,
-           dd],
-     eee,
-     ffff[gg,
-          hhh,
-          ii]]
-End
-      assert_equal(expected, tree(0))
-      assert_equal(expected, tree(19))
-    end
-
-    def test_tree_20_22
-      expected = <<'End'.chomp
-aaaa[bbbbb[ccc, dd],
-     eee,
-     ffff[gg,
-          hhh,
-          ii]]
-End
-      assert_equal(expected, tree(20))
-      assert_equal(expected, tree(22))
-    end
-
-    def test_tree_23_43
-      expected = <<'End'.chomp
-aaaa[bbbbb[ccc, dd],
-     eee,
-     ffff[gg, hhh, ii]]
-End
-      assert_equal(expected, tree(23))
-      assert_equal(expected, tree(43))
-    end
-
-    def test_tree_44
-      assert_equal(<<'End'.chomp, tree(44))
-aaaa[bbbbb[ccc, dd], eee, ffff[gg, hhh, ii]]
-End
-    end
-
-    def tree_alt(width)
-      PrettyPrint.format('', width) {|q| @tree.altshow(q)}
-    end
-
-    def test_tree_alt_00_18
-      expected = <<'End'.chomp
-aaaa[
-  bbbbb[
-    ccc,
-    dd
-  ],
-  eee,
-  ffff[
-    gg,
-    hhh,
-    ii
-  ]
-]
-End
-      assert_equal(expected, tree_alt(0))
-      assert_equal(expected, tree_alt(18))
-    end
-
-    def test_tree_alt_19_20
-      expected = <<'End'.chomp
-aaaa[
-  bbbbb[ ccc, dd ],
-  eee,
-  ffff[
-    gg,
-    hhh,
-    ii
-  ]
-]
-End
-      assert_equal(expected, tree_alt(19))
-      assert_equal(expected, tree_alt(20))
-    end
-
-    def test_tree_alt_20_49
-      expected = <<'End'.chomp
-aaaa[
-  bbbbb[ ccc, dd ],
-  eee,
-  ffff[ gg, hhh, ii ]
-]
-End
-      assert_equal(expected, tree_alt(21))
-      assert_equal(expected, tree_alt(49))
-    end
-
-    def test_tree_alt_50
-      expected = <<'End'.chomp
-aaaa[ bbbbb[ ccc, dd ], eee, ffff[ gg, hhh, ii ] ]
-End
-      assert_equal(expected, tree_alt(50))
-    end
-
-    class Tree # :nodoc:
-      def initialize(string, *children)
-        @string = string
-        @children = children
-      end
-
-      def show(q)
-        q.group {
-          q.text @string
-          q.nest(@string.length) {
-            unless @children.empty?
-              q.text '['
-              q.nest(1) {
-                first = true
-                @children.each {|t|
-                  if first
-                    first = false
-                  else
-                    q.text ','
-                    q.breakable
-                  end
-                  t.show(q)
-                }
-              }
-              q.text ']'
-            end
-          }
-        }
-      end
-
-      def altshow(q)
-        q.group {
-          q.text @string
-          unless @children.empty?
-            q.text '['
-            q.nest(2) {
-              q.breakable
-              first = true
-              @children.each {|t|
-                if first
-                  first = false
-                else
-                  q.text ','
-                  q.breakable
-                end
-                t.altshow(q)
-              }
-            }
-            q.breakable
-            q.text ']'
-          end
-        }
-      end
-
-    end
-  end
-
-  class StrictPrettyExample < Test::Unit::TestCase # :nodoc:
-    def prog(width)
-      PrettyPrint.format('', width) {|q|
-        q.group {
-          q.group {q.nest(2) {
-                       q.text "if"; q.breakable;
-                       q.group {
-                         q.nest(2) {
-                           q.group {q.text "a"; q.breakable; q.text "=="}
-                           q.breakable; q.text "b"}}}}
-          q.breakable
-          q.group {q.nest(2) {
-                       q.text "then"; q.breakable;
-                       q.group {
-                         q.nest(2) {
-                           q.group {q.text "a"; q.breakable; q.text "<<"}
-                           q.breakable; q.text "2"}}}}
-          q.breakable
-          q.group {q.nest(2) {
-                       q.text "else"; q.breakable;
-                       q.group {
-                         q.nest(2) {
-                           q.group {q.text "a"; q.breakable; q.text "+"}
-                           q.breakable; q.text "b"}}}}}
-      }
-    end
-
-    def test_00_04
-      expected = <<'End'.chomp
-if
-  a
-    ==
-    b
-then
-  a
-    <<
-    2
-else
-  a
-    +
-    b
-End
-      assert_equal(expected, prog(0))
-      assert_equal(expected, prog(4))
-    end
-
-    def test_05
-      expected = <<'End'.chomp
-if
-  a
-    ==
-    b
-then
-  a
-    <<
-    2
-else
-  a +
-    b
-End
-      assert_equal(expected, prog(5))
-    end
-
-    def test_06
-      expected = <<'End'.chomp
-if
-  a ==
-    b
-then
-  a <<
-    2
-else
-  a +
-    b
-End
-      assert_equal(expected, prog(6))
-    end
-
-    def test_07
-      expected = <<'End'.chomp
-if
-  a ==
-    b
-then
-  a <<
-    2
-else
-  a + b
-End
-      assert_equal(expected, prog(7))
-    end
-
-    def test_08
-      expected = <<'End'.chomp
-if
-  a == b
-then
-  a << 2
-else
-  a + b
-End
-      assert_equal(expected, prog(8))
-    end
-
-    def test_09
-      expected = <<'End'.chomp
-if a == b
-then
-  a << 2
-else
-  a + b
-End
-      assert_equal(expected, prog(9))
-    end
-
-    def test_10
-      expected = <<'End'.chomp
-if a == b
-then
-  a << 2
-else a + b
-End
-      assert_equal(expected, prog(10))
-    end
-
-    def test_11_31
-      expected = <<'End'.chomp
-if a == b
-then a << 2
-else a + b
-End
-      assert_equal(expected, prog(11))
-      assert_equal(expected, prog(15))
-      assert_equal(expected, prog(31))
-    end
-
-    def test_32
-      expected = <<'End'.chomp
-if a == b then a << 2 else a + b
-End
-      assert_equal(expected, prog(32))
-    end
-
-  end
-
-  class TailGroup < Test::Unit::TestCase # :nodoc:
-    def test_1
-      out = PrettyPrint.format('', 10) {|q|
-        q.group {
-          q.group {
-            q.text "abc"
-            q.breakable
-            q.text "def"
-          }
-          q.group {
-            q.text "ghi"
-            q.breakable
-            q.text "jkl"
-          }
-        }
-      }
-      assert_equal("abc defghi\njkl", out)
-    end
-  end
-
-  class NonString < Test::Unit::TestCase # :nodoc:
-    def format(width)
-      PrettyPrint.format([], width, 'newline', lambda {|n| "#{n} spaces"}) {|q|
-        q.text(3, 3)
-        q.breakable(1, 1)
-        q.text(3, 3)
-      }
-    end
-
-    def test_6
-      assert_equal([3, "newline", "0 spaces", 3], format(6))
-    end
-
-    def test_7
-      assert_equal([3, 1, 3], format(7))
-    end
-
-  end
-
-  class Fill < Test::Unit::TestCase # :nodoc:
-    def format(width)
-      PrettyPrint.format('', width) {|q|
-        q.group {
-          q.text 'abc'
-          q.fill_breakable
-          q.text 'def'
-          q.fill_breakable
-          q.text 'ghi'
-          q.fill_breakable
-          q.text 'jkl'
-          q.fill_breakable
-          q.text 'mno'
-          q.fill_breakable
-          q.text 'pqr'
-          q.fill_breakable
-          q.text 'stu'
-        }
-      }
-    end
-
-    def test_00_06
-      expected = <<'End'.chomp
-abc
-def
-ghi
-jkl
-mno
-pqr
-stu
-End
-      assert_equal(expected, format(0))
-      assert_equal(expected, format(6))
-    end
-
-    def test_07_10
-      expected = <<'End'.chomp
-abc def
-ghi jkl
-mno pqr
-stu
-End
-      assert_equal(expected, format(7))
-      assert_equal(expected, format(10))
-    end
-
-    def test_11_14
-      expected = <<'End'.chomp
-abc def ghi
-jkl mno pqr
-stu
-End
-      assert_equal(expected, format(11))
-      assert_equal(expected, format(14))
-    end
-
-    def test_15_18
-      expected = <<'End'.chomp
-abc def ghi jkl
-mno pqr stu
-End
-      assert_equal(expected, format(15))
-      assert_equal(expected, format(18))
-    end
-
-    def test_19_22
-      expected = <<'End'.chomp
-abc def ghi jkl mno
-pqr stu
-End
-      assert_equal(expected, format(19))
-      assert_equal(expected, format(22))
-    end
-
-    def test_23_26
-      expected = <<'End'.chomp
-abc def ghi jkl mno pqr
-stu
-End
-      assert_equal(expected, format(23))
-      assert_equal(expected, format(26))
-    end
-
-    def test_27
-      expected = <<'End'.chomp
-abc def ghi jkl mno pqr stu
-End
-      assert_equal(expected, format(27))
-    end
-
-  end
-end
diff --git a/lib/tsort.rb b/lib/tsort.rb
index 9fc4feadcd..aa562ad1c5 100644
--- a/lib/tsort.rb
+++ b/lib/tsort.rb
@@ -241,50 +241,3 @@ module TSort
     raise NotImplementedError.new
   end
 end
-
-if __FILE__ == $0
-  require 'test/unit'
-
-  class TSortHash < Hash # :nodoc:
-    include TSort
-    alias tsort_each_node each_key
-    def tsort_each_child(node, &block)
-      fetch(node).each(&block)
-    end
-  end
-
-  class TSortArray < Array # :nodoc:
-    include TSort
-    alias tsort_each_node each_index
-    def tsort_each_child(node, &block)
-      fetch(node).each(&block)
-    end
-  end
-
-  class TSortTest < Test::Unit::TestCase # :nodoc:
-    def test_dag
-      h = TSortHash[{1=>[2, 3], 2=>[3], 3=>[]}]
-      assert_equal([3, 2, 1], h.tsort)
-      assert_equal([[3], [2], [1]], h.strongly_connected_components)
-    end
-
-    def test_cycle
-      h = TSortHash[{1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}]
-      assert_equal([[4], [2, 3], [1]],
-        h.strongly_connected_components.map {|nodes| nodes.sort})
-      assert_raise(TSort::Cyclic) { h.tsort }
-    end
-
-    def test_array
-      a = TSortArray[[1], [0], [0], [2]]
-      assert_equal([[0, 1], [2], [3]],
-        a.strongly_connected_components.map {|nodes| nodes.sort})
-
-      a = TSortArray[[], [0]]
-      assert_equal([[0], [1]],
-        a.strongly_connected_components.map {|nodes| nodes.sort})
-    end
-  end
-
-end
-