* 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: http://svn.ruby-lang.org/repos/ruby/trunk@22321 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

3 files changed, 739 insertions, 12 deletions

diff --git a/test/test_pp.rb b/test/test_pp.rb
index 981fedd98..180977004 100644
--- a/test/test_pp.rb
+++ b/test/test_pp.rb
@@ -1,4 +1,180 @@
-require 'pathname'
-require Pathname.new(__FILE__).dirname.join('inlinetest.rb')
-target = __FILE__[/test_(.*\.rb)$/, 1]
-InlineTest.loadtest(target)
+require 'pp'
+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
diff --git a/test/test_prettyprint.rb b/test/test_prettyprint.rb
index 981fedd98..42178e7d0 100644
--- a/test/test_prettyprint.rb
+++ b/test/test_prettyprint.rb
@@ -1,4 +1,515 @@
-require 'pathname'
-require Pathname.new(__FILE__).dirname.join('inlinetest.rb')
-target = __FILE__[/test_(.*\.rb)$/, 1]
-InlineTest.loadtest(target)
+require 'prettyprint'
+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
diff --git a/test/test_tsort.rb b/test/test_tsort.rb
index 981fedd98..38018c49c 100644
--- a/test/test_tsort.rb
+++ b/test/test_tsort.rb
@@ -1,4 +1,44 @@
-require 'pathname'
-require Pathname.new(__FILE__).dirname.join('inlinetest.rb')
-target = __FILE__[/test_(.*\.rb)$/, 1]
-InlineTest.loadtest(target)
+require 'tsort'
+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
+