riess 0.0.8

data/vendor/log4r-1.0.5/tests/testcustom.rb

@@ -0,0 +1,33 @@
+require "include"
+require "runit/cui/testrunner"
+
+# tests the customization of Log4r levels
+class TestCustom < TestCase
+  def test_validation
+    assert_exception(TypeError) { Configurator.custom_levels "lowercase" }
+    assert_exception(TypeError) { Configurator.custom_levels "With space" }
+  end
+
+  def test_create
+    assert_no_exception { Configurator.custom_levels "Foo", "Bar", "Baz" }
+    assert_no_exception { Configurator.custom_levels }
+    assert_no_exception { Configurator.custom_levels "Bogus", "Levels" }
+  end
+  def test_methods
+    l = Logger.new 'custom1'
+    assert_respond_to(:foo, l)
+    assert_respond_to(:foo?, l)
+    assert_respond_to(:bar, l)
+    assert_respond_to(:bar?, l)
+    assert_respond_to(:baz, l)
+    assert_respond_to(:baz?, l)
+    assert_no_exception(NameError) { Bar }
+    assert_no_exception(NameError) { Baz }
+    assert_no_exception(NameError) { Foo }
+  end
+    
+end
+
+CUI::TestRunner.run(TestCustom.new("test_validation"))
+CUI::TestRunner.run(TestCustom.new("test_create"))
+CUI::TestRunner.run(TestCustom.new("test_methods"))

data/vendor/log4r-1.0.5/tests/testdefault.rb

@@ -0,0 +1,25 @@
+# actually, tests only the following:
+require "testlogger"
+require "testoutputter"
+require "testformatter"
+require "testpatternformatter"
+
+require "runit/testsuite"
+require "runit/cui/testrunner"
+
+class TestDefault
+  def TestDefault.suite
+    suite = TestSuite.new
+    for k in Object.constants.sort
+      next if /^Test/ !~ k
+      const = Object.const_get(k)
+      if const.kind_of?(Class) && const.superclass == RUNIT::TestCase
+        suite.add(const.suite)
+      end
+    end
+    suite
+  end
+end
+
+CUI::TestRunner.run(TestDefault.suite)
+

data/vendor/log4r-1.0.5/tests/testformatter.rb

@@ -0,0 +1,29 @@
+require "include"
+
+class TestFormatter < TestCase
+  def test_creation
+    assert_no_exception { Formatter.new.format(3) }
+    assert_no_exception { DefaultFormatter.new }
+    assert_kind_of(Formatter, DefaultFormatter.new)
+  end
+  def test_simple_formatter
+    sf = SimpleFormatter.new
+    f = Logger.new('simple formatter')
+    event = LogEvent.new(0, f, nil, "some data")
+    assert_match(sf.format(event), /simple formatter/)
+  end
+  def test_basic_formatter
+    b = BasicFormatter.new
+    f = Logger.new('fake formatter')
+    event = LogEvent.new(0, f, caller, "fake formatter")
+    event2 = LogEvent.new(0, f, nil, "fake formatter")
+    # this checks for tracing
+    assert_match(b.format(event), /in/)
+    assert_not_match(b.format(event2), /in/)
+    e = ArgumentError.new("argerror")
+    e.set_backtrace ['backtrace']
+    event3 = LogEvent.new(0, f, nil, e)
+    assert_match(b.format(event3), /ArgumentError/)
+    assert_match(b.format(LogEvent.new(0,f,nil,[1,2,3])), /Array/)
+  end
+end 

data/vendor/log4r-1.0.5/tests/testlogger.rb

@@ -0,0 +1,198 @@
+require "include"
+
+class MyFormatter1 < Formatter
+  def format(event)
+    return "MyFormatter1\n"
+  end
+end
+
+class MyFormatter2 < Formatter
+  def format(event)
+    return "MyFormatter2\n"
+  end
+end
+
+class TestLogger < TestCase
+  def test_root
+    l1 = Logger.root
+    l2 = Logger['root']
+    l3 = Logger.global
+    assert(l1 == l2, "RootLogger wasn't singleton!")
+    assert(l1 == l3)
+    assert(l1.is_root? == true, "is_root? not working")
+    assert(l1.parent == nil, "Root's parent wasn't nil!")
+  end
+  def test_validation
+    assert_exception(ArgumentError) { Logger.new }
+    assert_no_exception { Logger.new('validate', nil) }
+  end
+  def test_all_off
+    l = Logger.new("create_method")
+    l.level = WARN
+    assert(l.debug? == false)
+    assert(l.info? == false)
+    assert(l.warn? == true)
+    assert(l.error? == true)
+    assert(l.fatal? == true)
+    assert(l.off? == false)
+    assert(l.all? == false)
+    l.level = OFF
+    assert(l.off? == true)
+    assert(l.all? == false)
+    l.level = ALL
+    assert(l.off? == false)
+    assert(l.all? == true)
+  end
+  def test_add_outputters
+    StdoutOutputter.new('fake1')
+    StdoutOutputter.new('fake2')
+    a = Logger.new("add")
+    assert_exception(TypeError) { a.add 'bogus' }
+    assert_exception(TypeError) { a.add Class }
+    assert_exception(TypeError) { a.add 'fake1', Class }
+    assert_no_exception { a.add 'fake1', 'fake2' }
+  end
+  def test_repository
+    assert_exception(NameError) { Logger.get('bogusbogus') }
+    assert_no_exception { Logger['bogusbogus'] }
+  end
+  def test_heiarchy
+    a = Logger.new("a")
+    a.additive = true
+    assert(a.name == "a", "name wasn't set properly")
+    assert(a.path == "", "path wasn't set properly")
+    assert(a.level == Logger.root.level, "didn't inherit root's level") 
+    assert(a.parent == Logger.root)
+    a.level = WARN
+    b = Logger.new("a::b")
+    assert(b.name == "b", "name wasn't set properly")
+    assert(b.path == "a", "path wasn't set properly")
+    assert(b.level == a.level, "didn't inherit parent's level") 
+    assert(b.parent == a, "parent wasn't what is expected")
+    c = Logger.new("a::b::c")
+    assert(Logger["a::b::c"] == c)
+    assert(c.name == "c", "name wasn't set properly")
+    assert(c.path == "a::b", "path wasn't set properly")
+    assert(c.level == b.level, "didn't inherit parent's level") 
+    assert(c.parent == b, "parent wasn't what is expected")
+    d = Logger.new("a::d")
+    assert(Logger["a::d"] == d)
+    assert(d.name == "d", "name wasn't set properly")
+    assert(d.path == "a", "path wasn't set properly")
+    assert(d.level == a.level, "didn't inherit parent's level") 
+    assert(d.parent == a, "parent wasn't what is expected")
+    assert_exception(ArgumentError) { Logger.new("::a") }
+  end
+  def test_undefined_parents
+    a = Logger.new 'has::no::real::parents::me'
+    assert(a.parent == Logger.root)
+    b = Logger.new 'has::no::real::parents::me::child'
+    assert(b.parent == a)
+    c = Logger.new 'has::no::real::parents::metoo'
+    assert(c.parent == Logger.root)
+    p = Logger.new 'has::no::real::parents'
+    assert(p.parent == Logger.root)
+    assert(a.parent == p)
+    assert(b.parent == a)
+    assert(c.parent == p)
+    Logger.each{|fullname, logger|
+      if logger != a and logger != c
+        assert(logger.parent != p)
+      end
+    }
+  end
+  def test_levels
+    l = Logger.new("levels", WARN)
+    assert(l.level == WARN, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == true)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should show up. 3 total"
+    l.error "error messge should show up. 3 total"
+    l.fatal "fatal messge should show up. 3 total"
+    l.level = ERROR
+    assert(l.level == ERROR, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == false)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should NOT show up."
+    l.error "error messge should show up. 2 total"
+    l.fatal "fatal messge should show up. 2 total"
+    l.level = WARN
+  end
+  def test_log_blocks
+    l = Logger.new 'logblocks'
+    l.level = WARN
+    l.add(Outputter.stdout)
+    assert_no_exception {
+      l.debug { puts "should not show up"; "LOGBLOCKS" }
+      l.fatal { puts "should show up"; "LOGBLOCKS" }
+      l.fatal { nil }
+      l.fatal {}
+    }
+  end
+  def test_heiarchial_logging
+    a = Logger.new("one")
+    a.add(StdoutOutputter.new 'so1')
+    b = Logger.new("one::two")
+    b.add(StdoutOutputter.new 'so2')
+    c = Logger.new("one::two::three")
+    c.add(StdoutOutputter.new 'so3')
+    d = Logger.new("one::two::three::four")
+    d.add(StdoutOutputter.new 'so4')
+    d.additive = false
+    e = Logger.new("one::two::three::four::five")
+    e.add(StdoutOutputter.new 'so5')
+
+    a.fatal "statement from a should show up once"
+    b.fatal "statement from b should show up twice"
+    c.fatal "statement from c should show up thrice"
+    d.fatal "statement from d should show up once"
+    e.fatal "statement from e should show up twice"
+  end
+  def test_multi_outs
+    f1 = FileOutputter.new('f1', :filename => "./junk/tmp1.log", :level=>ALL)
+    f2 = FileOutputter.new('f2', :filename => "./junk/tmp2.log", :level=>DEBUG)
+    f3 = FileOutputter.new('f3', :filename => "./junk/tmp3.log", :level=>ERROR)
+    f4 = FileOutputter.new('f4', :filename => "./junk/tmp4.log", :level=>FATAL)
+
+    l = Logger.new("multi")
+    l.add(f1, f3, f4)
+
+    a = Logger.new("multi::multi2")
+    a.level = ERROR
+    a.add(f2, f4)
+    
+    l.debug "debug test_multi_outputters"
+    l.info "info test_multi_outputters"
+    l.warn "warn test_multi_outputters"
+    l.error "error test_multi_outputters"
+    l.fatal "fatal test_multi_outputters"
+
+    a.debug "debug test_multi_outputters"
+    a.info "info test_multi_outputters"
+    a.warn "warn test_multi_outputters"
+    a.error "error test_multi_outputters"
+    a.fatal "fatal test_multi_outputters"
+    
+    f1.close; f2.close; f3.close; f4.close
+  end
+  def test_custom_formatter
+    l = Logger.new('custom_formatter')
+    o = StdoutOutputter.new('formatter'=>MyFormatter1.new)
+    l.add o
+    l.error "try myformatter1"
+    l.fatal "try myformatter1"
+    o.formatter = MyFormatter2.new
+    l.error "try formatter2"
+    l.fatal "try formatter2"
+  end
+end 

data/vendor/log4r-1.0.5/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/vendor/log4r-1.0.5/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/vendor/log4r-1.0.5/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