eventmachine 1.0.3-x86-mingw32 → 1.2.0.dev.2-x86-mingw32

data/tests/test_iterator.rb

@@ -0,0 +1,115 @@
+require 'em_test_helper'
+
+class TestIterator < Test::Unit::TestCase
+
+  def get_time
+    EM.current_time.strftime('%H:%M:%S')
+  end
+
+  def test_default_concurrency
+    items = {}
+    list = 1..10
+    EM.run {
+      EM::Iterator.new(list).each( proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_default_concurrency_with_a_proc
+    items = {}
+    list = (1..10).to_a
+    original_list = list.dup
+    EM.run {
+      EM::Iterator.new(proc{list.pop || EM::Iterator::Stop}).each( proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal(original_list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_concurrency_bigger_than_list_size
+    items = {}
+    list = [1,2,3]
+    EM.run {
+      EM::Iterator.new(list,10).each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(1, items.keys.size)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+
+  def test_changing_concurrency_affects_active_iteration
+    items = {}
+    list = 1..25
+    EM.run {
+      i = EM::Iterator.new(list,5)
+      i.each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+      EM.add_timer(1){
+        i.concurrency = 1
+      }
+      EM.add_timer(3){
+        i.concurrency = 3
+      }
+    }
+    assert_equal(9, items.keys.size)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_map
+    list = 100..150
+    EM.run {
+      EM::Iterator.new(list).map(proc{ |num,iter|
+        EM.add_timer(0.01){ iter.return(num) }
+      }, proc{ |results|
+        assert_equal(list.to_a.size, results.size)
+       EM.stop
+      })
+    }
+  end
+
+  def test_inject
+    omit_if(windows?)
+
+    list = %w[ pwd uptime uname date ]
+    EM.run {
+      EM::Iterator.new(list, 2).inject({}, proc{ |hash,cmd,iter|
+        EM.system(cmd){ |output,status|
+          hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+          iter.return(hash)
+        }
+      }, proc{ |results|
+        assert_equal(results.keys.sort, list.sort)
+        EM.stop
+      })
+    }
+  end
+
+  def test_concurrency_is_0
+    EM.run {
+      assert_raise ArgumentError do
+        EM::Iterator.new(1..5,0)
+      end
+      EM.stop
+    }
+  end
+end

data/tests/test_kb.rb

@@ -2,33 +2,27 @@ require 'em_test_helper'
 
 class TestKeyboardEvents < Test::Unit::TestCase
 
-  if !jruby?
-    module KbHandler
-      include EM::Protocols::LineText2
-      def receive_line d
-        EM::stop if d == "STOP"
-      end
+  module KbHandler
+    include EM::Protocols::LineText2
+    def receive_line d
+      EM::stop if d == "STOP"
     end
+  end
 
-    # This test doesn't actually do anything useful but is here to
-    # illustrate the usage. If you removed the timer and ran this test
-    # by itself on a console, and then typed into the console, it would
-    # work.
-    # I don't know how to get the test harness to simulate actual keystrokes.
-    # When someone figures that out, then we can make this a real test.
-    #
-    def test_kb
-      EM.run {
-        EM.open_keyboard KbHandler
-        EM::Timer.new(1) { EM.stop }
-      } if $stdout.tty? # don't run the test unless it stands a chance of validity.
-    end
-  else
-    warn "EM.open_keyboard not implemented, skipping tests in #{__FILE__}"
-
-    # Because some rubies will complain if a TestCase class has no tests
-    def test_em_open_keyboard_unsupported
-      assert true
+  # This test doesn't actually do anything useful but is here to
+  # illustrate the usage. If you removed the timer and ran this test
+  # by itself on a console, and then typed into the console, it would
+  # work.
+  # I don't know how to get the test harness to simulate actual keystrokes.
+  # When someone figures that out, then we can make this a real test.
+  #
+  def test_kb
+    omit_if(jruby?)
+    omit_if(!$stdout.tty?) # don't run the test unless it stands a chance of validity.
+    EM.run do
+      EM.open_keyboard KbHandler
+      EM::Timer.new(1) { EM.stop }
     end
   end
+
 end

data/tests/test_ltp2.rb

@@ -26,6 +26,26 @@ class TestLineText2 < Test::Unit::TestCase
     assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
   end
 
+  # The basic test above shows that extra newlines are chomped
+  # This test shows that newlines are preserved if the delimiter isn't \n
+  class PreserveNewlines
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def initialize *args
+      super
+      @delim = "|"
+      set_delimiter @delim
+    end
+    def receive_line line
+      (@lines ||= []) << line
+    end
+  end
+  def test_preserve_newlines
+    a = PreserveNewlines.new
+    a.receive_data "aaa|bbb|ccc|\n|\r\n| \t ||"
+    assert_equal( ["aaa", "bbb", "ccc", "\n", "\r\n", " \t ", ""], a.lines )
+  end
+
   class ChangeDelimiter
     include EM::Protocols::LineText2
     attr_reader :lines

data/tests/test_many_fds.rb

@@ -0,0 +1,22 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestManyFDs < Test::Unit::TestCase
+  def setup
+    @port = next_port
+  end
+
+  def test_connection_class_cache
+    mod = Module.new
+    a = nil
+    Process.setrlimit(Process::RLIMIT_NOFILE, 4096) rescue nil
+    EM.run {
+      EM.start_server '127.0.0.1', @port, mod
+      1100.times do
+        a = EM.connect '127.0.0.1', @port, mod
+        assert_kind_of EM::Connection, a
+      end
+      EM.stop
+    }
+  end
+end

data/tests/test_pause.rb

@@ -67,6 +67,35 @@ class TestPause < Test::Unit::TestCase
         end
       end
     end
+
+    def test_pause_in_receive_data
+      incoming = []
+
+      test_server = Module.new do
+        define_method(:receive_data) do |data|
+          incoming << data
+          pause
+          EM.add_timer(0.5){ close_connection }
+        end
+        define_method(:unbind) do
+          EM.stop
+        end
+      end
+
+      buf = 'a' * 1024
+
+      EM.run do
+        EM.start_server "127.0.0.1", @port, test_server
+        cli = EM.connect "127.0.0.1", @port
+        128.times do
+          cli.send_data buf
+        end
+      end
+
+      assert_equal 1, incoming.size
+      assert incoming[0].bytesize > buf.bytesize
+      assert incoming[0].bytesize < buf.bytesize * 128
+    end
   else
     warn "EM.pause_connection not implemented, skipping tests in #{__FILE__}"
 

data/tests/test_pool.rb

@@ -1,3 +1,5 @@
+require 'em_test_helper'
+
 class TestPool < Test::Unit::TestCase
   def pool
     @pool ||= EM::Pool.new

data/tests/test_process_watch.rb

@@ -27,6 +27,8 @@ if EM.kqueue?
     end
 
     def test_events
+      omit_if(rbx?)
+      omit_if(jruby?)
       EM.run{
         # watch ourselves for a fork notification
         EM.watch_process(Process.pid, ParentProcessWatcher)

data/tests/test_processes.rb

@@ -37,8 +37,8 @@ class TestProcesses < Test::Unit::TestCase
       }
 
       assert( $out.length > 0 )
-      assert_equal($status.exitstatus, 0)
-      assert_equal($status.class, Process::Status)
+      assert_equal(0, $status.exitstatus)
+      assert_kind_of(Process::Status, $status)
     end
 
     def test_em_system_pid
@@ -57,8 +57,8 @@ class TestProcesses < Test::Unit::TestCase
       }
 
       assert( $out.length > 0 )
-      assert_equal($status.exitstatus, 0)
-      assert_equal($status.class, Process::Status)
+      assert_equal(0, $status.exitstatus)
+      assert_kind_of(Process::Status, $status)
     end
 
     def test_em_system_with_two_procs
@@ -111,9 +111,9 @@ class TestProcesses < Test::Unit::TestCase
         end
       end
 
-      EM.run{
-        EM.popen('cat /dev/random', test_client)
-      }
+      EM.run do
+        EM.popen('echo 1', test_client)
+      end
 
       assert_equal 1, c_rx
     end

data/tests/test_queue.rb

@@ -47,4 +47,18 @@ class TestEMQueue < Test::Unit::TestCase
     EM.run { EM.next_tick { EM.stop } }
     assert_equal many, q.num_waiting
   end
+
+  def test_big_queue
+    EM.run do
+      q = EM::Queue.new
+      2000.times do |i|
+        q.push(*0..1000)
+        q.pop { |v| assert_equal v, i % 1001 }
+      end
+      q.pop do
+        assert_equal 1_999_999, q.size
+        EM.stop
+      end
+    end
+  end
 end

data/tests/test_resolver.rb

@@ -1,7 +1,24 @@
 require 'em_test_helper'
 
 class TestResolver < Test::Unit::TestCase
+  def test_nameserver
+    assert_kind_of(String, EM::DNS::Resolver.nameserver)
+  end
+
+  def test_nameservers
+    assert_kind_of(Array, EM::DNS::Resolver.nameservers)
+  end
+
+  def test_hosts
+    assert_kind_of(Hash, EM::DNS::Resolver.hosts)
+
+    # Make sure that blank or comment lines are skipped
+    refute(EM::DNS::Resolver.hosts.include? nil)
+  end
+
   def test_a
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "google.com"
       d.errback { assert false }
@@ -29,27 +46,59 @@ class TestResolver < Test::Unit::TestCase
   end
 
   def test_a_pair
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
-      d = EM::DNS::Resolver.resolve "google.com"
-      d.errback { assert false }
+      d = EM::DNS::Resolver.resolve "yahoo.com"
+      d.errback { |err| assert false, "failed to resolve yahoo.com: #{err}" }
       d.callback { |r|
-        assert_equal(Array, r.class)
-        assert r.size > 1
+        assert_kind_of(Array, r)
+        assert r.size > 1, "returned #{r.size} results: #{r.inspect}"
         EM.stop
       }
     }
   end
 
   def test_localhost
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "localhost"
       d.errback { assert false }
       d.callback { |r|
-        assert_equal("127.0.0.1", r.first)
-        assert_equal(Array, r.class)
+        assert_include(["127.0.0.1", "::1"], r.first)
+        assert_kind_of(Array, r)
+
+        EM.stop
+      }
+    }
+  end
+
+  def test_timer_cleanup
+    pend('FIXME: this test is broken on Windows') if windows?
+
+    EM.run {
+      d = EM::DNS::Resolver.resolve "google.com"
+      d.errback { |err| assert false, "failed to resolve google.com: #{err}" }
+      d.callback { |r|
+        # This isn't a great test, but it's hard to get more canonical
+        # confirmation that the timer is cancelled
+        assert_nil(EM::DNS::Resolver.socket.instance_variable_get(:@timer))
+
+        EM.stop
+      }
+    }
+  end
+
+  def test_failure_timer_cleanup
+    EM.run {
+      d = EM::DNS::Resolver.resolve "asdfasdf"
+      d.callback { assert false }
+      d.errback {
+        assert_nil(EM::DNS::Resolver.socket.instance_variable_get(:@timer))
 
         EM.stop
       }
     }
   end
-end
+end

data/tests/test_set_sock_opt.rb

@@ -15,6 +15,8 @@ class TestSetSockOpt < Test::Unit::TestCase
     #-------------------------------------
 
     def test_set_sock_opt
+      omit_if(windows?)
+
       test = self
       EM.run do
         EM.connect 'google.com', 80, Module.new {

data/tests/test_smtpclient.rb

@@ -52,4 +52,24 @@ class TestSmtpClient < Test::Unit::TestCase
     assert(err)
   end
 
+
+  EM::Protocols::SmtpClient.__send__(:public, :escape_leading_dots)
+
+  def test_escaping
+    smtp = EM::Protocols::SmtpClient.new :domain => "example.com"
+
+    expectations = {
+      "Hello\r\n" => "Hello\r\n",
+      "\r\n.whatever\r\n" => "\r\n..whatever\r\n",
+      "\r\n.\r\n" => "\r\n..\r\n",
+      "\r\n.\r\n." => "\r\n..\r\n..",
+      ".\r\n.\r\n" => "..\r\n..\r\n",
+      "..\r\n" => "...\r\n"
+    }
+
+    expectations.each do |input, output|
+      assert_equal output, smtp.escape_leading_dots(input)
+    end
+  end
+
 end