sml-log4r 1.0.6

data/tests/testoutputter.rb

@@ -0,0 +1,112 @@
+require "include"
+
+class TestOutputter < TestCase
+  def test_validation
+    assert_exception(ArgumentError) { Outputter.new }
+    assert_exception(ArgumentError) { Outputter.new 'fonda', :level=>-10}
+    assert_exception(TypeError) { Outputter.new 'fonda', :formatter=>-10}
+  end
+  def test_io
+    assert_no_exception {
+      IOOutputter.new('foo3', $stdout)
+      IOOutputter.new('foo4', $stderr)
+    }
+    f = File.new("junk/tmpx.log", "w")
+    o = IOOutputter.new('asdf', f)
+    o.close
+    assert(f.closed? == true)
+    assert(o.level == OFF)
+  end
+  def test_repository
+    assert( Outputter['foo3'].type == IOOutputter )
+    assert( Outputter['foo4'].type == IOOutputter )
+    assert( Outputter['asdf'].type == IOOutputter )
+  end
+  def test_validation_and_creation
+    assert_no_exception {
+      StdoutOutputter.new('out', 'level'=>DEBUG)
+      FileOutputter.new('file', 'filename'=>'junk/test', :trunc=>true)
+    }
+    a = StdoutOutputter.new 'out2'
+    assert(a.level == Logger.root.level)
+    assert(a.formatter.type == DefaultFormatter)
+    b = StdoutOutputter.new('ook', :level => DEBUG, :formatter => Formatter)
+    assert(b.level == DEBUG)
+    assert(b.formatter.type == Formatter)
+    c = StdoutOutputter.new('akk', :formatter => Formatter)
+    assert(c.level == Logger.root.level)
+    assert(c.formatter.type == Formatter)
+    c = StderrOutputter.new('iikk', :level => OFF)
+    assert(c.level == OFF)
+    assert(c.formatter.type == DefaultFormatter)
+    o = StderrOutputter.new 'ik'
+    assert_no_exception(TypeError) { o.formatter = DefaultFormatter }
+    assert_equals(o.formatter.type, DefaultFormatter)
+  end
+  # test the resource= bounds
+  def test_boundaries
+    o = StderrOutputter.new('ak', :formatter => Formatter)
+    assert_exception(TypeError) { o.formatter = nil }
+    assert_exception(TypeError) { o.formatter = String }
+    assert_exception(TypeError) { o.formatter = "bogus" }
+    assert_exception(TypeError) { o.formatter = -3 }
+    # the formatter should be preserved
+    assert(o.formatter.type == Formatter) 
+  end
+  def test_file
+    assert_exception(TypeError) { FileOutputter.new 'f' }
+    assert_exception(TypeError) { FileOutputter.new('fa', :filename => DEBUG) }
+    assert_exception(TypeError) { FileOutputter.new('fo', :filename => nil) }
+    assert_no_exception { 
+      FileOutputter.new('fi', :filename => './junk/tmp')
+      FileOutputter.new('fum', :filename=>'./junk/tmp', :trunc => "true")
+    }
+    fo = FileOutputter.new('food', :filename => './junk/tmp', :trunc => false)
+    assert(fo.trunc == false)
+    assert(fo.filename == './junk/tmp')
+    assert(fo.closed? == false)
+    fo.close
+    assert(fo.closed? == true)
+    assert(fo.level == OFF)
+  end
+  # test the dynamic definition of outputter log messages
+  def test_log_methods
+    o = StderrOutputter.new('so1', :level => WARN )
+    # test to see if all of the methods are defined
+    for mname in LNAMES
+      next if mname == 'OFF' || mname == 'ALL'
+      assert_respond_to(mname.downcase, o, "Test respond to #{mname.to_s}")
+    end 
+    return # cuz the rest is borked
+    # we rely on BasicFormatter's inability to reference a nil Logger to test
+    # the log methods. Everything from WARN to FATAL should choke.
+    event = LogEvent.new(nil, nil, nil, nil) 
+    assert_no_exception { o.debug event }
+    assert_no_exception { o.info event }
+    assert_exception(NameError) { o.warn event }
+    assert_exception(NameError) { o.error event }
+    assert_exception(NameError) { o.fatal event }
+    # now let's dynamically change the level and repeat
+    o.level = ERROR
+    assert_no_exception { o.debug event}
+    assert_no_exception { o.info event}
+    assert_no_exception { o.warn event}  
+    assert_exception(NameError) { o.error event}
+    assert_exception(NameError) { o.fatal event}
+  end
+  def test_only_at_validation
+    o = StdoutOutputter.new 'so2'
+    assert_exception(ArgumentError) { o.only_at }
+    assert_exception(ArgumentError) { o.only_at ALL }
+    assert_exception(TypeError) { o.only_at OFF }
+    assert_no_exception { o.only_at DEBUG, ERROR }
+    return # cuz the rest is borked
+    # test the methods as before
+    event = LogEvent.new(nil,nil,nil,nil)
+    assert_exception(NameError) { o.debug event}
+    assert_exception(NameError) { o.error event}
+    assert_no_exception { o.warn event}
+    assert_no_exception { o.info event}
+    assert_no_exception { o.fatal event}
+  end
+end 

data/tests/testpatternformatter.rb

@@ -0,0 +1,26 @@
+require "include"
+require "runit/cui/testrunner"
+
+class TestPatternFormatter < TestCase
+  def test_pattern
+    l = Logger.new 'test::this::that'
+    l.trace = true
+    o = StdoutOutputter.new 'test' 
+    l.add o
+    assert_no_exception { 
+    f = PatternFormatter.new :pattern=> "%d %6l [%C]%c %% %-40.30M"
+                             #:date_pattern=> "%Y"
+                             #:date_method => :usec
+    Outputter['test'].formatter = f
+    l.debug "And this?"
+    l.info "How's this?"
+    l.error "and a really freaking huge line which we hope will be trimmed?"
+    e = ArgumentError.new("something barfed")
+    e.set_backtrace Array.new(5, "trace junk at thisfile.rb 154")
+    l.fatal e
+    l.info [1, 3, 5]
+    }
+  end
+end
+
+CUI::TestRunner.run(TestPatternFormatter.suite)

data/tests/testxmlconf.rb

@@ -0,0 +1,51 @@
+require "include"
+require "runit/cui/testrunner"
+
+One=<<-EOX
+<log4r_config><pre_config><custom_levels> Foo </custom_levels>
+</pre_config></log4r_config>
+EOX
+Two=<<-EOX
+<log4r_config><pre_config><global level="DEBUG"/></pre_config></log4r_config>
+EOX
+Three=<<-EOX
+<log4r_config><pre_config><custom_levels>Foo</custom_levels>
+<global level="Foo"/></pre_config>
+</log4r_config>
+EOX
+
+# must be run independently
+class TestXmlConf < TestCase
+  def test_load1
+    Configurator.load_xml_string(One)
+    assert_no_exception{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == ALL)
+    }
+  end
+  def test_load2
+    Configurator.load_xml_string(Two)
+    assert_no_exception{ 
+      assert(Logger.global.level == DEBUG)
+    }
+  end
+  def test_load3
+    Configurator.load_xml_string(Three)
+    assert_no_exception{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == Foo)
+    }
+  end
+  def test_load4
+    assert_no_exception {
+      Configurator['logpath'] = '.'
+      Configurator.load_xml_file "xml/testconf.xml"
+      a = Logger['first::second']
+      a.bing "what the heck"
+    }
+  end
+end
+
+if __FILE__ == $0
+  CUI::TestRunner.run(TestXmlConf.new("test_load#{ARGV[0]}"))
+end

data/tests/xml/testconf.xml

@@ -0,0 +1,37 @@
+<test>
+<log4r_config>
+
+  <pre_config>
+    <custom_levels>Foo, Bar,Baz, Bing</custom_levels>
+    <global level="Foo"/>
+    <parameters>
+      <mypattern>[%l] %d %t - %m</mypattern>
+    </parameters>
+    <parameter name="datem" value="usec"/>
+  </pre_config>
+
+  <!-- level and formatter are optional, -->
+  <outputter name="SO" type="StdoutOutputter">
+    <level>Foo</level>
+    <formatter type="Log4r::PatternFormatter">
+      <pattern>%d %c %l&gt; %m</pattern>
+      <date_method>#{datem}</date_method>
+    </formatter>
+  </outputter>
+  <outputter name="SE" type="StderrOutputter" level="Baz">
+    <formatter type="PatternFormatter" pattern="#{mypattern}">
+      <date_pattern>%H:%S</date_pattern>
+    </formatter>
+  </outputter>
+  <outputter name="F" type="FileOutputter">
+    <filename>#{logpath}/junk/foo.log</filename>
+    <trunc>true</trunc>
+    <only_at>Foo, Bar, Bing</only_at>
+  </outputter>
+  <!-- optional level, additive and outputters -->
+  <logger name="first::second" level="Bar" additive="false">
+    <trace>true</trace>
+    <outputters>SO, SE, F, stdout, stderr</outputters>
+  </logger>
+</log4r_config>
+</test>

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: sml-log4r
+version: !ruby/object:Gem::Version 
+  version: 1.0.6
+platform: ruby
+authors: 
+- Leon Torres
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Log4r is a comprehensive and flexible logging library written in Ruby for use in Ruby programs. It features a hierarchical logging system of any number of levels, custom level names, logger inheritance, multiple output destinations per log event, execution tracing, custom formatting, thread safteyness, XML and YAML configuration, and more.
+email: leon(at)ugcs.caltech.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- doc/content
+- doc/content/contact.html
+- doc/content/contribute.html
+- doc/content/index.html
+- doc/content/license.html
+- doc/content/manual.html
+- doc/dev
+- doc/dev/checklist
+- doc/dev/README.developers
+- doc/dev/things-to-do
+- doc/images
+- doc/images/crush
+- doc/images/crush/logo2.png
+- doc/images/log4r-logo.png
+- doc/images/logo2.png
+- doc/log4r.css
+- doc/old
+- doc/old/manual.html
+- doc/templates
+- doc/templates/main.html
+- examples/customlevels.rb
+- examples/fileroll.rb
+- examples/log4r_yaml.yaml
+- examples/logclient.rb
+- examples/logserver.rb
+- examples/moderate.xml
+- examples/moderateconfig.rb
+- examples/myformatter.rb
+- examples/outofthebox.rb
+- examples/README
+- examples/rrconfig.xml
+- examples/rrsetup.rb
+- examples/simpleconfig.rb
+- examples/xmlconfig.rb
+- examples/yaml.rb
+- src/log4r
+- src/log4r/base.rb
+- src/log4r/config.rb
+- src/log4r/configurator.rb
+- src/log4r/formatter
+- src/log4r/formatter/formatter.rb
+- src/log4r/formatter/patternformatter.rb
+- src/log4r/lib
+- src/log4r/lib/drbloader.rb
+- src/log4r/lib/xmlloader.rb
+- src/log4r/logevent.rb
+- src/log4r/logger.rb
+- src/log4r/loggerfactory.rb
+- src/log4r/logserver.rb
+- src/log4r/outputter
+- src/log4r/outputter/consoleoutputters.rb
+- src/log4r/outputter/datefileoutputter.rb
+- src/log4r/outputter/emailoutputter.rb
+- src/log4r/outputter/fileoutputter.rb
+- src/log4r/outputter/iooutputter.rb
+- src/log4r/outputter/outputter.rb
+- src/log4r/outputter/outputterfactory.rb
+- src/log4r/outputter/remoteoutputter.rb
+- src/log4r/outputter/rollingfileoutputter.rb
+- src/log4r/outputter/staticoutputter.rb
+- src/log4r/outputter/syslogoutputter.rb
+- src/log4r/rdoc
+- src/log4r/rdoc/configurator
+- src/log4r/rdoc/emailoutputter
+- src/log4r/rdoc/formatter
+- src/log4r/rdoc/log4r
+- src/log4r/rdoc/logger
+- src/log4r/rdoc/logserver
+- src/log4r/rdoc/outputter
+- src/log4r/rdoc/patternformatter
+- src/log4r/rdoc/syslogoutputter
+- src/log4r/rdoc/yamlconfigurator
+- src/log4r/repository.rb
+- src/log4r/staticlogger.rb
+- src/log4r/yamlconfigurator.rb
+- src/log4r.rb
+- tests/include.rb
+- tests/runtest.rb
+- tests/testbase.rb
+- tests/testcustom.rb
+- tests/testdefault.rb
+- tests/testformatter.rb
+- tests/testlogger.rb
+- tests/testoutputter.rb
+- tests/testpatternformatter.rb
+- tests/testxmlconf.rb
+- tests/xml
+- tests/xml/testconf.xml
+has_rdoc: true
+homepage: http://log4r.sourceforge.net
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- src
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: log4r
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Log4r is a comprehensive and flexible logging library for Ruby.
+test_files: []
+