sidekick-client 0.2.1 → 0.2.2

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

@@ -1,322 +0,0 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 25 Aug 2007
-# 
-# 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 TestSpawn < Test::Unit::TestCase
-
-  # Spawn a process that simply stops the reactor.
-  # Assert that the notification runs after the block that calls it.
-  #
-  def test_stop
-    x = nil
-    EM.run {
-      s = EM.spawn {EM.stop}
-      s.notify
-      x = true
-    }
-    assert x
-  end
-
-
-  # Pass a parameter to a spawned process.
-  #
-  def test_parms
-    val = 5
-    EM.run {
-      s = EM.spawn {|v| val *= v; EM.stop}
-      s.notify 3
-    }
-    assert_equal( 15, val )
-  end
-
-  # Pass multiple parameters to a spawned process.
-  #
-  def test_multiparms
-    val = 5
-    EM.run {
-      s = EM.spawn {|v1,v2| val *= (v1 + v2); EM.stop}
-      s.notify 3,4
-    }
-    assert_equal( 35, val )
-  end
-
-
-  # This test demonstrates that a notification does not happen immediately,
-  # but rather is scheduled sometime after the current code path completes.
-  #
-  def test_race
-    x = 0
-    EM.run {
-      s = EM.spawn {x *= 2; EM.stop}
-      s.notify
-      x = 2
-    }
-    assert_equal( 4, x)
-  end
-
-
-  # Spawn a process and notify it 25 times to run fibonacci
-  # on a pair of global variables.
-  #
-  def test_fibonacci
-    x = 1
-    y = 1
-    EM.run {
-      s = EM.spawn {x,y = y,x+y}
-      25.times {s.notify}
-
-      t = EM.spawn {EM.stop}
-      t.notify
-    }
-    assert_equal( 121393, x)
-    assert_equal( 196418, y)
-  end
-
-  # This one spawns 25 distinct processes, and notifies each one once,
-  # rather than notifying a single process 25 times.
-  #
-  def test_another_fibonacci
-    x = 1
-    y = 1
-    EM.run {
-      25.times {
-      s = EM.spawn {x,y = y,x+y}
-      s.notify
-    }
-
-    t = EM.spawn {EM.stop}
-    t.notify
-    }
-    assert_equal( 121393, x)
-    assert_equal( 196418, y)
-  end
-
-
-  # Make a chain of processes that notify each other in turn
-  # with intermediate fibonacci results. The final process in
-  # the chain stops the loop and returns the result.
-  #
-  def test_fibonacci_chain
-    a,b = nil
-
-    EM.run {
-      nextpid = EM.spawn {|x,y|
-        a,b = x,y
-        EM.stop
-      }
-
-      25.times {
-        n = nextpid
-        nextpid = EM.spawn {|x,y| n.notify( y, x+y )}
-      }
-
-      nextpid.notify( 1, 1 )
-    }
-
-    assert_equal( 121393, a)
-    assert_equal( 196418, b)
-  end
-
-
-  # EM#yield gives a spawed process to yield control to other processes
-  # (in other words, to stop running), and to specify a different code block
-  # that will run on its next notification.
-  #
-  def test_yield
-    a = 0
-    EM.run {
-      n = EM.spawn {
-        a += 10
-        EM.yield {
-          a += 20
-          EM.yield {
-            a += 30
-            EM.stop
-          }
-        }
-      }
-      n.notify
-      n.notify
-      n.notify
-    }
-    assert_equal( 60, a )
-  end
-
-  # EM#yield_and_notify behaves like EM#yield, except that it also notifies the
-  # yielding process. This may sound trivial, since the yield block will run very
-  # shortly after with no action by the program, but this actually can be very useful,
-  # because it causes the reactor core to execute once before the yielding process
-  # gets control back. So it can be used to allow heavily-used network connections
-  # to clear buffers, or allow other processes to process their notifications.
-  #
-  # Notice in this test code that only a simple notify is needed at the bottom
-  # of the initial block. Even so, all of the yielded blocks will execute.
-  #
-  def test_yield_and_notify
-    a = 0
-    EM.run {
-      n = EM.spawn {
-        a += 10
-        EM.yield_and_notify {
-          a += 20
-          EM.yield_and_notify {
-            a += 30
-            EM.stop
-          }
-        }
-      }
-      n.notify
-    }
-    assert_equal( 60, a )
-  end
-
-  # resume is an alias for notify.
-  #
-  def test_resume
-    EM.run {
-      n = EM.spawn {EM.stop}
-      n.resume
-    }
-    assert true
-  end
-
-  # run is an idiomatic alias for notify.
-  #
-  def test_run
-    EM.run {
-      (EM.spawn {EM.stop}).run
-    }
-    assert true
-  end
-
-
-  # Clones the ping-pong example from the Erlang tutorial, in much less code.
-  # Illustrates that a spawned block executes in the context of a SpawnableObject.
-  # (Meaning, we can pass self as a parameter to another process that can then
-  # notify us.)
-  #
-  def test_ping_pong
-    n_pongs = 0
-    EM.run {
-      pong = EM.spawn {|x, ping|
-        n_pongs += 1
-        ping.notify( x-1 )
-      }
-      ping = EM.spawn {|x|
-        if x > 0
-          pong.notify x, self
-        else
-          EM.stop
-        end
-      }
-      ping.notify 3
-    }
-    assert_equal( 3, n_pongs )
-  end
-
-  # Illustrates that you can call notify inside a notification, and it will cause
-  # the currently-executing process to be re-notified. Of course, the new notification
-  # won't run until sometime after the current one completes.
-  #
-  def test_self_notify
-    n = 0
-    EM.run {
-      pid = EM.spawn {|x|
-        if x > 0
-          n += x
-          notify( x-1 )
-        else
-          EM.stop
-        end
-      }
-      pid.notify 3
-    }
-    assert_equal( 6, n )
-  end
-
-
-  # Illustrates that the block passed to #spawn executes in the context of a
-  # SpawnedProcess object, NOT in the local context. This can often be deceptive.
-  #
-  class BlockScopeTest
-    attr_reader :var
-    def run
-      # The following line correctly raises a NameError.
-      # The problem is that the programmer expected the spawned block to
-      # execute in the local context, but it doesn't.
-      #
-      # (EM.spawn { do_something }).notify ### NO! BAD!
-
-
-
-      # The following line correctly passes self as a parameter to the
-      # notified process.
-      #
-      (EM.spawn {|obj| obj.do_something }).notify(self)
-
-
-
-      # Here's another way to do it. This works because "myself" is bound
-      # in the local scope, unlike "self," so the spawned block sees it.
-      #
-      myself = self
-      (EM.spawn { myself.do_something }).notify
-
-
-
-      # And we end the loop.
-      # This is a tangential point, but observe that #notify never blocks.
-      # It merely appends a message to the internal queue of a spawned process
-      # and returns. As it turns out, the reactor processes notifications for ALL
-      # spawned processes in the order that #notify is called. So there is a
-      # reasonable expectation that the process which stops the reactor will
-      # execute after the previous ones in this method. HOWEVER, this is NOT
-      # a documented behavior and is subject to change.
-      #
-      (EM.spawn {EM.stop}).notify
-    end
-    def do_something
-      @var ||= 0
-      @var += 100
-    end
-  end
-
-  def test_block_scope
-    bs = BlockScopeTest.new
-    EM.run {
-      bs.run
-    }
-    assert_equal( 200, bs.var )
-  end
-
-end

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

@@ -1,79 +0,0 @@
-require "test/unit"
-require 'tempfile'
-
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-require "eventmachine"
-
-module EventMachine
-  def self._set_mocks
-    class <<self
-      alias set_tls_parms_old set_tls_parms
-      alias start_tls_old start_tls
-      begin
-        old, $VERBOSE = $VERBOSE, nil
-        def set_tls_parms *args; end
-        def start_tls *args; end
-      ensure
-        $VERBOSE = old
-      end
-    end
-  end
-
-  def self._clear_mocks
-    class <<self
-      begin
-        old, $VERBOSE = $VERBOSE, nil
-        alias set_tls_parms set_tls_parms_old
-        alias start_tls start_tls_old
-      ensure
-        $VERBOSE = old
-      end
-    end
-  end
-end
-
-  
-
-class TestSslArgs < Test::Unit::TestCase
-  def setup
-    EventMachine._set_mocks
-  end
-  
-  def teardown
-    EventMachine._clear_mocks
-  end
-  
-  def test_tls_params_file_doesnt_exist
-    priv_file, cert_file = 'foo_priv_key', 'bar_cert_file'
-    [priv_file, cert_file].all? do |f|
-      assert(!File.exists?(f), "Cert file #{f} seems to exist, and should not for the tests")
-    end
-    
-    # associate_callback_target is a pain! (build!)
-    conn = EventMachine::Connection.new('foo')
-    
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:private_key_file => priv_file)
-    end
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:cert_chain_file => cert_file)
-    end
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:private_key_file => priv_file, :cert_chain_file => cert_file)
-    end
-  end
-  
-  def test_tls_params_file_does_exist
-    priv_file = Tempfile.new('em_test')
-    cert_file = Tempfile.new('em_test')
-    priv_file_path = priv_file.path
-    cert_file_path = cert_file.path
-    conn = EventMachine::Connection.new('foo')
-    params = {:private_key_file => priv_file_path, :cert_chain_file => cert_file_path}
-    begin
-      conn.start_tls params
-    rescue Object
-      assert(false, 'should not have raised an exception')
-    end
-  end
-end if EM.ssl?

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

@@ -1,50 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestSSLMethods < Test::Unit::TestCase
-
-  module ServerHandler
-
-    def post_init
-      start_tls
-    end
-
-    def ssl_handshake_completed
-      $server_called_back = true
-      $server_cert_value = get_peer_cert
-    end
-
-  end
-
-  module ClientHandler
-
-    def post_init
-      start_tls
-    end
-
-    def ssl_handshake_completed
-      $client_called_back = true
-      $client_cert_value = get_peer_cert
-      EM.stop_event_loop
-    end
-
-  end
-
-  def test_ssl_methods
-    $server_called_back, $client_called_back = false, false
-    $server_cert_value, $client_cert_value = nil, nil
-
-    EM.run {
-      EM.start_server("127.0.0.1", 9999, ServerHandler)
-      EM.connect("127.0.0.1", 9999, ClientHandler)
-    }
-
-    assert($server_called_back)
-    assert($client_called_back)
-
-    assert($server_cert_value.is_a?(NilClass))
-    assert($client_cert_value.is_a?(String))
-  end
-
-end if EM.ssl?

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

@@ -1,82 +0,0 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestSslVerify < Test::Unit::TestCase
-
-  def setup
-    $dir = File.dirname(File.expand_path(__FILE__)) + '/'
-    $cert_from_file = File.read($dir+'client.crt')
-  end
-
-  module Client
-    def connection_completed
-      start_tls(:private_key_file => $dir+'client.key', :cert_chain_file => $dir+'client.crt')
-    end
-
-    def ssl_handshake_completed
-      $client_handshake_completed = true
-      close_connection
-    end
-
-    def unbind
-      EM.stop_event_loop
-    end
-  end
-
-  module AcceptServer
-    def post_init
-      start_tls(:verify_peer => true)
-    end
-
-    def ssl_verify_peer(cert)
-      $cert_from_server = cert
-      true
-    end
-
-    def ssl_handshake_completed
-      $server_handshake_completed = true
-    end
-  end
-
-  module DenyServer
-    def post_init
-      start_tls(:verify_peer => true)
-    end
-
-    def ssl_verify_peer(cert)
-      $cert_from_server = cert
-      # Do not accept the peer. This should now cause the connection to shut down without the SSL handshake being completed.
-      false
-    end
-
-    def ssl_handshake_completed
-      $server_handshake_completed = true
-    end
-  end
-
-  def test_accept_server
-    $client_handshake_completed, $server_handshake_completed = false, false
-    EM.run {
-      EM.start_server("127.0.0.1", 16784, AcceptServer)
-      EM.connect("127.0.0.1", 16784, Client).instance_variable_get("@signature")
-    }
-
-    assert_equal($cert_from_file, $cert_from_server)
-    assert($client_handshake_completed)
-    assert($server_handshake_completed)
-  end
-
-  def test_deny_server
-    $client_handshake_completed, $server_handshake_completed = false, false
-    EM.run {
-      EM.start_server("127.0.0.1", 16784, DenyServer)
-      EM.connect("127.0.0.1", 16784, Client)
-    }
-
-    assert_equal($cert_from_file, $cert_from_server)
-    assert(!$client_handshake_completed)
-    assert(!$server_handshake_completed)
-  end
-
-end

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

@@ -1,162 +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 TestTimers < Test::Unit::TestCase
-
-  def test_timer_with_block
-    x = false
-    EventMachine.run {
-      EventMachine::Timer.new(0.25) {
-        x = true
-        EventMachine.stop
-      }
-    }
-    assert x
-  end
-
-  def test_timer_with_proc
-    x = false
-    EventMachine.run {
-      EventMachine::Timer.new(0.25, proc {
-        x = true
-        EventMachine.stop
-      })
-    }
-    assert x
-  end
-
-  def test_timer_cancel
-    x = true
-    EventMachine.run {
-      timer = EventMachine::Timer.new(0.25, proc { x = false })
-      timer.cancel
-      EventMachine::Timer.new(0.5, proc {EventMachine.stop})
-    }
-    assert x
-  end
-
-  def test_periodic_timer
-    x = 0
-    EventMachine.run {
-      EventMachine::PeriodicTimer.new(0.1) do
-        x += 1
-        EventMachine.stop if x == 4
-      end
-    }
-    assert( x == 4 )
-  end
-
-  def test_add_periodic_timer
-    x = 0
-    EM.run {
-      t = EM.add_periodic_timer(0.1) do
-        x += 1
-        EM.stop  if x == 4
-      end
-      assert t.respond_to?(:cancel)
-    }
-  end
-
-  def test_periodic_timer_cancel
-    x = 0
-    EventMachine.run {
-      pt = EventMachine::PeriodicTimer.new(0.25, proc { x += 1 })
-      pt.cancel
-      EventMachine::Timer.new(0.5) {EventMachine.stop}
-    }
-    assert( x == 0 )
-  end
-
-  def test_add_periodic_timer_cancel
-    x = 0
-    EventMachine.run {
-      pt = EM.add_periodic_timer(0.25) { x += 1 }
-      EM.cancel_timer(pt)
-      EM.add_timer(0.5) { EM.stop }
-    }
-    assert( x == 0 )
-  end
-
-  def test_periodic_timer_self_cancel
-    x = 0
-    EventMachine.run {
-      pt = EventMachine::PeriodicTimer.new(0.1) {
-        x += 1
-        if x == 4
-          pt.cancel
-          EventMachine.stop
-        end
-      }
-    }
-    assert( x == 4 )
-  end
-
-
-  # This test is only applicable to compiled versions of the reactor.
-  # Pure ruby and java versions have no built-in limit on the number of outstanding timers.
-  #
-  def test_timer_change_max_outstanding
-    ten_thousand_timers = proc {
-      10001.times {
-        EM.add_timer(5) {}
-      }
-    }
-
-    EM.run {
-      if EM.library_type == :pure_ruby
-        ten_thousand_timers.call
-      elsif EM.library_type == :java
-        ten_thousand_timers.call
-      else
-        begin
-          assert_raises( RuntimeError ) {
-            ten_thousand_timers.call
-          }
-        rescue Object
-          p $!
-          assert(false, $!.message)
-        end
-      end
-      EM.stop
-    }
-
-    assert(!EM.reactor_running?, 'Reactor running when it should not be.')
-    assert( EM.get_max_timers != 10001 )
-    EM.set_max_timers( 10001 )
-    assert( EM.get_max_timers == 10001 )
-
-    EM.run {
-      ten_thousand_timers.call
-      EM.stop
-    }
-  end
-
-end