depengine 0.0.31 → 3.0.0

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/README

@@ -1,10 +0,0 @@
-The unit tests are currently out of date. The examples actually provide
-a decent test suite for log4r. But the unit tests are still very important
-because of bounds-checking and a quicker turnaround for bug discovery.
-The unit files need to be converted to the new 'test/unit' paradigm.
-
-Because Log4r dynamically defines constants according to user preferences, 
-the unit testing can't all be done in one instance of ruby. It is planned
-to use popen to run each test that needs a clean ruby instance.
-
-The logs/ directory is where these tests dump generated log files.

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testGDC.rb

@@ -1,26 +0,0 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
-
-class TestGDC < Test::Unit::TestCase
-
-  def test_gdc_default
-    assert(GDC.get() == "testGDC.rb", "Expected 'testGDC.rb' got '#{GDC.get()}'" )
-  end
-
-  def test_gdc_set
-    assert_nothing_raised() { GDC.set("testGDCset") }
-    assert(GDC.get() == "testGDCset", "Expected 'testGDCset' got '#{GDC.get()}'" )
-  end
-  
-  def test_gdc_threaded
-    assert_nothing_raised() { GDC.set("testGDCset") }
-    t = Thread.new("test GDC thread") do |name|
-       assert_raise(RuntimeError) { GDC.set("somethingelse") }
-    end
-    t.join
-    assert(GDC.get() == "testGDCset", "Expected 'testGDCset' got '#{GDC.get()}'" )
-  end
-
-end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testMDC.rb

@@ -1,21 +0,0 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
-
-class TestMDC < Test::Unit::TestCase
-
-  def test_multithread_copy
-    Log4r::MDC.put("user","colbygk")
-    t = Thread.new("test first copy") do |name|
-      assert(Log4r::MDC.get("user") == "colbygk",
-	     "Did not get back expected value, '#{MDC.get("user")}'")
-      Log4r::MDC.put("user","unique")
-      assert(Log4r::MDC.get("user") == "unique",
-	     "Did not get back expected value, '#{MDC.get("user")}'")
-    end
-    t.join
-    assert(Log4r::MDC.get("user") == "colbygk",
-	   "Did not get back expected value, '#{MDC.get("user")}'")
-  end
-end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testNDC.rb

@@ -1,27 +0,0 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
-
-class TestNDC < Test::Unit::TestCase
-
-  def test_ndc_remove_push
-    NDC.remove()
-    NDC.push("ndc")
-    assert(Log4r::NDC.get() == "ndc", "Expected 'ndc' got '#{NDC.get()}'" )
-    NDC.push("ndc")
-    assert(Log4r::NDC.get() == "ndc ndc", "Expected 'ndc ndc' got '#{NDC.get()}'" )
-  end
-
-  def test_ndc_remove_push_clone_and_inherit
-    NDC.remove()
-    NDC.push("ndc")
-    NDC.push("ndc")
-    a = NDC.clone_stack()
-    NDC.remove()
-    assert(NDC.get() == "", "Expected '' got '#{NDC.get()}'" )
-    NDC.inherit(a)
-    assert(NDC.get() == "ndc ndc", "Expected 'ndc ndc' got '#{NDC.get()}'" )
-  end
-
-end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testall.rb

@@ -1,6 +0,0 @@
-$: << File.join("..", "lib")
-
-# because constants are dynamically defined, some tests need to
-# be opened in a fresh instance of Ruby, hence the popens
-
-IO.popen("date") { |f| puts f.gets }

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testbase.rb

@@ -1,49 +0,0 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
-
-class TestBase < Test::Unit::TestCase
-  # check that LNAMES loads properly (it uses an eval to load)
-  def test_default_levels
-    Logger.root              # doing this loads the default levels
-    assert_equal(ALL,0)
-    assert_equal(DEBUG,1)
-    assert_equal(INFO,2)
-    assert_equal(WARN,3)
-    assert_equal(ERROR,4)
-    assert_equal(FATAL,5)
-    assert_equal(OFF,6)
-    assert_equal(LEVELS, 7)
-    assert_equal(LNAMES.size, 7)
-  end
-  # check bad input and bounds for validate_level
-  def test_validate_level
-    7.times{|i| assert_nothing_raised {Log4rTools.validate_level(i)} }
-    assert_raises(ArgumentError) {Log4rTools.validate_level(-1)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level(LEVELS)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level(String)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level("bogus")}
-  end
-  # decode_bool turns a string 'true' into true and so on
-  def test_decode_bool
-    # when the key is a symbol :data
-    assert(Log4rTools.decode_bool({:data=> 'true'}   ,:data,false) == true)
-    assert(Log4rTools.decode_bool({:data=> true}     ,:data,false) == true)
-    assert(Log4rTools.decode_bool({:data=> 'false'}  ,:data,true) == false)
-    assert(Log4rTools.decode_bool({:data=> false}    ,:data,true) == false)
-    assert(Log4rTools.decode_bool({:data=> nil}      ,:data,true) == true)
-    assert(Log4rTools.decode_bool({:data=> nil}      ,:data,false) == false)
-    assert(Log4rTools.decode_bool({:data=> String}   ,:data,true) == true)
-    assert(Log4rTools.decode_bool({:data=> String}   ,:data,false) == false)
-    # now the key is a string 'data'
-    assert(Log4rTools.decode_bool({'data'=> 'true'}  ,:data,false) == true)
-    assert(Log4rTools.decode_bool({'data'=> true}    ,:data,false) == true)
-    assert(Log4rTools.decode_bool({'data'=> 'false'} ,:data,true) == false)
-    assert(Log4rTools.decode_bool({'data'=> false}   ,:data,true) == false)
-    assert(Log4rTools.decode_bool({'data'=> nil}     ,:data,true) == true)
-    assert(Log4rTools.decode_bool({'data'=> nil}     ,:data,false) == false)
-    assert(Log4rTools.decode_bool({'data'=> String}  ,:data,true) == true)
-    assert(Log4rTools.decode_bool({'data'=> String}  ,:data,false) == false)
-  end
-end

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testchainsaw.rb

@@ -1,48 +0,0 @@
-$: << File.join("..", "lib")
-
-require 'log4r'
-require 'log4r/staticlogger'
-require 'log4r/formatter/log4jxmlformatter'
-require 'log4r/outputter/udpoutputter'
-require 'log4r/outputter/consoleoutputters'
-
-include Log4r
-
-log4r = Logger.new 'log4r'
-log4r.trace = true
-log4r.outputters = StdoutOutputter.new 'log4r'
-log4r.level = ALL
-
-formatter = Log4jXmlFormatter.new
-outputter = UDPOutputter.new 'udp', :hostname => "localhost", :port => 8071
-outputter.formatter = formatter
-
-mylog = Logger.new 'mylog'
-mylog.trace = true
-mylog.outputters = [outputter]
-
-# Log4r::Formatter throws when formatting
-# an excpetion with a nil backtrace (line 73).
-def get_exception(msg)
-  begin
-    raise msg
-  rescue Exception => e
-    e
-  end
-end
-
-NDC.push "saw test"
-
-MDC.put "clientip", %q{10.33.33.33}
-
-def do_log(log)
-    log.debug "This is a message with level DEBUG"
-    log.info "This is a message with level INFO"
-    log.warn "This is a message with level WARN"
-    log.error "This is a message with level ERROR"
-    log.fatal "This is a message with level FATAL"
-
-    log.fatal get_exception( "This is an exception" )
-end
-
-do_log(mylog)

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testconf.xml

@@ -1,37 +0,0 @@
-<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>

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testcustom.rb

@@ -1,27 +0,0 @@
-
-# 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

data/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testformatter.rb

@@ -1,27 +0,0 @@
-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/etc/isolate/jruby-1.8/gems/log4r-1.1.8/tests/testlogger.rb

@@ -1,196 +0,0 @@
-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