sidekick-client 0.2.1 → 0.2.2

data/lib/ext/eventmachine-0.12.10/tests/test_ltp.rb

@@ -1,182 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-#
-
-require 'eventmachine'
-require 'test/unit'
-
-class TestLineAndTextProtocol < Test::Unit::TestCase
-
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-
-  #--------------------------------------------------------------------
-
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-    def receive_line line
-      @line_buffer << line
-    end
-  end
-
-  module StopClient
-    def set_receive_data(&blk)
-      @rdb = blk
-    end
-    
-    def receive_data data
-      @rdb.call(data) if @rdb
-    end
-    
-    def unbind
-      EM.add_timer(0.1) { EM.stop }
-    end
-  end
-
-
-  def test_simple_lines
-    lines_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
-        conn.instance_eval "@line_buffer = lines_received"
-      end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.send_data "aaa\nbbb\r\nccc\n"
-        c.close_connection_after_writing
-      end
-    }
-    assert_equal( %w(aaa bbb ccc), lines_received )
-  end
-
-  #--------------------------------------------------------------------
-
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-    def receive_error text
-      @error_message << text
-    end
-  end
-
-  def test_overlength_lines
-    lines_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
-        conn.instance_eval "@error_message = lines_received"
-      end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.send_data "a" * (16*1024 + 1)
-        c.send_data "\n"
-        c.close_connection_after_writing
-      end
-
-    }
-    assert_equal( ["overlength line"], lines_received )
-  end
-
-
-  #--------------------------------------------------------------------
-
-  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
-    def receive_line line
-      if line =~ /content-length:\s*(\d+)/i
-        @content_length = $1.to_i
-      elsif line.length == 0
-        set_binary_mode @content_length
-      end
-    end
-    def receive_binary_data text
-      send_data "received #{text.length} bytes"
-      close_connection_after_writing
-    end
-  end
-
-  def test_lines_and_text
-    output = ''
-    lines_received = []
-    text_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
-        conn.instance_eval "@lines = lines_received; @text = text_received"
-      end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.set_receive_data { |data| output << data }
-        c.send_data "Content-length: 400\n"
-        c.send_data "\n"
-        c.send_data "A" * 400
-        EM.add_timer(0.1) { c.close_connection_after_writing }
-      end
-    }
-    assert_equal( "received 400 bytes", output )
-  end
-
-  #--------------------------------------------------------------------
-
-
-  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
-    def receive_line line
-      if line =~ /content-length:\s*(\d+)/i
-        set_binary_mode $1.to_i
-      else
-        raise "protocol error"
-      end
-    end
-    def receive_binary_data text
-      send_data "received #{text.length} bytes"
-      close_connection_after_writing
-    end
-  end
-
-  def test_binary_text
-    output = ''
-    lines_received = []
-    text_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
-        conn.instance_eval "@lines = lines_received; @text = text_received"
-      end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.set_receive_data { |data| output << data }
-        c.send_data "Content-length: 10000\n"
-        c.send_data "A" * 10000
-        EM.add_timer(0.2) { c.close_connection_after_writing }
-      end
-    }
-    assert_equal( "received 10000 bytes", output )
-  end
-
-  #--------------------------------------------------------------------
-end

data/lib/ext/eventmachine-0.12.10/tests/test_ltp2.rb

@@ -1,317 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-# TODO!!! Need tests for overlength headers and text bodies.
-
-class TestLineText2 < Test::Unit::TestCase
-
-  # Run each of these tests two ways: passing in the whole test-dataset in one chunk,
-  # and passing it in one character at a time.
-
-  class Basic
-    include EM::Protocols::LineText2
-    attr_reader :lines
-    def receive_line line
-      (@lines ||= []) << line
-    end
-  end
-  def test_basic
-    testdata = "Line 1\nLine 2\r\nLine 3\n"
-
-    a = Basic.new
-    a.receive_data testdata
-    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
-
-    a = Basic.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
-  end
-
-  class ChangeDelimiter
-    include EM::Protocols::LineText2
-    attr_reader :lines
-    def initialize *args
-      super
-      @delim = "A"
-      set_delimiter @delim
-    end
-    def receive_line line
-      (@lines ||= []) << line
-      set_delimiter( @delim.succ! )
-    end
-  end
-
-  def test_change_delimiter
-    testdata = %Q(LineaALinebBLinecCLinedD)
-
-    a = ChangeDelimiter.new
-    a.receive_data testdata
-    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
-
-    a = ChangeDelimiter.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
-  end
-
-
-  #--
-  # Test two lines followed by an empty line, ten bytes of binary data, then
-  # two more lines.
-
-  class Binary
-    include EM::Protocols::LineText2
-    attr_reader :lines, :body
-    def initialize *args
-      super
-      @lines = []
-      @body = nil
-    end
-    def receive_line ln
-      if ln == ""
-        set_text_mode 10
-      else
-        @lines << ln
-      end
-    end
-    def receive_binary_data data
-      @body = data
-    end
-  end
-
-  def test_binary
-    testdata = %Q(Line 1
-Line 2
-
-0000000000Line 3
-Line 4
-)
-
-    a = Binary.new
-    a.receive_data testdata
-    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
-    assert_equal( "0000000000", a.body )
-
-    a = Binary.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
-    assert_equal( "0000000000", a.body )
-  end
-
-
-  # Test unsized binary data. The expectation is that each chunk of it
-  # will be passed to us as it it received.
-  class UnsizedBinary
-    include EM::Protocols::LineText2
-    attr_reader :n_calls, :body
-    def initialize *args
-      super
-      set_text_mode
-    end
-    def receive_binary_data data
-      @n_calls ||= 0
-      @n_calls += 1
-      (@body ||= "") << data
-    end
-  end
-
-  def test_unsized_binary
-    testdata = "X\0" * 1000
-
-    a = UnsizedBinary.new
-    a.receive_data testdata
-    assert_equal( 1, a.n_calls )
-    assert_equal( testdata, a.body )
-
-    a = UnsizedBinary.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( 2000, a.n_calls )
-    assert_equal( testdata, a.body )
-  end
-
-
-  # Test binary data with a "throw back" into line-mode.
-  class ThrowBack
-    include EM::Protocols::LineText2
-    attr_reader :headers
-    def initialize *args
-      super
-      @headers = []
-      @n_bytes = 0
-      set_text_mode
-    end
-    def receive_binary_data data
-      wanted = 25 - @n_bytes
-      will_take = if data.length > wanted
-                    data.length - wanted
-                  else
-                    data.length
-                  end
-      @n_bytes += will_take
-
-      if @n_bytes == 25
-        set_line_mode( data[will_take..-1] )
-      end
-    end
-    def receive_line ln
-      @headers << ln
-    end
-  end
-  def test_throw_back
-    testdata = "Line\n" * 10
-
-    a = ThrowBack.new
-    a.receive_data testdata
-    assert_equal( ["Line"] * 5, a.headers )
-
-    a = ThrowBack.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( ["Line"] * 5, a.headers )
-  end
-
-  # Test multi-character line delimiters.
-  # Also note that the test data has a "tail" with no delimiter, that will be
-  # discarded, but cf. the BinaryTail test.
-  # TODO!!! This test doesn't work in the byte-by-byte case.
-  class Multichar
-    include EM::Protocols::LineText2
-    attr_reader :lines
-    def initialize *args
-      super
-      @lines = []
-      set_delimiter "012"
-    end
-    def receive_line ln
-      @lines << ln
-    end
-  end
-  def test_multichar
-    testdata = "Line012Line012Line012Line"
-
-    a = Multichar.new
-    a.receive_data testdata
-    assert_equal( ["Line"]*3, a.lines )
-
-    a = Multichar.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    # DOESN'T WORK in this case. Multi-character delimiters are broken.
-    #assert_equal( ["Line"]*3, a.lines )
-  end
-
-  # Test a binary "tail," when a sized binary transfer doesn't complete because
-  # of an unbind. We get a partial result.
-  class BinaryTail
-    include EM::Protocols::LineText2
-    attr_reader :data
-    def initialize *args
-      super
-      @data = ""
-      set_text_mode 1000
-    end
-    def receive_binary_data data
-      # we expect to get all the data in one chunk, even in the byte-by-byte case,
-      # because sized transfers by definition give us exactly one call to
-      # #receive_binary_data.
-      @data = data
-    end
-  end
-  def test_binary_tail
-    testdata = "0" * 500
-
-    a = BinaryTail.new
-    a.receive_data testdata
-    a.unbind
-    assert_equal( "0" * 500, a.data )
-
-    a = BinaryTail.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    a.unbind
-    assert_equal( "0" * 500, a.data )
-  end
-
-
-  # Test an end-of-binary call. Arrange to receive binary data but don't bother counting it
-  # as it comes. Rely on getting receive_end_of_binary_data to signal the transition back to
-  # line mode.
-  # At the present time, this isn't strictly necessary with sized binary chunks because by
-  # definition we accumulate them and make exactly one call to receive_binary_data, but
-  # we may want to support a mode in the future that would break up large chunks into multiple
-  # calls.
-  class LazyBinary
-    include EM::Protocols::LineText2
-    attr_reader :data, :end
-    def initialize *args
-      super
-      @data = ""
-      set_text_mode 1000
-    end
-    def receive_binary_data data
-      # we expect to get all the data in one chunk, even in the byte-by-byte case,
-      # because sized transfers by definition give us exactly one call to
-      # #receive_binary_data.
-      @data = data
-    end
-    def receive_end_of_binary_data
-      @end = true
-    end
-  end
-  def test_receive_end_of_binary_data
-    testdata = "_" * 1000
-    a = LazyBinary.new
-    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
-    assert_equal( "_" * 1000, a.data )
-    assert( a.end )
-  end
-
-
-  # This tests a bug fix in which calling set_text_mode failed when called
-  # inside receive_binary_data.
-  #
-  class BinaryPair
-    include EM::Protocols::LineText2
-    attr_reader :sizes
-    def initialize *args
-      super
-      set_text_mode 1
-      @sizes = []
-    end
-    def receive_binary_data dt
-      @sizes <<  dt.length
-      set_text_mode( (dt.length == 1) ? 2 : 1 )
-    end
-  end
-  def test_binary_pairs
-    test_data = "123" * 5
-    a = BinaryPair.new
-    a.receive_data test_data
-    assert_equal( [1,2,1,2,1,2,1,2,1,2], a.sizes )
-  end
-
-end

data/lib/ext/eventmachine-0.12.10/tests/test_next_tick.rb

@@ -1,133 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestNextTick < Test::Unit::TestCase
-
-  def test_tick_arg
-    pr = proc {EM.stop}
-    EM.run {
-      EM.next_tick pr
-    }
-    assert true
-  end
-
-  def test_tick_block
-    EM.run {
-      EM.next_tick {EM.stop}
-    }
-    assert true
-  end
-
-  # This illustrates the solution to a long-standing problem.
-  # It's now possible to correctly nest calls to EM#run.
-  # See the source code commentary for EM#run for more info.
-  #
-  def test_run_run
-    EM.run {
-      EM.run {
-        EM.next_tick {EM.stop}
-      }
-    }
-  end
-
-  def test_pre_run_queue
-    x = false
-    EM.next_tick { EM.stop; x = true }
-    EM.run { EM.add_timer(0.2) { EM.stop } }
-    assert x
-  end
-
-  def test_cleanup_after_stop
-    x = true
-    EM.run{
-      EM.next_tick{
-        EM.stop
-        EM.next_tick{ x=false }
-      }
-    }
-    EM.run{
-      EM.next_tick{ EM.stop }
-    }
-    assert x
-  end
-
-  # We now support an additional parameter for EM#run.
-  # You can pass two procs to EM#run now. The first is executed as the normal
-  # run block. The second (if given) is scheduled for execution after the
-  # reactor loop completes.
-  # The reason for supporting this is subtle. There has always been an expectation
-  # that EM#run doesn't return until after the reactor loop ends. But now it's
-  # possible to nest calls to EM#run, which means that a nested call WILL
-  # RETURN. In order to write code that will run correctly either way, it's
-  # recommended to put any code which must execute after the reactor completes
-  # in the second parameter.
-  #
-  def test_run_run_2
-    a = proc {EM.stop}
-    b = proc {assert true}
-    EM.run a, b
-  end
-
-
-  # This illustrates that EM#run returns when it's called nested.
-  # This isn't a feature, rather it's something to be wary of when writing code
-  # that must run correctly even if EM#run is called while a reactor is already
-  # running.
-  def test_run_run_3
-    a = []
-    EM.run {
-      EM.run proc {EM.stop}, proc {a << 2}
-      a << 1
-    }
-    assert_equal( [1,2], a )
-  end
-
-
-  def test_schedule_on_reactor_thread
-    x = false
-    EM.run do
-      EM.schedule { x = true }
-      EM.stop
-    end
-    assert x
-  end
-
-  def test_schedule_from_thread
-    x = false
-    EM.run do
-      Thread.new { EM.schedule { x = true } }.join
-      assert !x
-      EM.next_tick { EM.stop }
-    end
-    assert x
-  end
-
-end

data/lib/ext/eventmachine-0.12.10/tests/test_object_protocol.rb

@@ -1,37 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestObjectProtocol < Test::Unit::TestCase
-  Host = "127.0.0.1"
-  Port = 9550
-
-  module Server
-    include EM::P::ObjectProtocol
-    def post_init
-      send_object :hello=>'world'
-    end
-    def receive_object obj
-      $server = obj
-      EM.stop
-    end
-  end
-
-  module Client
-    include EM::P::ObjectProtocol
-    def receive_object obj
-      $client = obj
-      send_object 'you_said'=>obj
-    end
-  end
-
-  def test_send_receive
-    EM.run{
-      EM.start_server Host, Port, Server
-      EM.connect Host, Port, Client
-    }
-
-    assert($client == {:hello=>'world'})
-    assert($server == {'you_said'=>{:hello=>'world'}})
-  end
-end