redcar 0.2.9dev

data/lib/logging/test/test_consolidate.rb

@@ -0,0 +1,46 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestConsolidate < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_root
+      Logging.consolidate :root
+      root = Logging.logger.root
+
+      assert_same root, Logging.logger['Foo']
+      assert_same root, Logging.logger['Foo::Bar']
+      assert_same root, Logging.logger[Array]
+    end
+
+    def test_foo
+      Logging.consolidate 'Foo'
+      logger = Logging.logger['Foo::Bar::Baz']
+
+      assert_same Logging.logger['Foo'], logger
+      assert_not_same Logging.logger.root, logger
+    end
+
+    def test_many
+      Logging.consolidate 'Foo', 'root', 'Foo::Bar::Baz'
+
+      root = Logging.logger.root
+      foo = Logging.logger['Foo']
+      fbb = Logging.logger['Foo::Bar::Baz']
+
+      assert_not_same root, foo
+      assert_not_same root, fbb
+      assert_not_same foo, fbb
+
+      assert_same root, Logging.logger[Hash]
+      assert_same root, Logging.logger['ActiveRecord::Base']
+      assert_same foo, Logging.logger['Foo::Bar']
+      assert_same fbb, Logging.logger['Foo::Bar::Baz::Buz']
+    end
+
+  end  # class TestConsolidate
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_layout.rb

@@ -0,0 +1,110 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLayout < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = ::Logging::Layout.new
+    end
+
+    def test_header
+      assert_equal '', @layout.header
+    end
+
+    def test_initialize
+      obj_format = lambda {|l| l.instance_variable_get :@obj_format}
+
+      assert_equal :string, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new 'format_as' => 'blah'
+      assert_equal :string, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new :format_as => :inspect
+      assert_equal :inspect, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new 'format_as' => :yaml
+      assert_equal :yaml, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new
+      assert_equal :string, obj_format[@layout]
+
+      ::Logging.format_as :yaml
+      @layout = ::Logging::Layout.new
+      assert_equal :yaml, obj_format[@layout]
+    end
+
+    def test_footer
+      assert_equal '', @layout.footer
+    end
+
+    def test_format
+      assert_nil @layout.format(::Logging::LogEvent.new('a','b','c',false))
+    end
+
+    def test_format_obj
+      obj = 'test string'
+      r = @layout.format_obj obj
+      assert_same obj, r
+
+      obj = RuntimeError.new
+      r = @layout.format_obj obj
+      assert_equal '<RuntimeError> RuntimeError', r
+
+      obj = TypeError.new 'only works with Integers'
+      r = @layout.format_obj obj
+      assert_equal '<TypeError> only works with Integers', r
+
+      obj = Exception.new 'some exception'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<Exception> some exception\n\tthis\n\tis\n\tthe\n\tbacktrace"
+      assert_equal obj, r
+
+      obj = [1, 2, 3, 4]
+      r = @layout.format_obj obj
+      assert_equal "<Array> #{[1,2,3,4]}", r
+
+      obj = %w( one two three four )
+      @layout = ::Logging::Layout.new :format_as => :inspect
+      r = @layout.format_obj obj
+      assert_equal '<Array> ["one", "two", "three", "four"]', r
+
+      @layout = ::Logging::Layout.new :format_as => :yaml
+      r = @layout.format_obj obj
+      assert_equal "<Array> \n--- \n- one\n- two\n- three\n- four\n", r
+      
+      r = @layout.format_obj Class
+      assert_equal "<Class> Class", r
+    end
+
+    def test_format_obj_without_backtrace
+      @layout = ::Logging::Layout.new :backtrace => 'off'
+
+      obj = Exception.new 'some exception'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<Exception> some exception"
+      assert_equal obj, r
+
+      ::Logging.backtrace :off
+      @layout = ::Logging::Layout.new
+
+      obj = ArgumentError.new 'wrong type of argument'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<ArgumentError> wrong type of argument"
+      assert_equal obj, r
+    end
+
+    def test_initializer
+      assert_raise(ArgumentError) {::Logging::Layout.new :backtrace => 'foo'}
+    end
+
+  end  # class TestLayout
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_log_event.rb

@@ -0,0 +1,80 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLogEvent < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      @appender = EventAppender.new('test')
+      @logger = ::Logging::Logger['TestLogger']
+      @logger.add_appenders @appender
+
+      @logger.info 'message 1'
+      @event = @appender.event
+    end
+
+    def test_data
+      assert_equal 'message 1', @event.data
+    end
+
+    def test_data_eq
+      @event.data = 'message 2'
+      assert_equal 'message 2', @event.data
+    end
+
+    def test_file
+      assert_equal '', @event.file
+
+      @logger.trace = true
+      @logger.warn 'warning message'
+      assert_match %r/test_log_event.rb\z/, @appender.event.file
+    end
+
+    def test_level
+      assert_equal 1, @event.level
+    end
+
+    def test_level_eq
+      @event.level = 3
+      assert_equal 3, @event.level
+    end
+
+    def test_line
+      assert_equal '', @event.file
+
+      @logger.trace = true
+      @logger.error 'error message'
+      assert_equal 50, @appender.event.line
+    end
+
+    def test_logger
+      assert_equal 'TestLogger', @event.logger
+    end
+
+    def test_logger_eq
+      @event.logger = 'MyLogger'
+      assert_equal 'MyLogger', @event.logger
+    end
+
+    def test_method
+      assert_equal '', @event.file
+
+      @logger.trace = true
+      @logger.debug 'debug message'
+      assert_equal 'test_method', @appender.event.method
+    end
+
+  end  # class TestLogEvent
+
+  class EventAppender < ::Logging::Appender
+    attr_reader :event
+    def append( event ) @event = event end
+  end
+
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_logger.rb

@@ -0,0 +1,699 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLogger < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      assert_nothing_raised {::Logging::Logger[:test]}
+      assert_equal ::Logging::Logger[:test], ::Logging::Logger['test']
+      assert_nothing_raised {::Logging::Logger.new(Object)}
+    end
+
+    def test_add
+      root = ::Logging::Logger[:root]
+      root.level = 'info'
+
+      a1 = ::Logging::Appenders::StringIo.new 'a1'
+      a2 = ::Logging::Appenders::StringIo.new 'a2'
+      log = ::Logging::Logger.new 'A Logger'
+
+      root.add_appenders a1
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add(0, 'this should NOT be logged')
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add(1, 'this should be logged')
+      assert_equal " INFO  A Logger : this should be logged\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add(2,[1,2,3,4])
+      assert_equal " WARN  A Logger : <Array> #{[1,2,3,4]}\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a2
+      log.add(3, 'an error has occurred')
+      assert_equal "ERROR  A Logger : an error has occurred\n", a1.readline
+      assert_equal "ERROR  A Logger : an error has occurred\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.additive = false
+      log.add(3, 'another error has occurred')
+      assert_equal "ERROR  A Logger : another error has occurred\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a1
+      log.add(4, 'fatal exception')
+      assert_equal "FATAL  A Logger : fatal exception\n", a1.readline
+      assert_equal "FATAL  A Logger : fatal exception\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+
+      log.level = :warn
+      log.add(2) do
+        str = 'a string of data'
+        str
+      end
+      assert_equal " WARN  A Logger : a string of data\n", a1.readline
+      assert_equal " WARN  A Logger : a string of data\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add(1) do
+        rb_raise(RuntimeError, "this block should not be executed")
+      end
+      assert_nil a1.readline
+      assert_nil a2.readline
+    end
+
+    def test_add_appenders
+      log = ::Logging::Logger.new 'A'
+
+      appenders = lambda {log.instance_variable_get :@appenders}
+      assert_equal [], appenders[]
+
+      assert_raise(ArgumentError) {log.add_appenders Object.new}
+      assert_raise(ArgumentError) {log.add_appenders 'not an appender'}
+
+      a = ::Logging::Appender.new 'test_appender_1'
+      b = ::Logging::Appender.new 'test_appender_2'
+      c = ::Logging::Appender.new 'test_appender_3'
+
+      log.add_appenders a
+      assert_equal [a], appenders[]
+
+      log.add_appenders a
+      assert_equal [a], appenders[]
+
+      log.add_appenders b
+      assert_equal [a,b], appenders[]
+
+      log.add_appenders c
+      assert_equal [a,b,c], appenders[]
+
+      log.add_appenders a, c
+      assert_equal [a,b,c], appenders[]
+
+      log.clear_appenders
+      assert_equal [], appenders[]
+
+      log.add_appenders a, c
+      assert_equal [a,c], appenders[]
+    end
+
+    def test_additive
+      root = ::Logging::Logger.new :root
+      log  = ::Logging::Logger.new 'A'
+
+      assert_raise(NoMethodError) {root.additive}
+      assert_equal true, log.additive
+    end
+
+    def test_additive_eq
+      root = ::Logging::Logger.new :root
+      log  = ::Logging::Logger.new 'A'
+
+      assert_raise(NoMethodError) {root.additive = false}
+      assert_equal true, log.additive
+
+      log.additive = false
+      assert_equal false, log.additive
+
+      log.additive = true
+      assert_equal true, log.additive
+
+      log.additive = 'false'
+      assert_equal false, log.additive
+
+      log.additive = 'true'
+      assert_equal true, log.additive
+
+      log.additive = nil
+      assert_equal true, log.additive
+
+      assert_raise(ArgumentError) {log.additive = Object}
+    end
+
+    def test_appenders_eq
+      log = ::Logging::Logger.new '42'
+
+      appenders = lambda {log.instance_variable_get :@appenders}
+      assert_equal [], appenders[]
+
+      assert_raise(ArgumentError) {log.appenders = Object.new}
+      assert_raise(ArgumentError) {log.appenders = 'not an appender'}
+
+      a = ::Logging::Appender.new 'test_appender_1'
+      b = ::Logging::Appender.new 'test_appender_2'
+      c = ::Logging::Appender.new 'test_appender_3'
+
+      log.appenders = a, b, c
+      assert_equal [a, b, c], appenders[]
+
+      log.appenders = b
+      assert_equal [b], appenders[]
+
+      log.appenders = c, a, b
+      assert_equal [c,a,b], appenders[]
+
+      log.appenders = nil
+      assert_equal [], appenders[]
+
+      log.appenders = %w[test_appender_1 test_appender_3]
+      assert_equal [a,c], appenders[]
+
+      assert_raise(ArgumentError) {log.appenders = 'unknown'}
+    end
+
+    def test_class_aref
+      root = ::Logging::Logger[:root]
+      assert_same root, ::Logging::Logger[:root]
+
+      a = []
+      assert_same ::Logging::Logger['Array'], ::Logging::Logger[Array]
+      assert_same ::Logging::Logger['Array'], ::Logging::Logger[a]
+
+      assert_not_same ::Logging::Logger['Array'], ::Logging::Logger[:root]
+      assert_not_same ::Logging::Logger['A'], ::Logging::Logger['A::B']
+    end
+
+    def test_class_root
+      root = ::Logging::Logger[:root]
+      assert_same root, ::Logging::Logger.root
+    end
+
+    def test_clear_appenders
+      log  = ::Logging::Logger.new 'Elliott'
+
+      appenders = lambda {log.instance_variable_get :@appenders}
+      assert_equal [], appenders[]
+
+      a = ::Logging::Appender.new 'test_appender_1'
+      b = ::Logging::Appender.new 'test_appender_2'
+      c = ::Logging::Appender.new 'test_appender_3'
+
+      log.add_appenders a, b, c
+      assert_equal [a,b,c], appenders[]
+
+      log.clear_appenders
+      assert_equal [], appenders[]
+    end
+
+    def test_concat
+      a1 = ::Logging::Appenders::StringIo.new 'a1'
+      a2 = ::Logging::Appenders::StringIo.new 'a2'
+      log = ::Logging::Logger.new 'A'
+
+      ::Logging::Logger[:root].add_appenders a1
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log << "this is line one of the log file\n"
+      assert_equal "this is line one of the log file\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log << "this is line two of the log file\n"
+      log << "this is line three of the log file\n"
+      assert_equal "this is line two of the log file\n", a1.readline
+      assert_equal "this is line three of the log file\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a2
+      log << "this is line four of the log file\n"
+      assert_equal "this is line four of the log file\n", a1.readline
+      assert_equal "this is line four of the log file\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.additive = false
+      log << "this is line five of the log file\n"
+      assert_equal "this is line five of the log file\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a1
+      log << "this is line six of the log file\n"
+      assert_equal "this is line six of the log file\n", a1.readline
+      assert_equal "this is line six of the log file\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+    end
+
+    def test_inspect
+      root = ::Logging::Logger.new :root
+
+      str = "<#{root.class.name}:0x%x name=\"#{root.name}\">" % root.object_id
+      assert_equal str, root.inspect
+    end
+
+    def test_level
+      root = ::Logging::Logger.new :root
+      log  = ::Logging::Logger.new 'A'
+
+      assert_equal 0, root.level
+      assert_equal 0, log.level
+
+      root.level = :warn
+      assert_equal 2, root.level
+      assert_equal 2, log.level
+
+      log.level = nil
+      assert_equal 2, root.level
+      assert_equal 2, log.level
+
+      log.level = :error
+      assert_equal 2, root.level
+      assert_equal 3, log.level
+    end
+
+    def test_level_eq
+      root = ::Logging::Logger.new :root
+      log  = ::Logging::Logger.new 'A'
+      logb = ::Logging::Logger.new 'A::B'
+
+      assert_equal 0, root.level
+      assert_equal 0, log.level
+      assert_equal 0, logb.level
+      assert_equal true, root.debug?
+      assert_equal true, log.debug?
+      assert_equal true, logb.debug?
+
+      assert_raise(ArgumentError) {root.level = -1}
+      assert_raise(ArgumentError) {root.level =  6}
+      assert_raise(ArgumentError) {root.level = Object}
+      assert_raise(ArgumentError) {root.level = 'bob'}
+      assert_raise(ArgumentError) {root.level = :wtf}
+
+      root.level = 'INFO'
+      assert_equal 1, root.level
+      assert_equal 1, log.level
+      assert_equal 1, logb.level
+      assert_equal false, root.debug?
+      assert_equal true,  root.info?
+      assert_equal false, log.debug?
+      assert_equal true , log.info?
+      assert_equal false, logb.debug?
+      assert_equal true , logb.info?
+
+      root.level = :warn
+      assert_equal 2, root.level
+      assert_equal 2, log.level
+      assert_equal 2, logb.level
+      assert_equal false, root.info?
+      assert_equal true,  root.warn?
+      assert_equal false, log.info?
+      assert_equal true , log.warn?
+      assert_equal false, logb.info?
+      assert_equal true , logb.warn?
+
+      root.level = 'error'
+      assert_equal 3, root.level
+      assert_equal 3, log.level
+      assert_equal 3, logb.level
+      assert_equal false, root.warn?
+      assert_equal true,  root.error?
+      assert_equal false, log.warn?
+      assert_equal true , log.error?
+      assert_equal false, logb.warn?
+      assert_equal true , logb.error?
+
+      root.level = 4
+      assert_equal 4, root.level
+      assert_equal 4, log.level
+      assert_equal 4, logb.level
+      assert_equal false, root.error?
+      assert_equal true,  root.fatal?
+      assert_equal false, log.error?
+      assert_equal true , log.fatal?
+      assert_equal false, logb.error?
+      assert_equal true , logb.fatal?
+
+      log.level = nil
+      assert_equal 4, root.level
+      assert_equal 4, log.level
+      assert_equal 4, logb.level
+      assert_equal false, root.error?
+      assert_equal true,  root.fatal?
+      assert_equal false, log.error?
+      assert_equal true , log.fatal?
+      assert_equal false, logb.error?
+      assert_equal true , logb.fatal?
+
+      log.level = :DEBUG
+      assert_equal 4, root.level
+      assert_equal 0, log.level
+      assert_equal 0, logb.level
+      assert_equal false, root.error?
+      assert_equal true,  root.fatal?
+      assert_equal true,  log.debug?
+      assert_equal true,  logb.debug?
+
+      log.level = :off
+      assert_equal 4, root.level
+      assert_equal 5, log.level
+      assert_equal 5, logb.level
+      assert_equal false, root.error?
+      assert_equal true,  root.fatal?
+      assert_equal false, log.fatal?
+      assert_equal false, logb.fatal?
+
+      root.level = :all
+      assert_equal 0, root.level
+      assert_equal 5, log.level
+      assert_equal 5, logb.level
+      assert_equal true,  root.debug?
+      assert_equal false, log.fatal?
+      assert_equal false, logb.fatal?
+
+      log.level = nil
+      assert_equal 0, root.level
+      assert_equal 0, log.level
+      assert_equal 0, logb.level
+      assert_equal true,  root.debug?
+      assert_equal true,  log.debug?
+      assert_equal true,  logb.debug?
+
+      logb.level = :warn
+      assert_equal 0, root.level
+      assert_equal 0, log.level
+      assert_equal 2, logb.level
+      assert_equal true,  root.debug?
+      assert_equal true,  log.debug?
+      assert_equal false, logb.info?
+      assert_equal true,  logb.warn?
+
+      log.level  = :info
+      logb.level = nil
+      assert_equal 0, root.level
+      assert_equal 1, log.level
+      assert_equal 1, logb.level
+      assert_equal true,  root.debug?
+      assert_equal false, logb.debug?
+      assert_equal true,  log.info?
+      assert_equal false, logb.debug?
+      assert_equal true,  logb.info?
+    end
+
+    def test_log
+      root = ::Logging::Logger[:root]
+      root.level = 'info'
+
+      a1 = ::Logging::Appenders::StringIo.new 'a1'
+      a2 = ::Logging::Appenders::StringIo.new 'a2'
+      log = ::Logging::Logger.new 'A Logger'
+
+      root.add_appenders a1
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.debug 'this should NOT be logged'
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.info 'this should be logged'
+      assert_equal " INFO  A Logger : this should be logged\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.warn [1,2,3,4]
+      assert_equal " WARN  A Logger : <Array> #{[1,2,3,4]}\n", a1.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a2
+      log.error 'an error has occurred'
+      assert_equal "ERROR  A Logger : an error has occurred\n", a1.readline
+      assert_equal "ERROR  A Logger : an error has occurred\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.additive = false
+      log.error 'another error has occurred'
+      assert_equal "ERROR  A Logger : another error has occurred\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.add_appenders a1
+      log.fatal 'fatal exception'
+      assert_equal "FATAL  A Logger : fatal exception\n", a1.readline
+      assert_equal "FATAL  A Logger : fatal exception\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      assert_equal false, log.debug
+      assert_equal true, log.info
+      assert_equal " INFO  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal " INFO  A Logger : <NilClass> nil\n", a2.readline
+      assert_equal true, log.warn
+      assert_equal " WARN  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal " WARN  A Logger : <NilClass> nil\n", a2.readline
+      assert_equal true, log.error
+      assert_equal "ERROR  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal "ERROR  A Logger : <NilClass> nil\n", a2.readline
+      assert_equal true, log.fatal
+      assert_equal "FATAL  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal "FATAL  A Logger : <NilClass> nil\n", a2.readline
+
+      log.level = :warn
+      assert_equal false, log.debug
+      assert_equal false, log.info
+      assert_equal true, log.warn
+      assert_equal " WARN  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal " WARN  A Logger : <NilClass> nil\n", a2.readline
+      assert_equal true, log.error
+      assert_equal "ERROR  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal "ERROR  A Logger : <NilClass> nil\n", a2.readline
+      assert_equal true, log.fatal
+      assert_equal "FATAL  A Logger : <NilClass> nil\n", a1.readline
+      assert_equal "FATAL  A Logger : <NilClass> nil\n", a2.readline
+
+      assert_raise(NoMethodError) {log.critical 'this log level does not exist'}
+
+      log.warn do
+        str = 'a string of data'
+        str
+      end
+      assert_equal " WARN  A Logger : a string of data\n", a1.readline
+      assert_equal " WARN  A Logger : a string of data\n", a2.readline
+      assert_nil a1.readline
+      assert_nil a2.readline
+
+      log.info do
+        rb_raise(RuntimeError, "this block should not be executed")
+      end
+      assert_nil a1.readline
+      assert_nil a2.readline
+    end
+
+    def test_log_eh
+      ::Logging::Logger[:root].level = 'info'
+      log = ::Logging::Logger['A Logger']
+
+      assert_equal false, log.debug?
+      assert_equal true, log.info?
+      assert_equal true, log.warn?
+      assert_equal true, log.error?
+      assert_equal true, log.fatal?
+
+      log.level = :warn
+      assert_equal false, log.debug?
+      assert_equal false, log.info?
+      assert_equal true, log.warn?
+      assert_equal true, log.error?
+      assert_equal true, log.fatal?
+
+      assert_raise(NoMethodError) do
+        log.critical? 'this log level does not exist'
+      end
+    end
+
+    def test_name
+      root = ::Logging::Logger.new :root
+      log  = ::Logging::Logger.new 'A'
+
+      assert_equal 'root', root.name
+      assert_equal 'A', log.name
+    end
+
+    def test_parent
+      logger = ::Logging::Logger
+      root = logger.new :root
+
+      assert_raise(NoMethodError) {root.parent}
+
+      assert_same root, logger['A'].parent
+      assert_same logger['A'], logger['A::B'].parent
+      assert_same logger['A::B'], logger['A::B::C::D'].parent
+      assert_same logger['A::B'], logger['A::B::C::E'].parent
+      assert_same logger['A::B'], logger['A::B::C::F'].parent
+
+      assert_same logger['A::B'], logger['A::B::C'].parent
+      assert_same logger['A::B::C'], logger['A::B::C::D'].parent
+      assert_same logger['A::B::C'], logger['A::B::C::E'].parent
+      assert_same logger['A::B::C'], logger['A::B::C::F'].parent
+
+      assert_same logger['A::B::C::E'], logger['A::B::C::E::G'].parent
+    end
+
+    def test_remove_appenders
+      log = ::Logging::Logger['X']
+
+      appenders = lambda {log.instance_variable_get :@appenders}
+      assert_equal [], appenders[]
+
+      a = ::Logging::Appender.new 'test_appender_1'
+      b = ::Logging::Appender.new 'test_appender_2'
+      c = ::Logging::Appender.new 'test_appender_3'
+
+      log.add_appenders a, b, c
+      assert_equal [a,b,c], appenders[]
+
+      assert_raise(ArgumentError) {log.remove_appenders Object.new}
+      assert_raise(ArgumentError) {log.remove_appenders 10}
+
+      log.remove_appenders b
+      assert_equal [a,c], appenders[]
+
+      log.remove_appenders 'test_appender_1'
+      assert_equal [c], appenders[]
+
+      log.remove_appenders c
+      assert_equal [], appenders[]
+
+      log.remove_appenders a, b, c
+      assert_equal [], appenders[]
+
+      log.add_appenders a, b, c
+      assert_equal [a,b,c], appenders[]
+
+      log.remove_appenders a, c
+      assert_equal [b], appenders[]
+    end
+
+    def test_spaceship
+      logs = %w(
+        A  A::B  A::B::C  A::B::C::D  A::B::C::E  A::B::C::E::G  A::B::C::F
+      ).map {|x| ::Logging::Logger[x]}
+      logs.unshift ::Logging::Logger[:root]
+
+      logs.inject do |a,b|
+        assert_equal(-1, a <=> b, "'#{a.name}' <=> '#{b.name}'")
+        b
+      end
+
+      assert_equal 1, logs[1] <=> ::Logging::Logger[:root]
+      assert_raise(ArgumentError) {logs[1] <=> Object.new}
+      assert_raise(ArgumentError) {::Logging::Logger[:root] <=> 'string'}
+    end
+
+    def test_trace
+      log = ::Logging::Logger[:root]
+      assert_equal false, log.trace
+
+      log.trace = true
+      assert_equal true, log.trace
+
+      log = ::Logging::Logger['A']
+      assert_equal false, log.trace
+
+      log.trace = true
+      assert_equal true, log.trace
+    end
+
+    def test_trace_eq
+      log = ::Logging::Logger.new 'A'
+      assert_equal false, log.trace
+
+      log.trace = true
+      assert_equal true, log.trace
+
+      log.trace = false
+      assert_equal false, log.trace
+
+      log.trace = 'true'
+      assert_equal true, log.trace
+
+      log.trace = 'false'
+      assert_equal false, log.trace
+
+      log.trace = nil
+      assert_equal false, log.trace
+
+      assert_raise(ArgumentError) {log.trace = Object}
+    end
+
+    def test_dump_configuration
+      log_a = ::Logging::Logger['A-logger']
+      log_b = ::Logging::Logger['A-logger::B-logger']
+      log_c = ::Logging::Logger['A-logger::B-logger::C-logger']
+      log_d = ::Logging::Logger['A-logger::D-logger']
+
+      sio = StringIO.new
+      sio.extend ::Logging::Appenders::StringIo::IoToS
+
+      log_a._dump_configuration( sio )
+      assert_equal(
+        "A-logger  ........................................   debug  +A  -T\n", sio.to_s)
+
+      log_b._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger  ..............................   debug  +A  -T\n", sio.to_s)
+
+      log_c._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger::C-logger  ....................   debug  +A  -T\n", sio.to_s)
+
+      log_d._dump_configuration( sio )
+      assert_equal(
+        "A-logger::D-logger  ..............................   debug  +A  -T\n", sio.to_s)
+
+      log_b.level = :warn
+      log_b.trace = true
+      log_b._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger  ..............................   *warn  +A  +T\n", sio.to_s)
+
+      log_c.additive = false
+      log_c._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger::C-logger  ....................    warn  -A  -T\n", sio.to_s)
+
+      # with an indent specified
+      log_a._dump_configuration( sio, 4 )
+      assert_equal(
+        "    A-logger  ....................................   debug  +A  -T\n", sio.to_s)
+
+      log_b._dump_configuration( sio, 8 )
+      assert_equal(
+        "        A-logger::B-logger  ......................   *warn  +A  +T\n", sio.to_s)
+
+      log_c._dump_configuration( sio, 10 )
+      assert_equal(
+        "          A-logger::B-logger::C-logger  ..........    warn  -A  -T\n", sio.to_s)
+
+      log_d._dump_configuration( sio, 22 )
+      assert_equal(
+        "                      A-logger::D-logger  ........   debug  +A  -T\n", sio.to_s)
+
+      log_c.level = 0
+      log_c._dump_configuration( sio, 26 )
+      assert_equal(
+        "                          A-logger::B...::C-logger  *debug  -A  -T\n", sio.to_s)
+    end
+
+  end  # class TestLogger
+end  # module TestLogging
+
+# EOF