dnsruby 1.55 → 1.56.0

data/test/tc_rr.rb

@@ -1,53 +1,50 @@
-#--
-#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 TestRR < Test::Unit::TestCase
+class TestRR < Minitest::Test
   def test_rr
-    #------------------------------------------------------------------------------
-    # Canned data.
-    #------------------------------------------------------------------------------
-    
+    # ------------------------------------------------------------------------------
+    #  Canned data.
+    # ------------------------------------------------------------------------------
+
     name			= "foo.example.com";
     klass			= "IN";
     ttl				= 43200;
-    
+
     rrs = [
     {  	#[0]
       :type        => Types.A,
-      :address     => '10.0.0.1',  
-    }, 
+      :address     => '10.0.0.1',
+    },
     {	#[1]
       :type      => Types::AAAA,
       :address     => '102:304:506:708:90a:b0c:d0e:ff10',
-    }, 
+    },
     {	#[2]
       :type         => 'AFSDB',
       :subtype      => 1,
       :hostname     => 'afsdb-hostname.example.com',
-    }, 
+    },
     {	#[3]
       :type         => Types.CNAME,
       :domainname        => 'cname-cname.example.com',
-    }, 
+    },
     {   #[4]
       :type         => Types.DNAME,
       :domainname        => 'dname.example.com',
@@ -56,29 +53,29 @@ class TestRR < Test::Unit::TestCase
       :type         => Types.HINFO,
       :cpu          => 'test-cpu',
       :os           => 'test-os',
-    }, 
+    },
     {	#[6]
       :type         => Types.ISDN,
       :address      => '987654321',
       :subaddress           => '001',
-    }, 
+    },
     {	#[7]
       :type         => Types.MB,
       :domainname      => 'mb-madname.example.com',
-    }, 
+    },
     {	#[8]
       :type         => Types.MG,
       :domainname   => 'mg-mgmname.example.com',
-    }, 
+    },
     {	#[9]
       :type         => Types.MINFO,
       :rmailbx      => 'minfo-rmailbx.example.com',
       :emailbx      => 'minfo-emailbx.example.com',
-    }, 
+    },
     {	#[10]
       :type         => Types.MR,
       :domainname      => 'mr-newname.example.com',
-    }, 
+    },
     {	#[11]
       :type         => Types.MX,
       :preference   => 10,
@@ -107,14 +104,14 @@ class TestRR < Test::Unit::TestCase
       :area         => '0020',
       :id           => '00800a123456',
       :sel          => '00',
-      #      #:address => '4700580005a001000002000800a12345600'
-      #      :address => '47000580005a0000001000002000800a12345600'
+      #       #:address => '4700580005a001000002000800a12345600'
+      #       :address => '47000580005a0000001000002000800a12345600'
     },
     {	#[15]
       :type         => Types.PTR,
       :domainname     => 'ptr-ptrdname.example.com',
     },
-    {	#[16] 
+    {	#[16]
       :type         => Types.PX,
       :preference   => 10,
       :map822       => 'px-map822.example.com',
@@ -182,48 +179,48 @@ class TestRR < Test::Unit::TestCase
       :exchange     => 'kx-exchange.example.com',
     },
     ]
-    
-    
-    #------------------------------------------------------------------------------
-    # Create the packet
-    #------------------------------------------------------------------------------
-    
+
+
+    # ------------------------------------------------------------------------------
+    #  Create the packet
+    # ------------------------------------------------------------------------------
+
     message = Message.new
     assert(message,         'Message created');
-    
-    
+
+
     rrs.each do |data|
       data.update({	   :name => name,
         :ttl  => ttl,
       })
       rr=RR.create(data)
-      
+
       message.add_answer(rr);
     end
-    
-    #------------------------------------------------------------------------------
-    # Re-create the packet from data.
-    #------------------------------------------------------------------------------
+
+    # ------------------------------------------------------------------------------
+    #  Re-create the packet from data.
+    # ------------------------------------------------------------------------------
     data = message.encode;
     assert(data,            'Packet has data after pushes');
-    
+
     message=nil;
     message= Message.decode(data);
-    
+
     assert(message,          'Packet reconstructed from data');
-    
+
     answer = message.answer;
-    
+
     i = 0
     rrs.each do |rec|
       ret_rr = answer[i]
       i += 1
       rec.each do |key, value|
-        #        method = key+'=?'
+        #         method = key+'=?'
         x = ret_rr.send(key)
         if (ret_rr.kind_of?RR::CERT and (key == :alg or key == :certtype))
           assert_equal(value.to_s, x.code.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
-        elsif (ret_rr.kind_of?RR::TXT and (key == :strings)) 
+        elsif (ret_rr.kind_of?RR::TXT and (key == :strings))
           assert_equal(value.to_s.downcase, x[0].to_s.downcase, "TXT strings wrong")
         else
           if (key == :type)
@@ -234,25 +231,25 @@ class TestRR < Test::Unit::TestCase
         end
       end
     end
-    
-    
-    
+
+
+
     while (!answer.empty? and !rrs.empty?)
       data = rrs.shift;
       rr   = answer.shift;
       type = data[:type];
-      
-      assert(rr,                         "#{type} - RR defined");    
-      assert_equal(name,       	rr.name.to_s,    "#{type} - name() correct");         
+
+      assert(rr,                         "#{type} - RR defined");
+      assert_equal(name,       	rr.name.to_s,    "#{type} - name() correct");
       assert_equal(klass,      	rr.klass.to_s,   "#{type} - class() correct");
-      assert_equal(ttl,        	rr.ttl,     "#{type} - ttl() correct");                
-      
-      #	foreach my $meth (keys %{data}) {
+      assert_equal(ttl,        	rr.ttl,     "#{type} - ttl() correct");
+
+      # 	foreach my $meth (keys %{data}) {
       data.keys.each do |meth|
         ret = rr.send(meth)
         if (rr.kind_of?RR::CERT and (meth == :alg or meth == :certtype))
           assert_equal(data[meth].to_s, ret.code.to_s.downcase, "#{type} - #{meth}() correct")
-        elsif (rr.kind_of?RR::TXT and (meth == :strings)) 
+        elsif (rr.kind_of?RR::TXT and (meth == :strings))
           assert_equal(data[meth].to_s, ret[0].to_s.downcase, "TXT strings wrong")
         else
           if (meth == :type)
@@ -313,4 +310,13 @@ class TestRR < Test::Unit::TestCase
     assert rr.to_s.index('"Shuttle-ST61G4 Intel PIV3000"')
     assert rr.to_s.index('"FreeBSD 7.0-STABLE"')
   end
+
+  def test_private_method_really_private
+    begin
+      RR._get_subclass(nil, nil, nil, nil, nil)
+      raise "This should not have gotten here; the method should have been private"
+    rescue NoMethodError
+      # We should be here because the method should not have been found.
+    end
+  end
 end

data/test/tc_rrset.rb

@@ -1,27 +1,26 @@
-#--
-#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
-#
+# --
+# 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.
-#++
+# 
+# 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 'test/unit'
-require 'dnsruby'
+require_relative 'spec_helper'
 
-class RrsetTest < Test::Unit::TestCase
+class RrsetTest < Minitest::Test
   def test_rrset
     rrset = Dnsruby::RRSet.new
 
-      
+
     rr=Dnsruby::RR.create({	   :name => "example.com",
         :ttl  => 3600,
         :type         => 'MX',
@@ -34,18 +33,18 @@ class RrsetTest < Test::Unit::TestCase
     rrset.add(rr)
     rr.preference = 1
     rrset.add(rr)
-    
+
     canon = rrset.sort_canonical
-    
+
     assert(1 == canon[0].preference)
     assert(10 == canon[1].preference)
     assert(12 == canon[2].preference)
-    
+
     assert(rrset.sigs.length == 0)
     assert(rrset.num_sigs == 0)
     assert(rrset.rrs.length == 3)
 
-    # Check RRSIG records (only of the right type) can be added to the RRSet
+    #  Check RRSIG records (only of the right type) can be added to the RRSet
     sig = Dnsruby::RR.create({:name=>"example.com",         :ttl  => 3600,
         :type         => 'RRSIG',
         :type_covered  => 'A',

data/test/tc_rrsig.rb

@@ -1,24 +1,23 @@
-#--
-#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
-#
+# --
+# 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.
-#++
+# 
+# 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 'test/unit'
-require 'dnsruby'
+require_relative 'spec_helper'
 
-class RrsigTest < Test::Unit::TestCase
-  INPUT = "host.example.com. 86400 IN RRSIG A 5 3 86400 20030322173103 ( " + 
+class RrsigTest < Minitest::Test
+  INPUT = "host.example.com. 86400 IN RRSIG A 5 3 86400 20030322173103 ( " +
     "20030220173103 2642 example.com. " +
     "oJB1W6WNGv+ldvQ3WDG0MQkg5IEhjRip8WTr" +
     "PYGv07h108dUKGMeDPKijVCHX3DDKdfb+v6o" +
@@ -27,7 +26,7 @@ class RrsigTest < Test::Unit::TestCase
     "J5D6fwFm8nN+6pBzeDQfsS3Ap3o= )"
   def test_rrsig_from_string
     rrsig = Dnsruby::RR.create(INPUT)
-    
+
     assert_equal(Dnsruby::Types.A, rrsig.type_covered)
     assert_equal(Dnsruby::Algorithms::RSASHA1, rrsig.algorithm)
     assert_equal(3, rrsig.labels)
@@ -41,7 +40,7 @@ class RrsigTest < Test::Unit::TestCase
     "B9wfuh3DTJXUAfI/M0zmO/zz8bW0Rznl8O3t" +
     "GNazPwQKkRN20XPXV6nwwfoXmJQbsLNrLfkG" +
     "J5D6fwFm8nN+6pBzeDQfsS3Ap3o=", ([rrsig.signature].pack("m*")).gsub(/\n/,"").chomp)
-    
+
     rrsig2 = Dnsruby::RR.create(rrsig.to_s)
     assert(rrsig2.to_s == rrsig.to_s)
   end

data/test/tc_single_resolver.rb

@@ -1,298 +1,295 @@
-#--
-#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'
-include Dnsruby
-class TestSingleResolver < Test::Unit::TestCase
-  Thread::abort_on_exception = true
-  #  Dnsruby.log.level=Logger::DEBUG
-  
-  def setup
-    Dnsruby::Config.reset
-  end
-  
-  Rrs = [
-    {
-      :type   		=> Types.A,
-      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :address 	=> '10.0.1.128'
-    },
-    {
-      :type		=> Types::MX,
-      :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :preference 	=> 10
-    },
-    {
-      :type		=> 'CNAME',
-      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
-    },
-    {
-      :type		=> Types.TXT,
-      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :strings		=> ['Net-DNS']
-    }		
-  ]		
-  
-  def test_simple
-    res = SingleResolver.new()
-    m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-  end
-  
-  def test_timeout
-    #    if ((RUBY_PLATFORM=~/darwin/) == nil)
-    # Run a query which will not respond, and check that the timeout works
-    start_time = 0
-    begin
-   udps = UDPSocket.new
-  udps.bind("127.0.0.1", 0)
-  port = *udps.addr.values_at(3,1)
-
-    begin
-      Dnsruby::PacketSender.clear_caches
-      res = SingleResolver.new("127.0.0.1")
-      res.port = port
-      res.packet_timeout=1
-      start_time = Time.now.to_i
-      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-      fail "Got response when should have got none"
-    rescue ResolvTimeout
-      stop_time = Time.now.to_i
-      assert((stop_time - start_time) <= (res.packet_timeout * 2),
-      "UDP timeout too long : #{stop_time - start_time}" +
-      ", should be #{res.packet_timeout}")
-    end
-    begin
-      Dnsruby::PacketSender.clear_caches
-      res = SingleResolver.new("127.0.0.1")
-      res.port = port
-      res.use_tcp = true
-      res.packet_timeout=1
-      start_time = Time.now.to_i
-#      TheLog.level = Logger::DEBUG
-      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-      fail "TCP timeouts"
-    rescue ResolvTimeout
-      #        print "Got Timeout for TCP\n"
-      stop_time = Time.now.to_i
-      assert((stop_time - start_time) <= (res.packet_timeout * 2),
-        "TCP timeout too long : #{stop_time - start_time}, should be #{res.packet_timeout}")
-    rescue Exception => e
-      fail(e)
-    end
-      TheLog.level = Logger::ERROR
-    rescue
-      udps.close
-        end
-  end
-  
-  def test_queue_timeout
-    port = 46129
-#    if (!RUBY_PLATFORM=~/darwin/)
-    begin
-   udps = UDPSocket.new
-  udps.bind("127.0.0.1", 0)
-  port = *udps.addr.values_at(3,1)
-      res = SingleResolver.new("127.0.0.1")
-      res.port = port
-      res.packet_timeout=1
-      q = Queue.new
-      msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-      res.send_async(msg, q, msg)
-      id,ret, error = q.pop
-      assert(id==msg)
-      assert(ret==nil)
-      assert(error.class == ResolvTimeout)
-    rescue
-      udps.close
-    end
-#    end
-  end
-  
-  def test_queries
-    res = SingleResolver.new
-    
-    Rrs.each do |data|
-      packet=nil
-      2.times do 
-        begin
-          packet = res.query(data[:name], data[:type])
-        rescue ResolvTimeout
-        end
-        break if packet
-      end
-      assert(packet)
-      assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
-      
-      assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
-      assert_equal(1, packet.header.qdcount, 'Only one question')
-      assert_equal(1, packet.header.ancount, 'Got single answer')
-      
-      question = (packet.question)[0]
-      answer   = (packet.answer)[0]
-      
-      assert(question,                           'Got question'            )
-      assert_equal(data[:name],  question.qname.to_s,  'Question has right name' )
-      assert_equal(Types.new(data[:type]),  question.qtype,  'Question has right type' )
-      assert_equal('IN',             question.qclass.string, 'Question has right class')
-      
-      assert(answer)
-      assert_equal(answer.klass,    'IN',             'Class correct'           )
-      
-      
-      data.keys.each do |meth| 
-        if (meth == :type)
-          assert_equal(Types.new(data[meth]).to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
-        else       
-          assert_equal(data[meth].to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
-        end
-      end
-    end # do
-  end # test_queries
-  
-  # @TODO@ Although the test_thread_stopped test runs in isolation, it won't run as part
-  # of the whole test suite (ts_dnsruby.rb). Commented out until I can figure out how to 
-  # get Test::Unit to run this one sequentially...  
-  #  def test_thread_stopped
-  #    res=SingleResolver.new
-  #    # Send a query, and check select_thread running.
-  #    m = res.query("example.com")
-  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
-  #    # Wait a second, and check select_thread stopped.
-  #    sleep(2)
-  #    assert(!Dnsruby::SelectThread.instance.select_thread_alive?)
-  #    # Send another query, and check select_thread running.
-  #    m = res.query("example.com")
-  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
-  #  end
-  
-  def test_res_config
-    res = Dnsruby::SingleResolver.new
-    
-    res.server=('a.t.dnsruby.validation-test-servers.nominet.org.uk')
-    ip = res.server
-    assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up IP.')
-    
-    res.server=('cname.t.dnsruby.validation-test-servers.nominet.org.uk')
-    ip = res.server
-    assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up cname.')
-  end
-  
-  def test_truncated_response
-    res = SingleResolver.new
-    #    print "Dnssec = #{res.dnssec}\n"
-    res.server=('ns0.validation-test-servers.nominet.org.uk')
-    res.packet_timeout = 15
-    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
-    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
-    assert(!m.header.tc, "Message was truncated!")
-  end
-
-  def test_illegal_src_port
-    # Try to set src_port to an illegal value - make sure error raised, and port OK
-    res = SingleResolver.new
-    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
-  end
-  
-  def test_add_src_port
-    # Try setting and adding port ranges, and invalid ports, and 0.
-    res = SingleResolver.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])
-  end
-
-  def test_options_preserved_on_tcp_resend
-    # Send a very small EDNS message to trigger tcp resend.
-    # Can we do that without using send_raw and avoiding the case we want to test?
-    # Sure - just knock up a little server here, which simply returns the response with the
-    # TC bit set, and records both packets sent to it
-    # Need to listen once on UDP and once on TCP
-    udpPacket = nil
-    tcpPacket = nil
-    port = 59821
-    thread = Thread.new {
-      u = UDPSocket.new()
-      u.bind("127.0.0.1", port)
-
-      s = u.recvfrom(15000)
-      received_query = s[0]
-      udpPacket = Message.decode(received_query)
-      u.connect(s[1][2], s[1][1])
-      udpPacket.header.tc = true
-      u.send(udpPacket.encode(),0)
-      u.close
-
-      ts = TCPServer.new(port)
-      t = ts.accept
-      packet = t.recvfrom(2)[0]
-
-      len = (packet[0]<<8)+packet[1]
-      if (RUBY_VERSION >= "1.9")
-        len = (packet[0].getbyte(0)<<8)+packet[1].getbyte(0)# Ruby 1.9
-      end
-      packet = t.recvfrom(len)[0]
-      tcpPacket = Message.decode(packet)
-      tcpPacket.header.tc = true
-      lenmsg = [tcpPacket.encode.length].pack('n')
-      t.send(lenmsg, 0)
-      t.write(tcpPacket.encode)
-      t.close
-      ts.close
-    }
-    ret = nil
-    thread2 = Thread.new {
-      r = SingleResolver.new("127.0.0.1")
-      r.port = port
-      ret = r.query("example.com")
-    }
-    thread.join
-    thread2.join
-    assert(tcpPacket && udpPacket)
-    assert(tcpPacket.header == udpPacket.header)
-    assert(tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl == udpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl, "UDP : #{udpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}, TCP #{tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}")
-
-  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 express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+
+include Dnsruby
+class TestSingleResolver < Minitest::Test
+  Thread::abort_on_exception = true
+  #   Dnsruby.log.level=Logger::DEBUG
+
+  def setup
+    Dnsruby::Config.reset
+  end
+
+  Rrs = [
+    {
+      :type   		=> Types.A,
+      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :address 	=> '10.0.1.128'
+    },
+    {
+      :type		=> Types::MX,
+      :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :preference 	=> 10
+    },
+    {
+      :type		=> 'CNAME',
+      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+    },
+    {
+      :type		=> Types.TXT,
+      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :strings		=> ['Net-DNS']
+    }
+  ]
+
+  def test_simple
+    res = SingleResolver.new()
+    m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+  end
+
+  def test_timeout
+    #     if ((RUBY_PLATFORM=~/darwin/) == nil)
+    #  Run a query which will not respond, and check that the timeout works
+    start_time = 0
+    begin
+   udps = UDPSocket.new
+  udps.bind("127.0.0.1", 0)
+  port = *udps.addr.values_at(3,1)
+
+    begin
+      Dnsruby::PacketSender.clear_caches
+      res = SingleResolver.new("127.0.0.1")
+      res.port = port
+      res.packet_timeout=1
+      start_time = Time.now.to_i
+      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      fail "Got response when should have got none"
+    rescue ResolvTimeout
+      stop_time = Time.now.to_i
+      assert((stop_time - start_time) <= (res.packet_timeout * 2),
+      "UDP timeout too long : #{stop_time - start_time}" +
+      ", should be #{res.packet_timeout}")
+    end
+    begin
+      Dnsruby::PacketSender.clear_caches
+      res = SingleResolver.new("127.0.0.1")
+      res.port = port
+      res.use_tcp = true
+      res.packet_timeout=1
+      start_time = Time.now.to_i
+#      TheLog.level = Logger::DEBUG
+      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      fail "TCP timeouts"
+    rescue ResolvTimeout
+      #         print "Got Timeout for TCP\n"
+      stop_time = Time.now.to_i
+      assert((stop_time - start_time) <= (res.packet_timeout * 2),
+        "TCP timeout too long : #{stop_time - start_time}, should be #{res.packet_timeout}")
+    rescue Exception => e
+      fail(e)
+    end
+      TheLog.level = Logger::ERROR
+    rescue
+      udps.close
+        end
+  end
+
+  def test_queue_timeout
+    port = 46129
+#    if (!RUBY_PLATFORM=~/darwin/)
+    begin
+   udps = UDPSocket.new
+  udps.bind("127.0.0.1", 0)
+  port = *udps.addr.values_at(3,1)
+      res = SingleResolver.new("127.0.0.1")
+      res.port = port
+      res.packet_timeout=1
+      q = Queue.new
+      msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      res.send_async(msg, q, msg)
+      id,ret, error = q.pop
+      assert(id==msg)
+      assert(ret==nil)
+      assert(error.class == ResolvTimeout)
+    rescue
+      udps.close
+    end
+#    end
+  end
+
+  def test_queries
+    res = SingleResolver.new
+
+    Rrs.each do |data|
+      packet=nil
+      2.times do
+        begin
+          packet = res.query(data[:name], data[:type])
+        rescue ResolvTimeout
+        end
+        break if packet
+      end
+      assert(packet)
+      assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+
+      assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
+      assert_equal(1, packet.header.qdcount, 'Only one question')
+      assert_equal(1, packet.header.ancount, 'Got single answer')
+
+      question = (packet.question)[0]
+      answer   = (packet.answer)[0]
+
+      assert(question,                           'Got question'            )
+      assert_equal(data[:name],  question.qname.to_s,  'Question has right name' )
+      assert_equal(Types.new(data[:type]),  question.qtype,  'Question has right type' )
+      assert_equal('IN',             question.qclass.string, 'Question has right class')
+
+      assert(answer)
+      assert_equal(answer.klass,    'IN',             'Class correct'           )
+
+
+      data.keys.each do |meth|
+        if (meth == :type)
+          assert_equal(Types.new(data[meth]).to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})")
+        else
+          assert_equal(data[meth].to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})")
+        end
+      end
+    end # do
+  end # test_queries
+
+  #  @TODO@ Although the test_thread_stopped test runs in isolation, it won't run as part
+  #  of the whole test suite (ts_dnsruby.rb). Commented out until I can figure out how to
+  #  get Test::Unit to run this one sequentially...
+  #   def test_thread_stopped
+  #     res=SingleResolver.new
+  #     # Send a query, and check select_thread running.
+  #     m = res.query("example.com")
+  #     assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #     # Wait a second, and check select_thread stopped.
+  #     sleep(2)
+  #     assert(!Dnsruby::SelectThread.instance.select_thread_alive?)
+  #     # Send another query, and check select_thread running.
+  #     m = res.query("example.com")
+  #     assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #   end
+
+  def test_res_config
+    res = Dnsruby::SingleResolver.new
+
+    res.server=('a.t.dnsruby.validation-test-servers.nominet.org.uk')
+    ip = res.server
+    assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up IP.')
+
+    res.server=('cname.t.dnsruby.validation-test-servers.nominet.org.uk')
+    ip = res.server
+    assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up cname.')
+  end
+
+  def test_truncated_response
+    res = SingleResolver.new
+    #     print "Dnssec = #{res.dnssec}\n"
+    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    res.packet_timeout = 15
+    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
+    assert(!m.header.tc, "Message was truncated!")
+  end
+
+  def test_illegal_src_port
+    #  Try to set src_port to an illegal value - make sure error raised, and port OK
+    res = SingleResolver.new
+    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
+  end
+
+  def test_add_src_port
+    #  Try setting and adding port ranges, and invalid ports, and 0.
+    res = SingleResolver.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])
+  end
+
+  def test_options_preserved_on_tcp_resend
+    #  Send a very small EDNS message to trigger tcp resend.
+    #  Can we do that without using send_raw and avoiding the case we want to test?
+    #  Sure - just knock up a little server here, which simply returns the response with the
+    #  TC bit set, and records both packets sent to it
+    #  Need to listen once on UDP and once on TCP
+    udpPacket = nil
+    tcpPacket = nil
+    port = 59821
+    thread = Thread.new {
+      u = UDPSocket.new()
+      u.bind("127.0.0.1", port)
+
+      s = u.recvfrom(15000)
+      received_query = s[0]
+      udpPacket = Message.decode(received_query)
+      u.connect(s[1][2], s[1][1])
+      udpPacket.header.tc = true
+      u.send(udpPacket.encode(),0)
+      u.close
+
+      ts = TCPServer.new(port)
+      t = ts.accept
+      packet = t.recvfrom(2)[0]
+
+      len = (packet[0]<<8)+packet[1]
+      if (RUBY_VERSION >= "1.9")
+        len = (packet[0].getbyte(0)<<8)+packet[1].getbyte(0)# Ruby 1.9
+      end
+      packet = t.recvfrom(len)[0]
+      tcpPacket = Message.decode(packet)
+      tcpPacket.header.tc = true
+      lenmsg = [tcpPacket.encode.length].pack('n')
+      t.send(lenmsg, 0)
+      t.write(tcpPacket.encode)
+      t.close
+      ts.close
+    }
+    ret = nil
+    thread2 = Thread.new {
+      r = SingleResolver.new("127.0.0.1")
+      r.port = port
+      ret = r.query("example.com")
+    }
+    thread.join
+    thread2.join
+    assert(tcpPacket && udpPacket)
+    assert(tcpPacket.header == udpPacket.header)
+    assert(tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl == udpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl, "UDP : #{udpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}, TCP #{tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}")
+
+  end
 end