lwes 0.7.0 → 0.8.0pre1

data/lib/lwes/struct.rb

@@ -1,172 +1,139 @@
-module LWES
-  class Struct
+# LWES Events in an ESF file can be automatically turned into
+# Ruby ::Struct-based objects and emitted directly through LWES::Emitter.
+#
+# LWES::Struct is may be more memory-efficient and faster if your application
+# uses all or most of the fields in the event definition.  LWES::Event should
+# be used in cases where many event fields are unused in a definition.
+class LWES::Struct
+  extend LWES::ClassMaker
 
-    # creates a new Struct-based class, takes the following
-    # options hash:
-    #
-    #   :db       - pre-created LWES::TypeDB object
-    #               this is required unless :file is given
-    #   :file     - pathname to the ESF file,
-    #               this is required unless :db is given
-    #   :class    - Ruby base class name, if the ESF file only has one
-    #               event defined (besides MetaEventInfo), then specifying
-    #               it is optional, otherwise it is required when multiple
-    #               events are defined in the same ESF :file given above
-    #   :parent   - parent class or module, the default is 'Object' putting
-    #               the new class in the global namespace.
-    #   :name     - event name if it differs from the Ruby base class name
-    #               given (or inferred) above.  For DRY-ness, you are
-    #               recommended to keep your event names and Ruby class
-    #               names in sync and not need this option.
-    #   :skip     - Array of field names to skip from the Event defininition
-    #               entirely, these could include fields that are only
-    #               implemented by the Listener.  This may also be a
-    #               regular expression.
-    #   :defaults - hash of default key -> value pairs to set at
-    #               creation time
-    #
-    def self.new(options, &block)
-      db = options[:db]
-      db ||= begin
-        file = options[:file] or
-          raise ArgumentError, "TypeDB :db or ESF :file missing"
-        test ?r, file or
-          raise ArgumentError, "file #{file.inspect} not readable"
-        TypeDB.new(file)
-      end
-      dump = db.to_hash
-      klass = options[:class] || begin
-        # make it easier to deal with single event files
-        events = (dump.keys -  [ :MetaEventInfo ])
-        events.size > 1 and
-            raise RuntimeError,
-                  "multiple event defs available: #{events.inspect}\n" \
-                  "pick one with :class"
-        events.first
-      end
+  # creates a new Struct-based class, takes the following
+  # options hash:
+  #
+  #   :db       - pre-created LWES::TypeDB object
+  #               this is required unless :file is given
+  #   :file     - pathname to the ESF file,
+  #               this is required unless :db is given
+  #   :class    - Ruby base class name, if the ESF file only has one
+  #               event defined (besides MetaEventInfo), then specifying
+  #               it is optional, otherwise it is required when multiple
+  #               events are defined in the same ESF :file given above
+  #   :parent   - parent class or module, the default is 'Object' putting
+  #               the new class in the global namespace.  May be +nil+ for
+  #               creating anonymous classes
+  #   :name     - event name if it differs from the Ruby base class name
+  #               given (or inferred) above.  For DRY-ness, you are
+  #               recommended to keep your event names and Ruby class
+  #               names in sync and not need this option.
+  #   :skip     - Array of field names to skip from the Event defininition
+  #               entirely, these could include fields that are only
+  #               implemented by the Listener.  This may also be a
+  #               regular expression.
+  #   :defaults - hash of default key -> value pairs to set at
+  #               creation time
+  #
+  def self.new(options, &block)
+    db = type_db(options)
+    dump = db.to_hash
+    klass, name, event_def = class_for(options, dump)
 
-      name = options[:name] || klass
-      parent = options[:parent] || Object
-      event_def = dump[name.to_sym] or
-        raise RuntimeError, "#{name.inspect} not defined in #{file}"
-
-      # merge MetaEventInfo fields in
-      meta_event_info = dump[:MetaEventInfo]
-      alpha = proc { |a,b| a.first.to_s <=> b.first.to_s }
-      event_def = event_def.sort(&alpha)
-      if meta_event_info
-        seen = event_def.map { |(field, _)| field }
-        meta_event_info.sort(&alpha).each do |field_type|
-          seen.include?(field_type.first) or event_def << field_type
-        end
+    # merge MetaEventInfo fields in
+    meta_event_info = dump[:MetaEventInfo]
+    alpha = proc { |a,b| a.first.to_s <=> b.first.to_s }
+    event_def = event_def.sort(&alpha)
+    if meta_event_info
+      seen = event_def.map { |(field, _)| field }
+      meta_event_info.sort(&alpha).each do |field_type|
+        seen.include?(field_type.first) or event_def << field_type
       end
+    end
 
-      Array(options[:skip]).each do |x|
-        if Regexp === x
-          event_def.delete_if { |(f,_)| x =~ f.to_s }
-        else
-          if x.to_sym == :MetaEventInfo
-            meta_event_info.nil? and
-              raise RuntimeError, "MetaEventInfo not defined in #{file}"
-            meta_event_info.each do |(field,_)|
-              event_def.delete_if { |(f,_)| field == f }
-            end
-          else
-            event_def.delete_if { |(f,_)| f == x.to_sym }
+    Array(options[:skip]).each do |x|
+      if Regexp === x
+        event_def.delete_if { |(f,_)| x =~ f.to_s }
+      else
+        if x.to_sym == :MetaEventInfo
+          meta_event_info.nil? and
+            raise RuntimeError, "MetaEventInfo not defined in #{file}"
+          meta_event_info.each do |(field,_)|
+            event_def.delete_if { |(f,_)| field == f }
           end
-        end
-      end
-
-      tmp = ::Struct.new(*(event_def.map { |(field,_)| field }))
-      components = klass.to_s.split(/::/)
-      components.each_with_index do |component, i|
-        if i == (components.size - 1)
-          tmp = parent.const_set(component, tmp)
         else
-          parent = begin
-            parent.const_get(component)
-          rescue NameError
-            eval "module #{parent.name}::#{component}; end"
-            parent.const_get(component)
-          end
+          event_def.delete_if { |(f,_)| f == x.to_sym }
         end
       end
-      tmp.const_set :TYPE_DB, db
-      tmp.const_set :NAME, name.to_s
-      ed = tmp.const_set :EVENT_DEF, {}
-      event_def.each { |(field,type)| ed[field] = type }
+    end
 
-      # freeze since emitter.c can segfault if this ever changes
-      type_list = event_def.map do |(field,type)|
-        [ field, field.to_s.freeze, type ].freeze
-      end.freeze
-      tmp.const_set :TYPE_LIST, type_list
+    tmp = ::Struct.new(*(event_def.map { |(field,_)| field }))
+    set_constants(tmp, db, klass, name, options)
+    ed = tmp.const_set :EVENT_DEF, {}
+    event_def.each { |(field,type)| ed[field] = type }
 
-      aref_map = tmp.const_set :AREF_MAP, {}
-      type_list.each_with_index do |(field_sym,field_str,_),idx|
-        aref_map[field_sym] = aref_map[field_str] = idx
-      end
+    # freeze since emitter.c can segfault if this ever changes
+    type_list = event_def.map do |(field,type)|
+      [ field, field.to_s.freeze, type ].freeze
+    end.freeze
+    tmp.const_set :TYPE_LIST, type_list
 
-      tmp.const_set :HAVE_ENCODING,
-                    type_list.include?([ :enc, 'enc', LWES::INT_16 ])
+    aref_map = tmp.const_set :AREF_MAP, {}
+    type_list.each_with_index do |(field_sym,field_str,_),idx|
+      aref_map[field_sym] = aref_map[field_str] = idx
+    end
 
-      defaults = options[:defaults] || {}
-      defaults = tmp.const_set :DEFAULTS, defaults.dup
-      tmp.class_eval(&block) if block_given?
+    tmp.const_set :HAVE_ENCODING,
+                  type_list.include?([ :enc, 'enc', LWES::INT_16 ])
 
-      # define a parent-level method, eval is faster than define_method
-      eval <<EOS
-class ::#{tmp.name}
-  class << self
-    alias _new new
-    undef_method :new
-    def new(*args)
-      if Hash === (init = args.first)
-        rv = _new()
-        DEFAULTS.merge(init).each_pair { |k,v| rv[k] = v }
-        rv
-      else
-        rv = _new(*args)
-        DEFAULTS.each_pair { |k,v| rv[k] ||= v }
-        rv
-      end
+    tmp.class_eval(&block) if block_given?
+
+    # define a parent-level method, eval is faster than define_method
+    tmp.class_eval <<EOS
+class << self
+  alias _new new
+  undef_method :new
+  def new(*args)
+    if Hash === (init = args.first)
+      rv = _new()
+      DEFAULTS.merge(init).each_pair { |k,v| rv[k] = v }
+      rv
+    else
+      rv = _new(*args)
+      DEFAULTS.each_pair { |k,v| rv[k] ||= v }
+      rv
     end
   end
 end
 EOS
 
-    # avoid linear scans for large structs, not sure if 50 is a good enough
-    # threshold but it won't help for anything <= 10 since Ruby (or at least
-    # MRI) already optimizes those cases
-    if event_def.size > 50
-      eval <<EOS
-class ::#{tmp.name}
-  alias __aref []
-  alias __aset []=
-  def [](key)
-    __aref(key.kind_of?(Fixnum) ? key : AREF_MAP[key])
-  end
+  # avoid linear scans for large structs, not sure if 50 is a good enough
+  # threshold but it won't help for anything <= 10 since Ruby (or at least
+  # MRI) already optimizes those cases
+  if event_def.size > 50
+    tmp.class_eval <<EOS
+alias __aref []
+alias __aset []=
+def [](key)
+  __aref(key.kind_of?(Fixnum) ? key : AREF_MAP[key])
+end
 
-  def []=(key, value)
-    __aset(key.kind_of?(Fixnum) ? key : AREF_MAP[key], value)
-  end
+def []=(key, value)
+  __aset(key.kind_of?(Fixnum) ? key : AREF_MAP[key], value)
+end
 end
 EOS
-      fast_methods = []
-      event_def.each_with_index do |(fld,type), idx|
-        next if idx <= 9
-        if idx != aref_map[fld]
-          raise LoadError, "event_def corrupt: #{event_def}"
-        end
-        fast_methods << "undef_method :#{fld}, :#{fld}=\n"
-        fast_methods << "\ndef #{fld}; __aref #{idx}; end\n"
-        fast_methods << "\ndef #{fld}=(val); __aset #{idx}, val ; end\n"
+    fast_methods = []
+    event_def.each_with_index do |(fld,_), idx|
+      next if idx <= 9
+      if idx != aref_map[fld]
+        raise LoadError, "event_def corrupt: #{event_def}"
       end
-
-      eval("class ::#{tmp.name}; #{fast_methods.join("\n")}\n end")
+      fast_methods << "undef_method :#{fld}, :#{fld}=\n"
+      fast_methods << "\ndef #{fld}; __aref #{idx}; end\n"
+      fast_methods << "\ndef #{fld}=(val); __aset #{idx}, val ; end\n"
     end
 
-    tmp
-    end
+    tmp.class_eval fast_methods.join("\n")
+  end
+
+  tmp
   end
 end

data/lib/lwes/type_db.rb

@@ -1,35 +1,38 @@
-module LWES
-  class TypeDB
+class LWES::TypeDB
 
-    # create LWES::Struct-derived classes based on the contents
-    # of the TypeDB object.  It is possible to place all classes
-    # into a namespace by specifying the :parent option to point
-    # to a class or module:
-    #
-    #   module MyEvents; end
-    #
-    #   type_db = LWES::TypeDB.new("my_events.esf")
-    #   type_db.create_classes!(:parent => MyEvents)
-    #
-    # Assuming you had "Event1" and "Event2" defined in your "my_events.esf"
-    # file, then the classes MyEvents::Event1 and MyEvents::Event2 should
-    # now be accessible.
-    def create_classes!(options = {})
-      classes = to_hash.keys - [ :MetaEventInfo ]
-      classes.sort { |a,b| a.to_s.size <=> b.to_s.size }.map do |klass|
-        LWES::Struct.new({ :db => self, :class => klass }.merge(options))
-      end
-    end
-
-    # :stopdoc:
-    # avoid GC mis-free-ing nuked objects
-    def dup
-      self
-    end
-
-    def clone
-      self
+  # create LWES::Struct-derived classes based on the contents
+  # of the TypeDB object.  It is possible to place all classes
+  # into a namespace by specifying the :parent option to point
+  # to a class or module:
+  #
+  #   module MyEvents; end
+  #
+  #   type_db = LWES::TypeDB.new("my_events.esf")
+  #   type_db.create_classes!(:parent => MyEvents)
+  #   type_db.create_classes!(:sparse => true)
+  #
+  # Assuming you had "Event1" and "Event2" defined in your "my_events.esf"
+  # file, then the classes MyEvents::Event1 and MyEvents::Event2 should
+  # now be accessible.
+  #
+  #   :parent   - parent class or module, the default is 'Object' putting
+  #               the new class in the global namespace.  May be +nil+ for
+  #               creating anonymous classes.
+  #   :sparse   - If +true+, this will subclass from LWES::Event instead of
+  #               :Struct for better memory efficiency when dealing with
+  #               events with many unused fields.  Default is +false+.
+  def create_classes!(options = {})
+    classes = to_hash.keys - [ :MetaEventInfo ]
+    classes.sort { |a,b| a.to_s.size <=> b.to_s.size }.map! do |klass|
+      opts = { :db => self, :class => klass }.merge!(options)
+      opts[:sparse] ? LWES::Event.subclass(opts) : LWES::Struct.new(opts)
     end
+  end
 
+  # :stopdoc:
+  # avoid GC mis-free-ing nuked objects
+  def dup
+    self
   end
+  alias clone dup
 end

data/lib/lwes.rb

@@ -1,10 +1,49 @@
+##
+# = Light Weight Event System bindings for Ruby
+#
+#    require 'lwes'
+#
+#    # create an Emitter which may be used for the lifetime of your process
+#    emitter = LWES::Emitter.new(:address => '224.1.1.11',
+#                                :port => 12345,
+#                                :heartbeat => 30, # nil to disable
+#                                :ttl => 1) # nil for default TTL(3)
+#
+#    # parse your ESF file at startup, the example below assumes you
+#    # have "Event1" and "Event2" defined in your ESF file:
+#    type_db = LWES::TypeDB.new("my_events.esf")
+#
+#    # create classes to use, by default and to encourage DRY-ness,
+#    # we map each event in the ESF file to a class
+#    # Optionally, you may specify :parent => module/namespace
+#    type_db.create_classes! :parent => MyApp
+#
+#    # inside your application, you may now do this to slowly build up
+#    # fields for the event
+#    my_event = MyApp::Event1.new
+#    my_event.started = Time.now.to_i
+#    my_event.remote_addr = "192.168.0.1"
+#    # ...do a lot of stuff here in between...
+#    my_event.field1 = value1
+#    my_event.field2 = value2
+#    my_event.field3 = value3
+#    my_event.finished = Time.now.to_i
+#    emitter << my_event
+#
+#    # Alternatively, if you know ahead of time all the fields you want to
+#    # set for an event, you can emit an event in one step:
+#
+#    emitter.emit MyApp::Event2, :field1 => value1, :field2 => value2 # ...
+#
 module LWES
-  # version of our library, currently 0.7.0
-  VERSION = "0.7.0"
+  # version of our library, currently 0.8.0pre1
+  VERSION = "0.8.0pre1"
 
+  autoload :ClassMaker, "lwes/class_maker"
   autoload :TypeDB, "lwes/type_db"
   autoload :Struct, "lwes/struct"
   autoload :Emitter, "lwes/emitter"
   autoload :Event, "lwes/event"
+  autoload :Listener, "lwes/listener"
 end
 require "lwes_ext"

data/lwes.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |s|
   s.name = %q{lwes}
-  s.version = "0.7.0"
+  s.version = "0.8.0pre1"
   s.date = Time.now
   s.authors = ["Erik S. Chang", "Frank Maritato"]
   s.email = %q{lwes-devel@lists.sourceforge.net}
-  s.summary = %q{Ruby API for the Light Weight Event System}
-  s.homepage = %q{http://www.lwes.org/}
-  s.extensions = %w(ext/lwes/extconf.rb)
+  s.summary = %q{Ruby bindings for the Light Weight Event System}
+  s.homepage = %q{http://lwes.rubyforge.org/}
+  s.extensions = %w(ext/lwes_ext/extconf.rb)
   s.description = %q{
 The LWES Light-Weight Event System is a framework for allowing the exchange of
 information from many machines to many machines in a controlled, platform
@@ -14,39 +14,9 @@ neutral, language neutral way.  The exchange of information is done in a
 connectless fashion using multicast or unicast UDP, and using self describing
 data so that any platform or language can translate it to it's local dialect.
 }.strip
-  s.files = %w(
-COPYING
-ChangeLog
-README
-Rakefile
-examples/demo.rb
-examples/my_events.esf
-ext/lwes/emitter.c
-ext/lwes/event.c
-ext/lwes/extconf.rb
-ext/lwes/lwes.c
-ext/lwes/lwes_ruby.h
-ext/lwes/numeric.c
-ext/lwes/type_db.c
-lib/lwes.rb
-lib/lwes/emitter.rb
-lib/lwes/event.rb
-lib/lwes/struct.rb
-lib/lwes/type_db.rb
-lwes.gemspec
-test/test_helper.rb
-test/unit/meta_only.esf
-test/unit/namespaced.esf
-test/unit/test1.esf
-test/unit/test2.esf
-test/unit/test_emit_struct.rb
-test/unit/test_emitter.rb
-test/unit/test_event.rb
-test/unit/test_struct.rb
-test/unit/test_type_db.rb
-) + %w(
-ext/lwes/lwes-0.23.1.tar.gz
-)
+  s.files = `git ls-files`.split(/\n/) +
+            %w(ext/lwes_ext/lwes-0.23.1.tar.gz)
   s.rubyforge_project = 'lwes'
   s.test_files = s.files.grep(%r{\Atest/unit/test_})
+  s.add_development_dependency(%q<rake-compiler>, [">= 0.7.6"])
 end

data/test/test_helper.rb

@@ -15,8 +15,8 @@ unless defined?(LISTENER_DEFAULTS)
   }
 end
 
-private_bin = "ext/lwes/.inst/bin"
-if test ?d, private_bin
+private_bin = "ext/lwes_ext/.inst/bin"
+if File.directory? private_bin
   ENV['PATH'] = "#{private_bin}:#{ENV['PATH']}"
 end
 

data/test/unit/test_emit_struct.rb

@@ -133,7 +133,7 @@ class TestEmitStruct < Test::Unit::TestCase
 
   def test_emit_from_class_bad_type
     out = lwes_listener do
-      e = assert_raises(TypeError) do
+      assert_raises(TypeError) do
         emitter = LWES::Emitter.new(@options)
         opt = {
           :t_int16 => -1000,

data/test/unit/test_event.rb

@@ -66,4 +66,84 @@ class TestEvent < Test::Unit::TestCase
     ensure
       receiver.close
   end
+
+  def test_subclass_aset_aref
+    tdb = LWES::TypeDB.new("#{File.dirname(__FILE__)}/test1.esf")
+    tmp = LWES::Event.subclass :name => "Event1", :db => tdb
+    e = tmp.new
+    assert_equal({}, e.to_hash)
+    vals = {
+      :t_bool => true,
+      :t_int16 => -1000,
+      :t_uint16 => 1000,
+      :t_int32 => -64444,
+      :t_uint32 => 64444,
+      :t_int64 => 10_000_000_000,
+      :t_uint64 => 10_000_000_000,
+      :t_ip_addr => "192.168.0.1",
+      :t_string => "STRING",
+      :enc => 0,
+      :st => "ruby",
+    }
+    vals.each do |k,v|
+      assert_nothing_raised { e[k.to_s] = v }
+      assert_equal v, e[k.to_s], e.to_hash.inspect
+    end
+
+    e2 = tmp.new
+    vals.each do |k,v|
+      assert_nothing_raised { e2[k] = v }
+      assert_equal v, e2[k], e2.to_hash.inspect
+    end
+    assert_equal e2.to_hash, e.to_hash
+    e3 = tmp.new
+    vals.each do |k,v|
+      assert_nothing_raised { e3.__send__ "#{k}=", v }
+      assert_equal v, e3.__send__(k), e3.to_hash.inspect
+    end
+    assert_equal e3.to_hash, e.to_hash
+  end
+
+  def test_merge
+    tdb = LWES::TypeDB.new("#{File.dirname(__FILE__)}/test1.esf")
+    tmp = LWES::Event.subclass :name => "Event1", :db => tdb
+    e = tmp.new.merge :t_string => "merged"
+    assert_equal "merged", e.t_string
+  end
+
+  def test_init_copy
+    tdb = LWES::TypeDB.new("#{File.dirname(__FILE__)}/test1.esf")
+    tmp = LWES::Event.subclass :name => "Event1", :db => tdb
+    a = tmp.new
+    b = a.dup
+    assert_equal a.to_hash, b.to_hash
+    a.t_string = "HELLO"
+    assert_equal "HELLO", a.t_string
+    assert_nil b.t_string
+    c = a.dup
+    assert_equal "HELLO", c.t_string
+  end
+
+  def test_emit_receive_subclassed
+    receiver = UDPSocket.new
+    receiver.bind(nil, @options[:port])
+    emitter = LWES::Emitter.new(@options)
+    tmp = { :t_string => 'hello' }
+
+    tdb = LWES::TypeDB.new("#{File.dirname(__FILE__)}/test1.esf")
+    ev1 = LWES::Event.subclass :name => "Event1", :db => tdb
+    emitter.emit "Event1", tmp
+    buf, _ = receiver.recvfrom(65536)
+    parsed = LWES::Event.parse(buf)
+    assert_instance_of ev1, parsed
+    assert_equal parsed.to_hash, ev1.new(tmp).to_hash
+    ensure
+      receiver.close
+  end
+
+  def teardown
+    new_classes = LWES::Event::CLASSES
+    new_classes.each_key { |k| Object.__send__ :remove_const, k.to_sym }
+    new_classes.clear
+  end
 end

data/test/unit/test_listener.rb

@@ -0,0 +1,82 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
+
+class TestListener < Test::Unit::TestCase
+  def setup
+    @options = LISTENER_DEFAULTS.dup
+    @listener = @emitter = nil
+  end
+
+  def teardown
+    assert_nil(@listener.close) if @listener
+    assert_nil(@emitter.close) if @emitter
+    LWES::Event::CLASSES.clear
+  end
+
+  def test_listen_and_close
+    listener = LWES::Listener.new @options.merge(:iface => nil)
+    assert_nil listener.close
+    assert_raises(IOError) { listener.close }
+  end
+
+  def test_listen_and_close_with_iface
+    listener = LWES::Listener.new @options
+    assert_nil listener.close
+    assert_raises(IOError) { listener.close }
+  end
+
+  def test_listen_emit_recv_and_close
+    @listener = LWES::Listener.new @options
+    @emitter = LWES::Emitter.new @options
+    @emitter.emit("E1", { :hello => "WORLD"})
+    event = @listener.recv.to_hash
+    assert_equal "E1", event[:name]
+    assert event[:SenderPort] > 0
+    assert event[:ReceiptTime] > (Time.now.to_i * 1000)
+    assert_equal "WORLD", event[:hello]
+    assert_equal @options[:address], event[:SenderIP]
+  end
+
+  def test_listen_emit_custom_event_recv_and_close
+    @listener = LWES::Listener.new @options
+    tdb = LWES::TypeDB.new("#{File.dirname(__FILE__)}/test1.esf")
+    tmp = LWES::Event.subclass :name => "Event1", :db => tdb, :parent => nil
+    @emitter = LWES::Emitter.new @options
+    @emitter << tmp.new(:t_string => "HI")
+    event = @listener.recv
+    assert_instance_of tmp, event
+    assert_equal "HI", event.t_string
+    assert event.SenderPort > 0
+    assert event.ReceiptTime > (Time.now.to_i * 1000)
+    assert_equal @options[:address], event.SenderIP
+  end
+
+  def test_listen_recv_timeout
+    @listener = LWES::Listener.new @options
+    t0 = Time.now.to_f
+    event = @listener.recv 10
+    assert_nil event
+    delta = Time.now.to_f - t0
+    assert(delta >= 0.01, "delta=#{delta}")
+  end
+
+  def test_listen_each_signal
+    signaled = false
+    handler = trap(:USR1) { signaled = true }
+    @listener = LWES::Listener.new @options
+    @emitter = LWES::Emitter.new @options
+    tmp = []
+    thr = Thread.new do
+      sleep 0.1
+      Process.kill :USR1, $$
+      @emitter.emit("E1", :hello => "WORLD")
+      :OK
+    end
+    @listener.each { |event| tmp << event and break }
+    assert thr.join
+    assert_equal :OK, thr.value
+    assert_equal 1, tmp.size
+    assert_equal "WORLD", tmp[0].to_hash[:hello]
+    ensure
+      trap(:USR1, handler)
+  end
+end if LWES::Listener.method_defined?(:recv)