dnsruby 1.55 → 1.56.0

data/test/tc_update.rb

@@ -1,37 +1,34 @@
-#--
-#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 TestUpdate < Test::Unit::TestCase
+class TestUpdate < Minitest::Test
   def is_empty(string)
     return true if string == nil || string.length == 0
-    
+
     return (string == "; no data" || string == "; rdlength = 0");
   end
-  
+
   def test_update
-    #------------------------------------------------------------------------------
-    # Canned data.
-    #------------------------------------------------------------------------------
-    
+    # ------------------------------------------------------------------------------
+    #  Canned data.
+    # ------------------------------------------------------------------------------
+
     zone	= "example.com";
     name	= "foo.example.com";
     klass	= Classes.CLASS32;
@@ -40,155 +37,155 @@ class TestUpdate < Test::Unit::TestCase
     ttl	    = 43200;
     rdata	= "10.1.2.3";
     rr      = nil;
-    
-    #------------------------------------------------------------------------------
-    # Packet creation.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Packet creation.
+    # ------------------------------------------------------------------------------
+
     update = Dnsruby::Update.new(zone, klass);
     z = (update.zone)[0];
-    
+
     assert(update,                                'new() returned packet');  #2
-    assert_equal(update.header.opcode, OpCode.UPDATE,      'header opcode correct');  #3 
+    assert_equal(update.header.opcode, OpCode.UPDATE,      'header opcode correct');  #3
     assert_equal(z.zname.to_s,  zone,                      'zname correct');          #4
     assert_equal(z.zclass.to_s, klass.to_s,                     'zclass correct');         #5
-    assert_equal(z.ztype,  Types.SOA,                      'ztype correct');          #6       
-    
-    #------------------------------------------------------------------------------
-    # RRset exists (value-independent).
-    #------------------------------------------------------------------------------
-    
+    assert_equal(z.ztype,  Types.SOA,                      'ztype correct');          #6
+
+    # ------------------------------------------------------------------------------
+    #  RRset exists (value-independent).
+    # ------------------------------------------------------------------------------
+
     rr = update.present(name, type);
-    
+
     assert(rr,                                    'yxrrset() returned RR');  #7
     assert_equal(name,                      rr.name.to_s,  'yxrrset - right name');   #8
     assert_equal(0,                          rr.ttl,   'yxrrset - right TTL');    #9
     assert_equal('ANY',                      rr.klass.string, 'yxrrset - right class');  #10
     assert_equal(type,                      rr.type,  'yxrrset - right type');   #11
     assert(is_empty(rr.rdata),                "yxrrset - data empty (#{rr.rdata})");   #12
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # RRset exists (value-dependent).
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  RRset exists (value-dependent).
+    # ------------------------------------------------------------------------------
+
     rr = update.present(name, type, rdata, klass);
-    
+
     assert(rr,                                    'yxrrset() returned RR');  #13
     assert_equal(name,                   rr.name.to_s,     'yxrrset - right name');   #14
     assert_equal(0,                       rr.ttl,      'yxrrset - right TTL');    #15
     assert_equal(klass,                  rr.klass.string,    'yxrrset - right class');  #16
     assert_equal(type,                   rr.type,     'yxrrset - right type');   #17
     assert_equal(rdata,                  rr.rdata, 'yxrrset - right data');   #18
-    
+
     rr=nil
-    
-    #------------------------------------------------------------------------------
-    # RRset does not exist.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  RRset does not exist.
+    # ------------------------------------------------------------------------------
+
     rr = update.absent(name, type);
-    
+
     assert(rr,                                    'nxrrset() returned RR');  #19
     assert_equal(name,                      rr.name.to_s,  'nxrrset - right name');   #20
     assert_equal(0,                          rr.ttl,   'nxrrset - right ttl');    #21
     assert_equal('NONE',                     rr.klass.string, 'nxrrset - right class');  #22
     assert_equal(type,                      rr.type,  'nxrrset - right type');   #23
     assert(is_empty(rr.rdata),                'nxrrset - data empty');   #24
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # Name is in use.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Name is in use.
+    # ------------------------------------------------------------------------------
+
     rr = update.present(name);
-    
+
     assert(rr,                                    'yxdomain() returned RR'); #25
     assert_equal(rr.name.to_s,  name,                      'yxdomain - right name');  #26
     assert_equal(rr.ttl,   0,                          'yxdomain - right ttl');   #27
     assert_equal(rr.klass.string, 'ANY',                      'yxdomain - right class'); #28
     assert_equal(rr.type.string,  'ANY',                      'yxdomain - right type');  #29
     assert(is_empty(rr.rdata),                'yxdomain - data empty');  #30
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # Name is not in use. (No Class)
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Name is not in use. (No Class)
+    # ------------------------------------------------------------------------------
+
     rr = update.absent(name);
-    
+
     assert(rr,                                    'nxdomain() returned RR'); #31
     assert_equal(rr.name.to_s,  name,                      'nxdomain - right name');  #32
     assert_equal(rr.ttl,   0,                          'nxdomain - right ttl');   #33
     assert_equal(rr.klass.string, 'NONE',                     'nxdomain - right class'); #34
     assert_equal(rr.type.string,  'ANY',                      'nxdomain - right type');  #35
     assert(is_empty(rr.rdata),                'nxdomain - data empty');  #36
-    
+
     rr = nil
-    
-    
-    
-    #------------------------------------------------------------------------------
-    # Add to an RRset.
-    #------------------------------------------------------------------------------
-    
+
+
+
+    # ------------------------------------------------------------------------------
+    #  Add to an RRset.
+    # ------------------------------------------------------------------------------
+
     rr = update.add(name, type, ttl, rdata);
-    
+
     assert(rr,                                    'rr_add() returned RR');   #37
     assert_equal(rr.name.to_s,     name,                   'rr_add - right name');    #38
     assert_equal(rr.ttl,      ttl,                    'rr_add - right ttl');     #39
     assert_equal(rr.klass,    klass,                  'rr_add - right class');   #40
     assert_equal(rr.type,     type,                   'rr_add - right type');    #41
     assert_equal(rr.rdata, rdata,                  'rr_add - right data');    #42
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # Delete an RRset.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Delete an RRset.
+    # ------------------------------------------------------------------------------
+
     rr = update.delete(name, type);
-    
+
     assert(rr,                                    'rr_del() returned RR');   #43
     assert_equal(name,                      rr.name.to_s,  'rr_del - right name');    #44
     assert_equal(0,                          rr.ttl,   'rr_del - right ttl');     #45
     assert_equal('ANY',                      rr.klass.string, 'rr_del - right class');   #46
     assert_equal(type,                      rr.type,  'rr_del - right type');    #47
     assert(is_empty(rr.rdata),                'rr_del - data empty');    #48
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # Delete All RRsets From A Name.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Delete All RRsets From A Name.
+    # ------------------------------------------------------------------------------
+
     rr = update.delete(name);
-    
+
     assert(rr,                                    'rr_del() returned RR');   #49
     assert_equal(name,                      rr.name.to_s,  'rr_del - right name');    #50
     assert_equal(0,                          rr.ttl,   'rr_del - right ttl');     #51
     assert_equal(Classes.ANY,                      rr.klass, 'rr_del - right class');   #52
     assert_equal(Classes.ANY,                      rr.type,  'rr_del - right type');    #53
     assert(is_empty(rr.rdata),                'rr_del - data empty');    #54
-    
+
     rr = nil
-    
-    #------------------------------------------------------------------------------
-    # Delete An RR From An RRset.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Delete An RR From An RRset.
+    # ------------------------------------------------------------------------------
+
     rr = update.delete(name, type, rdata);
-    
+
     assert(rr,                                    'rr_del() returned RR');   #55
     assert_equal(name,                   rr.name.to_s,     'rr_del - right name');    #56
     assert_equal(0,                       rr.ttl,      'rr_del - right ttl');     #57
     assert_equal('NONE',                  rr.klass.string,    'rr_del - right class');   #58
     assert_equal(type,                   rr.type,     'rr_del - right type');    #59
     assert_equal(rdata,                  rr.rdata, 'rr_del - right data');    #60
-    
+
     rr = nil
 
     data = update.encode
@@ -196,18 +193,18 @@ class TestUpdate < Test::Unit::TestCase
     assert(header.opcode == OpCode.Update)
     new_update = Message.decode(data)
     assert(new_update.header.opcode == OpCode.Update)
-    
-    #------------------------------------------------------------------------------
-    # Make sure RRs in an update packet have the same class as the zone, unless
-    # the class is NONE or ANY.
-    #------------------------------------------------------------------------------
-    
+
+    # ------------------------------------------------------------------------------
+    #  Make sure RRs in an update packet have the same class as the zone, unless
+    #  the class is NONE or ANY.
+    # ------------------------------------------------------------------------------
+
     update = Dnsruby::Update.new(zone, klass);
     assert(update,                               'packet created');          #61
-    
-    
+
+
     update.present(name, type, rdata);
-    
+
     update.present(name, type, rdata);
 
     update.present(name, type);
@@ -215,7 +212,7 @@ class TestUpdate < Test::Unit::TestCase
     update.absent(name, type);
 
     pre = update.pre;
-    
+
     assert_equal(3,                     pre.size, 'pushed inserted correctly'); #62
     assert_equal(klass,              pre[0].klass.string, 'first class right');         #63
     assert_equal(Classes.ANY,               pre[1].klass, 'third class right');         #65

data/test/tc_validator.rb

@@ -1,24 +1,24 @@
-#--
-#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_relative 'spec_helper'
 
-require 'test/unit'
-require 'dnsruby'
 include Dnsruby
 
-class TestValidator < Test::Unit::TestCase
+class TestValidator < Minitest::Test
   def test_validation
 #    Dnsruby::TheLog.level = Logger::DEBUG
     Dnsruby::Dnssec.clear_trusted_keys
@@ -41,11 +41,11 @@ class TestValidator < Test::Unit::TestCase
     ret = Dnsruby::Dnssec.validate(r)
     assert(ret, "Dnssec validation failed")
 
-    # @TODO@ Test other validation policies!!
+    #  @TODO@ Test other validation policies!!
   end
 
   def test_resolver_cd_validation_fails
-    # Should be able to check Nominet test-zone here - no keys point to it
+    #  Should be able to check Nominet test-zone here - no keys point to it
     res = Resolver.new
     res.dnssec=true
     r = res.query("uk-dnssec.nic.uk", Dnsruby::Types.A)
@@ -53,20 +53,20 @@ class TestValidator < Test::Unit::TestCase
   end
 
   def test_eventtype_api
-    # @TODO@ TEST THE Resolver::EventType interface!
+    #  @TODO@ TEST THE Resolver::EventType interface!
     print "Test EventType API!\n"
   end
 
   def test_config_api
-    # @TODO@ Test the different configuration options for the validator,
-    # and their defaults
-    #
-    # Should be able to set :
-    #  o Whether or not validation happens
-    #  o The async API queue tuples etc.
-    #  o Whether to use authoritative nameservers for validation
-    #  o Whether to use authoritative nameservers generally
-    #
+    #  @TODO@ Test the different configuration options for the validator,
+    #  and their defaults
+    # 
+    #  Should be able to set :
+    #   o Whether or not validation happens
+    #   o The async API queue tuples etc.
+    #   o Whether to use authoritative nameservers for validation
+    #   o Whether to use authoritative nameservers generally
+    # 
     print "Test validation configuration options!\n"
   end
 

data/test/tc_verifier.rb

@@ -1,26 +1,25 @@
-#--
-#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 VerifierTest < Test::Unit::TestCase
+class VerifierTest < Minitest::Test
 
   def test_sha2
-    # Check if OpenSSL supports SHA2
+    #  Check if OpenSSL supports SHA2
     have_sha2 = false
     begin
       OpenSSL::Digest::SHA256.new
@@ -28,7 +27,7 @@ class VerifierTest < Test::Unit::TestCase
     rescue Exception
     end
     if (have_sha2)
-      #      print "OpenSSL supports SHA2\n"
+      #       print "OpenSSL supports SHA2\n"
       do_test_sha256
       do_test_sha512
       do_test_nsec
@@ -72,13 +71,13 @@ class VerifierTest < Test::Unit::TestCase
   end
 
   def test_se_query
-    # Run some queries on the .se zone
+    #  Run some queries on the .se zone
     Dnsruby::Dnssec.clear_trusted_keys
     Dnsruby::Dnssec.clear_trust_anchors
     res = Dnsruby::Resolver.new(Dnsruby::Resolv.getaddress("a.ns.se"))
     res.dnssec = true
     r = res.query("se", Dnsruby::Types.ANY)
-    # See comment below
+    #  See comment below
     Dnsruby::Dnssec.anchor_verifier.add_trusted_key(r.answer.rrset("se", 'DNSKEY'))
     nss = r.answer.rrset("se", 'NS')
     ret = Dnsruby::Dnssec.verify_rrset(nss)
@@ -91,10 +90,10 @@ class VerifierTest < Test::Unit::TestCase
     res = Dnsruby::Resolver.new(Dnsruby::Resolv.getaddress("a.ns.se"))
     res.udp_size = 5000
     r = res.query("se", Dnsruby::Types.DNSKEY)
-    # This shouldn't be in the code - but the key is rotated by the .se registry
-    # so we can't keep up with it in the test code.
-    # Oh, for a signed root...
-    #    print "Adding keys : #{r.answer.rrset("se", 'DNSKEY')}\n"
+    #  This shouldn't be in the code - but the key is rotated by the .se registry
+    #  so we can't keep up with it in the test code.
+    #  Oh, for a signed root...
+    #     print "Adding keys : #{r.answer.rrset("se", 'DNSKEY')}\n"
     Dnsruby::Dnssec.anchor_verifier.add_trusted_key(r.answer.rrset("se", 'DNSKEY'))
     ret = Dnsruby::Dnssec.verify(r)
     assert(ret, "Dnssec message verification failed : #{ret}")
@@ -105,13 +104,13 @@ class VerifierTest < Test::Unit::TestCase
     Dnsruby::Dnssec.clear_trust_anchors
     res = Dnsruby::Resolver.new("a.ns.se")
     r = res.query("se", Dnsruby::Types.ANY)
-    # Haven't configured key for this, so should fail
+    #  Haven't configured key for this, so should fail
     begin
       ret = Dnsruby::Dnssec.verify(r)
       fail("Message shouldn't have verified")
     rescue (Dnsruby::VerifyError)
     end
-    #    assert(!ret, "Dnssec message verification failed")
+    #     assert(!ret, "Dnssec message verification failed")
   end
 
   def test_trusted_key
@@ -129,7 +128,7 @@ class VerifierTest < Test::Unit::TestCase
       ret = Dnsruby::Dnssec.verify(r)
       fail("Dnssec trusted key message verification should have failed with bad key")
     rescue (Dnsruby::VerifyError)
-      #    assert(!ret, "Dnssec trusted key message verification should have failed with bad key")
+      #     assert(!ret, "Dnssec trusted key message verification should have failed with bad key")
     end
     trusted_key = Dnsruby::RR.create({:name => "uk-dnssec.nic.uk.",
         :type => Dnsruby::Types.DNSKEY,
@@ -142,14 +141,14 @@ class VerifierTest < Test::Unit::TestCase
     ret = Dnsruby::Dnssec.verify(r)
     assert(ret, "Dnssec trusted key message verification failed")
 
-    #    # Check that keys have been added to trusted key cache
-    #    ret = Dnsruby::Dnssec.verify(r)
-    #    assert(ret, "Dnssec trusted key cache failed")
+    #     # Check that keys have been added to trusted key cache
+    #     ret = Dnsruby::Dnssec.verify(r)
+    #     assert(ret, "Dnssec trusted key cache failed")
   end
 
   def test_expired_keys
-    # Add some keys with an expiration of 1 second.
-    # Then wait a second or two, and check they are not available any more.
+    #  Add some keys with an expiration of 1 second.
+    #  Then wait a second or two, and check they are not available any more.
     Dnsruby::Dnssec.clear_trusted_keys
     Dnsruby::Dnssec.clear_trust_anchors
     assert(Dnsruby::Dnssec.anchor_verifier.trusted_keys.length==0)
@@ -164,30 +163,30 @@ class VerifierTest < Test::Unit::TestCase
   end
 
   def test_tcp
-    #These queries work:
-    #		 dig @194.0.1.13 isoc.lu dnskey
-    #		 dig @194.0.1.13 isoc.lu dnskey +dnssec
-    #		 dig @194.0.1.13 isoc.lu dnskey +tcp
+    # These queries work:
+    # 		 dig @194.0.1.13 isoc.lu dnskey
+    # 		 dig @194.0.1.13 isoc.lu dnskey +dnssec
+    # 		 dig @194.0.1.13 isoc.lu dnskey +tcp
 
-    #This one does not
-    #
-    #		 dig @194.0.1.13 isoc.lu dnskey +dnssec +tcp
+    # This one does not
+    # 
+    # 		 dig @194.0.1.13 isoc.lu dnskey +dnssec +tcp
     r = Dnsruby::SingleResolver.new()# "194.0.1.13")
     r.dnssec = true
     r.use_tcp = true
     ret = r.query("isoc.lu", Dnsruby::Types.DNSKEY)
-    #    print ret.to_s+"\n"
+    #     print ret.to_s+"\n"
 
     r = Dnsruby::SingleResolver.new("194.0.1.13")
     r.dnssec = true
-    #r.use_tcp = true
+    # r.use_tcp = true
     ret = r.query("isoc.lu", Dnsruby::Types.DNSKEY)
-    #    print ret.to_s+"\n"
+    #     print ret.to_s+"\n"
 
     r.use_tcp = true
     r.dnssec = false
     ret = r.query("isoc.lu", Dnsruby::Types.DNSKEY)
-    #    print ret.to_s+"\n"
+    #     print ret.to_s+"\n"
 
     r.dnssec = true
     begin
@@ -214,7 +213,7 @@ class VerifierTest < Test::Unit::TestCase
   end
 
   def test_dsa
-    # Let's check sources.org for DSA keys
+    #  Let's check sources.org for DSA keys
     Dnsruby::Dnssec.clear_trusted_keys
     Dnsruby::Dnssec.clear_trust_anchors
     res = Dnsruby::Recursor.new()
@@ -228,11 +227,11 @@ class VerifierTest < Test::Unit::TestCase
       end
     }
     assert(dsa)
-    # Now do something with it
+    #  Now do something with it
 
     response = res.query("sources.org", Dnsruby::Types.ANY)
     verified = 0
-    #    response.each_section {|sec|
+    #     response.each_section {|sec|
     response.answer.rrsets.each {|rs|
       if (rs.sigs()[0].algorithm == Dnsruby::Algorithms.DSA &&
             rs.sigs()[0].key_tag == dsa.key_tag)
@@ -241,7 +240,7 @@ class VerifierTest < Test::Unit::TestCase
         verified+=1
       end
     }
-    #   }
+    #    }
     assert(verified > 0)
   end
 
@@ -325,42 +324,42 @@ class VerifierTest < Test::Unit::TestCase
 #     zone2 = reader.process_file("cacert.signed.txt")
 #     assert(zone[1].to_s.index("DAQAB\""))
 #     assert(zone2[1].to_s.index("DAQAB\""))
-#
+# 
 #     assert(zone[1].to_s == zone2[1].to_s)
 #  end
-#
-  #  def test_txt_from_zone
-  #    reader = Dnsruby::ZoneReader.new("all.rr.org.")
-  #    zone = reader.process_file("zone.txt")
-  #    rrset = Dnsruby::RRSet.new
-  #    key_rrset = Dnsruby::RRSet.new
-  #    zone.each {|rr|
-  #      if ( (rr.type == Dnsruby::Types.TXT) || ((rr.type == Dnsruby::Types.RRSIG) && (rr.type_covered == Dnsruby::Types.TXT)))
-  #        rrset.add(rr)
-  #      end
-  #      if (rr.type == Dnsruby::Types.DNSKEY)
-  #        key_rrset.add(rr)
-  #      end
-  #    }
-  #     verifier = Dnsruby::SingleVerifier.new(Dnsruby::SingleVerifier::VerifierType::ANCHOR)
-  #    verifier.verify_rrset(rrset, key_rrset)
-  #  end
+# 
+  #   def test_txt_from_zone
+  #     reader = Dnsruby::ZoneReader.new("all.rr.org.")
+  #     zone = reader.process_file("zone.txt")
+  #     rrset = Dnsruby::RRSet.new
+  #     key_rrset = Dnsruby::RRSet.new
+  #     zone.each {|rr|
+  #       if ( (rr.type == Dnsruby::Types.TXT) || ((rr.type == Dnsruby::Types.RRSIG) && (rr.type_covered == Dnsruby::Types.TXT)))
+  #         rrset.add(rr)
+  #       end
+  #       if (rr.type == Dnsruby::Types.DNSKEY)
+  #         key_rrset.add(rr)
+  #       end
+  #     }
+  #      verifier = Dnsruby::SingleVerifier.new(Dnsruby::SingleVerifier::VerifierType::ANCHOR)
+  #     verifier.verify_rrset(rrset, key_rrset)
+  #   end
 
-  #  def test_naptr_from_zone
-  #    reader = Dnsruby::ZoneReader.new("all.rr.org.")
-  #    zone = reader.process_file("zone.txt")
-  #    rrset = Dnsruby::RRSet.new
-  #    key_rrset = Dnsruby::RRSet.new
-  #    zone.each {|rr|
-  #      if ((rr.type == Dnsruby::Types.NAPTR) || ((rr.type == Dnsruby::Types.RRSIG) && (rr.type_covered == Dnsruby::Types.NAPTR)))
-  #        rrset.add(rr)
-  #      end
-  #      if (rr.type == Dnsruby::Types.DNSKEY)
-  #        key_rrset.add(rr)
-  #      end
-  #    }
-  #     verifier = Dnsruby::SingleVerifier.new(Dnsruby::SingleVerifier::VerifierType::ANCHOR)
-  #    verifier.verify_rrset(rrset, key_rrset)
-  #  end
+  #   def test_naptr_from_zone
+  #     reader = Dnsruby::ZoneReader.new("all.rr.org.")
+  #     zone = reader.process_file("zone.txt")
+  #     rrset = Dnsruby::RRSet.new
+  #     key_rrset = Dnsruby::RRSet.new
+  #     zone.each {|rr|
+  #       if ((rr.type == Dnsruby::Types.NAPTR) || ((rr.type == Dnsruby::Types.RRSIG) && (rr.type_covered == Dnsruby::Types.NAPTR)))
+  #         rrset.add(rr)
+  #       end
+  #       if (rr.type == Dnsruby::Types.DNSKEY)
+  #         key_rrset.add(rr)
+  #       end
+  #     }
+  #      verifier = Dnsruby::SingleVerifier.new(Dnsruby::SingleVerifier::VerifierType::ANCHOR)
+  #     verifier.verify_rrset(rrset, key_rrset)
+  #   end
 end