* lib/logger.rb: typo fixed.

* test/logger/test_logger.rb: new file.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4580 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,9 @@
+Mon Sep 20 11:49:05 2003  NAKAMURA, Hiroshi  <nahi@ruby-lang.org>
+
+	* lib/logger.rb: typo fixed.
+
+	* test/logger/test_logger.rb: new file.
+
 Fri Sep 19 11:39:00 2003  Nathaniel Talbott <ntalbott@ruby-lang.org>
 
 	* test/testunit/*: Added.

MANIFEST

@@ -487,6 +487,7 @@ test/csv/test_csv.rb
 test/fileutils/fileassertions.rb
 test/fileutils/test_fileutils.rb
 test/fileutils/test_nowrite.rb
+test/logger/test_logger.rb
 test/ruby/test_alias.rb
 test/ruby/test_array.rb
 test/ruby/test_assignment.rb

lib/logger.rb

@@ -104,7 +104,7 @@ class Logger
   def info?; @level <= INFO; end
   def warn?; @level <= WARN; end
   def error?; @level <= ERROR; end
-  def fatail?; @level <= FATAL; end
+  def fatal?; @level <= FATAL; end
 
   # SYNOPSIS
   #   Logger.new(name, shift_age = 7, shift_size = 1048576)
@@ -128,7 +128,10 @@ class Logger
     @progname = nil
     @level = DEBUG
     @datetime_format = nil
-    @logdev = LogDevice.new(logdev, :shift_age => shift_age, :shift_size => shift_size) if logdev
+    @logdev = nil
+    if logdev
+      @logdev = LogDevice.new(logdev, :shift_age => shift_age, :shift_size => shift_size)
+    end
   end
 
   # SYNOPSIS
@@ -242,7 +245,7 @@ private
   SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY);
 
   def format_severity(severity)
-    SEV_LABEL[severity] || 'UNKNOWN'
+    SEV_LABEL[severity] || 'ANY'
   end
 
   def format_datetime(datetime)
@@ -253,9 +256,9 @@ private
     end
   end
 
+  Format = "%s, [%s#%d] %5s -- %s: %s\n"
   def format_message(severity, timestamp, msg, progname)
-    line = '%s, [%s#%d] %5s -- %s: %s' << "\n"
+    Format % [severity[0..0], timestamp, $$, severity, progname, msg]
-    line % [severity[0..0], timestamp, $$, severity, progname, msg]
   end
 
   def msg2str(msg)

test/logger/test_logger.rb

@@ -0,0 +1,212 @@
+require 'test/unit'
+require 'logger'
+
+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))
+      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)
+    r, w = IO.pipe
+    logger.instance_eval { @logdev = Logger::LogDevice.new(w) }
+    logger.__send__(msg_id, *arg, &block)
+    read_ready, = IO.select([r], nil, nil, 0.1)
+    w.close
+    if read_ready
+      line = r.read
+      r.close
+      Log.new(line)
+    else
+      r.close
+      nil
+    end
+  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_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"))
+    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.  19 might be changed.
+      assert(log.msg.split(/\n/).size >= 19)
+    end
+    log = log_add(logger, INFO, MyMsg.new)
+    assert_equal("my_msg\n", log.msg)
+  end
+end