[trac363] add more boundary test cases for python wrappers

src/lib/dns/python/messagerenderer_python.cc

@@ -185,7 +185,7 @@ MessageRenderer_setLengthLimit(s_MessageRenderer* self,
                         "No valid type in set_length_limit argument");
         return (NULL);
     }
-    if (lengthlimit < 0 || lengthlimit > 0xffff) {
+    if (lengthlimit < 0) {
         PyErr_SetString(PyExc_ValueError,
                         "MessageRenderer length limit out of range");
         return (NULL);

src/lib/dns/python/name_python.cc

@@ -532,7 +532,7 @@ Name_split(s_Name* self, PyObject* args) {
 // It is translated to a function that gets 3 arguments, an object,
 // an object to compare to, and an operator.
 //
-static PyObject* 
+static PyObject*
 Name_richcmp(s_Name* self, s_Name* other, int op) {
     bool c;
 

src/lib/dns/python/rrtype_python.cc

@@ -259,10 +259,10 @@ static PyObject*
 RRType_toWire(s_RRType* self, PyObject* args) {
     PyObject* bytes;
     s_MessageRenderer* mr;
-    
+
     if (PyArg_ParseTuple(args, "O", &bytes) && PySequence_Check(bytes)) {
         PyObject* bytes_o = bytes;
-        
+
         OutputBuffer buffer(2);
         self->rrtype->toWire(buffer);
         PyObject* n = PyBytes_FromStringAndSize(static_cast<const char*>(buffer.getData()), buffer.getLength());

src/lib/dns/python/tests/edns_python_test.py

@@ -62,15 +62,14 @@ class EDNSTest(unittest.TestCase):
         edns = EDNS()
         edns.set_udp_size(511)
         self.assertEqual(511, edns.get_udp_size())
-        edns.set_udp_size(0)
-        self.assertEqual(0, edns.get_udp_size())
-        edns.set_udp_size(65535)
-        self.assertEqual(65535, edns.get_udp_size())
-
         self.assertRaises(TypeError, edns.set_udp_size, "wrong")
 
         # Range check.  We need to do this at the binding level, so we need
         # explicit tests for it.
+        edns.set_udp_size(0)
+        self.assertEqual(0, edns.get_udp_size())
+        edns.set_udp_size(65535)
+        self.assertEqual(65535, edns.get_udp_size())
         self.assertRaises(ValueError, edns.set_udp_size, 0x10000)
         self.assertRaises(ValueError, edns.set_udp_size, -1)
 

src/lib/dns/python/tests/message_python_test.py

@@ -111,22 +111,28 @@ class MessageTest(unittest.TestCase):
         self.assertRaises(InvalidParameter, self.r.set_header_flag, 0)
         self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x7000)
         self.assertRaises(InvalidParameter, self.r.set_header_flag, 0x0800)
-        # this would cause out of range
-        self.assertRaises(ValueError, self.r.set_header_flag, 0x10000)
-        self.assertRaises(ValueError, self.r.set_header_flag, -1)
-
         self.assertRaises(InvalidMessageOperation,
                           self.p.set_header_flag, Message.HEADERFLAG_AA)
 
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.assertRaises(ValueError, self.r.set_header_flag, 0x10000)
+        self.assertRaises(ValueError, self.r.set_header_flag, -1)
+
     def test_set_qid(self):
         self.assertRaises(TypeError, self.r.set_qid, "wrong")
-        self.assertRaises(ValueError, self.r.set_qid, -1)
-        self.assertRaises(ValueError, self.r.set_qid, 0x10000)
         self.assertRaises(InvalidMessageOperation,
                           self.p.set_qid, 123)
-
         self.r.set_qid(1234)
         self.assertEqual(1234, self.r.get_qid())
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.r.set_qid(0)
+        self.assertEqual(0, self.r.get_qid())
+        self.r.set_qid(0xffff)
+        self.assertEqual(0xffff, self.r.get_qid())
+        self.assertRaises(ValueError, self.r.set_qid, -1)
+        self.assertRaises(ValueError, self.r.set_qid, 0x10000)
 
     def test_set_rcode(self):
         self.assertRaises(TypeError, self.r.set_rcode, "wrong")
@@ -137,7 +143,7 @@ class MessageTest(unittest.TestCase):
 
         self.assertRaises(InvalidMessageOperation,
                           self.p.set_rcode, rcode)
-        
+
         self.assertRaises(InvalidMessageOperation, self.p.get_rcode)
 
     def test_set_opcode(self):
@@ -199,7 +205,7 @@ class MessageTest(unittest.TestCase):
 
         self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
                           Message.SECTION_ANSWER, self.rrset_a)
-        
+
         self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Message.SECTION_ANSWER)))
         self.assertEqual(0, self.r.get_rr_count(Message.SECTION_ANSWER))
         self.r.add_rrset(Message.SECTION_ANSWER, self.rrset_a)

src/lib/dns/python/tests/messagerenderer_python_test.py

@@ -98,8 +98,11 @@ class MessageRendererTest(unittest.TestCase):
         renderer.set_length_limit(1024)
         self.assertEqual(1024, renderer.get_length_limit())
         self.assertRaises(TypeError, renderer.set_length_limit, "wrong")
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        renderer.set_length_limit(0)
+        self.assertEqual(0, renderer.get_length_limit())
         self.assertRaises(ValueError, renderer.set_length_limit, -1)
-        self.assertRaises(ValueError, renderer.set_length_limit, 0x10000)
 
     def test_messagerenderer_set_compress_mode(self):
         renderer = MessageRenderer()

src/lib/dns/python/tests/name_python_test.py

@@ -154,6 +154,14 @@ class NameTest(unittest.TestCase):
         self.assertEqual("completely.different.", s.to_text())
         self.assertRaises(TypeError, self.name1.split, "wrong", 1)
         self.assertRaises(TypeError, self.name1.split, 1, "wrong")
+
+        s = self.name1.split(0)
+        self.assertEqual("example.com.", s.to_text())
+        s = self.name1.split(1)
+        self.assertEqual("com.", s.to_text())
+
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
         self.assertRaises(IndexError, self.name1.split, 123, 1)
         self.assertRaises(IndexError, self.name1.split, 1, 123)
         self.assertRaises(IndexError, self.name1.split, 0x10000, 5)
@@ -161,13 +169,12 @@ class NameTest(unittest.TestCase):
         self.assertRaises(IndexError, self.name1.split, 0, -1)
         self.assertRaises(IndexError, self.name1.split, -1, 0x10000)
 
-        s = self.name1.split(1)
-        self.assertEqual("com.", s.to_text())
         s = self.name1.split(0)
         self.assertEqual("example.com.", s.to_text())
         self.assertRaises(IndexError, self.name1.split, 123)
         self.assertRaises(IndexError, self.name1.split, 0x10000)
         self.assertRaises(IndexError, self.name1.split, -123)
+        self.assertRaises(TypeError, self.name1.split, -1)
 
     def test_reverse(self):
         self.assertEqual("com.example.", self.name1.reverse().to_text())

src/lib/dns/python/tests/rcode_python_test.py

@@ -23,14 +23,8 @@ from pydnspp import *
 class RcodeTest(unittest.TestCase):
     def test_init(self):
         self.assertRaises(TypeError, Rcode, "wrong")
-        self.assertRaises(ValueError, Rcode, 65536)
-        self.assertRaises(ValueError, Rcode, 0x10, 0x100)
-        self.assertRaises(ValueError, Rcode, 0x100, 0x10)
-        self.assertEqual(Rcode(0).get_code(), 0)
-    
-        self.assertEqual(0, Rcode(0).get_code())
         self.assertEqual(0xfff, Rcode(0xfff).get_code()) # possible max code
-    
+
         # should fail on attempt of construction with an out of range code
         self.assertRaises(OverflowError, Rcode, 0x1000)
         self.assertRaises(OverflowError, Rcode, 0xffff)
@@ -40,7 +34,16 @@ class RcodeTest(unittest.TestCase):
         self.assertEqual(Rcode.BADVERS_CODE, Rcode(0, 1).get_code())
         self.assertEqual(0xfff, Rcode(0xf, 0xff).get_code())
         self.assertRaises(OverflowError, Rcode, 0x10, 0xff)
-        
+
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.assertEqual(Rcode(0).get_code(), 0)
+        self.assertEqual(Rcode(0, 0).get_code(), 0)
+        self.assertEqual(Rcode(0, 0).get_extended_code(), 0)
+        self.assertRaises(ValueError, Rcode, 65536)
+        self.assertRaises(ValueError, Rcode, 0x10, 0x100)
+        self.assertRaises(ValueError, Rcode, 0x100, 0x10)
+
     def test_constants(self):
         self.assertEqual(Rcode.NOERROR_CODE, Rcode(0).get_code())
         self.assertEqual(Rcode.FORMERR_CODE, Rcode(1).get_code())

src/lib/dns/python/tests/rrclass_python_test.py

@@ -32,13 +32,15 @@ class RRClassTest(unittest.TestCase):
         b = bytearray(1)
         b[0] = 123
         self.assertRaises(TypeError, RRClass, b)
-        self.assertRaises(ValueError, RRClass, 65536)
-        self.assertRaises(ValueError, RRClass, -12)
         self.assertEqual(self.c1, RRClass(1))
         b = bytearray()
         self.c1.to_wire(b)
         self.assertEqual(self.c1, RRClass(b))
-        
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.assertRaises(ValueError, RRClass, 65536)
+        self.assertRaises(TypeError, RRClass, -1)
+
     def test_rrclass_to_text(self):
         self.assertEqual("IN", self.c1.to_text())
         self.assertEqual("IN", str(self.c1))

src/lib/dns/python/tests/rrttl_python_test.py

@@ -33,14 +33,18 @@ class RRTTLTest(unittest.TestCase):
         b[0] = 123
         self.assertRaises(IncompleteRRTTL, RRTTL, b)
         self.assertRaises(InvalidRRTTL, RRTTL, "4294967296")
-        self.assertRaises(ValueError, RRTTL, -4)
-        self.assertRaises(ValueError, RRTTL, 4294967296)
         b = bytearray(4)
         b[0] = 0
         b[1] = 0
         b[2] = 0
         b[3] = 15
         self.assertEqual(15, RRTTL(b).get_value())
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.assertRaises(TypeError, RRTTL, -1)
+        self.assertRaises(ValueError, RRTTL, 4294967296)
+        self.assertEqual(0, RRTTL(0).get_value())
+        self.assertEqual(4294967295, RRTTL(4294967295).get_value())
 
     def test_rrttl_to_text(self):
         self.assertEqual("1", self.t1.to_text())

src/lib/dns/python/tests/rrtype_python_test.py

@@ -22,7 +22,7 @@ import os
 from pydnspp import *
 
 class TestModuleSpec(unittest.TestCase):
-    
+
     rrtype_1 = RRType(1)
     rrtype_0x80 = RRType(0x80);
     rrtype_0x800 = RRType(0x800);
@@ -32,24 +32,28 @@ class TestModuleSpec(unittest.TestCase):
 
 
     def test_init(self):
-        self.assertRaises(ValueError, RRType, 65537)
         b = bytearray(b'\x00\x01')
         self.assertEqual(RRType("A"), RRType(b))
         b = bytearray(b'\x01')
         self.assertRaises(IncompleteRRType, RRType, b)
         self.assertRaises(TypeError, RRType, Exception)
-    
+        # Range check.  We need to do this at the binding level, so we need
+        # explicit tests for it.
+        self.assertRaises(ValueError, RRType, 65536)
+        self.assertRaises(TypeError, RRType, -1)
+        self.assertEqual("TYPE65535", RRType(65535).to_text());
+        self.assertEqual("TYPE0", RRType(0).to_text());
+
     def test_init_from_text(self):
         self.assertEqual("A", RRType("A").to_text())
         self.assertEqual("NS", RRType("NS").to_text());
         self.assertEqual("NS", str(RRType("NS")));
-    
         self.assertEqual("TYPE65535", RRType("TYPE65535").to_text());
-    
+
         self.assertEqual(53, RRType("TYPE00053").get_code());
 
         self.assertRaises(InvalidRRType, RRType, "TYPE000053");
-    
+
         self.assertRaises(InvalidRRType, RRType, "TYPE");
         self.assertRaises(InvalidRRType, RRType, "TYPE-1");
         self.assertRaises(InvalidRRType, RRType, "TYPExxx");