sidekick-client 0.2.1 → 0.2.2

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

@@ -1,47 +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 TestDeferUsage < Test::Unit::TestCase
-
-  def test_defers
-    n = 0
-    n_times = 20
-    EM.run {
-      n_times.times {
-        work_proc = proc { n += 1 }
-        callback = proc { EM.stop if n == n_times }
-        EM.defer work_proc, callback
-      }
-    }
-    assert_equal( n, n_times )
-  end unless RUBY_VERSION >= '1.9.0'
-
-end
-

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

@@ -1,160 +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.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-# TODO, and I know this doesn't belong here, but if a datagram calls
-# send_data outside of a receive_data, there is no return address, and
-# the result is a very confusing error message.
-#
-
-require 'eventmachine'
-require 'test/unit'
-
-
-class TestEpoll < Test::Unit::TestCase
-
-  module TestEchoServer
-    def receive_data data
-      send_data data
-      close_connection_after_writing
-    end
-  end
-
-  module TestEchoClient
-    def connection_completed
-      send_data "ABCDE"
-      $max += 1
-    end
-    def receive_data data
-      raise "bad response" unless data == "ABCDE"
-    end
-    def unbind
-      $n -= 1
-      EM.stop if $n == 0
-    end
-  end
-
-
-  # We can set the rlimit/nofile of a process but we can only set it
-  # higher if we're running as root.
-  # On most systems, the default value is 1024.
-  # Java doesn't (currently) implement this.
-  def test_rlimit
-    unless RUBY_PLATFORM =~ /java/ or EM.set_descriptor_table_size >= 1024
-      a = EM.set_descriptor_table_size
-      assert( a <= 1024 )
-      a = EM.set_descriptor_table_size( 1024 )
-      assert( a == 1024 )
-    end
-  end
-
-  # Run a high-volume version of this test by kicking the number of connections
-  # up past 512. (Each connection uses two sockets, a client and a server.)
-  # (Will require running the test as root)
-  # This test exercises TCP clients and servers.
-  #
-  # XXX this test causes all sort of weird issues on OSX (when run as part of the suite)
-  def _test_descriptors
-    EM.epoll
-    s = EM.set_descriptor_table_size 60000
-    EM.run {
-      EM.start_server "127.0.0.1", 9800, TestEchoServer
-      $n = 0
-      $max = 0
-      100.times {
-        EM.connect("127.0.0.1", 9800, TestEchoClient) {$n += 1}
-      }
-    }
-    assert_equal(0, $n)
-    assert_equal(100, $max)
-  end
-
-  def test_defer
-    n = 0
-    work_proc = proc {n += 1}
-    callback_proc = proc {EM.stop}
-    EM.run {
-      EM.defer work_proc, callback_proc
-    }
-    assert_equal( 1, n )
-  end unless RUBY_VERSION >= '1.9.0'
-
-
-  module TestDatagramServer
-    def receive_data dgm
-      $in = dgm
-      send_data "abcdefghij"
-    end
-  end
-  module TestDatagramClient
-    def post_init
-      send_datagram "1234567890", "127.0.0.1", 9500
-    end
-    def receive_data dgm
-      $out = dgm
-      EM.stop
-    end
-  end
-
-  def test_datagrams
-    $in = $out = ""
-    EM.run {
-      EM.open_datagram_socket "127.0.0.1", 9500, TestDatagramServer
-      EM.open_datagram_socket "127.0.0.1", 0, TestDatagramClient
-    }
-    assert_equal( "1234567890", $in )
-    assert_equal( "abcdefghij", $out )
-  end
-
-  # XXX this test fails randomly..
-  def _test_unix_domain
-    fn = "/tmp/xxx.chain"
-    EM.epoll
-    s = EM.set_descriptor_table_size 60000
-    EM.run {
-      # The pure-Ruby version won't let us open the socket if the node already exists.
-      # Not sure, that actually may be correct and the compiled version is wrong.
-      # Pure Ruby also oddly won't let us make that many connections. This test used
-      # to run 100 times. Not sure where that lower connection-limit is coming from in
-      # pure Ruby.
-      # Let's not sweat the Unix-ness of the filename, since this test can't possibly
-      # work on Windows anyway.
-      #
-      File.unlink(fn) if File.exist?(fn)
-      EM.start_unix_domain_server fn, TestEchoServer
-      $n = 0
-      $max = 0
-      50.times {
-        EM.connect_unix_domain(fn, TestEchoClient) {$n += 1}
-      }
-      EM::add_timer(1) { $stderr.puts("test_unix_domain timed out!"); EM::stop }
-    }
-    assert_equal(0, $n)
-    assert_equal(50, $max)
-  ensure
-    File.unlink(fn) if File.exist?(fn)
-  end
-
-end
-

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

@@ -1,35 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestErrorHandler < Test::Unit::TestCase
-  def test_error_handler
-    error = nil
-    EM.error_handler{ |e|
-      error = e
-      EM.error_handler(nil)
-      EM.stop
-    }
-
-    assert_nothing_raised do
-      EM.run{
-        EM.add_timer(0){
-          raise 'test'
-        }
-      }
-    end
-
-    assert_equal error.class, RuntimeError
-    assert_equal error.message, 'test'
-  end
-
-  def test_without_error_handler
-    assert_raise RuntimeError do
-      EM.run{
-        EM.add_timer(0){
-          raise 'test'
-        }
-      }
-    end
-  end
-end

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

@@ -1,82 +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.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
-
-
-###### THIS TEST IS NOW OBSOLETE.
-###### As of 27Dec07, the hookable error handling is obsolete because
-###### of its performance impact.
-
-
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestErrors < Test::Unit::TestCase
-
-  Localhost = "127.0.0.1"
-  Localport = 9801
-
-  def setup
-  end
-
-  def obsolete_teardown
-    # Calling #set_runtime_error_hook with no block restores the
-    # default handling of runtime_errors.
-    #
-    EM.set_runtime_error_hook
-  end
-
-  def test_no_tests_stub
-  end
-
-  # EM has a default handler for RuntimeErrors that are emitted from
-  # user written code. You can override the handler if you wish, but it's
-  # easier to call #set_runtime_error_hook.
-  # Ordinarily, an error in user code invoked by the reactor aborts the
-  # run.
-  #
-  def obsolete_test_unhandled_error
-    assert_raises( RuntimeError ) {
-      EM.run {
-        EM.add_timer(0) {raise "AAA"}
-      }
-    }
-
-  end
-
-  def obsolete_test_handled_error
-    err = nil
-    EM.run {
-      EM.set_runtime_error_hook {
-        err = true
-        EM.stop
-      }
-      EM.add_timer(0) {raise "AAA"}
-    }
-    assert err
-  end
-end
-

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

@@ -1,55 +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 TestSomeExceptions < Test::Unit::TestCase
-
-  # Read the commentary in EventMachine#run.
-  # This test exercises the ensure block in #run that makes sure
-  # EventMachine#release_machine gets called even if an exception is
-  # thrown within the user code. Without the ensured call to release_machine,
-  # the second call to EventMachine#run will fail with a C++ exception
-  # because the machine wasn't cleaned up properly.
-
-  def test_a
-    assert_raises(RuntimeError) {
-      EventMachine.run {
-      raise "some exception"
-    }
-    }
-  end
-
-  def test_b
-    assert_raises(RuntimeError) {
-      EventMachine.run {
-      raise "some exception"
-    }
-    }
-  end
-
-end

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

@@ -1,49 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestFileWatch < Test::Unit::TestCase
-  module FileWatcher
-    def file_modified
-      $modified = true
-    end
-    def file_deleted
-      $deleted = true
-    end
-    def unbind
-      $unbind = true
-      EM.stop
-    end
-  end
-
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
-
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  end
-
-  def test_events
-    EM.run{
-      require 'tempfile'
-      file = Tempfile.new('em-watch')
-      $tmp_path = file.path
-
-      # watch it
-      watch = EM.watch_file(file.path, FileWatcher)
-      $path = watch.path
-
-      # modify it
-      File.open(file.path, 'w'){ |f| f.puts 'hi' }
-
-      # delete it
-      EM.add_timer(0.25){ file.close; file.delete }
-    }
-
-    assert_equal($path, $tmp_path)
-    assert($modified)
-    assert($deleted)
-    assert($unbind)
-  end
-end

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

@@ -1,198 +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 TestFutures < Test::Unit::TestCase
-
-  def setup
-  end
-
-  def teardown
-  end
-
-  def test_future
-      assert_equal(100, EventMachine::Deferrable.future(100) )
-
-      p1 = proc { 100 + 1 }
-      assert_equal(101, EventMachine::Deferrable.future(p1) )
-  end
-
-  class MyFuture
-      include EventMachine::Deferrable
-      def initialize *args
-        super
-        set_deferred_status :succeeded, 40
-      end
-  end
-
-  class MyErrorFuture
-      include EventMachine::Deferrable
-      def initialize *args
-        super
-        set_deferred_status :failed, 41
-      end
-  end
-
-
-  def test_future_1
-      # Call future with one additional argument and it will be treated as a callback.
-      def my_future
-        MyFuture.new
-      end
-
-      value = nil
-      EventMachine::Deferrable.future my_future, proc {|v| value=v}
-      assert_equal( 40, value )
-  end
-
-
-  def test_future_2
-      # Call future with two additional arguments and they will be treated as a callback
-      # and an errback.
-      value = nil
-      EventMachine::Deferrable.future MyErrorFuture.new, nil, proc {|v| value=v}
-      assert_equal( 41, value )
-  end
-
-
-  def test_future_3
-      # Call future with no additional arguments but with a block, and the block will be
-      # treated as a callback.
-      value = nil
-      EventMachine::Deferrable.future MyFuture.new do |v|
-        value=v
-      end
-      assert_equal( 40, value )
-  end
-
-
-  class RecursiveCallback
-      include EventMachine::Deferrable
-  end
-
-  # A Deferrable callback can call #set_deferred_status to change the values
-  # passed to subsequent callbacks.
-  #
-  def test_recursive_callbacks
-      n = 0 # counter assures that all the tests actually run.
-      rc = RecursiveCallback.new
-      rc.callback {|a|
-        assert_equal(100, a)
-        n += 1
-        rc.set_deferred_status :succeeded, 101, 101
-      }
-      rc.callback {|a,b|
-        assert_equal(101, a)
-        assert_equal(101, b)
-        n += 1
-        rc.set_deferred_status :succeeded, 102, 102, 102
-      }
-      rc.callback {|a,b,c|
-        assert_equal(102, a)
-        assert_equal(102, b)
-        assert_equal(102, c)
-        n += 1
-      }
-      rc.set_deferred_status :succeeded, 100
-      assert_equal(3, n)
-  end
-
-  def test_syntactic_sugar
-    rc = RecursiveCallback.new
-    rc.set_deferred_success 100
-    rc.set_deferred_failure 200
-  end
-
-  # It doesn't raise an error to set deferred status more than once.
-  # In fact, this is a desired and useful idiom when it happens INSIDE
-  # a callback or errback.
-  # However, it's less useful otherwise, and in fact would generally be
-  # indicative of a programming error. However, we would like to be resistant
-  # to such errors. So whenever we set deferred status, we also clear BOTH
-  # stacks of handlers.
-  #
-  def test_double_calls
-    s = 0
-    e = 0
-
-    d = EM::DefaultDeferrable.new
-    d.callback {s += 1}
-    d.errback {e += 1}
-
-    d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
-    d.fail	  # Presumably an error. We expect the errback NOT to be called.
-    d.succeed	# We expect the callback to have been discarded and NOT to be called again.
-
-    assert_equal(1, s)
-    assert_equal(0, e)
-  end
-
-  # Adding a callback to a Deferrable that is already in a success state executes the callback
-  # immediately. The same applies to a an errback added to an already-failed Deferrable.
-  # HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
-  # to failed ones.
-  #
-  # We illustrate this with a rather contrived test. The test calls #fail after #succeed,
-  # which ordinarily would not happen in a real program.
-  #
-  # What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
-  # failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
-  # type for immediate execution? For now at least, the official answer is "don't do that."
-  #
-  def test_delayed_callbacks
-    s1 = 0
-    s2 = 0
-    e = 0
-
-    d = EM::DefaultDeferrable.new
-    d.callback {s1 += 1}
-
-    d.succeed # Triggers and discards the callback.
-
-    d.callback {s2 += 1} # This callback is executed immediately and discarded.
-
-    d.errback {e += 1} # This errback should be DISCARDED and never execute.
-    d.fail # To prove it, fail and assert e is 0
-
-    assert_equal( [1,1], [s1,s2] )
-    assert_equal( 0, e )
-  end
-
-  def test_timeout
-    n = 0
-    EM.run {
-      d = EM::DefaultDeferrable.new
-      d.callback {n = 1; EM.stop}
-      d.errback {n = 2; EM.stop}
-      d.timeout(1)
-    }
-    assert_equal( 2, n )
-  end
-
-end

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

@@ -1,30 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'eventmachine'
-require 'socket'
-require 'test/unit'
-
-class TestGetSockOpt < Test::Unit::TestCase
-
-  def setup
-    assert(!EM.reactor_running?)
-  end
-
-  def teardown
-    assert(!EM.reactor_running?)
-  end
-
-  #-------------------------------------
-
-  def test_get_sock_opt
-    test = self
-    EM.run do
-      EM.connect 'google.com', 80, Module.new {
-        define_method :connection_completed do
-          val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_ERROR
-          test.assert_equal "\0\0\0\0", val
-          EM.stop
-        end
-      }
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestHandlerCheck < Test::Unit::TestCase
-
-  class Foo < EM::Connection; end;
-  module TestModule; end;
-
-  def test_with_correct_class
-    assert_nothing_raised do
-      EM.run {
-        EM.connect("127.0.0.1", 80, Foo)
-        EM.stop_event_loop
-      }
-    end
-  end
-
-  def test_with_incorrect_class
-    assert_raise(ArgumentError) do
-      EM.run {
-        EM.connect("127.0.0.1", 80, String)
-        EM.stop_event_loop
-      }
-    end
-  end
-
-  def test_with_module
-    assert_nothing_raised do
-      EM.run {
-        EM.connect("127.0.0.1", 80, TestModule)
-        EM.stop_event_loop
-      }
-    end
-  end
-
-end