autumn 3.1.8

data/spec/coder_spec.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'facets/array'
+require 'facets/string'
+
+require "autumn/coder"
+
+describe Autumn::Coder do
+  before :each do
+    @coder = Autumn::Coder.new
+  end
+  
+  it "should start with an indent of 0" do
+    @coder << "test string"
+    @coder.output.should eql("test string\n")
+  end
+  
+  it "should indent by two spaces" do
+    @coder.indent!
+    @coder << "test string"
+    @coder.unindent!
+    @coder.output.should eql("  test string\n")
+  end
+  
+  it "should indent each line of a multi-line string" do
+    @coder.indent!
+    @coder << "line 1\nline 2"
+    @coder.unindent!
+    @coder.output.should eql("  line 1\n  line 2\n")
+  end
+  
+  it "should insert a newline between consecutive calls to <<" do
+    @coder << "first string"
+    @coder << "second string"
+    @coder.output.should eql("first string\nsecond string\n")
+  end
+  
+  it "should unindent by two spaces" do
+    @coder.indent!
+    @coder << "first string"
+    @coder.unindent!
+    @coder << "second string"
+    @coder.output.should eql("  first string\nsecond string\n")
+  end
+  
+  it "should add newlines when given the newline! message" do
+    @coder << "first line"
+    @coder.newline!
+    @coder << "second line"
+    @coder.output.should eql("first line\n\nsecond line\n")
+  end
+  
+  it "should generate a basic class template" do
+    @coder.klass('TestClass')
+    @coder.output.should eql("class TestClass\nend\n")
+  end
+  
+  it "should generate a subclass template" do
+    @coder.klass('Subclass', 'Superclass')
+    @coder.output.should eql("class Subclass < Superclass\nend\n")
+  end
+  
+  it "should indent the contents of a class" do
+    @coder.klass('TestClass') { |klass| klass << "content" }
+    @coder.output.should eql("class TestClass\n  content\nend\n")
+  end
+  
+  it "should generate a basic method template" do
+    @coder.method('test_method')
+    @coder.output.should eql("def test_method\nend\n")
+  end
+  
+  it "should indent the contents of a method" do
+    @coder.method('test_method') { |meth| meth << "content" }
+    @coder.output.should eql("def test_method\n  content\nend\n")
+  end
+  
+  it "should properly generate a one-parameter method" do
+    @coder.method('test_method', :arg)
+    @coder.output.should eql("def test_method(arg)\nend\n")
+  end
+  
+  it "should properly generate a multi-parameter method" do
+    @coder.method('test_method', :arg1, :arg2)
+    @coder.output.should eql("def test_method(arg1, arg2)\nend\n")
+  end
+  
+  it "should properly generate optional parameters" do
+    @coder.method('test_method', { :arg => nil })
+    @coder.output.should eql("def test_method(arg=nil)\nend\n")
+  end
+  
+  it "should properly generate multiple optional and required parameters" do
+    @coder.method('test_method', :req1, :req2, { :opt1 => '' }, { :opt2 => Array.new })
+    @coder.output.should eql(%{def test_method(req1, req2, opt1="", opt2=[])\nend\n})
+  end
+  
+  it "should raise an exception for empty parameter names" do
+    lambda { @coder.method('test_method', '') }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise an exception for empty optional parameter names" do
+    lambda { @coder.method('test_method', { '' => nil }) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Autumn::TemplateCoder do
+  before :each do
+    @coder = Autumn::TemplateCoder.new
+  end
+  
+  it "should generate a proper leaf template" do
+    @coder.leaf('test_leaf')
+    
+    # HACK extlib and facets both define String#margin to do different things;
+    #      we need a way to un-require the dm-core gem once we've run the DM
+    #      specs. For now, we're forced to redefine String#margin
+    String.class_eval do
+      def margin(n=0)
+        #d = /\A.*\n\s*(.)/.match( self )[1]
+        #d = /\A\s*(.)/.match( self)[1] unless d
+        d = ((/\A.*\n\s*(.)/.match(self)) ||
+            (/\A\s*(.)/.match(self)))[1]
+        return '' unless d
+        if n == 0
+          gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+        else
+          gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
+        end
+      end
+    end
+    
+    @coder.output.should eql(%{
+      |# Controller for the TestLeaf leaf.
+      |
+      |class Controller < Autumn::Leaf
+      |  
+      |  # Typing "!about" displays some basic information about this leaf.
+      |  
+      |  def about_command(stem, sender, reply_to, msg)
+      |    # This method renders the file "about.txt.erb"
+      |  end
+      |end
+      |
+    }.margin)
+  end
+end

data/spec/ctcp_spec.rb

@@ -0,0 +1,222 @@
+require 'set'
+require 'rubygems'
+require 'facets/array'
+require 'facets/enumerable'
+require 'facets/kernel'
+require 'facets/string'
+require 'anise'
+
+require 'autumn/misc'
+require 'autumn/stem_facade'
+require 'autumn/daemon'
+require 'autumn/stem'
+require 'autumn/ctcp'
+
+describe Autumn::CTCP do
+  before :each do
+    @ctcp = Autumn::CTCP.new
+    @sender_hash = { :user => 'TestUser', :nick => 'TestNick', :host => 'ca.testhost.org' }
+  end
+  
+  describe "with a mock stem" do
+    before :each do
+      @stem = mock('stem')
+    end
+    
+    it "should parse CTCP requests in PRIVMSGs and broadcast two request-received methods" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_request, @ctcp, @stem, @sender_hash, [])
+      @stem.should_receive(:broadcast).once.with(:ctcp_request_received, :test, @ctcp, @stem, @sender_hash, [])
+      @ctcp.irc_privmsg_event @stem, @sender_hash, :message => "\01TEST\01"
+    end
+
+    it "should parse unencoded arguments in CTCP requests" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_request, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_request_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg2' ])
+      @ctcp.irc_privmsg_event @stem, @sender_hash, :message => "\01TEST arg1 arg2\01"
+    end
+    
+    it "should parse encoded arguments in CTCP requests" do
+      Autumn::CTCP::ENCODED_COMMANDS << 'TEST'
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_request, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg 2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_request_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg 2' ])
+      @ctcp.irc_privmsg_event @stem, @sender_hash, :message => "\01TEST arg1 arg\\@2\01"
+    end
+    
+    it "should correctly unescape all magic characters in its response" do
+      Autumn::CTCP::ENCODED_COMMANDS << 'TEST'
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_request, @ctcp, @stem, @sender_hash, [ "\000\001\n\r \\" ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_request_received, :test, @ctcp, @stem, @sender_hash, [ "\000\001\n\r \\" ])
+      @ctcp.irc_privmsg_event @stem, @sender_hash, :message => "\01TEST \\0\\1\\n\\r\\@\\\\\01"
+    end
+
+    it "should not parse space escapes in unencoded arguments in CTCP requests" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_request, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg\@2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_request_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg\@2' ])
+      @ctcp.irc_privmsg_event @stem, @sender_hash, :message => "\01TEST arg1 arg\\@2\01"
+    end
+
+    it "should parse CTCP responses in NOTICEs and broadcast two response-received methods" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_response, @ctcp, @stem, @sender_hash, [])
+      @stem.should_receive(:broadcast).once.with(:ctcp_response_received, :test, @ctcp, @stem, @sender_hash, [])
+      @ctcp.irc_notice_event @stem, @sender_hash, :message => "\01TEST\01"
+    end
+
+    it "should parse unencoded arguments in CTCP responses" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_response, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_response_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg2' ])
+      @ctcp.irc_notice_event @stem, @sender_hash, :message => "\01TEST arg1 arg2\01"
+    end
+
+    it "should parse encoded arguments in CTCP responses" do
+      Autumn::CTCP::ENCODED_COMMANDS << 'TEST'
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_response, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg 2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_response_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg 2' ])
+      @ctcp.irc_notice_event @stem, @sender_hash, :message => "\01TEST arg1 arg\\@2\01"
+    end
+
+    it "should not parse space escapes in unencoded arguments in CTCP responses" do
+      @stem.should_receive(:broadcast).once.with(:ctcp_test_response, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg\@2' ])
+      @stem.should_receive(:broadcast).once.with(:ctcp_response_received, :test, @ctcp, @stem, @sender_hash, [ 'arg1', 'arg\@2' ])
+      @ctcp.irc_notice_event @stem, @sender_hash, :message => "\01TEST arg1 arg\\@2\01"
+    end
+  end
+  
+  describe "with an actual stem" do
+    before :each do
+      @ctcp.instance_variable_set(:@reply_queue, Hash.new { |h,k| h[k] = Array.new })
+      
+      @stem = Autumn::Stem.new('irc.example.com', 'Example', :channel => '#example')
+      #TODO proper way to stub this?
+      @stem.instance_eval do
+        def privmsg(*args)
+          args
+        end
+      end
+      @stem.add_listener @ctcp
+    end
+    
+    it "should set the @ctcp variable in a stem when it's added as a listener to that stem" do
+      @stem.instance_variable_get(:@ctcp).should eql(@ctcp)
+    end
+    
+    it "should add a method of the form ctcp_* to the stem" do
+      lambda { @stem.ctcp_action("#example") }.should_not raise_error(NoMethodError)
+    end
+    
+    it "... which replies with a CTCP message" do
+      @stem.ctcp_action("#example").should eql([ "#example", "\001ACTION\001" ])
+    end
+    
+    it "... ... that properly encodes arguments when appropriate" do
+      @stem.ctcp_ping("#example", 'arg1', 'arg 2').should eql([ "#example", "\001PING arg1 arg\\@2\001" ])
+    end
+    
+    it "... ... ... escaping all magic characters" do
+      @stem.ctcp_ping("#example", "\n\r \\\000\001").should eql([ "#example", "\001PING " + '\n\r\@\\\\\0\1' + "\001" ])
+    end
+    
+    it "... ... that does not encode arguments when appropriate" do
+      @stem.ctcp_action("#example", "ABC 123").should eql([ "#example", "\001ACTION ABC 123\001" ])
+    end
+    
+    it "should add a method of the form ctcp_reply_* to the stem" do
+      lambda { @stem.ctcp_reply_ping("Pinger") }.should_not raise_error(NoMethodError)
+    end
+    
+    it "... which replies with a CTCP response" do
+      @stem.ctcp_reply_ping("Pinger")
+      reply_queue(@ctcp, @stem).shift.should == { :recipient => "Pinger", :message => "\001PING\001" }
+    end
+        
+    it "... ... that properly encodes arguments when appropriate" do
+      @stem.ctcp_reply_ping("Pinger", 'arg1', 'arg 2')
+      reply_queue(@ctcp, @stem).shift.should == { :recipient => "Pinger", :message => "\001PING arg1 arg\\@2\001" }
+    end
+    
+    it "... ... ... escaping all magic characters" do
+      @stem.ctcp_reply_ping("Pinger", "\n\r \\\000\001")
+      reply_queue(@ctcp, @stem).shift.should == { :recipient => "Pinger", :message => "\001PING " + '\n\r\@\\\\\0\1' + "\001" }
+    end
+    
+    it "... ... that does not encode arguments when appropriate" do
+      @stem.ctcp_reply_example("Tester", "ABC 123")
+      reply_queue(@ctcp, @stem).shift.should == { :recipient => "Tester", :message => "\001EXAMPLE ABC 123\001" }
+    end
+  end
+  
+  describe "with a mock stem that records message intervals" do
+    before :each do
+      @stem = Object.new
+      class << @stem
+        attr :received
+        
+        def notice(*args)
+          @received ||= Array.new
+          @received << Time.now
+        end
+        
+        def privmsg(*args)
+        end
+        
+        def average_interval
+          times = Array.new
+          @received.each_by { |a, b| times << b - a if a and b }
+          return times.sum/times.size.to_f
+        end
+      end
+      
+      @ctcp.added @stem
+    end
+    
+    it "should queue replies and fire them at the default interval of 0.25 seconds" do
+      10.times { @stem.ctcp_reply_ping "Pinger", "ABC123" }
+      sleep 3
+      @stem.average_interval.should be_close(0.25, 0.05)
+    end
+    
+    it "should drop replies from the queue when the default maximum of 10 is exceeded" do
+      Thread.exclusive { 15.times { @stem.ctcp_reply_ping "Pinger", "ABC123" } }
+      sleep 4
+      @stem.received.size.should be_close(10, 1.5)
+    end
+    
+    describe "with custom CTCP reply rate and queue length values" do
+      before :each do
+        @ctcp = Autumn::CTCP.new(:reply_rate => 0.5, :reply_queue_size => 5)
+        @ctcp.added @stem
+      end
+      
+      it "should queue replies and fire them at a custom interval" do
+        5.times { @stem.ctcp_reply_ping "Pinger", "ABC123" }
+        sleep 3
+        @stem.average_interval.should be_close(0.5, 0.05)
+      end
+      
+      it "should drop replies from the queue when a custom maximum is exceeded" do
+        15.times { @stem.ctcp_reply_ping "Pinger", "ABC123" }
+        sleep 4
+        @stem.received.size.should be_close(5, 1.5)
+      end
+    end
+  end
+  
+  it "should respond to CTCP VERSION requests" do
+    @ctcp.should respond_to(:ctcp_version_request)
+  end
+  
+  it "should respond to CTCP PING requests" do
+    @ctcp.should respond_to(:ctcp_ping_request)
+  end
+  
+  it "should respond to CTCP TIME requests" do
+    @ctcp.should respond_to(:ctcp_time_request)
+  end
+      
+  after :each do
+    Autumn::CTCP::ENCODED_COMMANDS.delete 'TEST'
+  end
+  
+  def reply_queue(ctcp, stem)
+    ctcp.instance_variable_get(:@reply_queue)[stem]
+  end
+end

data/spec/daemon_spec.rb

@@ -0,0 +1,202 @@
+require 'set'
+require 'rubygems'
+require 'facets/array'
+require 'facets/string'
+
+require 'autumn/misc'
+require 'autumn/daemon'
+
+describe Autumn::Daemon do
+  it "should not allow the creation of a default Daemon" do
+    lambda { Autumn::Daemon.new nil, nil }.should raise_error
+  end
+  
+  describe "(the default daemon)" do
+    it "should exist" do
+      Autumn::Daemon.default.should_not be_nil
+    end
+    
+    it "should parrot unknown properties" do
+      Autumn::Daemon.default.usermode['~'].should eql('~')
+      Autumn::Daemon.default.privilege['~'].should eql('~')
+      Autumn::Daemon.default.user_prefix['('].should eql('(')
+      Autumn::Daemon.default.channel_prefix['('].should eql('(')
+      Autumn::Daemon.default.channel_mode['~'].should eql('~')
+      Autumn::Daemon.default.server_mode['~'].should eql('~')
+      Autumn::Daemon.default.event[123].should eql(123)
+    end
+  end
+  
+  describe "with some standard options" do
+    before :each do
+      @daemon = Autumn::Daemon.new 'daemon', {
+        'usermode' => { 'f' => :first_usermode, 's' => :second_usermode },
+        'privilege' => { 'f' => :first_priv, 's' => :second_priv },
+        'user_prefix' => { '+' => :first_priv, '-' => :second_priv },
+        'channel_prefix' => { '#' => :first_chantype, '&' => :second_chantype },
+        'channel_mode' => { 'c' => :first_chanmode, 'd' => :second_chanmode },
+        'server_mode' => { 'F' => :first_srvrmode, 'S' => :second_srvrmode },
+        'event' => { 998 => :first_event, 997 => :second_event }
+      }
+    end
+  
+    it "should associate a Daemon with its name" do
+      Autumn::Daemon['daemon'].should equal(@daemon)
+    end
+    
+    it "should update the default Daemon with its properties" do
+      Autumn::Daemon.default.usermode['f'].should eql(:first_usermode)
+      Autumn::Daemon.default.privilege['f'].should eql(:first_priv)
+      Autumn::Daemon.default.user_prefix['+'].should eql(:first_priv)
+      Autumn::Daemon.default.channel_prefix['#'].should eql(:first_chantype)
+      Autumn::Daemon.default.channel_mode['c'].should eql(:first_chanmode)
+      Autumn::Daemon.default.server_mode['F'].should eql(:first_srvrmode)
+      Autumn::Daemon.default.event[998].should eql(:first_event)
+    end
+    
+    it "should return hashes merged with the default" do
+      Autumn::Daemon.default.usermode['b'] = :new_usermode
+      Autumn::Daemon.default.privilege['b'] = :new_priv
+      Autumn::Daemon.default.user_prefix['$'] = :new_uprefix
+      Autumn::Daemon.default.channel_prefix['%'] = :new_cprefix
+      Autumn::Daemon.default.channel_mode['b'] = :new_chanmode
+      Autumn::Daemon.default.server_mode['B'] = :new_srvmode
+      Autumn::Daemon.default.event[100] = :new_event
+      
+      @daemon.usermode['b'].should eql(:new_usermode)
+      @daemon.privilege['b'].should eql(:new_priv)
+      @daemon.user_prefix['$'].should eql(:new_uprefix)
+      @daemon.channel_prefix['%'].should eql(:new_cprefix)
+      @daemon.channel_mode['b'].should eql(:new_chanmode)
+      @daemon.server_mode['B'].should eql(:new_srvmode)
+      @daemon.event[100].should eql(:new_event)
+    end
+    
+    it "should parrot unknown properties" do
+      @daemon.usermode['~'].should eql('~')
+      @daemon.privilege['~'].should eql('~')
+      @daemon.user_prefix['('].should eql('(')
+      @daemon.channel_prefix['('].should eql('(')
+      @daemon.channel_mode['~'].should eql('~')
+      @daemon.server_mode['~'].should eql('~')
+      @daemon.event[123].should eql(123)
+    end
+    
+    it "should recognize a change in user privilege as such" do
+      @daemon.privilege_mode?('+f').should be_true
+    end
+    
+    it "should recognize a change in channel mode as such" do
+      @daemon.privilege_mode?('+c').should be_false
+    end
+    
+    it "should raise an exception when privilege_mode? is called with an invalid mode string" do
+      lambda { @daemon.privilege_mode?('invalid') }.should raise_error
+    end
+    
+    it "should recognize when a nick is prefixed" do
+      @daemon.nick_prefixed?('+Nick').should be_true
+    end
+    
+    it "should recognize when a nick is not prefixed" do
+      @daemon.nick_prefixed?('Nick').should be_false
+    end
+    
+    it "should be able to strip a nick of prefix characters" do
+      @daemon.just_nick('+Nick').should eql('Nick')
+    end
+    
+    it "should, when asked to strip a nick with no prefix characters, return that same nick" do
+      @daemon.just_nick('Nick').should eql('Nick')
+    end
+    
+    it "should give the privilege of a nick with no prefixes as :unvoiced" do
+      @daemon.nick_privilege('Nick').should eql(:unvoiced)
+    end
+    
+    it "should correctly give the privilege of a nick with one prefix" do
+      @daemon.nick_privilege('+Nick').should eql(:first_priv)
+    end
+    
+    it "should correctly give the privileges of a nick with multiple prefixes" do
+      @daemon.nick_privilege('+-Nick').should == [ :first_priv, :second_priv ].to_set
+    end
+    
+    it "should add predicate methods for each hash which return true for known values" do
+      @daemon.usermode?('f').should be_true
+      @daemon.privilege?('f').should be_true
+      @daemon.user_prefix?('+').should be_true
+      @daemon.channel_prefix?('#').should be_true
+      @daemon.channel_mode?('c').should be_true
+      @daemon.server_mode?('F').should be_true
+      @daemon.event?(998).should be_true
+    end
+    
+    it "... and return false for unknown values" do
+      @daemon.usermode?('~').should be_false
+      @daemon.privilege?('~').should be_false
+      @daemon.user_prefix?('(').should be_false
+      @daemon.channel_prefix?('(').should be_false
+      @daemon.channel_mode?('~').should be_false
+      @daemon.server_mode?('~').should be_false
+      @daemon.event?(123).should be_false
+    end
+    
+    it "... and should work with numeric prefix characters" do
+      @daemon.user_prefix?(?+).should be_true
+      @daemon.channel_prefix?(?#).should be_true
+    end
+    
+    it "... and should return values in the default daemon as well" do
+      Autumn::Daemon.default.usermode['b'] = :new_usermode
+      Autumn::Daemon.default.privilege['b'] = :new_priv
+      Autumn::Daemon.default.user_prefix['$'] = :new_uprefix
+      Autumn::Daemon.default.channel_prefix['%'] = :new_cprefix
+      Autumn::Daemon.default.channel_mode['b'] = :new_chanmode
+      Autumn::Daemon.default.server_mode['B'] = :new_srvmode
+      Autumn::Daemon.default.event[100] = :new_event
+      
+      @daemon.usermode?('b').should be_true
+      @daemon.privilege?('b').should be_true
+      @daemon.user_prefix?('$').should be_true
+      @daemon.channel_prefix?('%').should be_true
+      @daemon.channel_mode?('b').should be_true
+      @daemon.server_mode?('B').should be_true
+      @daemon.event?(100).should be_true
+    end
+    
+    describe "initialized along with a second Daemon with some duplicate properties" do
+      before :each do
+        @daemon2 = Autumn::Daemon.new 'daemon2', {
+          'usermode' => { 'f' => :first_usermode, 's' => :other_usermode },
+          'privilege' => { 'f' => :first_priv, 's' => :other_priv },
+          'user_prefix' => { '+' => :first_priv, '-' => :other_priv },
+          'channel_prefix' => { '#' => :first_chantype, '&' => :other_chantype },
+          'channel_mode' => { 'c' => :first_chanmode, 'd' => :other_chanmode },
+          'server_mode' => { 'F' => :first_srvrmode, 'S' => :other_srvrmode },
+          'event' => { 998 => :first_event, 997 => :other_event }
+        }
+      end
+      
+      it "should not remove the duplicate properties with identical values from the default Daemon" do
+        Autumn::Daemon.default.usermode['f'].should eql(:first_usermode)
+        Autumn::Daemon.default.privilege['f'].should eql(:first_priv)
+        Autumn::Daemon.default.user_prefix['+'].should eql(:first_priv)
+        Autumn::Daemon.default.channel_prefix['#'].should eql(:first_chantype)
+        Autumn::Daemon.default.channel_mode['c'].should eql(:first_chanmode)
+        Autumn::Daemon.default.server_mode['F'].should eql(:first_srvrmode)
+        Autumn::Daemon.default.event[998].should eql(:first_event)
+      end
+      
+      it "should remove the duplicate properties with different values from the default Daemon" do
+        Autumn::Daemon.default.usermode['s'].should eql('s')
+        Autumn::Daemon.default.privilege['s'].should eql('s')
+        Autumn::Daemon.default.user_prefix['-'].should eql('-')
+        Autumn::Daemon.default.channel_prefix['&'].should eql('&')
+        Autumn::Daemon.default.channel_mode['d'].should eql('d')
+        Autumn::Daemon.default.server_mode['S'].should eql('S')
+        Autumn::Daemon.default.event[997].should eql(997)
+      end
+    end
+  end
+end