dnsruby 1.55 → 1.56.0

data/test/tc_res_env.rb

@@ -1,54 +1,51 @@
-#--
-#Copyright 2007 Nominet UK
-#
-#Licensed under the Apache License, Version 2.0 (the "License");
-#you may not use this file except in compliance with the License. 
-#You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0 
-#
-#Unless required by applicable law or agreed to in writing, software 
-#distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#See the License for the specific language governing permissions and 
-#limitations under the License.
-#++
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
+# --
+# Copyright 2007 Nominet UK
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+
 include Dnsruby
-class TestResolverEnv < Test::Unit::TestCase
+class TestResolverEnv < Minitest::Test
 # @todo@ Dnsruby does not provide this functionality
   def test_res_env
     ENV['RES_NAMESERVERS'] = '10.0.1.128 10.0.2.128';
     ENV['RES_SEARCHLIST']  = 'dnsruby.validation-test-servers.nominet.org.uk lib.dnsruby.validation-test-servers.nominet.org.uk';
     ENV['LOCALDOMAIN']     = 't.dnsruby.validation-test-servers.nominet.org.uk';
     ENV['RES_OPTIONS']     = 'retrans:3 retry:2 debug';
-    
-    
+
+
     res = DNS.new;
-    
+
     assert(res,                       "new() returned something");
     assert(res.config.nameserver,   "nameservers() works");
-    
+
     servers = res.config.nameserver;
-    
+
     assert_equal(servers[0], '10.0.1.128',  'Nameserver set correctly');
     assert_equal(servers[1], '10.0.2.128',  'Nameserver set correctly');
-    
-    
+
+
     search = res.searchlist;
     assert_equal(search[0], 'dnsruby.validation-test-servers.nominet.org.uk',     'Search set correctly' );
     assert_equal(search[1], 'lib.dnsruby.validation-test-servers.nominet.org.uk', 'Search set correctly' );
-    
+
     assert_equal(res.domain,  't.dnsruby.validation-test-servers.nominet.org.uk', 'Local domain works'  );
     assert_equal(3, res.retrans,               'Retransmit works'    );
     assert_equal(2, res.retry,                 'Retry works'         );
     assert(res.debug,                    'Debug works'         );
-    
-    
+
+
   end
 end

data/test/tc_res_file.rb

@@ -1,45 +1,42 @@
-#--
-#Copyright 2007 Nominet UK
-#
-#Licensed under the Apache License, Version 2.0 (the "License");
-#you may not use this file except in compliance with the License. 
-#You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0 
-#
-#Unless required by applicable law or agreed to in writing, software 
-#distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#See the License for the specific language governing permissions and 
-#limitations under the License.
-#++
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
-class TestAResolverFile < Test::Unit::TestCase
+# --
+# Copyright 2007 Nominet UK
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+
+class TestAResolverFile < Minitest::Test
   def setup
     Dnsruby::Config.reset
   end
-  
+
   def test_resFile
     res = Dnsruby::DNS.new("test/resolv.conf")
-    
+
     assert(res,                "new() returned something")
     assert(res.config.nameserver,   "nameservers() works")
-    
+
     servers = res.config.nameserver
-    
+
     assert_equal(servers[0], '10.0.1.128',  'Nameserver set correctly')
     assert_equal(servers[1], '10.0.2.128',  'Nameserver set correctly')
-    
-    
+
+
     search = res.config.search
     assert(search.include?('dnsruby.validation-test-servers.nominet.org.uk'),     'Search set correctly' )
     assert(search.include?('lib.dnsruby.validation-test-servers.nominet.org.uk'), 'Search set correctly' )
-    
+
     assert(res.config.domain=='t.dnsruby.validation-test-servers.nominet.org.uk', 'Local domain works'  )
   end
 end

data/test/tc_res_opt.rb

@@ -1,54 +1,51 @@
-#--
-#Copyright 2007 Nominet UK
-#
-#Licensed under the Apache License, Version 2.0 (the "License");
-#you may not use this file except in compliance with the License. 
-#You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0 
-#
-#Unless required by applicable law or agreed to in writing, software 
-#distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#See the License for the specific language governing permissions and 
-#limitations under the License.
-#++
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
+# --
+# Copyright 2007 Nominet UK
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+
 include Dnsruby
-class TestResOpt < Test::Unit::TestCase
+class TestResOpt < Minitest::Test
   def test_dns_file
-    
-    # .txt because this test will run under windows, unlike the other file
-    # configuration tests.
+
+    #  .txt because this test will run under windows, unlike the other file
+    #  configuration tests.
     res = Dnsruby::DNS.new('test/custom.txt')
-    
+
     assert(res,                           'new() returned something')
     assert_instance_of(DNS, res, 'new() returns an object of the correct class.')
     assert(res.config.nameserver,       'nameservers() works')
-    
+
     servers = res.config.nameserver
-    
+
     assert_equal('10.0.1.42', servers[0],  'Nameserver set correctly')
     assert_equal('10.0.2.42',  servers[1], 'Nameserver set correctly')
-    
-    
+
+
     search = res.config.search
     assert(search.include?('alt.dnsruby.validation-test-servers.nominet.org.uk'), 'Search set correctly' )
     assert(search.include?('ext.dnsruby.validation-test-servers.nominet.org.uk'), 'Search set correctly' )
-    
+
     assert(res.config.domain == 't2.dnsruby.validation-test-servers.nominet.org.uk',  'Local domain works'  )
   end
-  
+
   def test_resolver_file
     res = Dnsruby::Resolver.new({:config_info => 'test/custom.txt'})
     assert(res.config.nameserver==['10.0.1.42', '10.0.2.42'], res.config.nameserver.to_s)
   end
-  
+
   def test_no_file
     Dnsruby.log.level=Logger::FATAL
     res=nil
@@ -64,10 +61,10 @@ class TestResOpt < Test::Unit::TestCase
     end
 #    Dnsruby.log.level=Logger::ERROR
   end
-  
+
   def test_config_hash_singleresolver
-    # Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
-    # SR : server, local_address, udp_size
+    #  Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
+    #  SR : server, local_address, udp_size
     test_config = {
       :server	   => '10.0.0.1',
       :port		   => 54, # SingleResolver and Multi-Resolver
@@ -80,17 +77,17 @@ class TestResOpt < Test::Unit::TestCase
       :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
       :dnssec         => true,
     }
-    
+
     res = SingleResolver.new(test_config)
     test_config.keys.each do |item|
       assert_equal(test_config[item], res.send(item), "#{item} is correct")
-    end	
+    end
   end
-  
+
   def test_config_hash_multiresolver
-    # Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
-    # ER : retries, load_balance. Also loads servers from Config and configures SRs to point to them
-    #   Also implements Resolver interface - but iterates this through *all* SRs
+    #  Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
+    #  ER : retries, load_balance. Also loads servers from Config and configures SRs to point to them
+    #    Also implements Resolver interface - but iterates this through *all* SRs
     test_config = {
       :nameserver	   => ['10.0.0.1', '10.0.0.2'], # for Multi-Resolver & DNS
       :port		   => 54, # SingleResolver and Multi-Resolver
@@ -101,12 +98,12 @@ class TestResOpt < Test::Unit::TestCase
       :retry_times		   => 5, # DNSand Multi-Resolver
       :use_tcp		   => true, # SingleResolver and Multi-Resolver
       :ignore_truncation          => true, # SingleResolver and Multi-Resolver
-      :recurse        => false, 
+      :recurse        => false,
       :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
       :query_timeout    => 60, # Multi-Resolver only
       :dnssec         => true,
     }
-    
+
     res = Resolver.new(test_config)
     test_config.keys.each do |item|
       if (item==:nameserver)
@@ -114,36 +111,36 @@ class TestResOpt < Test::Unit::TestCase
       else
         assert_equal(res.send(item), test_config[item], "#{item} is correct")
       end
-    end	
+    end
   end
-  
+
   def test_config_hash_lookup
-    # Lookup : can specify resolver, searchpath
-    #
-    # Check that we can set things in new()
-    #
+    #  Lookup : can specify resolver, searchpath
+    # 
+    #  Check that we can set things in new()
+    # 
     res=nil
-    
+
     test_config = {
       :nameserver	   => ['10.0.0.1', '10.0.0.2'], # for Multi-Resolver & DNS
       :domain	       => 'dnsruby.validation-test-servers.nominet.org.uk', # one for DNS only?
       :search	   => ['dnsruby.validation-test-servers.nominet.org.uk', 't.dnsruby.validation-test-servers.nominet.org.uk'], # one for DNS
       :ndots          => 2, # DNS only
-      :apply_search_list         => false, # DNS only 
-      :apply_domain => false, # DNS only 
+      :apply_search_list         => false, # DNS only
+      :apply_domain => false, # DNS only
     }
-    
+
     res = DNS.new(test_config)
     test_config.keys.each do |item|
       assert_equal(res.config.send(item), test_config[item], "#{item} is correct")
-    end	
+    end
   end
-  
-  
+
+
   def test_bad_config
     res=nil
     Dnsruby.log.level=Logger::FATAL
-    
+
     bad_input = {
       :tsig_rr        => 'set',
       :errorstring    => 'set',
@@ -157,11 +154,11 @@ class TestResOpt < Test::Unit::TestCase
       :cdflag         => 'set',
     }
     res=nil
-    begin    
+    begin
       res = Resolver.new(bad_input)
-    rescue Exception 
+    rescue Exception
     end
-    if (res)    
+    if (res)
       bad_input.keys.each do |key|
         begin
           assert_not_equal(res.send(key), 'set', "#{key} is not set")
@@ -169,13 +166,13 @@ class TestResOpt < Test::Unit::TestCase
         end
       end
     end
-    
+
     res=nil
-    begin    
+    begin
       res = DNS.new(bad_input)
-    rescue Exception 
+    rescue Exception
     end
-    if (res)        
+    if (res)
       bad_input.keys.each do |key|
         begin
           assert_not_equal(res.send(key), 'set', "#{key} is not set")

data/test/tc_resolver.rb

@@ -1,243 +1,288 @@
-#--
-#Copyright 2007 Nominet UK
-#
-#Licensed under the Apache License, Version 2.0 (the "License");
-#you may not use this file except in compliance with the License. 
-#You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0 
-#
-#Unless required by applicable law or agreed to in writing, software 
-#distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either tmexpress or implied. 
-#See the License for the specific language governing permissions and 
-#limitations under the License.
-#++
-require 'dnsruby'
-require 'socket'
-require 'test/unit'
-include Dnsruby
-#@TODO@ We also need a test server so we can control behaviour of server to test
-#different aspects of retry strategy.
-#Of course, with Ruby's limit of 256 open sockets per process, we'd need to run 
-#the server in a different Ruby process.
-
-class TestResolver < Test::Unit::TestCase
-  include Dnsruby
-  Thread::abort_on_exception = true
-  PORT = 42138
-  @@port = PORT
-  def setup
-    Dnsruby::Config.reset
-  end
-  
-  def test_send_message
-    res = Resolver.new
-    ret = res.send_message(Message.new("example.com", Types.A))
-    assert(ret.kind_of?(Message))
-  end
-
-  def test_send_plain_message
-    res = Resolver.new
-    response, error = res.send_plain_message(Message.new("example.com"))
-    assert(response.kind_of?(Message))
-    m = Message.new("fgjkhsklfjedfiuaufewriuf.com")
-    m.header.rd = true
-    response, error = res.send_plain_message(m)
-#    print "Response : #{response}\n"
-#    print "Error : #{error}\n"
-    assert(response.kind_of?(Message))
-    assert(error)
-    assert(error.kind_of?(NXDomain))
-  end
-
-  def test_query
-    res = Resolver.new
-    ret = res.query("example.com")
-    assert(ret.kind_of?(Message))
-  end
-
-  def test_query_async
-    res = Resolver.new
-    q = Queue.new
-    res.send_async(Message.new("example.com", Types.A),q,q)
-    id, ret, error = q.pop
-    assert_equal(id, q, "Id wrong!")
-    assert(ret.kind_of?(Message), "Ret wrong!")
-    assert(error==nil)
-  end
-
-  def test_query_one_duff_server_one_good
-    res = Resolver.new({:nameserver => ["localhost", "128.8.10.90"]})
-    res.retry_delay=1
-    q = Queue.new
-    res.send_async(Message.new("example.com", Types.A),q,q)
-    id, ret, error = q.pop
-    assert_equal(id, q, "Id wrong!")
-    assert(ret.kind_of?(Message), "Ret wrong! (#{ret.class}")
-    assert(error==nil)
-  end
-
-  # @TODO@ Implement!!  But then, why would anyone want to do this?
-  #  def test_many_threaded_clients
-  #    assert(false, "IMPLEMENT!")
-  #  end
-  
-  def test_reverse_lookup
-    m = Message.new("210.251.121.214", Types.PTR)
-    r = Resolver.new
-    q=Queue.new
-    r.send_async(m,q,q)
-    id,ret, error=q.pop
-    assert(ret.kind_of?(Message))
-    no_pointer=true
-    ret.each_answer do |answer|
-      if (answer.type==Types.PTR)
-        no_pointer=false
-        assert(answer.domainname.to_s=~/ruby-lang/)      
-      end
-    end
-    assert(!no_pointer)
-  end
-  
-#  def test_bad_host
-#    res = Resolver.new({:nameserver => "localhost"})
-#    res.retry_times=1
-#    res.retry_delay=0
-#    res.query_timeout = 1
-#    q = Queue.new
-#    res.send_async(Message.new("example.com", Types.A), q, q)
-#    id, m, err = q.pop
-#    assert(id==q)
-#    assert(m == nil)
-#    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
-#  end
-#  
-  def test_nxdomain
-    res=Resolver.new
-    q = Queue.new
-    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), q, 1)
-    id, m, err = q.pop
-    assert(id==1)
-    assert(m.rcode == RCode.NXDOMAIN)
-    assert(NXDomain === err)
-  end
-  
-  def test_timeouts
-    #test timeout behaviour for different retry, retrans, total timeout etc.
-    #Problem here is that many sockets will be created for queries which time out. 
-    # Run a query which will not respond, and check that the timeout works
-    if (!RUBY_PLATFORM=~/darwin/)
-      start=stop=0
-      retry_times = 3
-      retry_delay=1
-      packet_timeout=2
-      # Work out what time should be, then time it to check
-      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
-      begin
-        res = Resolver.new({:nameserver => "10.0.1.128"})
-        #      res = Resolver.new({:nameserver => "213.248.199.17"})
-        res.packet_timeout=packet_timeout
-        res.retry_times=retry_times
-        res.retry_delay=retry_delay
-        start=Time.now
-        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-        fail
-      rescue ResolvTimeout
-        stop=Time.now
-        time = stop-start
-        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-      end
-  end
-  end
-  
-  def test_packet_timeout
-        res = Resolver.new({:nameserver => []})
-#      res = Resolver.new({:nameserver => "10.0.1.128"})
-      start=stop=0
-      retry_times = retry_delay = packet_timeout= 10
-      query_timeout=2
-      begin
-        res.packet_timeout=packet_timeout
-        res.retry_times=retry_times
-        res.retry_delay=retry_delay
-        res.query_timeout=query_timeout
-        # Work out what time should be, then time it to check
-        expected = query_timeout
-        start=Time.now
-        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-        fail
-      rescue ResolvTimeout
-        stop=Time.now
-        time = stop-start
-        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-      end    #
-  end
-  
-  def test_queue_packet_timeout
-#    if (!RUBY_PLATFORM=~/darwin/)
-      res = Resolver.new({:nameserver => "10.0.1.128"})
-#      bad = SingleResolver.new("localhost")
-      res.add_server("localhost")
-      expected = 2
-      res.query_timeout=expected    
-      q = Queue.new
-      start = Time.now
-      m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
-      id,ret,err = q.pop
-      stop = Time.now
-      assert(id=q)
-      assert(ret==nil)
-      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
-      time = stop-start
-      assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-#    end
-  end
-  
-  def test_illegal_src_port
-    # Also test all singleresolver ports ok
-    # Try to set src_port to an illegal value - make sure error raised, and port OK
-    res = Resolver.new
-    res.port = 56789
-    tests = [53, 387, 1265, 3210, 48619]
-    tests.each do |bad_port|
-      begin
-        res.src_port = bad_port
-        fail("bad port #{bad_port}")
-      rescue
-      end
-    end
-    assert(res.single_resolvers[0].src_port = 56789)
-  end
-  
-  def test_add_src_port
-    # Try setting and adding port ranges, and invalid ports, and 0.
-    # Also test all singleresolver ports ok
-    res = Resolver.new
-    res.src_port = [56789,56790, 56793]
-    assert(res.src_port == [56789,56790, 56793])
-    res.src_port = 56889..56891
-    assert(res.src_port == [56889,56890,56891])
-    res.add_src_port(60000..60002)
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002])
-    res.add_src_port([60004,60005])
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005])
-    res.add_src_port(60006)
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
-    # Now test invalid src_ports
-    tests = [0, 53, [60007, 53], [60008, 0], 55..100]
-    tests.each do |x|
-      begin
-        res.add_src_port(x)
-        fail()
-      rescue
-      end
-    end
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
-    assert(res.single_resolvers[0].src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])    
-  end
-
-  def test_eventtype_api
-    # @TODO@ TEST THE Resolver::EventType interface!
-  end
+# --
+# Copyright 2007 Nominet UK
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either tmexpress or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+require_relative 'spec_helper'
+
+require 'socket'
+
+include Dnsruby
+# @TODO@ We also need a test server so we can control behaviour of server to test
+# different aspects of retry strategy.
+# Of course, with Ruby's limit of 256 open sockets per process, we'd need to run
+# the server in a different Ruby process.
+
+class TestResolver < Minitest::Test
+
+  include Dnsruby
+
+  Thread::abort_on_exception = true
+
+  GOOD_DOMAIN_NAME = 'example.com'
+  BAD_DOMAIN_NAME  = 'dnsruby-test-of-bad-domain-name.blah'
+
+  PORT = 42138
+  @@port = PORT
+
+  def setup
+    Dnsruby::Config.reset
+  end
+
+  def assert_valid_response(response)
+    assert(response.kind_of?(Message), "Expected response to be a message but was a #{response.class}")
+  end
+
+  def assert_nil_response(response)
+    assert(response.nil?, "Expected no response but got a #{response.class}:\n#{response}")
+  end
+
+  def assert_error_is_exception(error, error_class = Exception)
+    assert(error.is_a?(error_class), "Expected error to be an #{error_class}, but was a #{error.class}:\n#{error}")
+  end
+
+  def assert_nil_error(error)
+    assert(error.nil?, "Expected no error but got a #{error.class}:\n#{error}")
+  end
+
+  def test_send_message
+    response = Resolver.new.send_message(Message.new("example.com", Types.A))
+    assert_valid_response(response)
+  end
+
+  def test_send_message_bang_noerror
+    response, error = Resolver.new.send_message!(Message.new(GOOD_DOMAIN_NAME, Types.A))
+    assert_nil_error(error)
+    assert_valid_response(response)
+  end
+
+  def test_send_message_bang_error
+    message = Message.new(BAD_DOMAIN_NAME, Types.A)
+    response, error = Resolver.new.send_message!(message)
+    assert_nil_response(response)
+    assert_error_is_exception(error)
+  end
+
+  def test_send_plain_message
+    resolver = Resolver.new
+    response, error = resolver.send_plain_message(Message.new("cnn.com"))
+    assert_nil_error(error)
+    assert_valid_response(response)
+
+    m = Message.new(BAD_DOMAIN_NAME)
+    m.header.rd = true
+    response, error = resolver.send_plain_message(m)
+    assert_valid_response(response)
+    assert_error_is_exception(error, NXDomain)
+  end
+
+  def test_query
+    response = Resolver.new.query("example.com")
+    assert_valid_response(response)
+  end
+
+  def test_query_bang_noerror
+    response, error = Resolver.new.query!(GOOD_DOMAIN_NAME)
+    assert_nil_error(error)
+    assert_valid_response(response)
+  end
+
+  def test_query_bang_error
+    response, error = Resolver.new.query!(BAD_DOMAIN_NAME)
+    assert_nil_response(response)
+    assert_error_is_exception(error)
+  end
+
+  def test_query_async
+    q = Queue.new
+    Resolver.new.send_async(Message.new("example.com", Types.A),q,q)
+    id, response, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert_valid_response(response)
+    assert_nil_error(error)
+  end
+
+  def test_query_one_duff_server_one_good
+    res = Resolver.new({:nameserver => ["8.8.8.8", "8.8.8.7"]})
+    res.retry_delay=1
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, response, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert_valid_response(response)
+    assert_nil_error(error)
+  end
+
+  #  @TODO@ Implement!!  But then, why would anyone want to do this?
+  #   def test_many_threaded_clients
+  #     assert(false, "IMPLEMENT!")
+  #   end
+
+  def test_reverse_lookup
+    m = Message.new("8.8.8.8", Types.PTR)
+    r = Resolver.new
+    q=Queue.new
+    r.send_async(m,q,q)
+    id,ret, error=q.pop
+    assert(ret.kind_of?(Message))
+    no_pointer=true
+    ret.each_answer do |answer|
+      if (answer.type==Types.PTR)
+        no_pointer=false
+        assert(answer.domainname.to_s=~/google-public-dns/)
+      end
+    end
+    assert(!no_pointer)
+  end
+
+#  def test_bad_host
+#    res = Resolver.new({:nameserver => "localhost"})
+#    res.retry_times=1
+#    res.retry_delay=0
+#    res.query_timeout = 1
+#    q = Queue.new
+#    res.send_async(Message.new("example.com", Types.A), q, q)
+#    id, m, err = q.pop
+#    assert(id==q)
+#    assert(m == nil)
+#    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
+#  end
+# 
+  def test_nxdomain
+    resolver = Resolver.new
+    q = Queue.new
+    resolver .send_async(Message.new(BAD_DOMAIN_NAME, Types.A), q, 1)
+    id, m, error = q.pop
+    assert(id==1, "Id should have been 1 but was #{id}")
+    assert(m.rcode == RCode.NXDOMAIN, "Expected NXDOMAIN but got #{m.rcode} instead.")
+    assert_error_is_exception(error, NXDomain)
+  end
+
+  def test_timeouts
+    # test timeout behaviour for different retry, retrans, total timeout etc.
+    # Problem here is that many sockets will be created for queries which time out.
+    #  Run a query which will not respond, and check that the timeout works
+    if (!RUBY_PLATFORM=~/darwin/)
+      start=stop=0
+      retry_times = 3
+      retry_delay=1
+      packet_timeout=2
+      #  Work out what time should be, then time it to check
+      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
+      begin
+        res = Resolver.new({:nameserver => "10.0.1.128"})
+        #       res = Resolver.new({:nameserver => "213.248.199.17"})
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
+      end
+  end
+  end
+
+  def test_packet_timeout
+        res = Resolver.new({:nameserver => []})
+#      res = Resolver.new({:nameserver => "10.0.1.128"})
+      start=stop=0
+      retry_times = retry_delay = packet_timeout= 10
+      query_timeout=2
+      begin
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        res.query_timeout=query_timeout
+        #  Work out what time should be, then time it to check
+        expected = query_timeout
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
+      end    #
+  end
+
+  def test_queue_packet_timeout
+#    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+#      bad = SingleResolver.new("localhost")
+      res.add_server("localhost")
+      expected = 2
+      res.query_timeout=expected
+      q = Queue.new
+      start = Time.now
+      m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
+      id,ret,err = q.pop
+      stop = Time.now
+      assert(id=q)
+      assert(ret==nil)
+      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
+      time = stop-start
+      assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
+#    end
+  end
+
+  def test_illegal_src_port
+    #  Also test all singleresolver ports ok
+    #  Try to set src_port to an illegal value - make sure error raised, and port OK
+    res = Resolver.new
+    res.port = 56789
+    tests = [53, 387, 1265, 3210, 48619]
+    tests.each do |bad_port|
+      begin
+        res.src_port = bad_port
+        fail("bad port #{bad_port}")
+      rescue
+      end
+    end
+    assert(res.single_resolvers[0].src_port = 56789)
+  end
+
+  def test_add_src_port
+    #  Try setting and adding port ranges, and invalid ports, and 0.
+    #  Also test all singleresolver ports ok
+    res = Resolver.new
+    res.src_port = [56789,56790, 56793]
+    assert(res.src_port == [56789,56790, 56793])
+    res.src_port = 56889..56891
+    assert(res.src_port == [56889,56890,56891])
+    res.add_src_port(60000..60002)
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002])
+    res.add_src_port([60004,60005])
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005])
+    res.add_src_port(60006)
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+    #  Now test invalid src_ports
+    tests = [0, 53, [60007, 53], [60008, 0], 55..100]
+    tests.each do |x|
+      begin
+        res.add_src_port(x)
+        fail()
+      rescue
+      end
+    end
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+    assert(res.single_resolvers[0].src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+  end
+
+  def test_eventtype_api
+    #  @TODO@ TEST THE Resolver::EventType interface!
+  end
 end