asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/test/test_resolver.rb

@@ -0,0 +1,51 @@
+require "ae_test_helper"
+
+
+class TestResolver < AETest
+
+  def test_01_resolve_success
+    @num_ips = 0
+
+    AE.run do
+      AE::Resolver.resolve "google.com" do |error, ips|
+        assert_nil error
+        assert_equal Array, ips.class
+        @num_ips = ips.size
+        AE.stop
+      end
+    end
+
+    AE.run do
+      AE::Resolver.resolve "google.com", Socket::AF_UNSPEC do |error, ips|
+        assert_equal @num_ips, ips.size
+        AE.stop
+      end
+    end
+
+    AE.run do
+      AE::Resolver.resolve "google.com", Socket::AF_INET6 do |error, ips|
+        assert_true @num_ips > ips.size
+        AE.stop
+      end
+    end
+  end
+
+  def test_02_resolve_error
+    AE.run do
+      AE::Resolver.resolve "qweasdzxc.qwe" do |error, ips|
+        assert_true error.is_a? AE::UvError
+        assert_equal error.type, :ENOENT
+        AE.stop
+      end
+    end
+
+    AE.run do
+      AE::Resolver.resolve "ipv6.google.com", Socket::AF_INET do |error, ips|
+        assert_true error.is_a? AE::UvError
+        assert_equal error.type, :ENOENT
+        AE.stop
+      end
+    end
+  end
+
+end

data/test/test_threads.rb

@@ -0,0 +1,69 @@
+require "ae_test_helper"
+
+
+class TestThreads < AETest
+
+  def test_01_thread_works_as_expected
+    str = ""
+
+    AE.run do
+      AE.add_periodic_timer(0.1) {}
+
+      Thread.new { str << "a" }
+      Thread.new { sleep 0.01 ; str << "b" }
+      Thread.new { sleep 0.02 ; str << "c" }
+      Thread.new { sleep 0.03 ; str << "d" }
+      Thread.new { sleep 0.04 ; AE.stop }
+    end
+
+    assert_false AE.running?
+    assert_equal "abcd", str
+  end
+
+  def test_02_can_run_anything_in_call_from_other_thread
+    str = ""
+
+    AE.run do
+      Thread.new do
+        AE.call_from_other_thread { AE.next_tick { str << "a" } }
+      end
+      Thread.new do
+        sleep 0.02
+        AE.call_from_other_thread { AE.add_timer(0) { str << "b" } }
+      end
+      Thread.new do
+        sleep 0.02
+        AE.call_from_other_thread { AE.add_timer(0.05) { str << "c" } }
+      end
+      str << "1"
+      AE.next_tick { str << "2" }
+      AE.add_timer(0.1) { str << "d" ; AE.stop }
+    end
+
+    assert_false AE.running?
+    assert_equal "12abcd", str
+  end
+
+  def test_03_run_and_stop_are_thread_safe
+    summ = 0
+
+    th1 = Thread.new do
+      AE.run { AE.add_timer(0.1) { AE.stop } }
+    end
+
+    th2 = Thread.new do
+      sleep 0.01
+      AE.run { summ+=1 }
+    end
+
+    th3 = Thread.new do
+      sleep 0.01
+      AE.run { AE.add_timer(0) { summ+=1 } }
+    end
+
+    th1.join ; th2.join ; th3.join
+
+    assert_equal 2, summ
+  end
+
+end

data/test/test_timer.rb

@@ -0,0 +1,95 @@
+require "ae_test_helper"
+
+
+class TestTimer < AETest
+
+  def test_01_timer_fires
+    t1_executed = false
+
+    AE.run do
+      t1 = AE::Timer.new(0.01) { t1_executed = true ; assert_false t1.alive? }
+      assert_true t1.alive?
+      AE.add_timer(0.02) { assert_false t1.alive? }
+      AE.add_timer(0.03) { assert_false t1.close ; AE.stop }
+    end
+
+    assert_true t1_executed
+  end
+
+  def test_02_timer_closed
+    t1_executed = false
+    pt1_executed = false
+
+    AE.run do
+      t1 = AE::Timer.new(0.02) { t1_executed = true }
+      AE.add_timer(0.01) { assert_true t1.close ; assert_false t1.alive? }
+      AE.add_timer(0.03) { assert_false t1.close }
+
+      pt1 = AE::PeriodicTimer.new(0.02) { pt1_executed = true }
+      AE.add_timer(0.01) { assert_true pt1.close ; assert_false pt1.alive? }
+      AE.add_timer(0.03) { assert_false pt1.close ; AE.stop }
+    end
+
+    assert_false t1_executed
+    assert_false pt1_executed
+  end
+
+  def test_03_periodic_timer_closed_after_4_repeats
+    pt1_ticks = 0
+
+    AE.run do
+      pt1 = AE::PeriodicTimer.new(0.01) do
+        pt1_ticks += 1
+        AE.stop  if pt1_ticks == 4
+      end
+    end
+
+    assert_equal 4, pt1_ticks
+  end
+
+  def test_04_periodic_timer_interval_increased
+    pt1_ticks = 0
+    pt1_interval = 0.001
+
+    AE.run do
+      pt1 = AE::PeriodicTimer.new(pt1_interval) do
+        # This should stop after 0.015 seconds.
+        AE.stop  if (pt1_ticks += 1) == 4
+        pt1.restart (pt1_interval *= 2)
+      end
+
+      # So check that pt1 is terminated after 0.05 seconds (it should).
+      AE.add_timer(0.05) { assert_false pt1.alive? }
+    end
+
+    assert_equal 4, pt1_ticks
+  end
+
+  def test_05_timer_restarted
+    str1 = ""
+    str2 = ""
+
+    AE.run do
+      t1 = AE::Timer.new(0.01) { str1 << "0" }
+      t1.restart  # So "0" will be written.
+      AE.next_tick { t1.restart }
+      AE.add_timer(0.02) { assert_false t1.restart }  # Timer was terminated so nothing new occurs.
+
+      t2 = AE::Timer.new(0.01, Proc.new { str2 << "0" })
+      t2.pause
+      AE.add_timer(0.001) { t2.restart(0.002) }
+
+      AE.add_timer(0.05) { AE.stop }
+    end
+
+    assert_equal "0", str1
+    assert_equal "0", str2
+  end
+
+  def test_06_timer_closed_on_its_callback_does_not_crash
+    AE.run do
+      t1 = AE::Timer.new(0.001) { assert_false t1.close ; AE.stop }
+    end
+  end
+
+end

data/test/test_udp.rb

@@ -0,0 +1,216 @@
+require "ae_test_helper"
+
+
+class TestUdp < AETest
+
+  RECEIVED_DATAGRAMS = []
+
+  class MyUDP < AE::UDPSocket
+    def initialize
+      @local_ip, @local_port = local_address()
+    end
+  end
+
+  def setup
+    super
+    RECEIVED_DATAGRAMS.clear
+  end
+
+  def test_01_udp_basic_ipv4
+    return false  unless (ip = host_loopback_ipv4)
+    private_test_01_udp_basic ip
+  end
+
+  def test_01_udp_basic_ipv6
+    return false  unless (ip = host_loopback_ipv6)
+    private_test_01_udp_basic ip
+  end
+
+  def test_02_set_encoding_ipv4
+    return false  unless (ip = host_loopback_ipv4)
+    private_test_02_set_encoding ip
+  end
+
+  def test_02_set_encoding_ipv6
+    return false  unless (ip = host_loopback_ipv6)
+    private_test_02_set_encoding ip
+  end
+
+  def test_03_send_callback_ipv4
+    return false  unless (ip = host_loopback_ipv4)
+    private_test_03_send_callback ip
+  end
+
+  def test_03_send_callback_ipv6
+    return false  unless (ip = host_loopback_ipv6)
+    private_test_03_send_callback ip
+  end
+
+  def test_04_datagram_source_address_ipv4
+    return false  unless (ip = host_loopback_ipv4)
+    private_test_04_datagram_source_address ip
+  end
+
+  def test_04_datagram_source_address_ipv6
+    return false  unless (ip = host_loopback_ipv6)
+    private_test_04_datagram_source_address ip
+  end
+
+
+  private
+
+  def private_test_01_udp_basic ip
+    AE.run do
+      sock = AE.open_udp_socket ip, 0
+      local_ip, local_port = sock.local_address()
+
+      assert_true [:ipv4, :ipv6].include?(sock.ip_type)
+
+      def sock.on_datagram_received datagram, ip, port
+        RECEIVED_DATAGRAMS << datagram
+      end
+
+      assert_true sock.alive?
+      assert_false sock.paused?
+
+      assert_equal ip, local_ip
+
+      # This will be received.
+      assert_true sock.send_datagram("1", local_ip, local_port)
+
+      AE.add_timer(0.1) do
+        sock.pause
+        assert_true sock.paused?
+
+        # This wont be received.
+        assert_true sock.send_datagram("2", local_ip, local_port)
+      end
+
+      AE.add_timer(0.15) do
+        sock.resume
+        assert_false sock.paused?
+
+        # This will be received.
+        assert_true sock.send_datagram("3", local_ip, local_port)
+      end
+
+      AE.add_timer(0.2) do
+        assert_true sock.close()
+        assert_false sock.alive?
+
+        # Socket closed, cannot be sent.
+        assert_false sock.send_datagram "hello", "1.2.3.4", 1234
+
+        AE.stop
+      end
+    end
+
+    assert_equal ["1", "3"], RECEIVED_DATAGRAMS
+  end
+
+  def private_test_02_set_encoding ip
+    AE.run do
+      sock = AE.open_udp_socket ip, 0
+      local_ip, local_port = sock.local_address()
+
+      def sock.on_datagram_received datagram, ip, port
+        RECEIVED_DATAGRAMS << datagram
+        AE.stop  if RECEIVED_DATAGRAMS.size == 2
+        set_encoding_ascii()
+      end
+
+      # Default UDP receiving encoding is ASCII_8BIT.
+      assert_equal sock.encoding, :ascii
+
+      sock.set_encoding_utf8
+      assert_equal sock.encoding, :utf8
+      sock.send_datagram "\x80", local_ip, local_port
+
+      sock.send_datagram "\x80", local_ip, local_port
+    end
+
+    assert_equal RECEIVED_DATAGRAMS[0].encoding, Encoding::UTF_8
+    assert_false RECEIVED_DATAGRAMS[0].valid_encoding?
+    assert_equal RECEIVED_DATAGRAMS[1].encoding, Encoding::ASCII_8BIT
+    assert_true RECEIVED_DATAGRAMS[1].valid_encoding?
+  end
+
+  def private_test_03_send_callback ip
+    send_cb_ok = 0
+    send_cb_error = 0
+
+    AE.run do
+      sock = AE.open_udp_socket ip, 4444
+      local_ip, local_port = sock.local_address()
+
+      def sock.on_datagram_received datagram, ip, port
+        RECEIVED_DATAGRAMS << datagram
+      end
+
+      sock.send_datagram "1", local_ip, local_port do |error|
+        error ? (send_cb_error += 1) : (send_cb_ok += 1)
+      end
+
+      sock.send_datagram("2", local_ip, local_port, proc do |error|
+        error ? (send_cb_error += 1) : (send_cb_ok += 1)
+      end)
+
+      # Sending to destination port 0 causes a EINVAL error.
+      sock.send_datagram "3", local_ip, 0 do |error|
+        error ? (send_cb_error += 1) : (send_cb_ok += 1)
+        assert_equal error.class, AE::UvError
+        assert_equal error.type, :EINVAL
+      end
+
+      AE.add_timer(0.1) { assert_true sock.close() ; AE.stop }
+    end
+
+    assert_equal ["1", "2"], RECEIVED_DATAGRAMS
+    assert_equal 2, send_cb_ok
+    assert_equal 1, send_cb_error
+  end
+
+  def private_test_04_datagram_source_address ip
+    sock = nil
+    local_ip = nil
+    local_port = nil
+
+    AE.run do
+      sock = AE.open_udp_socket ip, 0
+      local_ip, local_port = sock.local_address()
+
+      def sock.on_datagram_received datagram, src_ip, src_port
+        RECEIVED_DATAGRAMS << datagram
+        @last_src_ip = src_ip
+        @last_src_port = src_port
+
+        case RECEIVED_DATAGRAMS.size
+        when 1
+          send_datagram "reply1", src_ip, src_port
+        when 2
+          send_datagram "reply2", src_ip, src_port do |error|
+            error ? (@reply_cb_error += 1) : (@reply_cb_ok += 1)
+          end
+        when 3
+          send_datagram("reply3", src_ip, src_port, proc do |error|
+            error ? (@reply_cb_error += 1) : (@reply_cb_ok += 1)
+          end)
+        when 4
+          AE.stop
+        end
+      end
+
+      sock.instance_variable_set :@reply_cb_ok, 0
+      sock.instance_variable_set :@reply_cb_error, 0
+
+      sock.send_datagram "hello", local_ip, local_port
+    end
+
+    assert_equal ["hello", "reply1", "reply2", "reply3"], RECEIVED_DATAGRAMS
+    assert_equal 2, sock.instance_variable_get(:@reply_cb_ok)
+    assert_equal 0, sock.instance_variable_get(:@reply_cb_error)
+    assert_equal sock.instance_variable_get(:@last_src_ip), local_ip
+    assert_equal sock.instance_variable_get(:@last_src_port), local_port
+  end
+
+end

data/test/test_utils.rb

@@ -0,0 +1,49 @@
+require "ae_test_helper"
+
+
+class TestUtils < AETest
+
+  def test_01_hrtime
+    assert (AE::Utils.get_hrtime < AE::Utils.get_hrtime)
+  end
+
+  def test_02_memory
+    assert (AE::Utils.get_free_memory < AE::Utils.get_total_memory)
+  end
+
+  def test_03_loadavg
+    loadavg = AE::Utils.get_loadavg
+
+    assert_true loadavg[0].is_a? Float
+    assert_true loadavg[1].is_a? Float
+    assert_true loadavg[2].is_a? Float
+  end
+
+  def test_04_uptime
+    assert (AE::Utils.get_uptime < AE::Utils.get_uptime)
+  end
+
+  def test_05_network_interfaces
+    AE::Utils.get_network_interfaces.each do |iface|
+      assert_true (iface.is_a? AE::Utils::NetworkInterface)
+      assert_true (iface.name.is_a? String)
+      assert_true ([true, false].include? iface.internal?)
+      assert_true ([:ipv4, :ipv6].include? iface.ip_type)
+      assert_true (iface.ip.is_a? String)
+    end
+  end
+
+  def test_06_cpu_info
+    AE::Utils.get_cpu_info.each do |cpu|
+      assert_true (cpu.is_a? AE::Utils::CpuInfo)
+      assert_true (cpu.model.is_a? String)
+      assert_true (cpu.speed.is_a? Fixnum)
+      assert_true (cpu.time_sys.is_a? Float)
+      assert_true (cpu.time_user.is_a? Float)
+      assert_true (cpu.time_idle.is_a? Float)
+      assert_true (cpu.time_irq.is_a? Float)
+      assert_true (cpu.time_nice.is_a? Float)
+    end
+  end
+
+end