TwP-logging 0.9.7

data/test/setup.rb

@@ -0,0 +1,74 @@
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? LOGGING_TEST_SETUP
+LOGGING_TEST_SETUP = true
+
+require 'rubygems'
+require 'test/unit'
+require 'fileutils'
+require 'stringio'
+begin
+  require 'turn'
+rescue LoadError; end
+
+# This line is needed for Ruby 1.9 -- hashes throw a "KeyError" in 1.9
+# whereas they throw an "IndexError" in 1.8
+#
+KeyError = IndexError if not defined? KeyError
+
+require File.join(File.dirname(__FILE__), %w[.. lib logging])
+
+
+module TestLogging
+module LoggingTestCase
+
+  TMP = 'tmp'
+
+  def setup
+    super
+
+    FileUtils.rm_rf TMP
+    FileUtils.mkdir TMP
+
+    ::Logging.module_eval do
+      ::Logging::LEVELS.clear
+      ::Logging::LNAMES.clear
+      remove_const :MAX_LEVEL_LENGTH if const_defined? :MAX_LEVEL_LENGTH
+      remove_const :OBJ_FORMAT if const_defined? :OBJ_FORMAT
+    end
+
+    ::Logging::Repository.class_eval do
+      if defined?(@singleton__instance__)
+        @singleton__instance__ = nil
+      else
+        @__instance__ = nil
+        class << self
+          nonce = class << Singleton; self; end
+          if defined?(nonce::FirstInstanceCall)
+            define_method(:instance, nonce::FirstInstanceCall)
+          else
+            remove_method(:instance)
+            Singleton.__init__(::Logging::Repository)
+          end
+        end
+      end
+    end
+  end
+    
+  def teardown
+    super
+    ::Logging.backtrace
+    ::Logging.__send__(:remove_instance_variable, :@backtrace)
+    h = ::Logging::Appender.instance_variable_get(:@appenders)
+    h.each_value {|a| a.close(false) unless a.nil? || a.closed?}
+    h.clear
+    FileUtils.rm_rf TMP
+  end
+
+end  # module LoggingTestCase
+end  # module TestLogging
+
+end  # unless defined?
+
+# EOF

data/test/test_appender.rb

@@ -0,0 +1,166 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestAppender < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+      @event = ::Logging::LogEvent.new('logger', @levels['debug'],
+                                       'message', false)
+      @appender = ::Logging::Appender.new 'test_appender'
+    end
+
+    def test_append
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender.append @event}
+      assert_equal "DEBUG  logger : message\n", ary.pop
+
+      @appender.level = :info
+      @appender.append @event
+      assert_nil ary.pop
+
+      @event.level = @levels['info']
+      @appender.append @event
+      assert_equal " INFO  logger : message\n", ary.pop
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append @event}
+    end
+
+    def test_class_stderr
+      stderr = ::Logging::Appender.stderr
+      assert_instance_of ::Logging::Appenders::Stderr, stderr
+      assert_equal 'stderr', stderr.name
+      assert_same stderr, ::Logging::Appender.stderr
+    end
+
+    def test_class_stdout
+      stdout = ::Logging::Appender.stdout
+      assert_instance_of ::Logging::Appenders::Stdout, stdout
+      assert_equal 'stdout', stdout.name
+      assert_same stdout, ::Logging::Appender.stdout
+    end
+
+    def test_close
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_closed_eh
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_concat
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender << 'log message'}
+      assert_equal 'log message', ary.pop
+
+      @appender.level = :off
+      @appender << 'another log message'
+      assert_nil ary.pop
+
+      layout = @appender.layout
+      def layout.footer() 'this is the footer' end
+
+      @appender.close
+      assert_raise(RuntimeError)  {@appender << 'log message'}
+      assert_equal 'this is the footer', ary.pop
+    end
+
+    def test_flush
+      assert_same @appender, @appender.flush
+    end
+
+    def test_initialize
+      assert_raise(TypeError) {::Logging::Appender.new 'test', :layout => []}
+
+      layout = ::Logging::Layouts::Basic.new
+      @appender = ::Logging::Appender.new 'test', :layout => layout
+      assert_same layout, @appender.instance_variable_get(:@layout)
+    end
+
+    def test_layout
+      assert_instance_of ::Logging::Layouts::Basic, @appender.layout
+    end
+
+    def test_layout_eq
+      layout = ::Logging::Layouts::Basic.new
+      assert_not_equal layout, @appender.layout
+
+      assert_raise(TypeError) {@appender.layout = Object.new}
+      assert_raise(TypeError) {@appender.layout = 'not a layout'}
+
+      @appender.layout = layout
+      assert_same layout, @appender.layout
+    end
+
+    def test_level
+      assert_equal 0, @appender.level
+    end
+
+    def test_level_eq
+      assert_equal 0, @appender.level
+
+      assert_raise(ArgumentError) {@appender.level = -1}
+      assert_raise(ArgumentError) {@appender.level =  6}
+      assert_raise(ArgumentError) {@appender.level = Object}
+      assert_raise(ArgumentError) {@appender.level = 'bob'}
+      assert_raise(ArgumentError) {@appender.level = :wtf}
+
+      @appender.level = 'INFO'
+      assert_equal 1, @appender.level
+
+      @appender.level = :warn
+      assert_equal 2, @appender.level
+
+      @appender.level = 'error'
+      assert_equal 3, @appender.level
+
+      @appender.level = 4
+      assert_equal 4, @appender.level
+
+      @appender.level = 'off'
+      assert_equal 5, @appender.level
+
+      @appender.level = :all
+      assert_equal 0, @appender.level
+    end
+
+    def test_name
+      assert_equal 'test_appender', @appender.name
+    end
+
+    def test_inspect
+      expected = "<Appender:0x%x name=\"test_appender\">" % @appender.object_id
+      assert_equal expected, @appender.inspect
+    end
+
+  end  # class TestAppender
+end  # module TestLogging
+
+# EOF

data/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/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_match %r/\d+/, @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/test/test_logger.rb

@@ -0,0 +1,734 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLogger < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+    end
+
+    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 = SioAppender.new 'a1'
+      a2 = SioAppender.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 = SioAppender.new 'a1'
+      a2 = SioAppender.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 = SioAppender.new 'a1'
+      a2 = SioAppender.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
+
+      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
+
+  class SioAppender < ::Logging::Appenders::IO
+
+    def initialize( name, opts = {} )
+      @sio = StringIO.new
+      super(name, @sio, opts)
+      begin readline rescue EOFError end
+    end
+
+    def readline
+      @pos ||= 0
+      @sio.seek @pos
+      begin
+        line = @sio.readline
+        @pos = @sio.tell
+        line
+      rescue EOFError
+        nil
+      end
+    end
+
+  end  # class SioAppender
+
+end  # module TestLogging
+
+class StringIO
+  def to_s
+    seek 0
+    str = read
+    seek 0
+    return str
+  end
+end
+
+# EOF