net-dns 0.8.0 → 0.20.0

data/lib/net/dns/core_ext.rb

@@ -1,52 +0,0 @@
-module Net # :nodoc:
-  module DNS
-
-    module HashKeys # :nodoc:
-
-      # Returns an hash with all the
-      # keys turned into downcase
-      #
-      #   hsh = {"Test" => 1, "FooBar" => 2}
-      #   hsh.downcase_keys!
-      #      #=> {"test"=>1,"foobar"=>2}
-      #
-      def downcase_keys!
-        hsh = Hash.new
-        self.each do |key,val|
-          hsh[key.downcase] = val
-        end
-        self.replace(hsh)
-      end
-      
-    end
-
-    module HashOperators # :nodoc:
-
-      # Performs a sort of group difference
-      # operation on hashes or arrays
-      #
-      #   a = {:a=>1,:b=>2,:c=>3}
-      #   b = {:a=>1,:b=>2}
-      #   c = [:a,:c]
-      #   a-b #=> {:c=>3}
-      #   a-c #=> {:b=>2}
-      #
-      def -(other)
-        case other
-          when Hash
-            delete_if { |k,v| other.has_key?(k) }
-          when Array
-            delete_if { |k,v| other.include?(k) }
-        end
-      end
-
-    end
-
-  end
-end
-
-
-class Hash # :nodoc:
-  include Net::DNS::HashKeys
-  include Net::DNS::HashOperators
-end

data/net-dns.gemspec

@@ -1,35 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "net-dns"
-  s.version = "0.8.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Marco Ceresa", "Simone Carletti"]
-  s.date = "2013-05-08"
-  s.description = "Net::DNS is a pure Ruby DNS library, with a clean OO interface and an extensible API."
-  s.email = ["ceresa@gmail.com", "weppos@weppos.net"]
-  s.files = [".gitignore", ".travis.yml", "CHANGELOG.md", "Gemfile", "README.md", "Rakefile", "THANKS.rdoc", "demo/check_soa.rb", "demo/threads.rb", "fixtures/resolv.conf", "lib/net/dns.rb", "lib/net/dns/core_ext.rb", "lib/net/dns/header.rb", "lib/net/dns/names.rb", "lib/net/dns/packet.rb", "lib/net/dns/question.rb", "lib/net/dns/resolver.rb", "lib/net/dns/resolver/socks.rb", "lib/net/dns/resolver/timeouts.rb", "lib/net/dns/rr.rb", "lib/net/dns/rr/a.rb", "lib/net/dns/rr/aaaa.rb", "lib/net/dns/rr/classes.rb", "lib/net/dns/rr/cname.rb", "lib/net/dns/rr/hinfo.rb", "lib/net/dns/rr/mr.rb", "lib/net/dns/rr/mx.rb", "lib/net/dns/rr/ns.rb", "lib/net/dns/rr/null.rb", "lib/net/dns/rr/ptr.rb", "lib/net/dns/rr/soa.rb", "lib/net/dns/rr/srv.rb", "lib/net/dns/rr/txt.rb", "lib/net/dns/rr/types.rb", "lib/net/dns/version.rb", "net-dns.gemspec", "test/header_test.rb", "test/names_test.rb", "test/packet_test.rb", "test/question_test.rb", "test/resolver/timeouts_test.rb", "test/resolver_test.rb", "test/rr/a_test.rb", "test/rr/aaaa_test.rb", "test/rr/classes_test.rb", "test/rr/cname_test.rb", "test/rr/hinfo_test.rb", "test/rr/mr_test.rb", "test/rr/mx_test.rb", "test/rr/ns_test.rb", "test/rr/types_test.rb", "test/rr_test.rb", "test/test_helper.rb"]
-  s.homepage = "http://github.com/bluemonk/net-dns"
-  s.require_paths = ["lib"]
-  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
-  s.rubyforge_project = "net-dns"
-  s.rubygems_version = "2.0.3"
-  s.summary = "Pure Ruby DNS library."
-  s.test_files = ["test/header_test.rb", "test/names_test.rb", "test/packet_test.rb", "test/question_test.rb", "test/resolver/timeouts_test.rb", "test/resolver_test.rb", "test/rr/a_test.rb", "test/rr/aaaa_test.rb", "test/rr/classes_test.rb", "test/rr/cname_test.rb", "test/rr/hinfo_test.rb", "test/rr/mr_test.rb", "test/rr/mx_test.rb", "test/rr/ns_test.rb", "test/rr/types_test.rb", "test/rr_test.rb", "test/test_helper.rb"]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rake>, ["~> 10.0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-    else
-      s.add_dependency(%q<rake>, ["~> 10.0"])
-      s.add_dependency(%q<yard>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rake>, ["~> 10.0"])
-    s.add_dependency(%q<yard>, [">= 0"])
-  end
-end

data/test/header_test.rb

@@ -1,167 +0,0 @@
-require 'test_helper'
-require 'net/dns/header'
-
-class HeaderTest < Test::Unit::TestCase
-  include Net::DNS
-  
-  def setup
-
-    @default = Header.new
-    @hash = Header.new(:id => 441,
-                       :qr => 1,
-                       :opCode => Header::IQUERY,
-                       :aa => 1,
-                       :tc => 1,
-                       :rd => 0,
-                       :cd => 0,
-                       :ad => 0,
-                       :ra => 1,
-                       :rCode => Header::RCode::FORMAT,
-                       :qdCount => 1,
-                       :anCount => 2,
-                       :nsCount => 3,
-                       :arCount => 3)
-    
-    @modified = Header.new
-    @modified.id = 442
-    @modified.qr = true
-    @modified.opCode = Header::IQUERY
-    @modified.aa = true
-    @modified.tc = true
-    @modified.rd = false
-    @modified.cd = false
-    @modified.ra = true
-    @modified.rCode = Header::RCode::FORMAT
-    @modified.qdCount = 1
-    @modified.anCount = 2
-    @modified.nsCount = 3
-    @modified.arCount = 3
-
-    @data = @modified.data
-    num = [(@data.unpack("n")[0]+1)].pack("n")
-    @data[0],@data[1] = num[0], num[1]
-    @binary = Header.parse(@data)
-    
-  end
-
-  def test_simple
-    assert_equal(@default.query?, true)
-    assert_equal(@default.response?, false)
-    assert_equal(@default.opCode, Header::QUERY)
-    assert_equal(@default.auth?, false)
-    assert_equal(@default.truncated?, false)
-    assert_equal(@default.recursive?, true)
-    assert_equal(@default.checking?, true)
-    assert_equal(@default.verified?, false)
-    assert_equal(@default.r_available?, false)
-    assert_equal(@default.rCode.code, Header::RCode::NOERROR)
-    assert_equal(@default.qdCount, 1)
-    assert_equal(@default.anCount, 0)
-    assert_equal(@default.nsCount, 0)
-    assert_equal(@default.arCount, 0)
-
-    assert_equal(@hash.id, 441)    
-    assert_equal(@hash.query?, false)
-    assert_equal(@hash.response?, true)
-    assert_equal(@hash.opCode, Header::IQUERY)
-    assert_equal(@hash.auth?, true)
-    assert_equal(@hash.truncated?, true)
-    assert_equal(@hash.recursive?, false)
-    assert_equal(@hash.checking?, true)
-    assert_equal(@hash.verified?, false)
-    assert_equal(@hash.r_available?, true)
-    assert_equal(@hash.rCode.code, Header::RCode::FORMAT)
-    assert_equal(@hash.qdCount, 1)
-    assert_equal(@hash.anCount, 2)
-    assert_equal(@hash.nsCount, 3)
-    assert_equal(@hash.arCount, 3)
-    
-    assert_equal(@modified.id, 442)    
-    assert_equal(@modified.query?, false)
-    assert_equal(@modified.response?, true)
-    assert_equal(@modified.opCode, Header::IQUERY)
-    assert_equal(@modified.auth?, true)
-    assert_equal(@modified.truncated?, true)
-    assert_equal(@modified.recursive?, false)
-    assert_equal(@modified.checking?, true)
-    assert_equal(@modified.verified?, false)
-    assert_equal(@modified.r_available?, true)
-    assert_equal(@modified.rCode.code, Header::RCode::FORMAT)
-    assert_equal(@modified.qdCount, 1)
-    assert_equal(@modified.anCount, 2)
-    assert_equal(@modified.nsCount, 3)
-    assert_equal(@modified.arCount, 3)
-    
-    assert_equal(@binary.data, @data)
-
-    assert_equal(@binary.id, 443)    
-    assert_equal(@binary.query?, false)
-    assert_equal(@binary.response?, true)
-    assert_equal(@binary.opCode, Header::IQUERY)
-    assert_equal(@binary.auth?, true)
-    assert_equal(@binary.truncated?, true)
-    assert_equal(@binary.recursive?, false)
-    assert_equal(@binary.checking?, true)
-    assert_equal(@binary.verified?, false)
-    assert_equal(@binary.r_available?, true)
-    assert_equal(@binary.rCode.code, Header::RCode::FORMAT)
-    assert_equal(@binary.qdCount, 1)
-    assert_equal(@binary.anCount, 2)
-    assert_equal(@binary.nsCount, 3)
-    assert_equal(@binary.arCount, 3)
-    
-    assert_raises(ArgumentError) do
-      Header.new(Array.new)
-    end
-    assert_raises(ArgumentError) do
-      Header.parse(Array.new)
-    end
-    assert_raises(ArgumentError) do
-      Header.parse("aa")
-    end
-    assert_raises(ArgumentError) do
-      @default.id = 1000000
-    end
-    assert_raises(ArgumentError) do
-      @default.qr=2
-    end
-    assert_raises(Header::WrongOpcodeError) do
-      @default.opCode=4
-    end
-    assert_raises(ArgumentError) do
-      @default.aa=2
-    end
-    assert_raises(ArgumentError) do
-      @default.tc=2
-    end
-    assert_raises(Header::WrongRecursiveError) do
-      @default.recursive=2
-    end
-    assert_raises(ArgumentError) do
-      @default.ra=2
-    end
-    assert_raises(ArgumentError) do
-      @default.cd=2
-    end
-    assert_raises(ArgumentError) do
-      @default.ad=2
-    end
-    assert_raises(ArgumentError) do
-      @default.rCode=46
-    end
-    assert_raises(Header::WrongCountError) do
-      @default.qdCount=100000
-    end
-    assert_raises(Header::WrongCountError) do
-      @default.anCount=100000
-    end
-    assert_raises(Header::WrongCountError) do
-      @default.nsCount=100000
-    end
-    assert_raises(Header::WrongCountError) do
-      @default.arCount=100000
-    end
-  end    
-
-end
-    

data/test/names_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-require 'net/dns/names'
-
-class NamesTest < Test::Unit::TestCase
-  include Net::DNS::Names
-
-  def test_long_names
-    assert_nothing_raised do
-      pack_name('a' * 63)
-    end
-    assert_raises ArgumentError do
-      pack_name('a' * 64)
-    end
-    assert_nothing_raised do
-      pack_name(['a' * 63, 'b' * 63, 'c' * 63, 'd' * 63].join('.'))
-    end
-    assert_raises ArgumentError do
-      pack_name(['a' * 63, 'b' * 63, 'c' * 63, 'd' * 63, 'e'].join('.'))
-    end
-  end
-end

data/test/packet_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-require 'net/dns/packet'
-
-class PacketTest < Test::Unit::TestCase
-
-  def setup
-    @klass  = Net::DNS::Packet
-    @domain = 'example.com'
-  end
-
-  def test_initialize
-    @record = @klass.new(@domain, Net::DNS::MX, Net::DNS::HS)
-    assert_instance_of @klass,              @record
-    assert_instance_of Net::DNS::Header,    @record.header
-    assert_instance_of Array,               @record.question
-    assert_instance_of Net::DNS::Question,  @record.question.first
-    assert_instance_of Array,               @record.answer
-    assert_instance_of Array,               @record.authority
-    assert_instance_of Array,               @record.additional
-  end
-
-  def test_initialize_should_set_question
-    @question = @klass.new(@domain).question.first
-    assert_equal @domain, @question.qName
-    assert_equal Net::DNS::RR::Types.new(Net::DNS::A).to_s, @question.qType.to_s
-    assert_equal Net::DNS::RR::Classes.new(Net::DNS::IN).to_s, @question.qClass.to_s 
-
-    @question = @klass.new(@domain, Net::DNS::MX, Net::DNS::HS).question.first
-    assert_equal @domain, @question.qName
-    assert_equal Net::DNS::RR::Types.new(Net::DNS::MX).to_s, @question.qType.to_s
-    assert_equal Net::DNS::RR::Classes.new(Net::DNS::HS).to_s, @question.qClass.to_s
-  end
-
-  def test_self_parse
-    packet = "\337M\201\200\000\001\000\003\000\004\000\004\006google\003com\000\000\001\000\001\300\f\000\001\000\001\000\000\001,\000\004@\351\273c\300\f\000\001\000\001\000\000\001,\000\004H\016\317c\300\f\000\001\000\001\000\000\001,\000\004@\351\247c\300\f\000\002\000\001\000\003\364\200\000\006\003ns1\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns2\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns3\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns4\300\f\300X\000\001\000\001\000\003\307\273\000\004\330\357 \n\300j\000\001\000\001\000\003\307\273\000\004\330\357\"\n\300|\000\001\000\001\000\003\307\273\000\004\330\357$\n\300\216\000\001\000\001\000\003\307\273\000\004\330\357&\n"
-    @record = @klass.parse(packet)
-    assert_instance_of @klass,              @record
-    assert_instance_of Net::DNS::Header,    @record.header
-    assert_instance_of Array,               @record.question
-    assert_instance_of Net::DNS::Question,  @record.question.first
-    assert_instance_of Array,               @record.answer
-    assert_instance_of Net::DNS::RR::A,     @record.answer.first
-    assert_instance_of Array,               @record.authority
-    assert_instance_of Net::DNS::RR::NS,    @record.authority.first
-    assert_instance_of Array,               @record.additional
-    assert_instance_of Net::DNS::RR::A,     @record.additional.first
-  end
-
-end    

data/test/question_test.rb

@@ -1,83 +0,0 @@
-require 'test_helper'
-require 'net/dns/question'
-
-class QuestionTest < Test::Unit::TestCase
-
-  def setup
-    @domain = 'example.com.'
-    @type   = 'MX'
-    @cls  = 'HS'
-    @data = "\006google\003com\000\000\001\000\001"
-
-    @default = Net::DNS::Question.new(@domain)
-    @string  = Net::DNS::Question.new(@domain,@type,@cls)
-    @binary  = Net::DNS::Question.parse(@data)
-    @binary2 = Net::DNS::Question.parse(@string.data)
-  end
-
-  def test_simple
-    assert_equal(@default.qName, @domain)
-    assert_equal(@default.qType.to_s, "A")
-    assert_equal(@default.qClass.to_s, "IN")
-
-    assert_equal(@string.qName, @domain)
-    assert_equal(@string.qType.to_s, "MX")
-    assert_equal(@string.qClass.to_s, "HS")
-
-    assert_equal(@binary.qName, "google.com.")
-    assert_equal(@binary.qType.to_s, "A")
-    assert_equal(@binary.qClass.to_s, "IN")
-
-    assert_equal(@binary2.qName, @domain)
-    assert_equal(@binary2.qType.to_s, "MX")
-    assert_equal(@binary2.qClass.to_s, "HS")
-  end
-
-  def test_raise
-    # assert_raises(Net::DNS::Question::NameInvalid) do
-    #   Net::DNS::Question.new(1)
-    # end
-    assert_raises(Net::DNS::Question::NameInvalid) do
-      Net::DNS::Question.new("test{")
-    end
-    assert_raises(ArgumentError) do
-      Net::DNS::Question.parse(Array.new)
-    end
-    assert_raises(ArgumentError) do
-      Net::DNS::Question.parse("test")
-    end
-  end
-
-  def test_inspect
-    assert_equal  "google.com.                  IN      A       ",
-                  Net::DNS::Question.new("google.com.").inspect
-    assert_equal  "google.com.                  IN      A       ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::A).inspect
-    assert_equal  "google.com.                  IN      NS      ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::NS).inspect
-    assert_equal  "google.com.                  IN      NS      ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::NS).inspect
-  end
-
-  def test_inspect_with_name_longer_than_29_chrs
-    assert_equal  "supercalifragilistichespiralidoso.com IN      A       ",
-                  Net::DNS::Question.new("supercalifragilistichespiralidoso.com").inspect
-  end
-
-  def test_to_s
-    assert_equal  "google.com.                  IN      A       ",
-                  Net::DNS::Question.new("google.com.").to_s
-    assert_equal  "google.com.                  IN      A       ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::A).to_s
-    assert_equal  "google.com.                  IN      NS      ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::NS).to_s
-    assert_equal  "google.com.                  IN      NS      ",
-                  Net::DNS::Question.new("google.com.", Net::DNS::NS).to_s
-  end
-
-  def test_to_s_with_name_longer_than_29_chrs
-    assert_equal  "supercalifragilistichespiralidoso.com IN      A       ",
-                  Net::DNS::Question.new("supercalifragilistichespiralidoso.com").to_s
-  end
-
-end

data/test/resolver/timeouts_test.rb

@@ -1,109 +0,0 @@
-require 'test_helper'
-require 'net/dns/resolver/timeouts'
-
-class DnsTimeoutTest < Test::Unit::TestCase
-
-  def setup
-    @klass = Net::DNS::Resolver::DnsTimeout
-  end
-
-  def test_initialize
-    timeout = @klass.new(0)
-    assert_instance_of @klass, timeout
-  end
-
-  def test_initialize_should_set_timeout
-    assert_equal 0, @klass.new(0).seconds
-    assert_equal 10, @klass.new(10).seconds
-  end
-
-  def test_initialize_should_set_raise_with_invalid_timeout
-    assert_raises(ArgumentError) { @klass.new(nil) }
-    assert_raises(ArgumentError) { @klass.new("") }
-    assert_raises(ArgumentError) { @klass.new("foo") }
-    assert_raises(ArgumentError) { @klass.new(-1) }
-  end
-
-
-  def test_to_s
-    assert_equal "", @klass.new(0).to_s
-    assert_equal "1", @klass.new(1).to_s
-    assert_equal "10", @klass.new(10).to_s
-  end
-
-
-  def test_timeout_should_raise_localjumperror_without_block
-    assert_raises(LocalJumpError) { @klass.new(1).timeout }
-  end
-
-end
-
-class TcpTimeoutTest < Test::Unit::TestCase
-
-  def test_initialize
-    assert_raises(ArgumentError) do
-      Net::DNS::Resolver::TcpTimeout.new("a")
-    end
-    assert_raises(ArgumentError) do
-      Net::DNS::Resolver::TcpTimeout.new(-1)
-    end
-    assert_raises(TimeoutError) do
-      Net::DNS::Resolver::TcpTimeout.new(0.1).timeout { sleep 2 }
-    end
-  end
-
-  def test_to_s
-    assert_equal "infinite", Net::DNS::Resolver::TcpTimeout.new(0).to_s
-    assert_equal "30", Net::DNS::Resolver::TcpTimeout.new(30).to_s
-  end
-
-  def test_pretty_to_s
-    assert_equal "30 seconds", Net::DNS::Resolver::TcpTimeout.new(30).pretty_to_s
-    assert_equal "1 minutes and 30 seconds", Net::DNS::Resolver::TcpTimeout.new(90).pretty_to_s
-    assert_equal "1 hours, 1 minutes and 30 seconds", Net::DNS::Resolver::TcpTimeout.new(3690).pretty_to_s
-  end
-
-  def test_timeout
-    assert_equal 2, Net::DNS::Resolver::TcpTimeout.new(1).timeout { 1 + 1 }
-  end
-
-  def test_timeout_should_raise_localjumperror_without_block
-    assert_raises(LocalJumpError) { Net::DNS::Resolver::TcpTimeout.new(1).timeout }
-  end
-
-end
-
-class UdpTimeoutTest < Test::Unit::TestCase
-
-  def test_initialize
-    assert_raises(ArgumentError) do
-      Net::DNS::Resolver::UdpTimeout.new("a")
-    end
-    assert_raises(ArgumentError) do
-      Net::DNS::Resolver::UdpTimeout.new(-1)
-    end
-    assert_raises(TimeoutError) do
-      Net::DNS::Resolver::UdpTimeout.new(0.1).timeout {sleep 2}
-    end
-  end
-
-  def test_to_s
-    assert_equal "not defined", Net::DNS::Resolver::UdpTimeout.new(0).to_s
-    assert_equal "30", Net::DNS::Resolver::UdpTimeout.new(30).to_s
-  end
-
-  def test_pretty_to_s
-    assert_equal "30 seconds", Net::DNS::Resolver::UdpTimeout.new(30).pretty_to_s
-    assert_equal "1 minutes and 30 seconds", Net::DNS::Resolver::UdpTimeout.new(90).pretty_to_s
-    assert_equal "1 hours, 1 minutes and 30 seconds", Net::DNS::Resolver::UdpTimeout.new(3690).pretty_to_s
-  end
-
-  def test_timeout
-    assert_equal 2, Net::DNS::Resolver::UdpTimeout.new(1).timeout { 1 + 1 }
-  end
-
-  def test_timeout_should_raise_localjumperror_without_block
-    assert_raises(LocalJumpError) { Net::DNS::Resolver::UdpTimeout.new(1).timeout }
-  end
-
-end

data/test/resolver_test.rb

@@ -1,117 +0,0 @@
-require 'test_helper'
-require 'net/dns/resolver'
-
-class Net::DNS::Resolver
-  attr_reader :config
-end
-
-
-class ResolverTest < Test::Unit::TestCase
-
-  def test_initialize
-    assert_nothing_raised { Net::DNS::Resolver.new }
-  end
-
-  def test_initialize_with_config
-    assert_nothing_raised { Net::DNS::Resolver.new({}) }
-  end
-
-  def test_initialize_with_multi_name_servers
-    resolver = Net::DNS::Resolver.new({:config_file => 'fixtures/resolv.conf'})
-    assert_equal ['192.168.1.1', '192.168.1.2', '192.168.1.3', '192.168.1.4'], resolver.nameservers
-  end
-
-  def test_initialize_with_invalid_config_should_raise_argumenterror
-    assert_raises(ArgumentError) { Net::DNS::Resolver.new("") }
-    assert_raises(ArgumentError) { Net::DNS::Resolver.new(0) }
-    assert_raises(ArgumentError) { Net::DNS::Resolver.new(:foo) }
-  end
-
-  def test_query_with_no_nameservers_should_raise_resolvererror
-    assert_raises(Net::DNS::Resolver::Error) { Net::DNS::Resolver.new(:nameservers => []).query("example.com") }
-  end
-
-  # def test_send_to_ipv6_nameserver_should_not_raise_einval
-  #   assert_nothing_raised { Net::DNS::Resolver.new(:nameservers => ['2001:4860:4860::8888', '2001:4860:4860::8844']).send('example.com')}
-  # end
-
-  # I know private methods are supposed to not be tested directly
-  # but since this library lacks unit tests, for now let me test them in this way.
-
-  def _make_query_packet(*args)
-    Net::DNS::Resolver.new.send(:make_query_packet, *args)
-  end
-
-  def test_make_query_packet_from_ipaddr
-    packet = _make_query_packet(IPAddr.new("192.168.1.1"), Net::DNS::A, cls = Net::DNS::IN)
-    assert_equal "1.1.168.192.in-addr.arpa",  packet.question.first.qName
-    assert_equal Net::DNS::PTR.to_i,          packet.question.first.qType.to_i
-    assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
-  end
-
-  def test_make_query_packet_from_string_like_ipv4
-    packet = _make_query_packet("192.168.1.1", Net::DNS::A, cls = Net::DNS::IN)
-    assert_equal "1.1.168.192.in-addr.arpa",  packet.question.first.qName
-    assert_equal Net::DNS::PTR.to_i,          packet.question.first.qType.to_i
-    assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
-  end
-
-  def test_make_query_packet_from_string_like_ipv6
-    packet = _make_query_packet("2001:1ac0::200:0:a5d1:6004:2", Net::DNS::A, cls = Net::DNS::IN)
-    assert_equal "2.0.0.0.4.0.0.6.1.d.5.a.0.0.0.0.0.0.2.0.0.0.0.0.0.c.a.1.1.0.0.2.ip6.arpa",  packet.question.first.qName
-    assert_equal Net::DNS::PTR.to_i,          packet.question.first.qType.to_i
-    assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
-  end
-
-  def test_make_query_packet_from_string_like_hostname
-    packet = _make_query_packet("ns2.google.com", Net::DNS::A, cls = Net::DNS::IN)
-    assert_equal "ns2.google.com",            packet.question.first.qName
-    assert_equal Net::DNS::A.to_i,            packet.question.first.qType.to_i
-    assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
-  end
-
-  def test_make_query_packet_from_string_like_hostname_with_number
-    packet = _make_query_packet("ns.google.com", Net::DNS::A, cls = Net::DNS::IN)
-    assert_equal "ns.google.com",             packet.question.first.qName
-    assert_equal Net::DNS::A.to_i,            packet.question.first.qType.to_i
-    assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
-  end
-
-  def test_should_return_state_without_exception
-    res = Net::DNS::Resolver.new
-    assert_nothing_raised {res.state}
-  end
-
-  RubyPlatforms = [
-    ["darwin9.0", false],   # Mac OS X
-    ["darwin", false],      # JRuby on Mac OS X
-    ["linux-gnu", false],
-    ["mingw32", true],      # ruby 1.8.6 (2008-03-03 patchlevel 114) [i386-mingw32]
-    ["mswin32", true],      # ruby 1.8.6 (2008-03-03 patchlevel 114) [i386-mswin32]
-    ["mswin32", true],      # ruby 1.8.6 (2008-04-22 rev 6555) [x86-jruby1.1.1]
-  ]
-
-  C = Object.const_get(defined?(RbConfig) ? :RbConfig : :Config)::CONFIG
-
-  def test_self_platform_windows_question
-    RubyPlatforms.each do |platform, is_windows|
-      assert_equal is_windows,
-                    override_platform(platform) { Net::DNS::Resolver.platform_windows? },
-                    "Expected `#{is_windows}' with platform `#{platform}'"
-    end
-  end
-
-
-  private
-
-  def override_platform(new_platform, &block)
-    raise LocalJumpError, "no block given" unless block_given?
-    old_platform = C["host_os"]
-    C["host_os"] = new_platform
-    result = yield
-  ensure
-    C["host_os"] = old_platform
-    result
-  end
-
-end