bluemonk-net-dns 0.5.0

data/test/net/dns/resolver/test_timeouts.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'net/dns/resolver/timeouts.rb'
+
+class Test_DnsTimeout < Test::Unit::TestCase
+
+  def test_tcp
+    assert_equal(TcpTimeout.new(0).to_s,"infinite")
+    assert_equal(TcpTimeout.new(30).to_s, "30")
+    assert_equal(TcpTimeout.new(30).pretty_to_s, "30 seconds")
+    assert_equal(TcpTimeout.new(90).pretty_to_s, 
+                 "1 minutes and 30 seconds")
+    assert_equal(TcpTimeout.new(3690).pretty_to_s, 
+                 "1 hours, 1 minutes and 30 seconds")
+    assert_equal(TcpTimeout.new(1).timeout {1+1}, 2)
+  end
+
+  def test_udp
+    assert_equal(UdpTimeout.new(0).to_s,"not defined")
+    assert_equal(UdpTimeout.new(30).to_s, "30")
+    assert_equal(UdpTimeout.new(30).pretty_to_s, "30 seconds")
+    assert_equal(UdpTimeout.new(90).pretty_to_s, 
+                 "1 minutes and 30 seconds")
+    assert_equal(UdpTimeout.new(3690).pretty_to_s, 
+                 "1 hours, 1 minutes and 30 seconds")
+    assert_equal(UdpTimeout.new(1).timeout {1+1}, 2)    
+  end
+  
+  def test_range_tcp
+    assert_raise(DnsTimeoutArgumentError) do
+      TcpTimeout.new("a")
+    end
+    assert_raise(DnsTimeoutArgumentError) do
+      TcpTimeout.new(-1)
+    end
+    assert_raise(DnsTimeoutArgumentError) do
+      TcpTimeout.new(1).timeout
+    end
+    assert_raise(TimeoutError) do
+      TcpTimeout.new(0.1).timeout {sleep 2}
+    end
+  end
+
+  def test_range_udp
+    assert_raise(DnsTimeoutArgumentError) do
+      UdpTimeout.new("a")
+    end
+    assert_raise(DnsTimeoutArgumentError) do
+      UdpTimeout.new(-1)
+    end
+    assert_raise(DnsTimeoutArgumentError) do
+      UdpTimeout.new(1).timeout
+    end
+    assert_raise(TimeoutError) do
+      UdpTimeout.new(0.1).timeout {sleep 2}
+    end
+  end
+
+end
+    

data/test/net/dns/rr/test_a.rb

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'net/dns/rr'
+
+class Test_A < Test::Unit::TestCase
+  def setup
+    
+    @name = "google.com."
+    @type = "A"
+    @cls = "IN"
+    @ttl = 10800
+    @address = "64.233.187.99"
+
+    
+    @hash = Net::DNS::RR::A.new(:name => @name,
+                                :address => @address)
+    
+    @string = Net::DNS::RR::A.new("google.com. 10800 IN A 64.233.187.99")
+    
+    @arr = Net::DNS::RR.parse(@string.data)
+
+    @str = "google.com.             10800   IN      A       64.233.187.99"
+  end
+    
+  def test_simple
+    assert_equal(@str,@hash.inspect)
+    assert_equal(@name, @hash.name)
+    assert_equal(@type, @hash.type)
+    assert_equal(@cls, @hash.cls)
+    assert_equal(@ttl, @hash.ttl)
+    assert_equal(@address, @hash.address.to_s)
+
+    assert_equal(@str, @string.inspect)
+    assert_equal(@name, @string.name)
+    assert_equal(@type, @string.type)
+    assert_equal(@cls, @string.cls)
+    assert_equal(@ttl, @string.ttl)
+    assert_equal(@address, @string.address.to_s)
+    
+    assert_equal(@str, @arr.inspect)
+    assert_equal(@name, @arr.name)
+    assert_equal(@type, @arr.type)
+    assert_equal(@cls, @arr.cls)
+    assert_equal(@ttl, @arr.ttl)
+    assert_equal(@address, @arr.address.to_s)
+  end
+
+  def test_range
+    assert_raise(RRArgumentError) do 
+      Net::DNS::RR::A.new(:name => "google.com",
+                          :address => "255.256")
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new(:name => "google.com")
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new(Object.new)
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new(Array.new(7))
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new("10800 IN A")
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new("google.com. 10800 IN B")
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::A.new("google.com. 10800 IM A")
+    end
+  end
+end
+    

data/test/net/dns/rr/test_classes.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'net/dns/rr/classes'
+
+class Test_Classes < Test::Unit::TestCase
+  def setup
+    @classes = {
+      'IN'        => 1,       # RFC 1035
+      'CH'        => 3,       # RFC 1035
+      'HS'        => 4,       # RFC 1035
+      'NONE'      => 254,     # RFC 2136
+      'ANY'       => 255,     # RFC 1035
+    }
+    @regexp_string = "HS|ANY|NONE|CH|IN"
+  end
+    
+  def test_default
+    # Default type should be ANY => 255
+    instance = Net::DNS::RR::Classes.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("IN", instance.to_s)
+    
+    # Let's change default behaviour
+    Net::DNS::RR::Classes.default = "CH"
+    instance = Net::DNS::RR::Classes.new(nil)
+    assert_equal("3", instance.to_str)
+    assert_equal("CH", instance.to_s)
+
+    Net::DNS::RR::Classes.default = "IN"
+    instance = Net::DNS::RR::Classes.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("IN", instance.to_s)
+    
+  end
+
+  def test_classes
+    @classes.each do |key,num|
+      instance_from_string = Net::DNS::RR::Classes.new(key) 
+      instance_from_num = Net::DNS::RR::Classes.new(num)
+      assert_equal(key, instance_from_string.to_s)
+      assert_equal(num.to_s, instance_from_string.to_str)
+      assert_equal(key, instance_from_num.to_s)
+      assert_equal(num.to_s, instance_from_num.to_str)
+    end
+    assert_raise(ClassArgumentError) do
+      Net::DNS::RR::Classes.new(Hash.new)
+    end
+  end
+
+  def test_regexp
+    assert_equal(@regexp_string, Net::DNS::RR::Classes.regexp)
+  end
+  
+  def test_valid
+    assert_equal(true,  Net::DNS::RR::Classes.valid?("IN"))
+    assert_equal(true,  Net::DNS::RR::Classes.valid?(1))
+    assert_equal(false, Net::DNS::RR::Classes.valid?("Q"))
+    assert_equal(false, Net::DNS::RR::Classes.valid?(256))
+    assert_raise(ClassArgumentError) do
+      Net::DNS::RR::Classes.valid? Hash.new
+    end
+  end
+
+  def test_to_str
+    assert_equal("IN", Net::DNS::RR::Classes.to_str(1))
+    assert_raise(ClassArgumentError) do
+      Net::DNS::RR::Classes.to_str(256)
+    end
+    assert_raise(ClassArgumentError) do
+      Net::DNS::RR::Classes.to_str("string")
+    end
+  end
+
+end

data/test/net/dns/rr/test_ns.rb

@@ -0,0 +1,66 @@
+require 'test/unit'
+require 'net/dns/rr'
+
+class Test_NS < Test::Unit::TestCase
+  def setup
+    
+    @name = "google.com."
+    @type = "NS"
+    @cls = "IN"
+    @ttl = 10800
+    @nsdname = "ns1.google.com."
+
+    
+    @hash = Net::DNS::RR::NS.new(:name => @name,
+                                 :nsdname => @nsdname)
+    
+    @string = Net::DNS::RR::NS.new("google.com. 10800 IN NS ns1.google.com.")
+    
+    @arr = Net::DNS::RR.parse(@string.data)
+
+    @str = "google.com.             10800   IN      NS      ns1.google.com."
+  end
+    
+  def test_simple
+    assert_equal(@str,@hash.inspect)
+    assert_equal(@name, @hash.name)
+    assert_equal(@type, @hash.type)
+    assert_equal(@cls, @hash.cls)
+    assert_equal(@ttl, @hash.ttl)
+    assert_equal(@nsdname, @hash.nsdname)
+
+    assert_equal(@str, @string.inspect)
+    assert_equal(@name, @string.name)
+    assert_equal(@type, @string.type)
+    assert_equal(@cls, @string.cls)
+    assert_equal(@ttl, @string.ttl)
+    assert_equal(@nsdname, @string.nsdname)
+    
+    assert_equal(@str, @arr.inspect)
+    assert_equal(@name, @arr.name)
+    assert_equal(@type, @arr.type)
+    assert_equal(@cls, @arr.cls)
+    assert_equal(@ttl, @arr.ttl)
+    assert_equal(@nsdname, @arr.nsdname)
+  end
+  
+  def test_range
+    assert_raise(RRArgumentError) do 
+      Net::DNS::RR::NS.new(:name => "google.com",
+                          :nsdname => "255.256")
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::NS.new(:name => "google.com")
+    end
+    assert_raise(ArgumentError) do
+      Net::DNS::RR::NS.new(Range.new)
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::NS.new(Array.new(7))
+    end
+    assert_raise(RRArgumentError) do
+      Net::DNS::RR::NS.new("10800 IN A")
+    end
+  end
+end
+    

data/test/net/dns/rr/test_types.rb

@@ -0,0 +1,127 @@
+require 'test/unit'
+require 'net/dns/rr/types'
+
+class Test_Types < Test::Unit::TestCase
+  def setup
+    @types = {
+      'SIGZERO'   => 0, 
+      'A'         => 1, 
+      'NS'        => 2, 
+      'MD'        => 3, 
+      'MF'        => 4, 
+      'CNAME'     => 5, 
+      'SOA'       => 6, 
+      'MB'        => 7, 
+      'MG'        => 8, 
+      'MR'        => 9, 
+      'NULL'      => 10,
+      'WKS'       => 11,
+      'PTR'       => 12,
+      'HINFO'     => 13,
+      'MINFO'     => 14,
+      'MX'        => 15,
+      'TXT'       => 16,
+      'RP'        => 17,
+      'AFSDB'     => 18,
+      'X25'       => 19,
+      'ISDN'      => 20,
+      'RT'        => 21,
+      'NSAP'      => 22,
+      'NSAP_PTR'  => 23,
+      'SIG'       => 24,
+      'KEY'       => 25,
+      'PX'        => 26,
+      'GPOS'      => 27,
+      'AAAA'      => 28,
+      'LOC'       => 29,
+      'NXT'       => 30,
+      'EID'       => 31,
+      'NIMLOC'    => 32,
+      'SRV'       => 33,
+      'ATMA'      => 34,
+      'NAPTR'     => 35,
+      'KX'        => 36,
+      'CERT'      => 37,
+      'DNAME'     => 39,
+      'OPT'       => 41,
+      'DS'        => 43,
+      'SSHFP'     => 44,
+      'RRSIG'     => 46,
+      'NSEC'      => 47,
+      'DNSKEY'    => 48, 
+      'UINFO'     => 100,
+      'UID'       => 101,
+      'GID'       => 102,
+      'UNSPEC'    => 103,
+      'TKEY'      => 249,
+      'TSIG'      => 250,
+      'IXFR'      => 251,
+      'AXFR'      => 252,
+      'MAILB'     => 253,
+      'MAILA'     => 254,
+      'ANY'       => 255,
+    }
+
+    @regexp_string = "UNSPEC|ATMA|EID|LOC|NSAP|ISDN|MX|ANY|MAILA|SRV|AFSDB|MD|" +
+      "A|MAILB|TKEY|GID|KX|GPOS|RT|HINFO|PTR|CNAME|MF|SIGZERO|DNSKEY|DS|AAAA|" + 
+      "MG|UID|NSEC|NIMLOC|NSAP_PTR|X25|TXT|MR|SOA|NS|DNAME|CERT|SIG|AXFR|IXFR|" + 
+      "UINFO|NAPTR|OPT|PX|RP|TSIG|SSHFP|KEY|MINFO|WKS|NULL|RRSIG|NXT|MB"
+  end
+    
+  def test_default
+    # Default type should be ANY => 255
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("A", instance.to_s)
+    
+    # Let's change default behaviour
+    Net::DNS::RR::Types.default = "A"
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("A", instance.to_s)
+
+    Net::DNS::RR::Types.default = "ANY"
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("255", instance.to_str)
+    assert_equal("ANY", instance.to_s)
+  end
+
+  def test_types
+    @types.each do |key,num|
+      instance_from_string = Net::DNS::RR::Types.new(key) 
+      instance_from_num = Net::DNS::RR::Types.new(num)
+      assert_equal(key, instance_from_string.to_s)
+      assert_equal(num.to_s, instance_from_string.to_str)
+      assert_equal(key, instance_from_num.to_s)
+      assert_equal(num.to_s, instance_from_num.to_str)
+    end
+    assert_raise(TypeArgumentError) do
+      Net::DNS::RR::Types.new(Hash.new)
+    end
+  end
+
+  def test_regexp
+    assert_equal(@regexp_string, Net::DNS::RR::Types.regexp)
+  end
+  
+  def test_valid
+    assert_equal(true,  Net::DNS::RR::Types.valid?("A"))
+    assert_equal(true,  Net::DNS::RR::Types.valid?(1))
+    assert_equal(false, Net::DNS::RR::Types.valid?("Q"))
+    assert_equal(false, Net::DNS::RR::Types.valid?(256))
+    assert_raise(TypeArgumentError) do
+      Net::DNS::RR::Types.valid? Hash.new
+    end
+  end
+
+  def test_to_str
+    assert_equal("A", Net::DNS::RR::Types.to_str(1))
+    assert_raise(TypeArgumentError) do
+      Net::DNS::RR::Types.to_str(256)
+    end
+    assert_raise(TypeArgumentError) do
+      Net::DNS::RR::Types.to_str("string")
+    end
+  end
+
+end

data/test/net/dns/test_header.rb

@@ -0,0 +1,170 @@
+require 'test/unit'
+require 'net/dns/header'
+
+class Test_Header < 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_raise(HeaderArgumentError) do
+      Header.new(Array.new)
+    end
+    assert_raise(HeaderArgumentError) do
+      Header.parse(Array.new)
+    end
+    assert_raise(HeaderArgumentError) do
+      Header.parse("aa")
+    end
+    assert_raise(HeaderDuplicateID) do
+      @default.id = 441
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.id = 1000000
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.qr=2
+    end
+    assert_raise(HeaderWrongOpcode) do
+      @default.opCode=4
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.aa=2
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.tc=2
+    end
+    assert_raise(HeaderWrongRecursive) do
+      @default.recursive=2
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.ra=2
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.cd=2
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.ad=2
+    end
+    assert_raise(HeaderArgumentError) do
+      @default.rCode=46
+    end
+    assert_raise(HeaderWrongCount) do
+      @default.qdCount=100000
+    end
+    assert_raise(HeaderWrongCount) do
+      @default.anCount=100000
+    end
+    assert_raise(HeaderWrongCount) do
+      @default.nsCount=100000
+    end
+    assert_raise(HeaderWrongCount) do
+      @default.arCount=100000
+    end
+  end    
+
+end
+    

data/test/net/dns/test_packet.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'net/dns/packet'
+
+class Test_Packet < Test::Unit::TestCase
+  include Net::DNS
+
+  def setup
+    @domain = 'example.com'
+    @type   = 'MX'
+    @cls  = 'HS'
+     
+    @default = Packet.new(@domain)
+    @string = Packet.new(@domain, MX, HS)
+    
+    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"
+    
+    @binary = Packet.parse(packet)
+    
+  end
+  
+  def test_instances
+    assert_instance_of(Net::DNS::Packet, @string)
+    assert_instance_of(Net::DNS::Header, @string.header)
+    assert_instance_of(Array, @string.question)
+    assert_instance_of(Net::DNS::Question, @string.question[0])
+    assert_instance_of(Array, @string.answer)
+    assert_instance_of(Array, @string.authority)
+    assert_instance_of(Array, @string.additional)    
+
+    assert_instance_of(Net::DNS::Packet, @binary)    
+    assert_instance_of(Net::DNS::Header, @binary.header)
+    assert_instance_of(Array, @binary.question)
+    assert_instance_of(Net::DNS::Question, @binary.question[0])
+    assert_instance_of(Array, @binary.answer)
+    assert_instance_of(Net::DNS::RR::A, @binary.answer[0])
+    assert_instance_of(Array, @binary.authority)
+    assert_instance_of(Net::DNS::RR::NS, @binary.authority[0])
+    assert_instance_of(Array, @binary.additional)    
+    assert_instance_of(Net::DNS::RR::A, @binary.additional[0])    
+  end
+  
+end    

data/test/net/dns/test_question.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'net/dns/question'
+
+class Test_Question < Test::Unit::TestCase
+  include Net::DNS
+
+  def setup
+    @domain = 'example.com.'
+    @type   = 'MX'
+    @cls  = 'HS'
+    @data = "\006google\003com\000\000\001\000\001"
+    
+    @default = Question.new(@domain)
+    @string  = Question.new(@domain,@type,@cls)
+    @binary  = Question.parse(@data)
+    @binary2 = 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_raise(QuestionNameError) do
+      Question.new(1)
+    end
+    assert_raise(QuestionNameError) do
+      Question.new("test{")
+    end
+    assert_raise(QuestionArgumentError) do
+      Question.parse(Array.new)
+    end
+    assert_raise(QuestionArgumentError) do
+      Question.parse("test")
+    end
+    
+  end
+  
+  
+end