mono_logger 1.1.0 → 1.1.1

data/lib/mono_logger/version.rb

@@ -1,5 +1,5 @@
-require 'logger'
-
-class MonoLogger < Logger
-  VERSION = "1.1.0"
-end
+require 'logger'
+
+class MonoLogger < Logger
+  VERSION = "1.1.1"
+end

data/mono_logger.gemspec

@@ -1,25 +1,24 @@
-# coding: utf-8
- 
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'mono_logger/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "mono_logger"
-  spec.version       = MonoLogger::VERSION
-  spec.authors       = ["Steve Klabnik"]
-  spec.email         = ["steve@steveklabnik.com"]
-  spec.description   = %q{A lock-free logger compatible with Ruby 2.0. Ruby does not allow you to request a lock in a trap handler because that could deadlock, so Logger is not sufficient.}
-  spec.summary       = %q{A lock-free logger compatible with Ruby 2.0.}
-  spec.homepage      = "http://github.com/steveklabnik/mono_logger"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest", "~> 4.0"
-end
+# coding: utf-8
+ 
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mono_logger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mono_logger"
+  spec.version       = MonoLogger::VERSION
+  spec.authors       = ["Steve Klabnik"]
+  spec.email         = ["steve@steveklabnik.com"]
+  spec.description   = %q{A lock-free logger compatible with Ruby 2.0. Ruby does not allow you to request a lock in a trap handler because that could deadlock, so Logger is not sufficient.}
+  spec.summary       = %q{A lock-free logger compatible with Ruby 2.0.}
+  spec.homepage      = "http://github.com/steveklabnik/mono_logger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/test/mri_logger_test.rb

@@ -1,533 +1,550 @@
-# coding: US-ASCII
-require 'test/unit'
-require 'mono_logger'
-require 'tempfile'
-
-Logger = MonoLogger
-
-
-class TestLoggerSeverity < Test::Unit::TestCase
-  def test_enum
-    logger_levels = Logger.constants
-    levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
-    Logger::Severity.constants.each do |level|
-      assert(levels.include?(level.to_s))
-      assert(logger_levels.include?(level))
-    end
-    assert_equal(levels.size, Logger::Severity.constants.size)
-  end
-end
-
-
-class TestLogger < Test::Unit::TestCase
-  include Logger::Severity
-
-  def setup
-    @logger = Logger.new(nil)
-  end
-
-  class Log
-    attr_reader :label, :datetime, :pid, :severity, :progname, :msg
-    def initialize(line)
-      /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
-      @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
-    end
-  end
-
-  def log_add(logger, severity, msg, progname = nil, &block)
-    log(logger, :add, severity, msg, progname, &block)
-  end
-
-  def log(logger, msg_id, *arg, &block)
-    Log.new(log_raw(logger, msg_id, *arg, &block))
-  end
-
-  def log_raw(logger, msg_id, *arg, &block)
-    logdev = Tempfile.new(File.basename(__FILE__) + '.log')
-    logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
-    logger.__send__(msg_id, *arg, &block)
-    logdev.open
-    msg = logdev.read
-    logdev.close
-    msg
-  end
-
-  def test_level
-    @logger.level = UNKNOWN
-    assert_equal(UNKNOWN, @logger.level)
-    @logger.level = INFO
-    assert_equal(INFO, @logger.level)
-    @logger.sev_threshold = ERROR
-    assert_equal(ERROR, @logger.sev_threshold)
-    @logger.sev_threshold = WARN
-    assert_equal(WARN, @logger.sev_threshold)
-    assert_equal(WARN, @logger.level)
-
-    @logger.level = DEBUG
-    assert(@logger.debug?)
-    assert(@logger.info?)
-    @logger.level = INFO
-    assert(!@logger.debug?)
-    assert(@logger.info?)
-    assert(@logger.warn?)
-    @logger.level = WARN
-    assert(!@logger.info?)
-    assert(@logger.warn?)
-    assert(@logger.error?)
-    @logger.level = ERROR
-    assert(!@logger.warn?)
-    assert(@logger.error?)
-    assert(@logger.fatal?)
-    @logger.level = FATAL
-    assert(!@logger.error?)
-    assert(@logger.fatal?)
-    @logger.level = UNKNOWN
-    assert(!@logger.error?)
-    assert(!@logger.fatal?)
-  end
-
-  def test_progname
-    assert_nil(@logger.progname)
-    @logger.progname = "name"
-    assert_equal("name", @logger.progname)
-  end
-
-  def test_datetime_format
-    dummy = STDERR
-    logger = Logger.new(dummy)
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+ $/, log.datetime)
-    logger.datetime_format = "%d%b%Y@%H:%M:%S"
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
-    logger.datetime_format = ""
-    log = log_add(logger, INFO, "foo")
-    assert_match(/^$/, log.datetime)
-  end
-
-  def test_formatter
-    dummy = STDERR
-    logger = Logger.new(dummy)
-    # default
-    log = log(logger, :info, "foo")
-    assert_equal("foo\n", log.msg)
-    # config
-    logger.formatter = proc { |severity, timestamp, progname, msg|
-      "#{severity}:#{msg}\n\n"
-    }
-    line = log_raw(logger, :info, "foo")
-    assert_equal("INFO:foo\n\n", line)
-    # recover
-    logger.formatter = nil
-    log = log(logger, :info, "foo")
-    assert_equal("foo\n", log.msg)
-    # again
-    o = Object.new
-    def o.call(severity, timestamp, progname, msg)
-      "<<#{severity}-#{msg}>>\n"
-    end
-    logger.formatter = o
-    line = log_raw(logger, :info, "foo")
-    assert_equal("<""<INFO-foo>>\n", line)
-  end
-
-  def test_initialize
-    logger = Logger.new(STDERR)
-    assert_nil(logger.progname)
-    assert_equal(DEBUG, logger.level)
-    assert_nil(logger.datetime_format)
-  end
-
-  def test_add
-    logger = Logger.new(nil)
-    logger.progname = "my_progname"
-    assert(logger.add(INFO))
-    log = log_add(logger, nil, "msg")
-    assert_equal("ANY", log.severity)
-    assert_equal("my_progname", log.progname)
-    logger.level = WARN
-    assert(logger.log(INFO))
-    assert_nil(log_add(logger, INFO, "msg").msg)
-    log = log_add(logger, WARN, nil) { "msg" }
-    assert_equal("msg\n", log.msg)
-    log = log_add(logger, WARN, "") { "msg" }
-    assert_equal("\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    log = log_add(logger, WARN, nil, "progname?")
-    assert_equal("progname?\n", log.msg)
-    assert_equal("my_progname", log.progname)
-  end
-
-  def test_level_log
-    logger = Logger.new(nil)
-    logger.progname = "my_progname"
-    log = log(logger, :debug, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("DEBUG", log.severity)
-    assert_equal("D", log.label)
-    #
-    log = log(logger, :debug) { "msg_block" }
-    assert_equal("msg_block\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    log = log(logger, :debug, "msg_inline")
-    assert_equal("msg_inline\n", log.msg)
-    assert_equal("my_progname", log.progname)
-    #
-    log = log(logger, :info, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("INFO", log.severity)
-    assert_equal("I", log.label)
-    #
-    log = log(logger, :warn, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("WARN", log.severity)
-    assert_equal("W", log.label)
-    #
-    log = log(logger, :error, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("ERROR", log.severity)
-    assert_equal("E", log.label)
-    #
-    log = log(logger, :fatal, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("FATAL", log.severity)
-    assert_equal("F", log.label)
-    #
-    log = log(logger, :unknown, "custom_progname") { "msg" }
-    assert_equal("msg\n", log.msg)
-    assert_equal("custom_progname", log.progname)
-    assert_equal("ANY", log.severity)
-    assert_equal("A", log.label)
-  end
-
-  def test_close
-    r, w = IO.pipe
-    assert(!w.closed?)
-    logger = Logger.new(w)
-    logger.close
-    assert(w.closed?)
-    r.close
-  end
-
-  class MyError < StandardError
-  end
-
-  class MyMsg
-    def inspect
-      "my_msg"
-    end
-  end
-
-  def test_format
-    logger = Logger.new(nil)
-    log = log_add(logger, INFO, "msg\n")
-    assert_equal("msg\n\n", log.msg)
-    begin
-      raise MyError.new("excn")
-    rescue MyError => e
-      log = log_add(logger, INFO, e)
-      assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
-      # expects backtrace is dumped across multi lines.  10 might be changed.
-      assert(log.msg.split(/\n/).size >= 10)
-    end
-    log = log_add(logger, INFO, MyMsg.new)
-    assert_equal("my_msg\n", log.msg)
-  end
-
-  def test_lshift
-    r, w = IO.pipe
-    logger = Logger.new(w)
-    logger << "msg"
-    read_ready, = IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg", msg)
-    #
-    r, w = IO.pipe
-    logger = Logger.new(w)
-    logger << "msg2\n\n"
-    read_ready, = IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg2\n\n", msg)
-  end
-end
-
-class TestLogDevice < Test::Unit::TestCase
-  class LogExcnRaiser
-    def write(*arg)
-      raise 'disk is full'
-    end
-
-    def close
-    end
-
-    def stat
-      Object.new
-    end
-  end
-
-  def setup
-    @tempfile = Tempfile.new("logger")
-    @tempfile.close
-    @filename = @tempfile.path
-    File.unlink(@filename)
-  end
-
-  def teardown
-    @tempfile.close(true)
-  end
-
-  def d(log, opt = {})
-    Logger::LogDevice.new(log, opt)
-  end
-
-  def test_initialize
-    logdev = d(STDERR)
-    assert_equal(STDERR, logdev.dev)
-    assert_nil(logdev.filename)
-    assert_raises(TypeError) do
-      d(nil)
-    end
-    #
-    logdev = d(@filename)
-    begin
-      assert(File.exist?(@filename))
-      assert(logdev.dev.sync)
-      assert_equal(@filename, logdev.filename)
-      logdev.write('hello')
-    ensure
-      logdev.close
-    end
-    # create logfile whitch is already exist.
-    logdev = d(@filename)
-    begin
-      logdev.write('world')
-      logfile = File.read(@filename)
-      assert_equal(2, logfile.split(/\n/).size)
-      assert_match(/^helloworld$/, logfile)
-    ensure
-      logdev.close
-    end
-  end
-
-  def test_write
-    r, w = IO.pipe
-    logdev = d(w)
-    logdev.write("msg2\n\n")
-    read_ready, = IO.select([r], nil, nil, 0.1)
-    w.close
-    msg = r.read
-    r.close
-    assert_equal("msg2\n\n", msg)
-    #
-    logdev = d(LogExcnRaiser.new)
-    class << (stderr = '')
-      alias write <<
-    end
-    $stderr, stderr = stderr, $stderr
-    begin
-      assert_nothing_raised do
-        logdev.write('hello')
-      end
-    ensure
-      logdev.close
-      $stderr, stderr = stderr, $stderr
-    end
-    assert_equal "log writing failed. disk is full\n", stderr
-  end
-
-  def test_close
-    r, w = IO.pipe
-    logdev = d(w)
-    logdev.write("msg2\n\n")
-    read_ready, = IO.select([r], nil, nil, 0.1)
-    assert(!w.closed?)
-    logdev.close
-    assert(w.closed?)
-    r.close
-  end
-
-  def test_shifting_size
-    skip("shifting age doesn't work because rotation doesn't work")
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
-    logfile = tmpfile.path
-    logfile0 = logfile + '.0'
-    logfile1 = logfile + '.1'
-    logfile2 = logfile + '.2'
-    logfile3 = logfile + '.3'
-    tmpfile.close(true)
-    File.unlink(logfile) if File.exist?(logfile)
-    File.unlink(logfile0) if File.exist?(logfile0)
-    File.unlink(logfile1) if File.exist?(logfile1)
-    File.unlink(logfile2) if File.exist?(logfile2)
-    logger = Logger.new(logfile, 4, 100)
-    logger.error("0" * 15)
-    assert(File.exist?(logfile))
-    assert(!File.exist?(logfile0))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile0))
-    assert(!File.exist?(logfile1))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile1))
-    assert(!File.exist?(logfile2))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile2))
-    assert(!File.exist?(logfile3))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile3))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile3))
-    logger.close
-    File.unlink(logfile)
-    File.unlink(logfile0)
-    File.unlink(logfile1)
-    File.unlink(logfile2)
-
-    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
-    logfile = tmpfile.path
-    logfile0 = logfile + '.0'
-    logfile1 = logfile + '.1'
-    logfile2 = logfile + '.2'
-    logfile3 = logfile + '.3'
-    tmpfile.close(true)
-    logger = Logger.new(logfile, 4, 150)
-    logger.error("0" * 15)
-    assert(File.exist?(logfile))
-    assert(!File.exist?(logfile0))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile0))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile0))
-    assert(!File.exist?(logfile1))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile1))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile1))
-    assert(!File.exist?(logfile2))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile2))
-    logger.error("0" * 15)
-    assert(File.exist?(logfile2))
-    assert(!File.exist?(logfile3))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile3))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile3))
-    logger.error("0" * 15)
-    assert(!File.exist?(logfile3))
-    logger.close
-    File.unlink(logfile)
-    File.unlink(logfile0)
-    File.unlink(logfile1)
-    File.unlink(logfile2)
-  end
-
-  def test_shifting_age_variants
-    skip("shifting age doesn't work because rotation doesn't work")
-    logger = Logger.new(@filename, 'daily')
-    logger.info('daily')
-    logger.close
-    logger = Logger.new(@filename, 'weekly')
-    logger.info('weekly')
-    logger.close
-    logger = Logger.new(@filename, 'monthly')
-    logger.info('monthly')
-    logger.close
-  end
-
-  def test_shifting_age
-    skip("shifting age doesn't work because rotation doesn't work")
-    # shift_age other than 'daily', 'weekly', and 'monthly' means 'everytime'
-    yyyymmdd = Time.now.strftime("%Y%m%d")
-    filename1 = @filename + ".#{yyyymmdd}"
-    filename2 = @filename + ".#{yyyymmdd}.1"
-    filename3 = @filename + ".#{yyyymmdd}.2"
-    begin
-      logger = Logger.new(@filename, 'now')
-      assert(File.exist?(@filename))
-      assert(!File.exist?(filename1))
-      assert(!File.exist?(filename2))
-      assert(!File.exist?(filename3))
-      logger.info("0" * 15)
-      assert(File.exist?(@filename))
-      assert(File.exist?(filename1))
-      assert(!File.exist?(filename2))
-      assert(!File.exist?(filename3))
-      logger.warn("0" * 15)
-      assert(File.exist?(@filename))
-      assert(File.exist?(filename1))
-      assert(File.exist?(filename2))
-      assert(!File.exist?(filename3))
-      logger.error("0" * 15)
-      assert(File.exist?(@filename))
-      assert(File.exist?(filename1))
-      assert(File.exist?(filename2))
-      assert(File.exist?(filename3))
-    ensure
-      logger.close if logger
-      [filename1, filename2, filename3].each do |filename|
-        File.unlink(filename) if File.exist?(filename)
-      end
-    end
-  end
-end
-
-
-class TestLoggerApplication < Test::Unit::TestCase
-  def setup
-    @app = Logger::Application.new('appname')
-    @tempfile = Tempfile.new("logger")
-    @tempfile.close
-    @filename = @tempfile.path
-    File.unlink(@filename)
-  end
-
-  def teardown
-    @tempfile.close(true)
-  end
-
-  def test_initialize
-    app = Logger::Application.new('appname')
-    assert_equal('appname', app.appname)
-  end
-
-  def test_start
-    @app.set_log(@filename)
-    begin
-      @app.level = Logger::UNKNOWN
-      @app.start # logs FATAL log
-      assert_equal(1, File.read(@filename).split(/\n/).size)
-    ensure
-      @app.logger.close
-    end
-  end
-
-  def test_logger
-    @app.level = Logger::WARN
-    @app.set_log(@filename)
-    begin
-      assert_equal(Logger::WARN, @app.logger.level)
-    ensure
-      @app.logger.close
-    end
-    @app.logger = logger = Logger.new(STDOUT)
-    assert_equal(logger, @app.logger)
-    assert_equal(Logger::WARN, @app.logger.level)
-    @app.log = @filename
-    begin
-      assert(logger != @app.logger)
-      assert_equal(Logger::WARN, @app.logger.level)
-    ensure
-      @app.logger.close
-    end
-  end
-end
-
+# coding: US-ASCII
+require 'simplecov'
+SimpleCov.start do
+  add_filter do |source_file|
+    source_file.filename =~ /test/
+  end
+end
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/autorun'
+require 'mono_logger'
+# Logger::Application was dropped at Ruby 2.2.
+require 'logger-application' unless defined?(Logger::Application)
+require 'tempfile'
+
+if defined? Minitest::Test
+  # We're on Minitest 5+. Nothing to do here.
+else
+  # Minitest 4 doesn't have Minitest::Test yet.
+  Minitest::Test = MiniTest::Unit::TestCase
+end
+
+Logger = MonoLogger
+
+
+class TestLoggerSeverity < Minitest::Test
+  def test_enum
+    logger_levels = Logger.constants
+    levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
+    Logger::Severity.constants.each do |level|
+      assert(levels.include?(level.to_s))
+      assert(logger_levels.include?(level))
+    end
+    assert_equal(levels.size, Logger::Severity.constants.size)
+  end
+end
+
+
+class TestLogger < Minitest::Test
+  include Logger::Severity
+
+  def setup
+    @logger = Logger.new(nil)
+  end
+
+  class Log
+    attr_reader :label, :datetime, :pid, :severity, :progname, :msg
+    def initialize(line)
+      /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
+      @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
+    end
+  end
+
+  def log_add(logger, severity, msg, progname = nil, &block)
+    log(logger, :add, severity, msg, progname, &block)
+  end
+
+  def log(logger, msg_id, *arg, &block)
+    Log.new(log_raw(logger, msg_id, *arg, &block))
+  end
+
+  def log_raw(logger, msg_id, *arg, &block)
+    logdev = Tempfile.new(File.basename(__FILE__) + '.log')
+    logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
+    logger.__send__(msg_id, *arg, &block)
+    logdev.open
+    msg = logdev.read
+    logdev.close
+    msg
+  end
+
+  def test_level
+    @logger.level = UNKNOWN
+    assert_equal(UNKNOWN, @logger.level)
+    @logger.level = INFO
+    assert_equal(INFO, @logger.level)
+    @logger.sev_threshold = ERROR
+    assert_equal(ERROR, @logger.sev_threshold)
+    @logger.sev_threshold = WARN
+    assert_equal(WARN, @logger.sev_threshold)
+    assert_equal(WARN, @logger.level)
+
+    @logger.level = DEBUG
+    assert(@logger.debug?)
+    assert(@logger.info?)
+    @logger.level = INFO
+    assert(!@logger.debug?)
+    assert(@logger.info?)
+    assert(@logger.warn?)
+    @logger.level = WARN
+    assert(!@logger.info?)
+    assert(@logger.warn?)
+    assert(@logger.error?)
+    @logger.level = ERROR
+    assert(!@logger.warn?)
+    assert(@logger.error?)
+    assert(@logger.fatal?)
+    @logger.level = FATAL
+    assert(!@logger.error?)
+    assert(@logger.fatal?)
+    @logger.level = UNKNOWN
+    assert(!@logger.error?)
+    assert(!@logger.fatal?)
+  end
+
+  def test_progname
+    assert_nil(@logger.progname)
+    @logger.progname = "name"
+    assert_equal("name", @logger.progname)
+  end
+
+  def test_datetime_format
+    dummy = STDERR
+    logger = Logger.new(dummy)
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+ $/, log.datetime)
+    logger.datetime_format = "%d%b%Y@%H:%M:%S"
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
+    logger.datetime_format = ""
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^$/, log.datetime)
+  end
+
+  def test_formatter
+    dummy = STDERR
+    logger = Logger.new(dummy)
+    # default
+    log = log(logger, :info, "foo")
+    assert_equal("foo\n", log.msg)
+    # config
+    logger.formatter = proc { |severity, timestamp, progname, msg|
+      "#{severity}:#{msg}\n\n"
+    }
+    line = log_raw(logger, :info, "foo")
+    assert_equal("INFO:foo\n\n", line)
+    # recover
+    logger.formatter = nil
+    log = log(logger, :info, "foo")
+    assert_equal("foo\n", log.msg)
+    # again
+    o = Object.new
+    def o.call(severity, timestamp, progname, msg)
+      "<<#{severity}-#{msg}>>\n"
+    end
+    logger.formatter = o
+    line = log_raw(logger, :info, "foo")
+    assert_equal("<""<INFO-foo>>\n", line)
+  end
+
+  def test_initialize
+    logger = Logger.new(STDERR)
+    assert_nil(logger.progname)
+    assert_equal(DEBUG, logger.level)
+    assert_nil(logger.datetime_format)
+  end
+
+  def test_add
+    logger = Logger.new(nil)
+    logger.progname = "my_progname"
+    assert(logger.add(INFO))
+    log = log_add(logger, nil, "msg")
+    assert_equal("ANY", log.severity)
+    assert_equal("my_progname", log.progname)
+    logger.level = WARN
+    assert(logger.log(INFO))
+    assert_nil(log_add(logger, INFO, "msg").msg)
+    log = log_add(logger, WARN, nil) { "msg" }
+    assert_equal("msg\n", log.msg)
+    log = log_add(logger, WARN, "") { "msg" }
+    assert_equal("\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    log = log_add(logger, WARN, nil, "progname?")
+    assert_equal("progname?\n", log.msg)
+    assert_equal("my_progname", log.progname)
+  end
+
+  def test_level_log
+    logger = Logger.new(nil)
+    logger.progname = "my_progname"
+    log = log(logger, :debug, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("DEBUG", log.severity)
+    assert_equal("D", log.label)
+    #
+    log = log(logger, :debug) { "msg_block" }
+    assert_equal("msg_block\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    log = log(logger, :debug, "msg_inline")
+    assert_equal("msg_inline\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    #
+    log = log(logger, :info, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("INFO", log.severity)
+    assert_equal("I", log.label)
+    #
+    log = log(logger, :warn, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("WARN", log.severity)
+    assert_equal("W", log.label)
+    #
+    log = log(logger, :error, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("ERROR", log.severity)
+    assert_equal("E", log.label)
+    #
+    log = log(logger, :fatal, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("FATAL", log.severity)
+    assert_equal("F", log.label)
+    #
+    log = log(logger, :unknown, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("ANY", log.severity)
+    assert_equal("A", log.label)
+  end
+
+  def test_close
+    r, w = IO.pipe
+    assert(!w.closed?)
+    logger = Logger.new(w)
+    logger.close
+    assert(w.closed?)
+    r.close
+  end
+
+  class MyError < StandardError
+  end
+
+  class MyMsg
+    def inspect
+      "my_msg"
+    end
+  end
+
+  def test_format
+    logger = Logger.new(nil)
+    log = log_add(logger, INFO, "msg\n")
+    assert_equal("msg\n\n", log.msg)
+    begin
+      raise MyError.new("excn")
+    rescue MyError => e
+      log = log_add(logger, INFO, e)
+      assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
+      # expects backtrace is dumped across multi lines.  10 might be changed.
+      assert(log.msg.split(/\n/).size >= 10)
+    end
+    log = log_add(logger, INFO, MyMsg.new)
+    assert_equal("my_msg\n", log.msg)
+  end
+
+  def test_lshift
+    r, w = IO.pipe
+    logger = Logger.new(w)
+    logger << "msg"
+    _, = IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg", msg)
+    #
+    r, w = IO.pipe
+    logger = Logger.new(w)
+    logger << "msg2\n\n"
+    _, = IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg2\n\n", msg)
+  end
+end
+
+class TestLogDevice < Minitest::Test
+  class LogExcnRaiser
+    def write(*arg)
+      raise 'disk is full'
+    end
+
+    def close
+    end
+
+    def stat
+      Object.new
+    end
+  end
+
+  def setup
+    @tempfile = Tempfile.new("logger")
+    @tempfile.close
+    @filename = @tempfile.path
+    File.unlink(@filename)
+  end
+
+  def teardown
+    @tempfile.close(true)
+  end
+
+  def d(log, opt = {})
+    Logger::LogDevice.new(log, **opt)
+  end
+
+  def test_initialize
+    logdev = d(STDERR)
+    assert_equal(STDERR, logdev.dev)
+    assert_nil(logdev.filename)
+    assert_raises(TypeError) do
+      d(nil)
+    end
+    #
+    logdev = d(@filename)
+    begin
+      assert(File.exist?(@filename))
+      assert(logdev.dev.sync)
+      assert_equal(@filename, logdev.filename)
+      logdev.write('hello')
+    ensure
+      logdev.close
+    end
+    # create logfile whitch is already exist.
+    logdev = d(@filename)
+    begin
+      logdev.write('world')
+      logfile = File.read(@filename)
+      assert_equal(2, logfile.split(/\n/).size)
+      assert_match(/^helloworld$/, logfile)
+    ensure
+      logdev.close
+    end
+  end
+
+  def test_write
+    r, w = IO.pipe
+    logdev = d(w)
+    logdev.write("msg2\n\n")
+    _, = IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg2\n\n", msg)
+    #
+    logdev = d(LogExcnRaiser.new)
+    class << (stderr = '')
+      alias write <<
+    end
+    $stderr, stderr = stderr, $stderr
+    begin
+      logdev.write('hello')
+    ensure
+      logdev.close
+      $stderr, stderr = stderr, $stderr
+    end
+    assert_equal "log writing failed. disk is full\n", stderr
+  end
+
+  def test_close
+    r, w = IO.pipe
+    logdev = d(w)
+    logdev.write("msg2\n\n")
+    _, = IO.select([r], nil, nil, 0.1)
+    assert(!w.closed?)
+    logdev.close
+    assert(w.closed?)
+    r.close
+  end
+
+  def test_shifting_size
+    skip("shifting age doesn't work because rotation doesn't work")
+    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_1.log'])
+    logfile = tmpfile.path
+    logfile0 = logfile + '.0'
+    logfile1 = logfile + '.1'
+    logfile2 = logfile + '.2'
+    logfile3 = logfile + '.3'
+    tmpfile.close(true)
+    File.unlink(logfile) if File.exist?(logfile)
+    File.unlink(logfile0) if File.exist?(logfile0)
+    File.unlink(logfile1) if File.exist?(logfile1)
+    File.unlink(logfile2) if File.exist?(logfile2)
+    logger = Logger.new(logfile, 4, 100)
+    logger.error("0" * 15)
+    assert(File.exist?(logfile))
+    assert(!File.exist?(logfile0))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile0))
+    assert(!File.exist?(logfile1))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile1))
+    assert(!File.exist?(logfile2))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile2))
+    assert(!File.exist?(logfile3))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile3))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile3))
+    logger.close
+    File.unlink(logfile)
+    File.unlink(logfile0)
+    File.unlink(logfile1)
+    File.unlink(logfile2)
+
+    tmpfile = Tempfile.new([File.basename(__FILE__, '.*'), '_2.log'])
+    logfile = tmpfile.path
+    logfile0 = logfile + '.0'
+    logfile1 = logfile + '.1'
+    logfile2 = logfile + '.2'
+    logfile3 = logfile + '.3'
+    tmpfile.close(true)
+    logger = Logger.new(logfile, 4, 150)
+    logger.error("0" * 15)
+    assert(File.exist?(logfile))
+    assert(!File.exist?(logfile0))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile0))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile0))
+    assert(!File.exist?(logfile1))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile1))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile1))
+    assert(!File.exist?(logfile2))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile2))
+    logger.error("0" * 15)
+    assert(File.exist?(logfile2))
+    assert(!File.exist?(logfile3))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile3))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile3))
+    logger.error("0" * 15)
+    assert(!File.exist?(logfile3))
+    logger.close
+    File.unlink(logfile)
+    File.unlink(logfile0)
+    File.unlink(logfile1)
+    File.unlink(logfile2)
+  end
+
+  def test_shifting_age_variants
+    skip("shifting age doesn't work because rotation doesn't work")
+    logger = Logger.new(@filename, 'daily')
+    logger.info('daily')
+    logger.close
+    logger = Logger.new(@filename, 'weekly')
+    logger.info('weekly')
+    logger.close
+    logger = Logger.new(@filename, 'monthly')
+    logger.info('monthly')
+    logger.close
+  end
+
+  def test_shifting_age
+    skip("shifting age doesn't work because rotation doesn't work")
+    # shift_age other than 'daily', 'weekly', and 'monthly' means 'everytime'
+    yyyymmdd = Time.now.strftime("%Y%m%d")
+    filename1 = @filename + ".#{yyyymmdd}"
+    filename2 = @filename + ".#{yyyymmdd}.1"
+    filename3 = @filename + ".#{yyyymmdd}.2"
+    begin
+      logger = Logger.new(@filename, 'now')
+      assert(File.exist?(@filename))
+      assert(!File.exist?(filename1))
+      assert(!File.exist?(filename2))
+      assert(!File.exist?(filename3))
+      logger.info("0" * 15)
+      assert(File.exist?(@filename))
+      assert(File.exist?(filename1))
+      assert(!File.exist?(filename2))
+      assert(!File.exist?(filename3))
+      logger.warn("0" * 15)
+      assert(File.exist?(@filename))
+      assert(File.exist?(filename1))
+      assert(File.exist?(filename2))
+      assert(!File.exist?(filename3))
+      logger.error("0" * 15)
+      assert(File.exist?(@filename))
+      assert(File.exist?(filename1))
+      assert(File.exist?(filename2))
+      assert(File.exist?(filename3))
+    ensure
+      logger.close if logger
+      [filename1, filename2, filename3].each do |filename|
+        File.unlink(filename) if File.exist?(filename)
+      end
+    end
+  end
+end
+
+
+class TestLoggerApplication < Minitest::Test
+  def setup
+    @app = Logger::Application.new('appname')
+    @tempfile = Tempfile.new("logger")
+    @tempfile.close
+    @filename = @tempfile.path
+    File.unlink(@filename)
+  end
+
+  def teardown
+    @tempfile.close(true)
+  end
+
+  def test_initialize
+    app = Logger::Application.new('appname')
+    assert_equal('appname', app.appname)
+  end
+
+  def test_start
+    @app.set_log(@filename)
+    begin
+      @app.level = Logger::UNKNOWN
+      @app.start # logs FATAL log
+      assert_equal(1, File.read(@filename).split(/\n/).size)
+    ensure
+      @app.logger.close
+    end
+  end
+
+  def test_logger
+    @app.level = Logger::WARN
+    @app.set_log(@filename)
+    begin
+      assert_equal(Logger::WARN, @app.logger.level)
+    ensure
+      @app.logger.close
+    end
+    @app.logger = logger = Logger.new(STDOUT)
+    assert_equal(logger, @app.logger)
+    assert_equal(Logger::WARN, @app.logger.level)
+    @app.log = @filename
+    begin
+      assert(logger != @app.logger)
+      assert_equal(Logger::WARN, @app.logger.level)
+    ensure
+      @app.logger.close
+    end
+  end
+end
+