message_python_test.py 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475
  1. # Copyright (C) 2010 Internet Systems Consortium.
  2. #
  3. # Permission to use, copy, modify, and distribute this software for any
  4. # purpose with or without fee is hereby granted, provided that the above
  5. # copyright notice and this permission notice appear in all copies.
  6. #
  7. # THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SYSTEMS CONSORTIUM
  8. # DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  9. # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  10. # INTERNET SYSTEMS CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  11. # INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  12. # FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  13. # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  14. # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15. #
  16. # Tests for the message part of the pydnspp module
  17. #
  18. import unittest
  19. import os
  20. from pydnspp import *
  21. from testutil import *
  22. # helper functions for tests taken from c++ unittests
  23. if "TESTDATA_PATH" in os.environ:
  24. testdata_path = os.environ["TESTDATA_PATH"]
  25. else:
  26. testdata_path = "../tests/testdata"
  27. def factoryFromFile(message, file):
  28. data = read_wire_data(file)
  29. message.from_wire(data)
  30. pass
  31. # we don't have direct comparison for rrsets right now (should we?
  32. # should go in the cpp version first then), so also no direct list
  33. # comparison. Created a helper function
  34. def compare_rrset_list(list1, list2):
  35. if len(list1) != len(list2):
  36. return False
  37. for i in range(0, len(list1)):
  38. if str(list1[i]) != str(list2[i]):
  39. return False
  40. return True
  41. # a complete message taken from cpp tests, for testing towire and totext
  42. def create_message():
  43. message_render = Message(Message.RENDER)
  44. message_render.set_qid(0x1035)
  45. message_render.set_opcode(Opcode.QUERY())
  46. message_render.set_rcode(Rcode.NOERROR())
  47. message_render.set_header_flag(Message.HEADERFLAG_QR)
  48. message_render.set_header_flag(Message.HEADERFLAG_RD)
  49. message_render.set_header_flag(Message.HEADERFLAG_AA)
  50. message_render.add_question(Question(Name("test.example.com"),
  51. RRClass("IN"), RRType("A")))
  52. rrset = RRset(Name("test.example.com"), RRClass("IN"),
  53. RRType("A"), RRTTL(3600))
  54. rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
  55. rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
  56. message_render.add_rrset(Message.SECTION_ANSWER, rrset)
  57. return message_render
  58. def strip_mutable_tsig_data(data):
  59. # Unfortunately we cannot easily compare TSIG RR because we can't tweak
  60. # current time. As a work around this helper function strips off the time
  61. # dependent part of TSIG RDATA, i.e., the MAC (assuming HMAC-MD5) and
  62. # Time Signed.
  63. return data[0:-32] + data[-26:-22] + data[-6:]
  64. class MessageTest(unittest.TestCase):
  65. def setUp(self):
  66. self.p = Message(Message.PARSE)
  67. self.r = Message(Message.RENDER)
  68. self.rrset_a = RRset(Name("example.com"), RRClass("IN"), RRType("A"),
  69. RRTTL(3600))
  70. self.rrset_a.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
  71. self.rrset_a.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
  72. self.rrset_aaaa = RRset(Name("example.com"), RRClass("IN"),
  73. RRType("AAAA"), RRTTL(3600))
  74. self.rrset_aaaa.add_rdata(Rdata(RRType("AAAA"), RRClass("IN"),
  75. "2001:db8::134"))
  76. self.bogus_section = Message.SECTION_ADDITIONAL + 1
  77. self.bogus_below_section = Message.SECTION_QUESTION - 1
  78. self.tsig_key = TSIGKey("www.example.com:SFuWd/q99SzF8Yzd1QbB9g==")
  79. self.tsig_ctx = TSIGContext(self.tsig_key)
  80. def test_init(self):
  81. self.assertRaises(TypeError, Message, -1)
  82. self.assertRaises(TypeError, Message, 3)
  83. self.assertRaises(TypeError, Message, "wrong")
  84. def test_header_flag(self): # set and get methods
  85. self.assertRaises(TypeError, self.p.get_header_flag, "wrong")
  86. self.assertRaises(TypeError, self.r.set_header_flag, "wrong")
  87. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_QR))
  88. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AA))
  89. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_TC))
  90. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_RD))
  91. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_RA))
  92. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AD))
  93. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_CD))
  94. self.r.set_header_flag(Message.HEADERFLAG_QR)
  95. self.assertTrue(self.r.get_header_flag(Message.HEADERFLAG_QR))
  96. self.r.set_header_flag(Message.HEADERFLAG_AA, True)
  97. self.assertTrue(self.r.get_header_flag(Message.HEADERFLAG_AA))
  98. self.r.set_header_flag(Message.HEADERFLAG_AA, False)
  99. self.assertFalse(self.r.get_header_flag(Message.HEADERFLAG_AA))
  100. self.assertRaises(InvalidParameter, self.r.set_header_flag, 0)
  101. self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x7000)
  102. self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x0800)
  103. self.assertRaises(InvalidMessageOperation,
  104. self.p.set_header_flag, Message.HEADERFLAG_AA)
  105. # Range check. We need to do this at the binding level, so we need
  106. # explicit tests for it.
  107. self.assertRaises(ValueError, self.r.set_header_flag, 0x10000)
  108. self.assertRaises(ValueError, self.r.set_header_flag, -1)
  109. def test_set_qid(self):
  110. self.assertRaises(TypeError, self.r.set_qid, "wrong")
  111. self.assertRaises(InvalidMessageOperation,
  112. self.p.set_qid, 123)
  113. self.r.set_qid(1234)
  114. self.assertEqual(1234, self.r.get_qid())
  115. # Range check. We need to do this at the binding level, so we need
  116. # explicit tests for it.
  117. self.r.set_qid(0)
  118. self.assertEqual(0, self.r.get_qid())
  119. self.r.set_qid(0xffff)
  120. self.assertEqual(0xffff, self.r.get_qid())
  121. self.assertRaises(ValueError, self.r.set_qid, -1)
  122. self.assertRaises(ValueError, self.r.set_qid, 0x10000)
  123. def test_set_rcode(self):
  124. self.assertRaises(TypeError, self.r.set_rcode, "wrong")
  125. rcode = Rcode.BADVERS()
  126. self.r.set_rcode(rcode)
  127. self.assertEqual(rcode, self.r.get_rcode())
  128. self.assertRaises(InvalidMessageOperation,
  129. self.p.set_rcode, rcode)
  130. self.assertRaises(InvalidMessageOperation, self.p.get_rcode)
  131. def test_set_opcode(self):
  132. self.assertRaises(TypeError, self.r.set_opcode, "wrong")
  133. opcode = Opcode.IQUERY()
  134. self.r.set_opcode(opcode)
  135. self.assertEqual(opcode, self.r.get_opcode())
  136. self.assertRaises(InvalidMessageOperation,
  137. self.p.set_opcode, opcode)
  138. self.assertRaises(InvalidMessageOperation, self.p.get_opcode)
  139. def test_get_edns(self):
  140. self.assertEqual(None, self.p.get_edns())
  141. message_parse = Message(Message.PARSE)
  142. factoryFromFile(message_parse, "message_fromWire10.wire")
  143. edns = message_parse.get_edns()
  144. self.assertEqual(0, edns.get_version())
  145. self.assertEqual(4096, edns.get_udp_size())
  146. self.assertTrue(edns.get_dnssec_awareness())
  147. def test_set_edns(self):
  148. self.assertRaises(InvalidMessageOperation, self.p.set_edns, EDNS())
  149. edns = EDNS()
  150. edns.set_udp_size(1024)
  151. self.r.set_edns(edns)
  152. self.assertEqual(1024, self.r.get_edns().get_udp_size())
  153. def test_get_rr_count(self):
  154. # counts also tested in add_section
  155. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_QUESTION))
  156. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ANSWER))
  157. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_AUTHORITY))
  158. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
  159. self.r.add_question(Question(Name("example.com"), RRClass("IN"),
  160. RRType("A")))
  161. self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
  162. self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
  163. self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
  164. factoryFromFile(self.p, "message_fromWire11.wire")
  165. self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
  166. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
  167. self.assertRaises(OverflowError, self.r.get_rr_count,
  168. self.bogus_section)
  169. self.assertRaises(TypeError, self.r.get_rr_count, "wrong")
  170. def test_get_section(self):
  171. self.assertRaises(TypeError, self.r.get_section, "wrong")
  172. section_rrset = [self.rrset_a]
  173. self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
  174. Message.SECTION_ANSWER, self.rrset_a)
  175. self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ANSWER)))
  176. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ANSWER))
  177. self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
  178. self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ANSWER)))
  179. self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
  180. self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_AUTHORITY)))
  181. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_AUTHORITY))
  182. self.r.add_rrset(Message.SECTION_AUTHORITY, self.rrset_a)
  183. self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_AUTHORITY)))
  184. self.assertEqual(2, self.r.get_rr_count(Message.SECTION_AUTHORITY))
  185. self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ADDITIONAL)))
  186. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
  187. self.r.add_rrset(Message.SECTION_ADDITIONAL, self.rrset_a)
  188. self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ADDITIONAL)))
  189. self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ADDITIONAL))
  190. def test_add_question(self):
  191. self.assertRaises(TypeError, self.r.add_question, "wrong", "wrong")
  192. q = Question(Name("example.com"), RRClass("IN"), RRType("A"))
  193. qs = [q]
  194. self.assertFalse(compare_rrset_list(qs, self.r.get_question()))
  195. self.assertEqual(0, self.r.get_rr_count(Message.SECTION_QUESTION))
  196. self.r.add_question(q)
  197. self.assertTrue(compare_rrset_list(qs, self.r.get_question()))
  198. self.assertEqual(1, self.r.get_rr_count(Message.SECTION_QUESTION))
  199. def test_add_rrset(self):
  200. self.assertRaises(TypeError, self.r.add_rrset, "wrong")
  201. self.assertRaises(TypeError, self.r.add_rrset)
  202. # we can currently only test the no-sign case.
  203. self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)
  204. self.assertEqual(2, self.r.get_rr_count(Message.SECTION_ANSWER))
  205. def test_bad_add_rrset(self):
  206. self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
  207. Message.SECTION_ANSWER, self.rrset_a)
  208. self.assertRaises(OverflowError, self.r.add_rrset,
  209. self.bogus_section, self.rrset_a)
  210. self.assertRaises(OverflowError, self.r.add_rrset,
  211. self.bogus_below_section, self.rrset_a)
  212. def test_clear(self):
  213. self.assertEqual(None, self.r.clear(Message.PARSE))
  214. self.assertEqual(None, self.r.clear(Message.RENDER))
  215. self.assertRaises(TypeError, self.r.clear, "wrong")
  216. self.assertRaises(TypeError, self.r.clear, 3)
  217. def test_to_wire(self):
  218. self.assertRaises(TypeError, self.r.to_wire, 1)
  219. self.assertRaises(InvalidMessageOperation,
  220. self.p.to_wire, MessageRenderer())
  221. message_render = create_message()
  222. renderer = MessageRenderer()
  223. message_render.to_wire(renderer)
  224. self.assertEqual(b'\x105\x85\x00\x00\x01\x00\x02\x00\x00\x00\x00\x04test\x07example\x03com\x00\x00\x01\x00\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x02',
  225. renderer.get_data())
  226. def test_to_wire_without_opcode(self):
  227. self.r.set_rcode(Rcode.NOERROR())
  228. self.assertRaises(InvalidMessageOperation, self.r.to_wire,
  229. MessageRenderer())
  230. def test_to_wire_without_rcode(self):
  231. self.r.set_opcode(Opcode.QUERY())
  232. self.assertRaises(InvalidMessageOperation, self.r.to_wire,
  233. MessageRenderer())
  234. def __common_tsigquery_setup(self):
  235. self.r.set_opcode(Opcode.QUERY())
  236. self.r.set_rcode(Rcode.NOERROR())
  237. self.r.set_header_flag(Message.HEADERFLAG_RD)
  238. self.r.add_question(Question(Name("www.example.com"),
  239. RRClass("IN"), RRType("A")))
  240. def __common_tsig_checks(self, expected_file):
  241. renderer = MessageRenderer()
  242. self.r.to_wire(renderer, self.tsig_ctx)
  243. actual_wire = strip_mutable_tsig_data(renderer.get_data())
  244. expected_wire = strip_mutable_tsig_data(read_wire_data(expected_file))
  245. self.assertEqual(expected_wire, actual_wire)
  246. def test_to_wire_with_tsig(self):
  247. self.r.set_qid(0x2d65)
  248. self.__common_tsigquery_setup()
  249. self.__common_tsig_checks("message_toWire2.wire")
  250. def test_to_wire_with_edns_tsig(self):
  251. self.r.set_qid(0x6cd)
  252. self.__common_tsigquery_setup()
  253. edns = EDNS()
  254. edns.set_udp_size(4096)
  255. self.r.set_edns(edns)
  256. self.__common_tsig_checks("message_toWire3.wire")
  257. def test_to_text(self):
  258. message_render = create_message()
  259. msg_str =\
  260. """;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 4149
  261. ;; flags: qr aa rd; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
  262. ;; QUESTION SECTION:
  263. ;test.example.com. IN A
  264. ;; ANSWER SECTION:
  265. test.example.com. 3600 IN A 192.0.2.1
  266. test.example.com. 3600 IN A 192.0.2.2
  267. """
  268. self.assertEqual(msg_str, message_render.to_text())
  269. self.assertEqual(msg_str, str(message_render))
  270. def test_to_text_without_opcode(self):
  271. self.r.set_rcode(Rcode.NOERROR())
  272. self.assertRaises(InvalidMessageOperation, self.r.to_text)
  273. def test_to_text_without_rcode(self):
  274. self.r.set_opcode(Opcode.QUERY())
  275. self.assertRaises(InvalidMessageOperation, self.r.to_text)
  276. def test_from_wire(self):
  277. self.assertRaises(TypeError, self.r.from_wire, 1)
  278. self.assertRaises(InvalidMessageOperation,
  279. Message.from_wire, self.r, bytes())
  280. self.assertRaises(MessageTooShort,
  281. Message.from_wire, self.p, bytes())
  282. test_name = Name("test.example.com");
  283. message_parse = Message(0)
  284. factoryFromFile(message_parse, "message_fromWire1")
  285. self.assertEqual(0x1035, message_parse.get_qid())
  286. self.assertEqual(Opcode.QUERY(), message_parse.get_opcode())
  287. self.assertEqual(Rcode.NOERROR(), message_parse.get_rcode())
  288. self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_QR))
  289. self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_RD))
  290. self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_AA))
  291. #QuestionPtr q = *message_parse.beginQuestion()
  292. q = message_parse.get_question()[0]
  293. self.assertEqual(test_name, q.get_name())
  294. self.assertEqual(RRType("A"), q.get_type())
  295. self.assertEqual(RRClass("IN"), q.get_class())
  296. self.assertEqual(1, message_parse.get_rr_count(Message.SECTION_QUESTION))
  297. self.assertEqual(2, message_parse.get_rr_count(Message.SECTION_ANSWER))
  298. self.assertEqual(0, message_parse.get_rr_count(Message.SECTION_AUTHORITY))
  299. self.assertEqual(0, message_parse.get_rr_count(Message.SECTION_ADDITIONAL))
  300. #RRsetPtr rrset = *message_parse.beginSection(Message.SECTION_ANSWER)
  301. rrset = message_parse.get_section(Message.SECTION_ANSWER)[0]
  302. self.assertEqual(test_name, rrset.get_name())
  303. self.assertEqual(RRType("A"), rrset.get_type())
  304. self.assertEqual(RRClass("IN"), rrset.get_class())
  305. ## TTL should be 3600, even though that of the 2nd RR is 7200
  306. self.assertEqual(RRTTL(3600), rrset.get_ttl())
  307. rdata = rrset.get_rdata();
  308. self.assertEqual("192.0.2.1", rdata[0].to_text())
  309. self.assertEqual("192.0.2.2", rdata[1].to_text())
  310. self.assertEqual(2, len(rdata))
  311. def test_EDNS0ExtCode(self):
  312. # Extended Rcode = BADVERS
  313. message_parse = Message(Message.PARSE)
  314. factoryFromFile(message_parse, "message_fromWire10.wire")
  315. self.assertEqual(Rcode.BADVERS(), message_parse.get_rcode())
  316. # Maximum extended Rcode
  317. message_parse.clear(Message.PARSE)
  318. factoryFromFile(message_parse, "message_fromWire11.wire")
  319. self.assertEqual(0xfff, message_parse.get_rcode().get_code())
  320. def test_BadEDNS0(self):
  321. message_parse = Message(Message.PARSE)
  322. # OPT RR in the answer section
  323. self.assertRaises(DNSMessageFORMERR,
  324. factoryFromFile,
  325. message_parse,
  326. "message_fromWire4")
  327. # multiple OPT RRs (in the additional section)
  328. message_parse.clear(Message.PARSE)
  329. self.assertRaises(DNSMessageFORMERR,
  330. factoryFromFile,
  331. message_parse,
  332. "message_fromWire5")
  333. ## OPT RR of a non root name
  334. message_parse.clear(Message.PARSE)
  335. self.assertRaises(DNSMessageFORMERR,
  336. factoryFromFile,
  337. message_parse,
  338. "message_fromWire6")
  339. # Compressed owner name of OPT RR points to a root name.
  340. # Not necessarily bogus, but very unusual and mostly pathological.
  341. # We accept it, but is it okay?
  342. message_parse.clear(Message.PARSE)
  343. factoryFromFile(message_parse, "message_fromWire7")
  344. # Unsupported Version
  345. message_parse.clear(Message.PARSE)
  346. self.assertRaises(DNSMessageBADVERS,
  347. factoryFromFile,
  348. message_parse,
  349. "message_fromWire9")
  350. def test_from_wire_with_tsig(self):
  351. # Initially there should be no TSIG
  352. self.assertEqual(None, self.p.get_tsig_record())
  353. # getTSIGRecord() is only valid in the parse mode.
  354. self.assertRaises(InvalidMessageOperation, self.r.get_tsig_record)
  355. factoryFromFile(self.p, "message_toWire2.wire")
  356. tsig_rr = self.p.get_tsig_record()
  357. self.assertEqual(Name("www.example.com"), tsig_rr.get_name())
  358. self.assertEqual(85, tsig_rr.get_length())
  359. self.assertEqual(TSIGKey.HMACMD5_NAME,
  360. tsig_rr.get_rdata().get_algorithm())
  361. # If we clear the message for reuse, the recorded TSIG will be cleared.
  362. self.p.clear(Message.PARSE)
  363. self.assertEqual(None, self.p.get_tsig_record())
  364. def test_from_wire_with_tsigcompressed(self):
  365. # Mostly same as fromWireWithTSIG, but the TSIG owner name is
  366. # compressed.
  367. factoryFromFile(self.p, "message_fromWire12.wire");
  368. tsig_rr = self.p.get_tsig_record()
  369. self.assertEqual(Name("www.example.com"), tsig_rr.get_name())
  370. # len(www.example.com) = 17, but when fully compressed, the length is
  371. # 2 bytes. So the length of the record should be 15 bytes shorter.
  372. self.assertEqual(70, tsig_rr.get_length())
  373. def test_from_wire_with_badtsig(self):
  374. # Multiple TSIG RRs
  375. self.assertRaises(DNSMessageFORMERR, factoryFromFile,
  376. self.p, "message_fromWire13.wire")
  377. self.p.clear(Message.PARSE)
  378. # TSIG in the answer section (must be in additional)
  379. self.assertRaises(DNSMessageFORMERR, factoryFromFile,
  380. self.p, "message_fromWire14.wire")
  381. self.p.clear(Message.PARSE)
  382. # TSIG is not the last record.
  383. self.assertRaises(DNSMessageFORMERR, factoryFromFile,
  384. self.p, "message_fromWire15.wire")
  385. self.p.clear(Message.PARSE)
  386. # Unexpected RR Class (this will fail in constructing TSIGRecord)
  387. self.assertRaises(DNSMessageFORMERR, factoryFromFile,
  388. self.p, "message_fromWire16.wire")
  389. if __name__ == '__main__':
  390. unittest.main()