From d464704f111d211c1f1ff9ef23ef1d755054be00 Mon Sep 17 00:00:00 2001 From: shyouhei Date: Wed, 15 Aug 2007 19:08:43 +0000 Subject: add tag v1_8_5_54 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_8_5_54@12952 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ruby_1_8_5/test/logger/test_logger.rb | 376 ++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 ruby_1_8_5/test/logger/test_logger.rb (limited to 'ruby_1_8_5/test/logger/test_logger.rb') diff --git a/ruby_1_8_5/test/logger/test_logger.rb b/ruby_1_8_5/test/logger/test_logger.rb new file mode 100644 index 0000000000..ab578a1b81 --- /dev/null +++ b/ruby_1_8_5/test/logger/test_logger.rb @@ -0,0 +1,376 @@ +require 'test/unit' +require 'logger' +require 'tempfile' + + +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) + 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("<>\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 + def d(log) + Logger::LogDevice.new(log) + end + + def test_initialize + logdev = d(STDERR) + assert_equal(STDERR, logdev.dev) + assert_nil(logdev.filename) + assert_raises(TypeError) do + d(nil) + end + # + filename = __FILE__ + ".#{$$}" + begin + logdev = d(filename) + assert(File.exist?(filename)) + assert(logdev.dev.sync) + assert_equal(filename, logdev.filename) + ensure + logdev.close + File.unlink(filename) + 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) + 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 + logfile = File.basename(__FILE__) + '_1.log' + logfile0 = logfile + '.0' + logfile1 = logfile + '.1' + logfile2 = logfile + '.2' + logfile3 = logfile + '.3' + 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) + + logfile = File.basename(__FILE__) + '_2.log' + logfile0 = logfile + '.0' + logfile1 = logfile + '.1' + logfile2 = logfile + '.2' + logfile3 = logfile + '.3' + 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 +end -- cgit v1.2.3