Dnsruby 0.5.0

data/test/tc_res_file.rb

@@ -0,0 +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.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+class TestAResolverFile < Test::Unit::TestCase
+  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

@@ -0,0 +1,185 @@
+#--
+#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 'dnsruby'
+include Dnsruby
+class TestResOpt < Test::Unit::TestCase
+  def test_dns_file
+    
+    # .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
+    res=nil
+    begin
+      res = DNS.new('nosuch.txt')
+      assert_equal(["0.0.0.0"], res.nameserver,"No nameservers should be set for #{test} = #{input}")
+    rescue Exception
+    end
+    begin
+      res = Resolver.new('nosuch.txt')
+      assert_equal(["0.0.0.0"], res.nameserver,"No nameservers should be set for #{test} = #{input}")
+    rescue Exception
+    end
+  end
+  
+  def test_config_hash_singleresolver
+    # Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
+    # SR : server, local_address, persistent_tcp, persistent_udp, udp_size
+    test_config = {
+      :server	   => '10.0.0.1',
+      :port		   => 54, # SingleResolver and Multi-Resolver
+      :src_address        => '10.1.0.1', # SingleResolver and Multi-Resolver
+      :src_port        => 53, # SingleResolver and Multi-Resolver
+      :use_tcp		   => true, # SingleResolver and Multi-Resolver
+      :ignore_truncation          => true, # SingleResolver and Multi-Resolver
+      :recurse        => false,
+      :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
+      :persistent_tcp => true, # SingleResolver and Multi-Resolver
+      :persistent_udp => true, # SingleResolver and Multi-Resolver
+      #@todo Add dnssec when dnssec added to Net::DNS
+      #	'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
+  
+  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
+    test_config = {
+      :nameserver	   => ['10.0.0.1', '10.0.0.2'], # for Multi-Resolver & DNS
+      :port		   => 54, # SingleResolver and Multi-Resolver
+      :src_address        => '10.1.0.1', # SingleResolver and Multi-Resolver
+      :src_port        => 53, # SingleResolver and Multi-Resolver
+      :retry_delay	       => 6, # DNS and Multi-Resolver
+      :retry_times		   => 5, # DNSand Multi-Resolver
+      :use_tcp		   => true, # SingleResolver and Multi-Resolver
+      :ignore_truncation          => true, # SingleResolver and Multi-Resolver
+      :recurse        => false, 
+      :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
+      :query_timeout    => 60, # Multi-Resolver only
+      :persistent_tcp => true, # SingleResolver and Multi-Resolver
+      :persistent_udp => true, # SingleResolver and Multi-Resolver
+      #@todo Add dnssec when dnssec added to Net::DNS
+      #	'dnssec'         => true,
+    }
+    
+    res = Resolver.new(test_config)
+    test_config.keys.each do |item|
+      if (item==:nameserver)
+        assert_equal(res.config.nameserver, test_config[item], "#{item} is correct")
+      else
+        assert_equal(res.send(item), test_config[item], "#{item} is correct")
+      end
+    end	
+  end
+  
+  def test_config_hash_lookup
+    # 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 
+    }
+    
+    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
+  
+  
+  def test_bad_config
+    res=nil
+    
+    bad_input = {
+      :tsig_rr        => 'set',
+      :errorstring    => 'set',
+      :answerfrom     => 'set',
+      :answersize     => 'set',
+      :querytime      => 'set',
+      :axfr_sel       => 'set',
+      :axfr_rr        => 'set',
+      :axfr_soa_count => 'set',
+      :udppacketsize  => 'set',
+      :cdflag         => 'set',
+    }
+    res=nil
+    begin    
+      res = Resolver.new(bad_input)
+    rescue Exception 
+    end
+    if (res)    
+      bad_input.keys.each do |key|
+        begin
+          assert_not_equal(res.send(key), 'set', "#{key} is not set")
+        rescue Exception
+        end
+      end
+    end
+    
+    res=nil
+    begin    
+      res = DNS.new(bad_input)
+    rescue Exception 
+    end
+    if (res)        
+      bad_input.keys.each do |key|
+        begin
+          assert_not_equal(res.send(key), 'set', "#{key} is not set")
+        rescue Exception
+        end
+      end
+    end
+  end
+end

data/test/tc_resolver.rb

@@ -0,0 +1,177 @@
+#--
+#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 '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
+  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_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!!  
+#  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)
+    print err.class
+    assert(err.kind_of?(OtherResolvError))
+  end
+  
+  def test_nxdomain
+    res=Resolver.new
+    q = Queue.new
+    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), 1, q)
+    id, m, err = q.pop
+    assert(id==1)
+    assert(m.header.rcode == RCode.NXDOMAIN)
+    assert(err.kind_of?(NXDomain))
+  end
+  
+  def test_timeouts
+    #@TODO@ 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({: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.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+    end
+  end
+  
+  def test_packet_timeout
+    res = Resolver.new({:nameserver => "10.0.1.128"})
+    start=stop=0
+    retry_times = retry_delay = packet_timeout= 10
+    query_timeout=1
+    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_packet_timeout
+    res = Resolver.new({:nameserver => "10.0.1.128"})
+    bad = SingleResolver.new("localhost")
+    res.add_resolver(bad)
+    expected = 1
+    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.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+  end
+    
+end

data/test/tc_rr-opt.rb

@@ -0,0 +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.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestRrOpt < Test::Unit::TestCase
+  def test_RrOpt
+    size=2048;
+    ednsflags=0x9e22;
+    
+    optrr = RR::OPT.new(
+    			  :name         => '',
+			  :class => size,  # Decimal UDPpayload
+			  :flags    => ednsflags # first bit set see RFC 3225
+    )
+    assert(optrr.d_o,"DO bit set")
+    optrr.d_o=false
+    assert_equal(optrr.flags,0x1e22,"Clearing do, leaving the other bits ");
+    assert(!optrr.d_o,"DO bit cleared")
+    optrr.d_o=true
+    assert_equal(optrr.flags,0x9e22,"Clearing do, leaving the other bits ");
+    
+    
+    assert_equal(optrr.payloadsize,2048,"Size read")
+    assert_equal(optrr.payloadsize=(1498),1498,"Size set")
+    
+  end
+end

data/test/tc_rr-txt.rb

@@ -0,0 +1,137 @@
+#--
+#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 'dnsruby'
+include Dnsruby
+class TestRrTest < Test::Unit::TestCase
+  #Stimulus, expected response, and test name:
+  
+  TESTLIST =	[
+  {	# 2-5
+    :stim		=>	%<"">,
+    :rdatastr	=>	%<"">,
+    :char_str_list_r	=>	['',],
+    :descr		=>	'Double-quoted null string',
+  },
+  {	# 6-9
+    :stim		=>	%<''>,
+    :rdatastr	=>	%<"">,
+    :char_str_list_r	=>	['',],
+    :descr		=>	'Single-quoted null string',
+  },
+  {	# 10-13
+    :stim		=>	%<" \t">,
+    :rdatastr	=>	%<" \t">,
+    :char_str_list_r	=>	[ %< \t>, ],
+    :descr		=>	'Double-quoted whitespace string',
+  },
+  {	# 14-17
+    :stim		=>	%<noquotes>,
+    :rdatastr	=>	%<"noquotes">,
+    :char_str_list_r	=>	[ %<noquotes>, ],
+    :descr		=>	'unquoted single string',
+  },
+  {	# 18-21
+    :stim		=>	%<"yes_quotes">,
+    :rdatastr	=>	%<"yes_quotes">,
+    :char_str_list_r	=>	[ %<yes_quotes>, ],
+    :descr		=>	'Double-quoted single string',
+  },
+  {	# 26-29
+    :stim		=>	%<two tokens>,
+    :rdatastr	=>	%<"two" "tokens">,
+    :char_str_list_r	=>	[ %q|two|, %q|tokens|, ],
+    :descr		=>	'Two unquoted strings',
+  },
+  # @TODO@ Why don't escaped quotes work?
+  #    {	# 22-25
+  #			:stim		=>	%<"escaped \" quote">,
+  #			:rdatastr	=>	%<"escaped \" quote">,
+  #			:char_str_list_r	=>	[ %<escaped " quote>, ],
+  #			:descr		=>	'Quoted, escaped double-quote',
+  #    },
+  #    { # 30-33
+  #			:stim		=> %<"missing quote>,
+  #			:rdatastr    => %<>,
+  #			:char_str_list_r	=>	[],
+  #			:descr    	=> 'Unbalanced quotes work',
+  #    }
+  ]
+  
+  def test_RrTest
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    name			= 'foo.example.com';
+    klass			= 'IN';
+    type			= 'TXT';
+    ttl				= 43201;
+    
+    rr_base	= [name, ttl, klass, type, "    " ].join(' ')
+    
+    
+    #------------------------------------------------------------------------------
+    # Run the tests
+    #------------------------------------------------------------------------------
+    
+    TESTLIST.each do |test_hr|
+      assert( uut = RR.create(rr_base + test_hr[:stim]), 	
+      test_hr[:descr] + " -- Stimulus " ) 
+            
+      assert_equal(test_hr[:rdatastr], uut.rdata_to_string(), 			
+      test_hr[:descr] + " -- Response ( rdatastr ) " ) 
+      
+      list = uut.strings	
+      
+      assert_equal(test_hr[:char_str_list_r], list,
+                   test_hr[:descr] +  " -- char_str_list equality"  ) 		
+    end
+    
+    string1 = %<no>
+    string2 = %<quotes>
+    
+    rdata = [string1.length].pack("C") + string1
+    rdata += [string2.length].pack("C") + string2
+    
+    work_hash = {
+      :name		=> name,
+      :ttl		=> ttl,
+      :class		=> klass,
+      :type		=> type,
+    }
+    
+    
+    # Don't break RR.new_from_hash (e.i. "See the manual pages for each RR 
+    # type to see what fields the type requires.").
+    
+    work_hash[:strings] = %<no quotes>
+    
+    uut = RR.create(work_hash)    
+    assert( uut , 		# 30
+    "RR.new_from_hash with txtdata -- Stimulus")
+    assert_equal( uut.rdata_to_string() , %<"no" "quotes">, 		# 31
+    "RR.new_from_hash with txtdata -- Response (rdatastr())")
+    
+    rr_rdata = MessageEncoder.new {|msg|
+      uut.encode_rdata(msg)
+    }.to_s
+    assert( rr_rdata == rdata , "TXT.rr_rdata" )	# 32
+    
+    
+  end
+end

data/test/tc_rr-unknown.rb

@@ -0,0 +1,99 @@
+#--
+#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 'dnsruby'
+class TestRrUnknown < Test::Unit::TestCase
+  def test_RrUnknown
+    assert_equal(10226, Types::typesbyname('TYPE10226'), 'typesbyname(TYPE10226) returns 10226')
+    assert_equal('TYPE10226', Types::typesbyval(10226),        'typesbyval(10226) returns TYPE10226')
+    assert_equal(Types::typesbyval(1), "A",           '       typesbyval(1) returns A')
+    
+    assert_equal(Types::typesbyval(Types.typesbyname('TYPE001')), 'A', 'typesbyval(typebyname(TYPE001)) returns A')
+    
+    
+    begin
+      Types.typesbyval(0xffff+1)
+      flunk("Should fail on large TYPE code")
+    rescue Exception
+    end
+    
+    assert_equal(Classes::classesbyname('CLASS124'), 124,       'classesbyname(CLASS124) returns 124')
+    assert_equal(Classes::classesbyval(125),         'CLASS125','classesbyval(125) returns CLASS125')
+    assert_equal(Classes::classesbyval(1),           'IN',      'classesbyval(1) returns IN')
+    
+    assert_equal('HS', Classes::classesbyval(Classes::classesbyname('CLASS04')), 'classesbyval(typebyname(CLASS04)) returns HS')
+    
+    begin
+      Classes::classesbyval(0xffff+1)
+      flunk("Should fail on large CLASS code")
+    rescue Exception
+    end
+  end
+  
+  def test_rr_new
+    rr = RR.new_from_string('e.example CLASS01 TYPE01 10.0.0.2')
+    assert_equal(RR::IN::A, rr.class,  'TYPE01 parsed OK')
+    assert_equal('A', rr.type.string,  'TYPE01 parsed OK')
+    assert_equal('IN', rr.klass.string,'CLASS01 parsed OK')
+    assert_equal(1, rr.klass.code,'CLASS01 parsed OK')
+    
+    rr = RR.new_from_string('e.example IN A \# 4  0A0000 01  ')
+    assert_equal('10.0.0.1', rr.address.to_s,'Unknown RR representation for A parsed OK')
+    
+    begin
+      res=RR.new_from_string('e.example IN A \# 4  0A0000 01 11 ')
+      flunk "Should fail on inconsistent length and hex presentation"
+    rescue Exception
+      #like($@, '/\\\# 4  0A0000 01 11 assert_equal inconsistent\ length does not match content/', 'Fails on inconsassert_equaltent length and hex presentation')
+    end
+    
+    
+    rr = RR.new_from_string('e.example IN TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	IN	TYPE4555	\# 4 0a000001', rr.to_s, 'Fully unknown RR parsed correctly')
+    
+    rr4 = RR.new_from_string('e.example CLASS122 TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	CLASS122	TYPE4555	\# 4 0a000001', rr4.to_s, 'Fully unknown RR in unknown CLASS parsed correctly')
+  end
+  
+  def test_real_data
+    uuencodedPacket=%w{
+02 79 85 00 00 01 
+00 01 00 01 00 01 04 54  45 53 54 07 65 78 61 6d 
+70 6c 65 03 63 6f 6d 00  00 ff 00 01 c0 0c 30 39 
+00 01 00 00 00 7b 00 0a  11 22 33 44 55 aa bb cc 
+dd ee c0 11 00 02 00 01  00 00 03 84 00 05 02 6e 
+73 c0 11 c0 44 00 01 00  01 00 00 03 84 00 04 7f 
+00 00 01}
+    
+    #    packetdata = uuencodedPacket.pack('H*')
+    #    packetdata = packetdata.gsub("\s*", "")
+    
+    uuencodedPacket.map!{|e| e.hex}
+    packetdata = uuencodedPacket.pack('c*')
+#    packet     = Net::Packet.new_from_binary(packetdata)
+    packet = Message.decode(packetdata)
+    
+    string_representation = (packet.answer)[0].to_s
+    #string_representation =~ s/\s+/ /g,
+    string_representation = string_representation.gsub(/\s+/, " ")
+    assert_equal(
+	'TEST.example.com. 123 IN TYPE12345 \# 10 1122334455aabbccddee',
+    string_representation,
+	'Packet read from a packet dumped by bind...'
+    )
+  end
+end