Dnsruby 0.5.0 → 0.6.0

data/test/tc_em_deferrable.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'Dnsruby'
+#begin
+#  require 'test/tc_single_resolver'
+#rescue Exception
+#  require 'tc_single_resolver'
+#end
+
+class EmDeferrableTest < Test::Unit::TestCase
+    Dnsruby::Resolver.use_eventmachine(true)
+  def setup
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+  end
+  
+  def test_deferrable_success
+    Dnsruby::TheLog.level=Logger::DEBUG
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine
+    q = Queue.new
+    id = 1
+    done = false
+        EM.run {
+    df = res.send_async(Dnsruby::Message.new("nominet.org.uk"), id, q) #@TODO@ Shouldn't need ID and queue
+    df.callback {|id, msg| puts "callback: #{id}, #{msg}"; done = true; EM.stop}
+    df.errback {|id, msg, err| puts "errback: #{id}, #{msg}, #{err}"; done = true; EM.stop}
+        }
+#    while (!done)
+#      sleep 0.1
+#    end
+#    #    id+=1
+#    #    df2 = res.send_async(Dnsruby::Message.new("example.com"), id, q)
+#    #    df2.callback {|obj| puts "callback" + obj}
+#    #    df2.errback {|obj| puts "errback" + obj}
+  end
+  
+  def test_deferrable_timeout
+    flunk("IMPLEMENT!")    
+  end
+end

data/test/tc_event_machine_deferrable.rb

@@ -0,0 +1,85 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'Dnsruby'
+
+class EventMachineTestDeferrable < Test::Unit::TestCase
+  Dnsruby::Resolver.use_eventmachine(true)
+  def setup
+#    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_success
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop}
+      df.errback {|msg, err| 
+        EM.stop 
+        assert(false)}
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine
+    res.packet_timeout=2
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop; assert(false)}
+      df.errback {|msg, err| 
+        EM.stop 
+        }
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+
+  def test_deferrable_success
+    sleep(0.1) # Give the Event loop a chance to close down from previous test
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    res = Dnsruby::Resolver.new
+    q = Queue.new
+    id = 1
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| done = true; EM.stop}
+      df.errback {|msg, err| 
+        puts "errback: #{msg}, #{err}"
+        done = true
+        EM.stop 
+        assert(false)}
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_timeout
+    sleep(0.1) # Give the Event loop a chance to close down from previous test
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    Dnsruby::Resolver.use_eventmachine
+    res = Dnsruby::Resolver.new("10.0.1.128")
+    res.query_timeout=2
+    q = Queue.new
+    id = 1
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop; assert(false)}
+      df.errback {|msg, err| 
+        EM.stop 
+      }
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+end

data/test/tc_event_machine_res.rb

@@ -0,0 +1,174 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'Dnsruby'
+
+class EventMachineTestResolver < Test::Unit::TestCase
+  include Dnsruby
+  Dnsruby::Resolver.use_eventmachine(true)
+  Thread::abort_on_exception = true
+  def setup
+    Dnsruby::Config.reset
+    #    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  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_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
+  
+  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_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.header.rcode == RCode.NXDOMAIN)
+    assert(err.kind_of?(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
+    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("10.0.1.128")
+      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.1 && time >= expected *0.9, "Wrong time taken, expected #{expected}, took #{time}")        
+    end
+  end
+  
+  def test_query_timeout
+    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.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+    end    
+  end
+  
+  def test_queue_query_timeout
+    res = Resolver.new({:nameserver => "10.0.1.128"})
+    bad = SingleResolver.new("localhost")
+    res.add_resolver(bad)
+    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.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+  end
+  
+  
+  
+  def test_tcp
+    res = Dnsruby::Resolver.new
+    res.use_tcp = true
+    Dnsruby::Resolver.use_eventmachine
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      itemid = q.pop[0]
+      assert(itemid <= id)
+      assert(itemid >= 0)
+    end
+  end
+  
+  def test_truncated_response
+    res = Dnsruby::Resolver.new('ns0.validation-test-servers.nominet.org.uk')
+    res.packet_timeout = 10
+    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
+  
+end

data/test/tc_event_machine_single_res.rb

@@ -0,0 +1,101 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'Dnsruby'
+
+class EventMachineTestSingleResolver < Test::Unit::TestCase
+  Dnsruby::Resolver.use_eventmachine(true)
+  def setup
+#    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def test_udp
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      item = q.pop
+      assert(item[1].class==Dnsruby::Message)
+      assert(item[0] <= id)
+      assert(item[0] >= 0)
+    end
+    Dnsruby::TheLog.level=Logger::ERROR
+  end
+  
+  def test_tcp
+    res = Dnsruby::SingleResolver.new
+    res.use_tcp = true
+    Dnsruby::Resolver.use_eventmachine
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      itemid, response, error = q.pop
+      assert(itemid <= id)
+      assert(itemid >= 0)
+      assert(error==nil)
+    end
+    #@TODO@ How do we check that TCP was actually used? Do we need a test server for this?
+    #Or will the truncated test catch this? (Query retried over TCP to fetch all records)
+  end
+  
+  def test_tcp_queue_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine(true)
+    res.packet_timeout=2
+    res.use_tcp=true
+    q = Queue.new
+    msg = Dnsruby::Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+    res.send_async(msg, q, 1)
+    start=Time.now
+    id,ret,error = q.pop
+    end_time = Time.now
+    assert(id==1)
+    assert(ret==nil)
+    assert(error.class == Dnsruby::ResolvTimeout)
+    p "Difference = #{end_time-start}"
+    assert(end_time - start >= 1.9)
+    assert(end_time - start <= 2.2)
+  end
+  
+  def test_udp_queue_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine(true)
+    res.packet_timeout=2
+    q = Queue.new
+    start=Time.now
+    msg = Dnsruby::Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+    res.send_async(msg, q, 1)
+    id,ret,error = q.pop
+    end_time = Time.now
+    assert(id==1)
+    assert(ret==nil)
+    p "Difference = #{end_time-start}"
+    assert(error.class == Dnsruby::ResolvTimeout)
+    assert(end_time - start >= 1.9)
+    assert(end_time - start <= 2.2)
+  end
+  
+  def test_truncated_response
+   res = Dnsruby::SingleResolver.new
+    res.packet_timeout = 10
+    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    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
+end

data/test/tc_event_machine_soak.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'Dnsruby'
+begin
+  require 'test/tc_soak_base'
+rescue Exception
+  require 'tc_soak_base'
+end
+
+class TestEventMachineSoak < Test::Unit::TestCase
+  def setup
+    #    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+  end
+  def test_single_res
+    #    TestSoakBase.test_continuous_queries_asynch_single_res
+  end
+  def test_single_deferrable
+    sleep(0.1)
+    @@dfs = {}
+    @@num_sent = 0
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    q = Queue.new
+    id = 1
+    done = false
+    EM.run {
+      100.times do |i|
+        send_next_deferrable(res)
+      end
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_sequential
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+    res = Dnsruby::SingleResolver.new
+    res.packet_timeout = 2
+    q = Queue.new
+    240.times do |i|
+      puts i
+      res.send_async(Dnsruby::Message.new("example#{i}.com"), q, i)      
+    end
+    240.times do |i|
+      puts "Receiving #{i}"
+      id, msg, error = q.pop
+      if (error != nil)
+        puts ("Error : #{error}")
+      end
+    end
+  end
+  
+  def test_resolver_deferrable
+    sleep(0.1)
+    @@dfs = {}
+    @@num_sent = 0
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    res = Dnsruby::Resolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    q = Queue.new
+    id = 1
+    done = false
+    EM.run {
+      50.times do |i|
+        send_next_deferrable(res)
+      end
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)    
+  end
+
+  def send_next_deferrable(res)
+    if (@@num_sent>2000) 
+      EM.stop
+      return
+    end
+    id = @@num_sent
+    @@num_sent+=1
+    @@dfs[id] = res.send_async(Dnsruby::Message.new("example.com"))
+    @@dfs[id].callback {|msg| puts "callback: #{id}"
+      @@dfs.delete(id)
+      send_next_deferrable(res)
+    }
+    @@dfs[id].errback {|msg, err| 
+      @@dfs.delete(id)
+      puts "errback: #{id}, #{err}"
+      send_next_deferrable(res)
+    }
+  end  
+end

data/test/tc_inet6.rb

@@ -0,0 +1,170 @@
+#--
+#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 'rubygems'
+require 'test/unit'
+require 'Net/DNS'
+require 'socket'
+class TestInet6 < Test::Unit::TestCase
+  def ip6ok?
+    if (@checkedip6)
+      if !@ip6ok
+        return false
+      end
+    end
+    @checkedip6 = true
+    @ip6ok = true
+    # First use the local resolver to query for the AAAA record of a 
+    # well known nameserver, than use v6 transport to get to that record.
+    puts ""
+    puts ""
+    puts "\tTesting for global IPv6 connectivity...\n"
+    puts "\t\t preparing..."
+    
+    tstsock = UDPSocket.new() 
+    begin
+      tstsock.bind("::1", 8765)
+    rescue Exception
+      #      raise RuntimeError, "\n\n\t\tFailed to bind to ::1\n\t\t#{$!}\n\n\t\tWe assume there is no IPv6 connectivity and skip the tests\n\n"
+      puts "\n\n\t\tFailed to bind to ::1\n\t\t#{$!}\n\n\t\tWe assume there is no IPv6 connectivity and skip the tests\n\n"
+      @ip6ok=false
+      return false
+    ensure
+      tstsock.close
+    end
+    return true
+  end
+  
+  def test_inet6
+    if (!ip6ok?)
+      return
+    end
+    res=Net::DNS::Resolver.new
+    #	res.debug(1)
+    nsanswer=res.send("ripe.net",'NS','IN')
+    assert_instance_of(Net::DNS::RR::NS, (nsanswer.answer)[0], "Preparing  for v6 transport, got NS records for ripe.net")
+    
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns| 
+      next if ns.nsdname !~ /ripe\.net/ # User ripe.net only
+      a_answer=res.send(ns.nsdname, 'A','IN')
+      next if (a_answer.header.ancount == 0)
+      assert_instance_of(Net::DNS::RR::A, (a_answer.answer)[0], "Preparing  for v4 transport, got A records for " + ns.nsdname)
+      a_address=(a_answer.answer)[0].address
+      
+      
+      puts("\n\t\t Will try to connect to  " + ns.nsdname + " (#{a_address})")
+      break
+    end
+    
+    
+    aaaa_address=""
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns| 
+      next if ns.nsdname !~ /ripe\.net/ # User ripe.net only
+      aaaa_answer=res.send(ns.nsdname,'AAAA','IN')
+      next if (aaaa_answer.header.ancount == 0)
+      assert_equal((aaaa_answer.answer)[0].type,"AAAA", "Preparing  for v6 transport, got AAAA records for " + ns.nsdname)
+      aaaa_address=(aaaa_answer.answer)[0].address
+      
+      
+      puts("\n\t\t Will try to connect to  #{ns.nsdname} (#{aaaa_address})")
+      break
+    end
+    
+    res.nameservers=(aaaa_address)
+    # res.print
+    answer=res.send("ripe.net",'SOA','IN')
+    if(res.errorstring =~ /Send error: /)
+      puts "\n\t\t Connection failed: " + res.errorstring 
+      puts "\n\t\t It seems you do not have global IPv6 connectivity' \n" 
+      puts "\t\t This is not an error in Net::DNS \n"
+      
+      puts "\t\t You can confirm this by trying 'ping6 " + aaaa_address + "' \n\n"
+    end
+    
+    
+    
+    # answer.print
+    assert_equal((answer.answer)[0].type, "SOA","Query over udp6 succeeded")
+    
+    res.usevc(1)
+    res.force_v4(1)
+    # res.print
+    # res.debug(1)
+    answer=res.send("ripe.net",'SOA','IN')
+    assert_equal(res.errorstring,"no nameservers","Correct errorstring when forcing v4")
+    
+    
+    res.force_v4(0)
+    answer=res.send("ripe.net",'NS','IN')
+    if (answer)
+      assert_equal((answer.answer)[0].type, "NS","Query over tcp6  succeeded")
+    else
+      puts "You can safely ignore the following message:"
+      puts(res.errorstring) if (res.errorstring != "connection failed(IPv6 socket failure)")
+      puts("configuring " + aaaa_address + " " +  a_address + " as nameservers")
+      res.nameservers(aaaa_address,a_address)
+      answer = nil
+      #	res.print
+      answer=res.send("ripe.net",'NS','IN')
+      assert_equal((answer.answer)[0].type, "NS","Fallback to V4 succeeded")
+      
+      
+    end
+    
+  end 
+  
+  
+  
+  
+  def test_axfr
+    if (!ip6ok?)
+      return
+    end
+    #  
+    # Now test AXFR functionality.
+    #
+    #
+    # First use the local resolver to query for the AAAA record of a 
+    
+    aaaa_address=""
+    res2=Net::DNS::Resolver.new
+    # res2.debug(1)
+    nsanswer=res2.send("net-dns.org",'NS','IN')
+    assert_equal((nsanswer.answer)[0].type, "NS","Preparing  for v6 transport, got NS records for net-dns.org")
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns|
+      #	    next if ns.nsdname !~ /ripe\.net/ # User rupe.net only
+      aaaa_answer=res2.send(ns.nsdname,'AAAA','IN')
+      next if (aaaa_answer.header.ancount == 0)
+      assert_equal((aaaa_answer.answer)[0].type,"AAAA", "Preparing  for v6 transport, got AAAA records for " + ns.nsdname)
+      aaaa_address=(aaaa_answer.answer)[0].address
+      
+      puts("\n\t\t Trying to connect to  " + ns.nsdname + " (#{aaaa_address})")
+      break
+    end
+    
+    res2.nameservers=(aaaa_address)
+    # res2.print
+    
+    socket=res2.axfr_start('example.com')
+            
+    assert_instance_of(Socket, socket,"axfr_start returns IPv6 Socket")
+     (rr,err)=res2.axfr_next
+    assert_equal(res2.errorstring,'Response code from server: NOTAUTH',"Transfer is not authorized (but our connection worked)")
+    
+  end
+end