[trac363] update excepiton type and data type

src/lib/dns/python/edns_python.cc

@@ -305,7 +305,7 @@ EDNS_setUDPSize(s_EDNS* self, PyObject* args) {
         return (NULL);
     }
     if (size < 0 || size > 0xffff) {
-        PyErr_SetString(PyExc_OverflowError,
+        PyErr_SetString(PyExc_ValueError,
                         "UDP size is not an unsigned 16-bit integer");
         return (NULL);
     }

src/lib/dns/python/message_python.cc

@@ -284,7 +284,7 @@ Message_setHeaderFlag(s_Message* self, PyObject* args) {
         return (NULL);
     }
     if (messageflag < 0 || messageflag > 0xffff) {
-        PyErr_SetString(PyExc_OverflowError, "Message header flag out of range");
+        PyErr_SetString(PyExc_ValueError, "Message header flag out of range");
         return (NULL);
     }
 
@@ -318,7 +318,7 @@ Message_setQid(s_Message* self, PyObject* args) {
         return (NULL);
     }
     if (id < 0 || id > 0xffff) {
-        PyErr_SetString(PyExc_OverflowError,
+        PyErr_SetString(PyExc_ValueError,
                         "Message id out of range");
         return (NULL);
     }

src/lib/dns/python/messagerenderer_python.cc

@@ -186,7 +186,7 @@ MessageRenderer_setLengthLimit(s_MessageRenderer* self,
         return (NULL);
     }
     if (lengthlimit < 0 || lengthlimit > 0xffff) {
-        PyErr_SetString(PyExc_OverflowError,
+        PyErr_SetString(PyExc_ValueError,
                         "MessageRenderer length limit out of range");
         return (NULL);
     }

src/lib/dns/python/name_python.cc

@@ -330,7 +330,8 @@ Name_init(s_Name* self, PyObject* args) {
                          PyObject_AsCharBuffer(bytes_obj, &bytes, &len) != -1) {
         try {
             if (position < 0) {
-                PyErr_SetString(PyExc_TypeError,
+                // Throw IndexError here since name index should be unsigned
+                PyErr_SetString(PyExc_IndexError,
                                 "Name index shouldn't be negative");
                 return (-1);
             }
@@ -372,9 +373,10 @@ Name_at(s_Name* self, PyObject* args) {
     if (!PyArg_ParseTuple(args, "i", &pos)) {
         return (NULL);
     }
-    if (pos < 0 || pos > 0xffff) {
-        PyErr_SetString(PyExc_OverflowError,
-                        "name index out of range");
+    if (pos < 0) {
+        // Throw IndexError here since name index should be unsigned
+        PyErr_SetString(PyExc_IndexError,
+                        "name index shouldn't be negative");
         return (NULL);
     }
 
@@ -416,10 +418,10 @@ static PyObject*
 Name_toWire(s_Name* self, PyObject* args) {
     PyObject* bytes;
     s_MessageRenderer* mr;
-    
+
     if (PyArg_ParseTuple(args, "O", &bytes) && PySequence_Check(bytes)) {
         PyObject* bytes_o = bytes;
-        
+
         OutputBuffer buffer(Name::MAX_WIRE);
         self->name->toWire(buffer);
         PyObject* name_bytes = PyBytes_FromStringAndSize(static_cast<const char*>(buffer.getData()), buffer.getLength());
@@ -474,9 +476,10 @@ Name_split(s_Name* self, PyObject* args) {
     s_Name* ret = NULL;
 
     if (PyArg_ParseTuple(args, "ii", &first, &n)) {
-        if (first < 0 || first > 0xffff || n < 0 || n > 0xffff) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "name index out of range");
+        if (first < 0 || n < 0) {
+            // Throw IndexError here since name index should be unsigned
+            PyErr_SetString(PyExc_IndexError,
+                            "name index shouldn't be negative");
             return (NULL);
         }
         ret = PyObject_New(s_Name, &name_type);
@@ -495,9 +498,10 @@ Name_split(s_Name* self, PyObject* args) {
         }
     } else if (PyArg_ParseTuple(args, "i", &n)) {
         PyErr_Clear();
-        if (n < 0 || n > 0xffff) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "name index out of range");
+        if (n < 0) {
+            // Throw IndexError here since name index should be unsigned
+            PyErr_SetString(PyExc_IndexError,
+                            "name index shouldn't be negative");
             return (NULL);
         }
         ret = PyObject_New(s_Name, &name_type);

src/lib/dns/python/rcode_python.cc

@@ -176,13 +176,13 @@ Rcode_init(s_Rcode* const self, PyObject* args) {
 
     if (PyArg_ParseTuple(args, "l", &code)) {
         if (code < 0 || code > 0xffff) {
-            PyErr_SetString(PyExc_OverflowError, "Rcode out of range");
+            PyErr_SetString(PyExc_ValueError, "Rcode out of range");
             return (-1);
         }
         ext_code = -1;
     } else if (PyArg_ParseTuple(args, "li", &code, &ext_code)) {
         if (code < 0 || code > 0xff || ext_code < 0 || ext_code > 0xff) {
-            PyErr_SetString(PyExc_OverflowError, "Rcode out of range");
+            PyErr_SetString(PyExc_ValueError, "Rcode out of range");
             return (-1);
         }
     } else {

src/lib/dns/python/rrclass_python.cc

@@ -168,7 +168,7 @@ RRClass_init(s_RRClass* self, PyObject* args) {
         } else if (PyArg_ParseTuple(args, "l", &i)) {
             if (i < 0 || i > 0xffff) {
                 PyErr_Clear();
-                PyErr_SetString(PyExc_OverflowError,
+                PyErr_SetString(PyExc_ValueError,
                                 "RR class number out of range");
                 return (-1);
             }

src/lib/dns/python/rrttl_python.cc

@@ -145,7 +145,7 @@ static PyTypeObject rrttl_type = {
 static int
 RRTTL_init(s_RRTTL* self, PyObject* args) {
     const char* s;
-    unsigned long i;
+    long long i;
     PyObject* bytes = NULL;
     // The constructor argument can be a string ("1234"), an integer (1),
     // or a sequence of numbers between 0 and 255 (wire code)
@@ -158,10 +158,10 @@ RRTTL_init(s_RRTTL* self, PyObject* args) {
         if (PyArg_ParseTuple(args, "s", &s)) {
             self->rrttl = new RRTTL(s);
             return (0);
-        } else if (PyArg_ParseTuple(args, "k", &i)) {
+        } else if (PyArg_ParseTuple(args, "L", &i)) {
             PyErr_Clear();
-            if (i > 0xffffffff) {
-                PyErr_SetString(po_InvalidRRTTL, "RR TTL number out of range");
+            if (i < 0 || i > 0xffffffff) {
+                PyErr_SetString(PyExc_ValueError, "RR TTL number out of range");
                 return (-1);
             }
             self->rrttl = new RRTTL(i);

src/lib/dns/python/rrtype_python.cc

@@ -198,7 +198,7 @@ RRType_init(s_RRType* self, PyObject* args) {
         } else if (PyArg_ParseTuple(args, "l", &i)) {
             PyErr_Clear();
             if (i < 0 || i > 0xffff) {
-                PyErr_SetString(PyExc_OverflowError, "RR Type number out of range");
+                PyErr_SetString(PyExc_ValueError, "RR Type number out of range");
                 return (-1);
             }
             self->rrtype = new RRType(i);

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

@@ -71,8 +71,8 @@ class EDNSTest(unittest.TestCase):
 
         # Range check.  We need to do this at the binding level, so we need
         # explicit tests for it.
-        self.assertRaises(OverflowError, edns.set_udp_size, 0x10000)
-        self.assertRaises(OverflowError, edns.set_udp_size, -1)
+        self.assertRaises(ValueError, edns.set_udp_size, 0x10000)
+        self.assertRaises(ValueError, edns.set_udp_size, -1)
 
     def test_get_version(self):
         self.assertEqual(EDNS.SUPPORTED_VERSION, EDNS().get_version())

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

@@ -111,17 +111,17 @@ 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 overflow
-        self.assertRaises(OverflowError, self.r.set_header_flag, 0x10000)
-        self.assertRaises(OverflowError, self.r.set_header_flag, -1)
+        # 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)
 
     def test_set_qid(self):
         self.assertRaises(TypeError, self.r.set_qid, "wrong")
-        self.assertRaises(OverflowError, self.r.set_qid, -1)
-        self.assertRaises(OverflowError, self.r.set_qid, 0x10000)
+        self.assertRaises(ValueError, self.r.set_qid, -1)
+        self.assertRaises(ValueError, self.r.set_qid, 0x10000)
         self.assertRaises(InvalidMessageOperation,
                           self.p.set_qid, 123)
 

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

@@ -98,8 +98,8 @@ class MessageRendererTest(unittest.TestCase):
         renderer.set_length_limit(1024)
         self.assertEqual(1024, renderer.get_length_limit())
         self.assertRaises(TypeError, renderer.set_length_limit, "wrong")
-        self.assertRaises(OverflowError, renderer.set_length_limit, -1)
-        self.assertRaises(OverflowError, renderer.set_length_limit, 0x10000)
+        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

@@ -95,15 +95,15 @@ class NameTest(unittest.TestCase):
         b = bytearray()
         b += b'\x07example'*32 + b'\x03com\x00'
         self.assertRaises(DNSMessageFORMERR, Name, b, 0)
-        self.assertRaises(TypeError, Name, b, -1)
+        self.assertRaises(IndexError, Name, b, -1)
 
     def test_at(self):
         self.assertEqual(7, self.name1.at(0))
         self.assertEqual(101, self.name1.at(1))
         self.assertRaises(IndexError, self.name1.at, 100)
+        self.assertRaises(IndexError, self.name1.at, 0x10000)
+        self.assertRaises(IndexError, self.name1.at, -1)
         self.assertRaises(TypeError, self.name1.at, "wrong")
-        self.assertRaises(OverflowError, self.name1.at, -1)
-        self.assertRaises(OverflowError, self.name1.at, 0x10000)
 
     def test_get_length(self):
         self.assertEqual(13, self.name1.get_length())
@@ -156,20 +156,18 @@ class NameTest(unittest.TestCase):
         self.assertRaises(TypeError, self.name1.split, 1, "wrong")
         self.assertRaises(IndexError, self.name1.split, 123, 1)
         self.assertRaises(IndexError, self.name1.split, 1, 123)
-        # Out of range
-        self.assertRaises(OverflowError, self.name1.split, -1, 123)
-        self.assertRaises(OverflowError, self.name1.split, 0, -1)
-        self.assertRaises(OverflowError, self.name1.split, 1, 0x10000)
-        self.assertRaises(OverflowError, self.name1.split, 0x10000, 5)
+        self.assertRaises(IndexError, self.name1.split, 0x10000, 5)
+        self.assertRaises(IndexError, self.name1.split, -1, -1)
+        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)
-        # Out of range
-        self.assertRaises(OverflowError, self.name1.split, 0x10000)
-        self.assertRaises(OverflowError, self.name1.split, -123)
+        self.assertRaises(IndexError, self.name1.split, 0x10000)
+        self.assertRaises(IndexError, self.name1.split, -123)
 
     def test_reverse(self):
         self.assertEqual("com.example.", self.name1.reverse().to_text())

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

@@ -23,7 +23,9 @@ from pydnspp import *
 class RcodeTest(unittest.TestCase):
     def test_init(self):
         self.assertRaises(TypeError, Rcode, "wrong")
-        self.assertRaises(OverflowError, Rcode, 65536)
+        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())

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

@@ -32,8 +32,8 @@ class RRClassTest(unittest.TestCase):
         b = bytearray(1)
         b[0] = 123
         self.assertRaises(TypeError, RRClass, b)
-        self.assertRaises(OverflowError, RRClass, 65536)
-        self.assertRaises(OverflowError, RRClass, -12)
+        self.assertRaises(ValueError, RRClass, 65536)
+        self.assertRaises(ValueError, RRClass, -12)
         self.assertEqual(self.c1, RRClass(1))
         b = bytearray()
         self.c1.to_wire(b)

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

@@ -25,7 +25,7 @@ class RRTTLTest(unittest.TestCase):
     def setUp(self):
         self.t1 = RRTTL(1)
         self.t2 = RRTTL(3600)
-        
+
     def test_init(self):
         self.assertRaises(InvalidRRTTL, RRTTL, "wrong")
         self.assertRaises(TypeError, RRTTL, Exception())
@@ -33,13 +33,15 @@ 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())
-        
+
     def test_rrttl_to_text(self):
         self.assertEqual("1", self.t1.to_text())
         self.assertEqual("1", str(self.t1))

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

@@ -32,7 +32,7 @@ class TestModuleSpec(unittest.TestCase):
 
 
     def test_init(self):
-        self.assertRaises(OverflowError, RRType, 65537)
+        self.assertRaises(ValueError, RRType, 65537)
         b = bytearray(b'\x00\x01')
         self.assertEqual(RRType("A"), RRType(b))
         b = bytearray(b'\x01')