ttk 0.1.580 → 0.2.0

data/test/ressources/runit/good.rb

@@ -7,9 +7,7 @@ class Good
 end
 
 
-if __FILE__ == $0
-
-require 'test/unit/ui/yaml/testrunner'
+test_section __FILE__ do
 
 class GoodTest < Test::Unit::TestCase
 
@@ -24,7 +22,5 @@ class GoodTest < Test::Unit::TestCase
 
 end
 
-Test::Unit::UI::Yaml::TestRunner.run(GoodTest)
-
 end
 

data/test/runit/dumpers/xml_test.rb

@@ -3,10 +3,9 @@
 # License: Ruby license.
 
 # $LastChangedBy$
-# $Id: xml_test.rb 578 2005-04-14 20:46:09Z ertai $
+# $Id: xml_test.rb 609 2005-06-05 17:07:25Z ertai $
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 module TTK
 
@@ -74,4 +73,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Dumpers::Xml::Test)
+end

data/test/runit/dumpers/yaml_test.rb

@@ -3,10 +3,9 @@
 # License: Ruby license.
 
 # $LastChangedBy$
-# $Id: yaml_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: yaml_test.rb 609 2005-06-05 17:07:25Z ertai $
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 module TTK
 
@@ -65,4 +64,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Dumpers::Yaml::Test)
+end

data/test/runit/fetchers/fetchers_test.rb

@@ -3,10 +3,10 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: fetchers_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: fetchers_test.rb 609 2005-06-05 17:07:25Z ertai $
 
 
-require 'test/unit/ui/yaml/testrunner'
+test_section __FILE__ do
 require 'ttkd'
 
 
@@ -17,11 +17,10 @@ module TTK
     class FetchersTest < ::Test::Unit::TestCase
 
       def test_simple
-        me_dir, @me = Pathname.new(__FILE__).split
         q_in = Queue.new
         q_out = Queue.new
         thr_srv = Thread.new do
-          srv = Server.new(nil, me_dir)
+          srv = Server.new(nil, @tmp)
           drbsrv = DRb::DRbServer.new(nil, srv)
           q_out.push drbsrv.uri
           q_in.pop
@@ -29,13 +28,23 @@ module TTK
         srv_uri = q_out.pop
         clt = Client.new(nil, DRb::DRbObject.new_with_uri(srv_uri))
         drbsrv = DRb::DRbServer.new(nil, clt)
-        stat = drbsrv.front.fetch(@me, Pathname.new(Dir.tmpdir))
+        stat = drbsrv.front.fetch(@resource, @tmp)
         assert(stat[:success])
         q_in.push(42)
       end
 
+
+      def setup
+        @resource = 'foo.txt'.to_path
+        @tmp = TempPath.new
+        @tmp.mkpath
+        (@tmp + @resource).open('w') do |f|
+          f.puts 'foo' * 100
+        end
+      end
+
       def teardown
-        File.delete("#{Dir.tmpdir}/#{@me}")
+        @tmp.clean if @tmp
       end
 
     end # class ClientTest
@@ -44,5 +53,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Fetchers::FetchersTest)
-
+end

data/test/runit/logger/section_node_test.rb

@@ -3,11 +3,10 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: section_node_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: section_node_test.rb 609 2005-06-05 17:07:25Z ertai $
 
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 
 module TTK
@@ -120,6 +119,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Logger::SectionNodeTest)
-
-
+end

data/test/runit/logger/severity_test.rb

@@ -3,11 +3,10 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: severity_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: severity_test.rb 609 2005-06-05 17:07:25Z ertai $
 
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 module TTK
 
@@ -28,7 +27,7 @@ module TTK
       end
 
       def test_label
-        assert_equal('WARN', Severity.label(2))
+        assert_equal('WARN', Severity.label(3))
       end
 
     end # class SeverityTest
@@ -37,5 +36,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Logger::SeverityTest)
-
+end

data/test/runit/logger/verbosity_test.rb

@@ -3,11 +3,10 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: verbosity_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: verbosity_test.rb 609 2005-06-05 17:07:25Z ertai $
 
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 module TTK
 
@@ -44,6 +43,4 @@ module TTK
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::Logger::VerbosityTest)
-
-
+end

data/test/runit/logger_test.rb

@@ -3,11 +3,10 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: logger_test.rb 567 2005-04-13 08:00:06Z polrop $
+# $Id: logger_test.rb 609 2005-06-05 17:07:25Z ertai $
 
 
-require 'test/unit/ui/yaml/testrunner'
-require 'ttk'
+test_section __FILE__ do
 
 module TTK
 
@@ -27,220 +26,216 @@ module TTK
 
     end # class MockObsv
 
+    def setup
+      @mo = MockObsv.new
+      @l = Logger.new(@mo)
+    end
+
     def test_path
-      l = Logger.new
-      assert_equal([], l.path)
-      assert_equal('/', l.path.to_s)
+      assert_equal([], @l.path)
+      assert_equal('/', @l.path.to_s)
     end
 
     def test_new_leaf
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      assert_equal([], mo.args)
-      assert_equal([], l.path)
-      l.new_leaf('foo')
-      assert_equal([:new_leaf, [], "foo"], mo.args.last)
-      assert_equal([], l.path)
+      assert_equal([], @mo.args)
+      assert_equal([], @l.path)
+      @l.new_leaf('foo')
+      assert_equal([:new_leaf, [], "foo"], @mo.args.last)
+      assert_equal([], @l.path)
     end
 
     def test_new_node
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l.new_node('foo') do
-        assert_equal([:new_node, [[:foo, :map]]], mo.args.last)
-        l.new_leaf('leaf_bar')
-        assert_equal('/foo', l.path.to_s)
-        assert_equal([:new_leaf, [[:foo, :map]], 'leaf_bar'], mo.args.last)
+      @l.new_node('foo') do
+        assert_equal([:new_node, [[:foo, :map]]], @mo.args.last)
+        @l.new_leaf('leaf_bar')
+        assert_equal('/foo', @l.path.to_s)
+        assert_equal([:new_leaf, [[:foo, :map]], 'leaf_bar'], @mo.args.last)
       end
-      assert_equal([:up, []], mo.args.last)
-      assert_equal(3, mo.args.size)
-      l.close
-      assert_equal([:close], mo.args.last)
-      assert_equal(4, mo.args.size)
-      assert_equal('/', l.path.to_s)
+      assert_equal([:up, []], @mo.args.last)
+      assert_equal(3, @mo.args.size)
+      @l.close
+      assert_equal([:close], @mo.args.last)
+      assert_equal(4, @mo.args.size)
+      assert_equal('/', @l.path.to_s)
     end
 
     def test_log__basic
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l.log { 'foo' }
+      @l.log { 'foo' }
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_leaf, [[:log_0, :map]], 'foo'],
+                     [:new_node, [[:UNKNOWN, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map]], 'foo'],
                      [:up, []],
-                   ], mo.args)
+                   ], @mo.args)
     end
 
     def test_severity_level
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l.severity_level = Logger::Severity::ERROR
-      l.log(Logger::Severity::INFO) { 'foo' }
-      assert_equal([], mo.args)
-      l.log(Logger::Severity::ERROR) { 'foo' }
+      @l.severity_level = Logger::Severity::ERROR
+      @l.log(Logger::Severity::INFO) { 'foo' }
+      assert_equal([], @mo.args)
+      @l.log(Logger::Severity::ERROR) { 'foo' }
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_leaf, [[:log_0, :map]], 'foo'],
+                     [:new_node, [[:ERROR, :map]]],
+                     [:new_leaf, [[:ERROR, :map]], 'foo'],
                      [:up, []],
-                   ], mo.args)
+                   ], @mo.args)
+    end
+
+    def test_block_returning_nil_with_severity_level
+      @l.severity_level = Logger::Severity::ERROR
+      x = 0
+      @l.log(Logger::Severity::INFO) { x = 1 }
+      assert_equal(0, x)
+      @l.log(Logger::Severity::ERROR) { x = 2 ; nil }
+      assert_equal([], @mo.args)
+      assert_equal(2, x)
     end
 
     def test_verbosity_level__simple
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      assert_raises(ArgumentError) { l.verbosity_level = -1 }
-      l.verbosity_level = 1
-      l.log { 'foo' }
+      assert_raises(ArgumentError) { @l.verbosity_level = -1 }
+      @l.verbosity_level = 1
+      @l.log { 'foo' }
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:severity_level, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:severity_level, :map]],
+                     [:new_node, [[:UNKNOWN, :map]]],
+                     [:new_node, [[:UNKNOWN, :map], [:severity_level, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map], [:severity_level, :map]],
                         'UNKNOWN'],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:message, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:message, :map]], 'foo'],
-                     [:up, [[:log_0, :map]]],
+                     [:up, [[:UNKNOWN, :map]]],
+                     [:new_node, [[:UNKNOWN, :map], [:message, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map], [:message, :map]], 'foo'],
+                     [:up, [[:UNKNOWN, :map]]],
                      [:up, []]
-                   ], mo.args)
+                   ], @mo.args)
     end
 
     def test_verbosity_level__complex
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      assert_raises(ArgumentError) { l.verbosity_level = -1 }
-      l.verbosity_level = 2
-      l.log { 'foo' }
+      assert_raises(ArgumentError) { @l.verbosity_level = -1 }
+      @l.verbosity_level = 2
+      @l.log { 'foo' }
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:severity_level, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:severity_level, :map]],
+                     [:new_node, [[:UNKNOWN, :map]]],
+                     [:new_node, [[:UNKNOWN, :map], [:severity_level, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map], [:severity_level, :map]],
                         'UNKNOWN'],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:sections, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:sections, :map]], []],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:message, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:message, :map]], 'foo'],
-                     [:up, [[:log_0, :map]]],
+                     [:up, [[:UNKNOWN, :map]]],
+                     [:new_node, [[:UNKNOWN, :map], [:sections, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map], [:sections, :map]], []],
+                     [:up, [[:UNKNOWN, :map]]],
+                     [:new_node, [[:UNKNOWN, :map], [:message, :map]]],
+                     [:new_leaf, [[:UNKNOWN, :map], [:message, :map]], 'foo'],
+                     [:up, [[:UNKNOWN, :map]]],
                      [:up, []]
-                   ], mo.args)
+                   ], @mo.args)
     end
 
     def test_active_section
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l.section_tree.push(Logger::SectionNode.new('foo'),
+      @l.section_tree.push(Logger::SectionNode.new('foo'),
                           Logger::SectionNode.new('bar',
                                             Logger::SectionNode.new('baz'),
                                             Logger::SectionNode.new('goo')))
       %w(all foo bar baz goo).each do |s|
-        assert(! l.active_section?(s), "section active #{s}")
+        assert(! @l.active_section?(s), "section active #{s}")
       end
-      l.active_section(true, 'foo', 'baz')
+      @l.active_section(true, 'foo', 'baz')
       expected_section = %w(all foo bar baz)
       expected_section.each do |s|
-        assert(l.active_section?(s), "section not active #{s}")
+        assert(@l.active_section?(s), "section not active #{s}")
       end
-      l.severity_level = Logger::Severity::WARN
-      l.verbosity_level = 2
-      l.log(Logger::Severity::ERROR, 'foo', 'baz') { 'foo' }
+      @l.severity_level = Logger::Severity::WARN
+      @l.verbosity_level = 2
+      @l.log(Logger::Severity::ERROR, 'foo', 'baz') { 'foo' }
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:severity_level, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:severity_level, :map]], 
+                     [:new_node, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:severity_level, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:severity_level, :map]], 
                         'ERROR'],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:sections, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:sections, :map]],
+                     [:up, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:sections, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:sections, :map]],
                         ['foo', 'baz']],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:message, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:message, :map]], 'foo'],
-                     [:up, [[:log_0, :map]]],
+                     [:up, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:message, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:message, :map]], 'foo'],
+                     [:up, [[:ERROR, :map]]],
                      [:up, []]
-                   ], mo.args)
-      mo.args.clear
-      l.log(Logger::Severity::FATAL, 'all') { 'toto' }
+                   ], @mo.args)
+      @mo.args.clear
+      @l.log(Logger::Severity::FATAL, 'all') { 'toto' }
       assert_equal([
-                     [:new_node, [[:log_1, :map]]],
-                     [:new_node, [[:log_1, :map], [:severity_level, :map]]],
-                     [:new_leaf, [[:log_1, :map], [:severity_level, :map]],
+                     [:new_node, [[:FATAL_1, :map]]],
+                     [:new_node, [[:FATAL_1, :map], [:severity_level, :map]]],
+                     [:new_leaf, [[:FATAL_1, :map], [:severity_level, :map]],
                         'FATAL'],
-                     [:up, [[:log_1, :map]]],
-                     [:new_node, [[:log_1, :map], [:sections, :map]]],
-                     [:new_leaf, [[:log_1, :map], [:sections, :map]],
+                     [:up, [[:FATAL_1, :map]]],
+                     [:new_node, [[:FATAL_1, :map], [:sections, :map]]],
+                     [:new_leaf, [[:FATAL_1, :map], [:sections, :map]],
                         ['all']],
-                     [:up, [[:log_1, :map]]],
-                     [:new_node, [[:log_1, :map], [:message, :map]]],
-                     [:new_leaf, [[:log_1, :map], [:message, :map]],
+                     [:up, [[:FATAL_1, :map]]],
+                     [:new_node, [[:FATAL_1, :map], [:message, :map]]],
+                     [:new_leaf, [[:FATAL_1, :map], [:message, :map]],
                         'toto'],
-                     [:up, [[:log_1, :map]]],
+                     [:up, [[:FATAL_1, :map]]],
                      [:up, []]
-                   ], mo.args)
-      mo.args.clear
-      l.log(Logger::Severity::FATAL, 'goo') { 'titi' }
-      assert_equal([], mo.args)
+                   ], @mo.args)
+      @mo.args.clear
+      @l.log(Logger::Severity::FATAL, 'goo') { 'titi' }
+      assert_equal([], @mo.args)
     end
 
     def test_make_log_arguments
-      l = Logger.new
       assert_equal([Logger::Severity::FATAL],
-                   l.make_log_arguments('log_fatal'))
+                   @l.make_log_arguments('fatal'))
       assert_equal([Logger::Severity::ERROR],
-                   l.make_log_arguments('log_erROr'))
-      assert_raises(NameError) { l.make_log_arguments('log_foo') }
+                   @l.make_log_arguments('erROr'))
+      assert_raises(NameError) { @l.make_log_arguments('foo') }
       assert_equal([Logger::Severity::WARN, 'all', 'goo', 'foo', 'baz'],
-                   l.make_log_arguments('log_warN_all_goo_foo_baz'))
+                   @l.make_log_arguments('warN_all_goo_foo_baz'))
     end
 
     def test_sugar
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l.section_tree.push(Logger::SectionNode.new('foo'),
+      @l.section_tree.push(Logger::SectionNode.new('foo'),
                           Logger::SectionNode.new('bar',
                                             Logger::SectionNode.new('baz'),
                                             Logger::SectionNode.new('goo')))
       %w(all foo bar baz goo).each do |s|
-        assert(! l.active_section?(s), "section active #{s}")
+        assert(! @l.active_section?(s), "section active #{s}")
       end
-      l.active_section(true, 'foo', 'baz')
+      @l.active_section(true, 'foo', 'baz')
       expected_section = %w(all foo bar baz)
       expected_section.each do |s|
-        assert(l.active_section?(s), "section not active #{s}")
+        assert(@l.active_section?(s), "section not active #{s}")
       end
-      l.severity_level = Logger::Severity::WARN
-      l.verbosity_level = 2
-      l.log_error_foo_baz{'foo'}
+      @l.severity_level = Logger::Severity::WARN
+      @l.verbosity_level = 2
+      @l.error_foo_baz{'foo'}
       assert_equal([
-                     [:new_node, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:severity_level, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:severity_level, :map]],
+                     [:new_node, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:severity_level, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:severity_level, :map]],
                         'ERROR'],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:sections, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:sections, :map]],
+                     [:up, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:sections, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:sections, :map]],
                         ['foo', 'baz']],
-                     [:up, [[:log_0, :map]]],
-                     [:new_node, [[:log_0, :map], [:message, :map]]],
-                     [:new_leaf, [[:log_0, :map], [:message, :map]], 'foo'],
-                     [:up, [[:log_0, :map]]],
+                     [:up, [[:ERROR, :map]]],
+                     [:new_node, [[:ERROR, :map], [:message, :map]]],
+                     [:new_leaf, [[:ERROR, :map], [:message, :map]], 'foo'],
+                     [:up, [[:ERROR, :map]]],
                      [:up, []]
-                   ], mo.args)
-      mo.args.clear
+                   ], @mo.args)
+      @mo.args.clear
     end
 
     def test_severity_level_writer
-      l = Logger.new
       high_bad_value = Logger::Severity.higher + 1
-      assert_raises(ArgumentError) { l.severity_level = high_bad_value }
+      assert_raises(ArgumentError) { @l.severity_level = high_bad_value }
       low_bad_value = Logger::Severity.lower - 1
-      assert_raises(ArgumentError) { l.severity_level = low_bad_value }
+      assert_raises(ArgumentError) { @l.severity_level = low_bad_value }
       good_value = Logger::Severity.lower + 1
-      assert_nothing_raised { l.severity_level = good_value }
-      assert_equal(good_value, l.severity_level)
-      assert_raises(NameError) { l.severity_level = 'toto' }
-      assert_nothing_raised { l.severity_level = 'warn' }
-      assert_equal(Logger::Severity::WARN, l.severity_level)
+      assert_nothing_raised { @l.severity_level = good_value }
+      assert_equal(good_value, @l.severity_level)
+      assert_raises(NameError) { @l.severity_level = 'toto' }
+      assert_nothing_raised { @l.severity_level = 'warn' }
+      assert_equal(Logger::Severity::WARN, @l.severity_level)
     end
 
     def test_log_complex_structure
@@ -280,16 +275,13 @@ module TTK
           [:up, []]
         ]
 
-      mo = MockObsv.new
-      l = Logger.new(mo)
-      l << in_ref
+      @l << in_ref
 
-      assert_equal(out_ref, mo.args)
+      assert_equal(out_ref, @mo.args)
     end
 
   end # class LoggerTest
 
 end # module TTK
 
-Test::Unit::UI::Yaml::TestRunner.run(TTK::LoggerTest)
-
+end