eventmachine 0.12.6-java → 0.12.8-java

data/tests/test_errors.rb

@@ -36,47 +36,47 @@ require 'test/unit'
 
 class TestErrors < Test::Unit::TestCase
 
-	Localhost = "127.0.0.1"
-	Localport = 9801
+  Localhost = "127.0.0.1"
+  Localport = 9801
 
-	def setup
-	end
+  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 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
+  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"}
-			}
-		}
+  # 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
+  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
+  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/tests/test_exc.rb

@@ -29,30 +29,27 @@ 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
-
+  # 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/tests/test_file_watch.rb

@@ -0,0 +1,49 @@
+$:.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/tests/test_futures.rb

@@ -28,8 +28,6 @@ $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
-
-
 class TestFutures < Test::Unit::TestCase
 
   def setup
@@ -45,21 +43,19 @@ class TestFutures < Test::Unit::TestCase
       assert_equal(101, EventMachine::Deferrable.future(p1) )
   end
 
-
-
   class MyFuture
       include EventMachine::Deferrable
       def initialize *args
-	  super
-	  set_deferred_status :succeeded, 40
+        super
+        set_deferred_status :succeeded, 40
       end
   end
 
   class MyErrorFuture
       include EventMachine::Deferrable
       def initialize *args
-	  super
-	  set_deferred_status :failed, 41
+        super
+        set_deferred_status :failed, 41
       end
   end
 
@@ -67,7 +63,7 @@ class TestFutures < Test::Unit::TestCase
   def test_future_1
       # Call future with one additional argument and it will be treated as a callback.
       def my_future
-	  MyFuture.new
+        MyFuture.new
       end
 
       value = nil
@@ -90,7 +86,7 @@ class TestFutures < Test::Unit::TestCase
       # treated as a callback.
       value = nil
       EventMachine::Deferrable.future MyFuture.new do |v|
-	  value=v
+        value=v
       end
       assert_equal( 40, value )
   end
@@ -107,108 +103,96 @@ class TestFutures < Test::Unit::TestCase
       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
+        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
+        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
+        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
 
-	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 {s += 1}
+    d.errback {e += 1}
 
-		d = EM::DefaultDeferrable.new
-		d.callback {s1 += 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.
 
-		d.succeed	# Triggers and discards the callback.
+    assert_equal(1, s)
+    assert_equal(0, e)
+  end
 
-		d.callback {s2 += 1}	# This callback is executed immediately and discarded.
+  # 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.errback {e += 1}	# This errback should be DISCARDED and never execute.
-		d.fail		# To prove it, let's 
+    d = EM::DefaultDeferrable.new
+    d.callback {s1 += 1}
 
-		assert_equal( [1,1], [s1,s2] )
-		assert_equal( 0, e )
-	end
+    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
+  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/tests/test_hc.rb

@@ -176,7 +176,7 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       "GET / HTTP/1.0",
       "Accept: aaa",
       "User-Agent: bbb",
-      "Host:	    ccc",
+      "Host: ccc",
       "x-tempest-header:ddd"
     ]
 
@@ -215,4 +215,4 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     assert_equal(expect, hsh)
   end
 
-end
+end

data/tests/test_httpclient.rb

@@ -91,23 +91,23 @@ class TestHttpClient < Test::Unit::TestCase
   #
   class EmptyContent < EventMachine::Connection
       def initialize *args
-	  super
+        super
       end
       def receive_data data
-	  send_data "HTTP/1.0 404 ...\r\nContent-length: 0\r\n\r\n"
-	  close_connection_after_writing
+        send_data "HTTP/1.0 404 ...\r\nContent-length: 0\r\n\r\n"
+        close_connection_after_writing
       end
   end
 
   def test_http_empty_content
       ok = false
       EventMachine.run {
-	  EventMachine.start_server "127.0.0.1", 9701, EmptyContent
-	  c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
-	  c.callback {|result|
-	      ok = true
-	      EventMachine.stop
-	  }
+        EventMachine.start_server "127.0.0.1", 9701, EmptyContent
+        c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+        c.callback {|result|
+          ok = true
+          EventMachine.stop
+        }
       }
       assert ok
   end
@@ -117,40 +117,41 @@ class TestHttpClient < Test::Unit::TestCase
 
   class PostContent < EventMachine::Protocols::LineAndTextProtocol
       def initialize *args
-	  super
-	  @lines = []
+        super
+        @lines = []
       end
       def receive_line line
-	  if line.length > 0
-	      @lines << line
-	  else
-	      process_headers
-	  end
+        if line.length > 0
+          @lines << line
+        else
+          process_headers
+        end
       end
       def receive_binary_data data
-	  @post_content = data
-	  send_response
+        @post_content = data
+        send_response
       end
       def process_headers
-	  if @lines.first =~ /\APOST ([^\s]+) HTTP\/1.1\Z/
-	      @uri = $1.dup
-	  else
-	      raise "bad request"
-	  end
-	  @lines.each {|line|
-	      if line =~ /\AContent-length:\s*(\d+)\Z/i
-		  @content_length = $1.dup.to_i
-	      elsif line =~ /\AContent-type:\s*(\d+)\Z/i
-		  @content_type = $1.dup
-	      end
-	  }
-
-	  raise "invalid content length" unless @content_length
-	  set_binary_mode @content_length
+        if @lines.first =~ /\APOST ([^\s]+) HTTP\/1.1\Z/
+          @uri = $1.dup
+        else
+          raise "bad request"
+        end
+
+        @lines.each {|line|
+          if line =~ /\AContent-length:\s*(\d+)\Z/i
+            @content_length = $1.dup.to_i
+          elsif line =~ /\AContent-type:\s*(\d+)\Z/i
+            @content_type = $1.dup
+          end
+        }
+
+        raise "invalid content length" unless @content_length
+        set_binary_mode @content_length
       end
       def send_response
-	  send_data "HTTP/1.1 200 ...\r\nConnection: close\r\nContent-length: 10\r\nContent-type: text/html\r\n\r\n0123456789"
-	  close_connection_after_writing
+        send_data "HTTP/1.1 200 ...\r\nConnection: close\r\nContent-length: 10\r\nContent-type: text/html\r\n\r\n0123456789"
+        close_connection_after_writing
       end
   end
 
@@ -159,15 +160,20 @@ class TestHttpClient < Test::Unit::TestCase
   def test_post
       response = nil
       EventMachine.run {
-	  EventMachine.start_server Localhost, Localport, PostContent
-	  EventMachine.add_timer(2) {raise "timed out"}
-	  c = EventMachine::Protocols::HttpClient.request :host=>Localhost,
-	      :port=>Localport, :method=>:post, :request=>"/aaa", :content=>"XYZ",
-	      :content_type=>"text/plain"
-          c.callback {|r|
-	      response = r
-	      EventMachine.stop
-	  }
+        EventMachine.start_server Localhost, Localport, PostContent
+        EventMachine.add_timer(2) {raise "timed out"}
+        c = EventMachine::Protocols::HttpClient.request(
+          :host=>Localhost,
+          :port=>Localport,
+          :method=>:post,
+          :request=>"/aaa",
+          :content=>"XYZ",
+          :content_type=>"text/plain"
+        )
+        c.callback {|r|
+          response = r
+          EventMachine.stop
+        }
       }
 
       assert_equal( 200, response[:status] )
@@ -190,16 +196,16 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
-
-
   # We can tell the client to send an HTTP/1.0 request (default is 1.1).
   # This is useful for suppressing chunked responses until those are working.
   def test_version_1_0
     ok = false
     EM.run {
-      c = EM::P::HttpClient.request :host => "www.bayshorenetworks.com",
-      	:port => 80,
-	:version => "1.0"
+      c = EM::P::HttpClient.request(
+        :host => "www.bayshorenetworks.com",
+        :port => 80,
+        :version => "1.0"
+      )
       c.callback {|result|
         ok = true;
         EventMachine.stop
@@ -209,7 +215,4 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
-
 end
-
-