← Back to branch summary

~ubuntu-branches/ubuntu/natty/python3.1/natty-security

« back to all changes in this revision

Viewing changes to Modules/testcapi_long.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2010-07-06 16:52:42 UTC
  • mfrom: (1.2.1 upstream) (2.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20100706165242-2xv4i019r3et6c0j
Tags: 3.1.2+20100706-1ubuntu1
* Merge with Debian; remaining changes:
  - Regenerate the control file.
  - Add debian/patches/overwrite-semaphore-check for Lucid buildds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/testcapi_long.h
1
1
/* Poor-man's template.  Macros used:
2
 
   TESTNAME     name of the test (like test_long_api_inner)
3
 
   TYPENAME     the signed type (like long)
4
 
   F_S_TO_PY    convert signed to pylong; TYPENAME -> PyObject*
5
 
   F_PY_TO_S    convert pylong to signed; PyObject* -> TYPENAME
6
 
   F_U_TO_PY    convert unsigned to pylong; unsigned TYPENAME -> PyObject*
 
2
   TESTNAME     name of the test (like test_long_api_inner)
 
3
   TYPENAME     the signed type (like long)
 
4
   F_S_TO_PY    convert signed to pylong; TYPENAME -> PyObject*
 
5
   F_PY_TO_S    convert pylong to signed; PyObject* -> TYPENAME
 
6
   F_U_TO_PY    convert unsigned to pylong; unsigned TYPENAME -> PyObject*
7
7
   F_PY_TO_U    convert pylong to unsigned; PyObject* -> unsigned TYPENAME
8
8
*/
9
9
 
10
10
static PyObject *
11
11
TESTNAME(PyObject *error(const char*))
12
12
{
13
 
        const int NBITS = sizeof(TYPENAME) * 8;
14
 
        unsigned TYPENAME base;
15
 
        PyObject *pyresult;
16
 
        int i;
17
 
 
18
 
        /* Note:  This test lets PyObjects leak if an error is raised.  Since
19
 
           an error should never be raised, leaks are impossible <wink>. */
20
 
 
21
 
        /* Test native -> PyLong -> native roundtrip identity.
22
 
         * Generate all powers of 2, and test them and their negations,
23
 
         * plus the numbers +-1 off from them.
24
 
         */
25
 
        base = 1;
26
 
        for (i = 0;
27
 
             i < NBITS + 1;  /* on last, base overflows to 0 */
28
 
             ++i, base <<= 1)
29
 
        {
30
 
                int j;
31
 
                for (j = 0; j < 6; ++j) {
32
 
                        TYPENAME in, out;
33
 
                        unsigned TYPENAME uin, uout;
34
 
 
35
 
                        /* For 0, 1, 2 use base; for 3, 4, 5 use -base */
36
 
                        uin = j < 3 ? base
37
 
                                    : (unsigned TYPENAME)(-(TYPENAME)base);
38
 
 
39
 
                        /* For 0 & 3, subtract 1.
40
 
                         * For 1 & 4, leave alone.
41
 
                         * For 2 & 5, add 1.
42
 
                         */
43
 
                        uin += (unsigned TYPENAME)(TYPENAME)(j % 3 - 1);
44
 
 
45
 
                        pyresult = F_U_TO_PY(uin);
46
 
                        if (pyresult == NULL)
47
 
                                return error(
48
 
                                 "unsigned unexpected null result");
49
 
 
50
 
                        uout = F_PY_TO_U(pyresult);
51
 
                        if (uout == (unsigned TYPENAME)-1 && PyErr_Occurred())
52
 
                                return error(
53
 
                                        "unsigned unexpected -1 result");
54
 
                        if (uout != uin)
55
 
                                return error(
56
 
                                        "unsigned output != input");
57
 
                        UNBIND(pyresult);
58
 
 
59
 
                        in = (TYPENAME)uin;
60
 
                        pyresult = F_S_TO_PY(in);
61
 
                        if (pyresult == NULL)
62
 
                                return error(
63
 
                                        "signed unexpected null result");
64
 
 
65
 
                        out = F_PY_TO_S(pyresult);
66
 
                        if (out == (TYPENAME)-1 && PyErr_Occurred())
67
 
                                return error(
68
 
                                        "signed unexpected -1 result");
69
 
                        if (out != in)
70
 
                                return error(
71
 
                                        "signed output != input");
72
 
                        UNBIND(pyresult);
73
 
                }
74
 
        }
75
 
 
76
 
        /* Overflow tests.  The loop above ensured that all limit cases that
77
 
         * should not overflow don't overflow, so all we need to do here is
78
 
         * provoke one-over-the-limit cases (not exhaustive, but sharp).
79
 
         */
80
 
        {
81
 
                PyObject *one, *x, *y;
82
 
                TYPENAME out;
83
 
                unsigned TYPENAME uout;
84
 
 
85
 
                one = PyLong_FromLong(1);
86
 
                if (one == NULL)
87
 
                        return error(
88
 
                                "unexpected NULL from PyLong_FromLong");
89
 
 
90
 
                /* Unsigned complains about -1? */
91
 
                x = PyNumber_Negative(one);
92
 
                if (x == NULL)
93
 
                        return error(
94
 
                                "unexpected NULL from PyNumber_Negative");
95
 
 
96
 
                uout = F_PY_TO_U(x);
97
 
                if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
98
 
                        return error(
99
 
                                "PyLong_AsUnsignedXXX(-1) didn't complain");
100
 
                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
101
 
                        return error(
102
 
                                "PyLong_AsUnsignedXXX(-1) raised "
103
 
                                "something other than OverflowError");
104
 
                PyErr_Clear();
105
 
                UNBIND(x);
106
 
 
107
 
                /* Unsigned complains about 2**NBITS? */
108
 
                y = PyLong_FromLong((long)NBITS);
109
 
                if (y == NULL)
110
 
                        return error(
111
 
                                "unexpected NULL from PyLong_FromLong");
112
 
 
113
 
                x = PyNumber_Lshift(one, y); /* 1L << NBITS, == 2**NBITS */
114
 
                UNBIND(y);
115
 
                if (x == NULL)
116
 
                        return error(
117
 
                                "unexpected NULL from PyNumber_Lshift");
118
 
 
119
 
                uout = F_PY_TO_U(x);
120
 
                if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
121
 
                        return error(
122
 
                                "PyLong_AsUnsignedXXX(2**NBITS) didn't "
123
 
                                "complain");
124
 
                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
125
 
                        return error(
126
 
                                "PyLong_AsUnsignedXXX(2**NBITS) raised "
127
 
                                "something other than OverflowError");
128
 
                PyErr_Clear();
129
 
 
130
 
                /* Signed complains about 2**(NBITS-1)?
131
 
                   x still has 2**NBITS. */
132
 
                y = PyNumber_Rshift(x, one); /* 2**(NBITS-1) */
133
 
                UNBIND(x);
134
 
                if (y == NULL)
135
 
                        return error(
136
 
                                "unexpected NULL from PyNumber_Rshift");
137
 
 
138
 
                out = F_PY_TO_S(y);
139
 
                if (out != (TYPENAME)-1 || !PyErr_Occurred())
140
 
                        return error(
141
 
                                "PyLong_AsXXX(2**(NBITS-1)) didn't "
142
 
                                "complain");
143
 
                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
144
 
                        return error(
145
 
                                "PyLong_AsXXX(2**(NBITS-1)) raised "
146
 
                                "something other than OverflowError");
147
 
                PyErr_Clear();
148
 
 
149
 
                /* Signed complains about -2**(NBITS-1)-1?;
150
 
                   y still has 2**(NBITS-1). */
151
 
                x = PyNumber_Negative(y);  /* -(2**(NBITS-1)) */
152
 
                UNBIND(y);
153
 
                if (x == NULL)
154
 
                        return error(
155
 
                                "unexpected NULL from PyNumber_Negative");
156
 
 
157
 
                y = PyNumber_Subtract(x, one); /* -(2**(NBITS-1))-1 */
158
 
                UNBIND(x);
159
 
                if (y == NULL)
160
 
                        return error(
161
 
                                "unexpected NULL from PyNumber_Subtract");
162
 
 
163
 
                out = F_PY_TO_S(y);
164
 
                if (out != (TYPENAME)-1 || !PyErr_Occurred())
165
 
                        return error(
166
 
                                "PyLong_AsXXX(-2**(NBITS-1)-1) didn't "
167
 
                                "complain");
168
 
                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
169
 
                        return error(
170
 
                                "PyLong_AsXXX(-2**(NBITS-1)-1) raised "
171
 
                                "something other than OverflowError");
172
 
                PyErr_Clear();
173
 
                UNBIND(y);
174
 
 
175
 
                Py_XDECREF(x);
176
 
                Py_XDECREF(y);
177
 
                Py_DECREF(one);
178
 
        }
179
 
 
180
 
        Py_INCREF(Py_None);
181
 
        return Py_None;
 
13
    const int NBITS = sizeof(TYPENAME) * 8;
 
14
    unsigned TYPENAME base;
 
15
    PyObject *pyresult;
 
16
    int i;
 
17
 
 
18
    /* Note:  This test lets PyObjects leak if an error is raised.  Since
 
19
       an error should never be raised, leaks are impossible <wink>. */
 
20
 
 
21
    /* Test native -> PyLong -> native roundtrip identity.
 
22
     * Generate all powers of 2, and test them and their negations,
 
23
     * plus the numbers +-1 off from them.
 
24
     */
 
25
    base = 1;
 
26
    for (i = 0;
 
27
         i < NBITS + 1;  /* on last, base overflows to 0 */
 
28
         ++i, base <<= 1)
 
29
    {
 
30
        int j;
 
31
        for (j = 0; j < 6; ++j) {
 
32
            TYPENAME in, out;
 
33
            unsigned TYPENAME uin, uout;
 
34
 
 
35
            /* For 0, 1, 2 use base; for 3, 4, 5 use -base */
 
36
            uin = j < 3 ? base
 
37
                        : (unsigned TYPENAME)(-(TYPENAME)base);
 
38
 
 
39
            /* For 0 & 3, subtract 1.
 
40
             * For 1 & 4, leave alone.
 
41
             * For 2 & 5, add 1.
 
42
             */
 
43
            uin += (unsigned TYPENAME)(TYPENAME)(j % 3 - 1);
 
44
 
 
45
            pyresult = F_U_TO_PY(uin);
 
46
            if (pyresult == NULL)
 
47
                return error(
 
48
                 "unsigned unexpected null result");
 
49
 
 
50
            uout = F_PY_TO_U(pyresult);
 
51
            if (uout == (unsigned TYPENAME)-1 && PyErr_Occurred())
 
52
                return error(
 
53
                    "unsigned unexpected -1 result");
 
54
            if (uout != uin)
 
55
                return error(
 
56
                    "unsigned output != input");
 
57
            UNBIND(pyresult);
 
58
 
 
59
            in = (TYPENAME)uin;
 
60
            pyresult = F_S_TO_PY(in);
 
61
            if (pyresult == NULL)
 
62
                return error(
 
63
                    "signed unexpected null result");
 
64
 
 
65
            out = F_PY_TO_S(pyresult);
 
66
            if (out == (TYPENAME)-1 && PyErr_Occurred())
 
67
                return error(
 
68
                    "signed unexpected -1 result");
 
69
            if (out != in)
 
70
                return error(
 
71
                    "signed output != input");
 
72
            UNBIND(pyresult);
 
73
        }
 
74
    }
 
75
 
 
76
    /* Overflow tests.  The loop above ensured that all limit cases that
 
77
     * should not overflow don't overflow, so all we need to do here is
 
78
     * provoke one-over-the-limit cases (not exhaustive, but sharp).
 
79
     */
 
80
    {
 
81
        PyObject *one, *x, *y;
 
82
        TYPENAME out;
 
83
        unsigned TYPENAME uout;
 
84
 
 
85
        one = PyLong_FromLong(1);
 
86
        if (one == NULL)
 
87
            return error(
 
88
                "unexpected NULL from PyLong_FromLong");
 
89
 
 
90
        /* Unsigned complains about -1? */
 
91
        x = PyNumber_Negative(one);
 
92
        if (x == NULL)
 
93
            return error(
 
94
                "unexpected NULL from PyNumber_Negative");
 
95
 
 
96
        uout = F_PY_TO_U(x);
 
97
        if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
 
98
            return error(
 
99
                "PyLong_AsUnsignedXXX(-1) didn't complain");
 
100
        if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 
101
            return error(
 
102
                "PyLong_AsUnsignedXXX(-1) raised "
 
103
                "something other than OverflowError");
 
104
        PyErr_Clear();
 
105
        UNBIND(x);
 
106
 
 
107
        /* Unsigned complains about 2**NBITS? */
 
108
        y = PyLong_FromLong((long)NBITS);
 
109
        if (y == NULL)
 
110
            return error(
 
111
                "unexpected NULL from PyLong_FromLong");
 
112
 
 
113
        x = PyNumber_Lshift(one, y); /* 1L << NBITS, == 2**NBITS */
 
114
        UNBIND(y);
 
115
        if (x == NULL)
 
116
            return error(
 
117
                "unexpected NULL from PyNumber_Lshift");
 
118
 
 
119
        uout = F_PY_TO_U(x);
 
120
        if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
 
121
            return error(
 
122
                "PyLong_AsUnsignedXXX(2**NBITS) didn't "
 
123
                "complain");
 
124
        if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 
125
            return error(
 
126
                "PyLong_AsUnsignedXXX(2**NBITS) raised "
 
127
                "something other than OverflowError");
 
128
        PyErr_Clear();
 
129
 
 
130
        /* Signed complains about 2**(NBITS-1)?
 
131
           x still has 2**NBITS. */
 
132
        y = PyNumber_Rshift(x, one); /* 2**(NBITS-1) */
 
133
        UNBIND(x);
 
134
        if (y == NULL)
 
135
            return error(
 
136
                "unexpected NULL from PyNumber_Rshift");
 
137
 
 
138
        out = F_PY_TO_S(y);
 
139
        if (out != (TYPENAME)-1 || !PyErr_Occurred())
 
140
            return error(
 
141
                "PyLong_AsXXX(2**(NBITS-1)) didn't "
 
142
                "complain");
 
143
        if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 
144
            return error(
 
145
                "PyLong_AsXXX(2**(NBITS-1)) raised "
 
146
                "something other than OverflowError");
 
147
        PyErr_Clear();
 
148
 
 
149
        /* Signed complains about -2**(NBITS-1)-1?;
 
150
           y still has 2**(NBITS-1). */
 
151
        x = PyNumber_Negative(y);  /* -(2**(NBITS-1)) */
 
152
        UNBIND(y);
 
153
        if (x == NULL)
 
154
            return error(
 
155
                "unexpected NULL from PyNumber_Negative");
 
156
 
 
157
        y = PyNumber_Subtract(x, one); /* -(2**(NBITS-1))-1 */
 
158
        UNBIND(x);
 
159
        if (y == NULL)
 
160
            return error(
 
161
                "unexpected NULL from PyNumber_Subtract");
 
162
 
 
163
        out = F_PY_TO_S(y);
 
164
        if (out != (TYPENAME)-1 || !PyErr_Occurred())
 
165
            return error(
 
166
                "PyLong_AsXXX(-2**(NBITS-1)-1) didn't "
 
167
                "complain");
 
168
        if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 
169
            return error(
 
170
                "PyLong_AsXXX(-2**(NBITS-1)-1) raised "
 
171
                "something other than OverflowError");
 
172
        PyErr_Clear();
 
173
        UNBIND(y);
 
174
 
 
175
        Py_XDECREF(x);
 
176
        Py_XDECREF(y);
 
177
        Py_DECREF(one);
 
178
    }
 
179
 
 
180
    Py_INCREF(Py_None);
 
181
    return Py_None;
182
182
}