1"""
2Some basic tests for converting values to and from Objective-C
3
4TODO: This only tests C values at the moment.
5"""
6from __future__ import absolute_import
7from PyObjCTools.TestSupport import *
8
9from .testbndl import pyObjCPy, carrayMaker
10from .testbndl import UCHAR_MAX
11from .testbndl import CHAR_MAX, CHAR_MIN
12from .testbndl import SCHAR_MAX, SCHAR_MIN
13from .testbndl import USHRT_MAX, SHRT_MAX, SHRT_MIN
14from .testbndl import UINT_MAX, INT_MAX, INT_MIN
15from .testbndl import ULONG_MAX, LONG_MAX, LONG_MIN
16from .testbndl import ULLONG_MAX, LLONG_MAX, LLONG_MIN
17from .testbndl import DBL_MAX, DBL_MIN, DBL_EPSILON
18from .testbndl import FLT_MAX, FLT_MIN, FLT_EPSILON
19import objc
20import array, sys
21
22
23
24class TestNumbers (TestCase):
25    """
26    Test of conversion of numbers, especially boundary cases
27    """
28
29    def test_unsigned_char(self):
30        self.assertEqual(0, pyObjCPy(objc._C_UCHR, 0))
31        self.assertEqual(0, pyObjCPy(objc._C_UCHR, b'\0'))
32
33        if sys.version_info[0] == 2:
34            self.assertEqual(0, pyObjCPy(objc._C_UCHR, long(0)))
35        self.assertEqual(0, pyObjCPy(objc._C_UCHR, float(0)))
36
37        self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, UCHAR_MAX))
38        if sys.version_info[0] == 2:
39            self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, chr(UCHAR_MAX)))
40        else:
41            self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, bytes([UCHAR_MAX])))
42            self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, bytearray([UCHAR_MAX])))
43
44        if sys.version_info[0] == 2:
45            self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, long(UCHAR_MAX)))
46        self.assertEqual(UCHAR_MAX, pyObjCPy(objc._C_UCHR, float(UCHAR_MAX)))
47
48        self.assertRaises((IndexError, ValueError), pyObjCPy, objc._C_UCHR, SCHAR_MIN)
49        self.assertRaises((IndexError, ValueError), pyObjCPy, objc._C_UCHR, SCHAR_MIN - 1)
50
51    def test_char(self):
52        self.assertEqual(0, pyObjCPy(objc._C_CHR, 0))
53        self.assertEqual(0, pyObjCPy(objc._C_CHR, b'\x00'))
54        if sys.version_info[0] == 2:
55            self.assertEqual(0, pyObjCPy(objc._C_CHR, long(0)))
56
57        self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, CHAR_MAX))
58        if sys.version_info[0] == 2:
59            self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, chr(CHAR_MAX)))
60        else:
61            self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, bytes([CHAR_MAX])))
62            self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, bytearray([CHAR_MAX])))
63        self.assertEqual(CHAR_MIN, pyObjCPy(objc._C_CHR, CHAR_MIN))
64        if sys.version_info[0] == 2:
65            self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, long(CHAR_MAX)))
66            self.assertEqual(CHAR_MIN, pyObjCPy(objc._C_CHR, long(CHAR_MIN)))
67        self.assertEqual(CHAR_MAX, pyObjCPy(objc._C_CHR, float(CHAR_MAX)))
68        self.assertEqual(CHAR_MIN, pyObjCPy(objc._C_CHR, float(CHAR_MIN)))
69
70        # XXX: Is this right, chr(-1) raises an exception, and is not
71        # equivalent to '\xff'. Should (char)-1 be converted to '\xff'/255 ?
72        self.assertEqual(-1, pyObjCPy(objc._C_CHR, b'\xff'))
73
74        self.assertRaises(ValueError, pyObjCPy, objc._C_CHR, CHAR_MAX + 1)
75        self.assertRaises(ValueError, pyObjCPy, objc._C_CHR, CHAR_MIN - 1)
76
77    def test_unsigned_short(self):
78        self.assertEqual(0, pyObjCPy(objc._C_USHT, 0))
79        self.assertEqual(USHRT_MAX, pyObjCPy(objc._C_USHT, USHRT_MAX))
80        if sys.version_info[0] == 2:
81            self.assertEqual(0, pyObjCPy(objc._C_USHT, long(0)))
82            self.assertEqual(USHRT_MAX, pyObjCPy(objc._C_USHT, long(USHRT_MAX)))
83        self.assertEqual(0, pyObjCPy(objc._C_USHT, float(0)))
84        self.assertEqual(USHRT_MAX, pyObjCPy(objc._C_USHT, float(USHRT_MAX)))
85
86        self.assertRaises(ValueError, pyObjCPy, objc._C_USHT, SHRT_MIN)
87        self.assertRaises(ValueError, pyObjCPy, objc._C_USHT, SHRT_MIN - 1)
88
89        self.assertRaises(ValueError, pyObjCPy, objc._C_USHT, "1")
90        self.assertRaises(ValueError, pyObjCPy, objc._C_USHT, b"1")
91
92    def test_short(self):
93        self.assertEqual(0, pyObjCPy(objc._C_SHT, 0))
94        self.assertEqual(SHRT_MAX, pyObjCPy(objc._C_SHT, SHRT_MAX))
95        self.assertEqual(SHRT_MIN, pyObjCPy(objc._C_SHT, SHRT_MIN))
96        if sys.version_info[0] == 2:
97            self.assertEqual(0, pyObjCPy(objc._C_SHT, long(0)))
98            self.assertEqual(SHRT_MAX, pyObjCPy(objc._C_SHT, long(SHRT_MAX)))
99            self.assertEqual(SHRT_MIN, pyObjCPy(objc._C_SHT, long(SHRT_MIN)))
100        self.assertEqual(0, pyObjCPy(objc._C_SHT, float(0)))
101        self.assertEqual(SHRT_MAX, pyObjCPy(objc._C_SHT, float(SHRT_MAX)))
102        self.assertEqual(SHRT_MIN, pyObjCPy(objc._C_SHT, float(SHRT_MIN)))
103
104        self.assertRaises(ValueError, pyObjCPy, objc._C_SHT, SHRT_MAX + 1)
105        self.assertRaises(ValueError, pyObjCPy, objc._C_SHT, SHRT_MIN - 1)
106
107        self.assertRaises(ValueError, pyObjCPy, objc._C_SHT, "1")
108        self.assertRaises(ValueError, pyObjCPy, objc._C_SHT, b"1")
109
110    def test_unsigned_int(self):
111        self.assertEqual(0, pyObjCPy(objc._C_UINT, 0))
112        self.assertEqual(UINT_MAX, pyObjCPy(objc._C_UINT, UINT_MAX))
113        if sys.version_info[0] == 2:
114            self.assertEqual(0, pyObjCPy(objc._C_UINT, long(0)))
115            self.assertEqual(UINT_MAX, pyObjCPy(objc._C_UINT, long(UINT_MAX)))
116        self.assertEqual(0, pyObjCPy(objc._C_UINT, float(0)))
117        self.assertEqual(UINT_MAX, pyObjCPy(objc._C_UINT, float(UINT_MAX)))
118
119        self.assertRaises(ValueError, pyObjCPy, objc._C_UINT, INT_MIN)
120        self.assertRaises(ValueError, pyObjCPy, objc._C_UINT, INT_MIN - 1)
121
122        self.assertRaises(ValueError, pyObjCPy, objc._C_UINT, "1")
123        self.assertRaises(ValueError, pyObjCPy, objc._C_UINT, b"1")
124
125    def test_int(self):
126        self.assertEqual(0, pyObjCPy(objc._C_INT, 0))
127        self.assertEqual(INT_MAX, pyObjCPy(objc._C_INT, INT_MAX))
128        self.assertEqual(INT_MIN, pyObjCPy(objc._C_INT, INT_MIN))
129        if sys.version_info[0] == 2:
130            self.assertEqual(0, pyObjCPy(objc._C_INT, long(0)))
131            self.assertEqual(INT_MAX, pyObjCPy(objc._C_INT, long(INT_MAX)))
132            self.assertEqual(INT_MIN, pyObjCPy(objc._C_INT, long(INT_MIN)))
133        self.assertEqual(0, pyObjCPy(objc._C_INT, float(0)))
134        self.assertEqual(INT_MAX, pyObjCPy(objc._C_INT, float(INT_MAX)))
135        self.assertEqual(INT_MIN, pyObjCPy(objc._C_INT, float(INT_MIN)))
136
137        self.assertRaises(ValueError, pyObjCPy, objc._C_INT, INT_MAX + 1)
138        self.assertRaises(ValueError, pyObjCPy, objc._C_INT, INT_MIN - 1)
139
140        # Check implicit conversion
141        self.assertRaises(ValueError, pyObjCPy, objc._C_INT, "1")
142        self.assertRaises(ValueError, pyObjCPy, objc._C_INT, b"1")
143
144    def test_unsigned_long(self):
145        self.assertEqual(0, pyObjCPy(objc._C_ULNG, 0))
146        self.assertEqual(ULONG_MAX, pyObjCPy(objc._C_ULNG, ULONG_MAX))
147        if sys.version_info[0] == 2:
148            self.assertEqual(0, pyObjCPy(objc._C_ULNG, long(0)))
149            self.assertEqual(ULONG_MAX, pyObjCPy(objc._C_ULNG, long(ULONG_MAX)))
150        self.assertEqual(0, pyObjCPy(objc._C_ULNG, float(0)))
151
152        if sys.maxsize < 2 ** 32:
153            self.assertEqual(ULONG_MAX, pyObjCPy(objc._C_ULNG, float(ULONG_MAX)))
154            self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG, LONG_MIN)
155            self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG, LONG_MIN - 1)
156
157        self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG, "1")
158        self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG, b"1")
159
160    def test_long(self):
161        self.assertEqual(0, pyObjCPy(objc._C_LNG, 0))
162        self.assertEqual(LONG_MAX, pyObjCPy(objc._C_LNG, LONG_MAX))
163        self.assertEqual(LONG_MIN, pyObjCPy(objc._C_LNG, LONG_MIN))
164        if sys.version_info[0] == 2:
165            self.assertEqual(0, pyObjCPy(objc._C_LNG, long(0)))
166            self.assertEqual(LONG_MAX, pyObjCPy(objc._C_LNG, long(LONG_MAX)))
167            self.assertEqual(LONG_MIN, pyObjCPy(objc._C_LNG, long(LONG_MIN)))
168        self.assertEqual(0, pyObjCPy(objc._C_LNG, float(0)))
169        if sys.maxsize < 2 ** 32:
170            self.assertEqual(LONG_MAX, pyObjCPy(objc._C_LNG, float(LONG_MAX)))
171            self.assertEqual(LONG_MIN, pyObjCPy(objc._C_LNG, float(LONG_MIN)))
172
173        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG, LONG_MAX + 1)
174        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG, LONG_MIN - 1)
175
176        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG, "1")
177        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG, b"1")
178
179    def test_unsigned_long_long(self):
180        self.assertEqual(0, pyObjCPy(objc._C_ULNG_LNG, 0))
181        self.assertEqual(ULLONG_MAX, pyObjCPy(objc._C_ULNG_LNG, ULLONG_MAX))
182        if sys.version_info[0] == 2:
183            self.assertEqual(0, pyObjCPy(objc._C_ULNG_LNG, long(0)))
184            self.assertEqual(ULLONG_MAX, pyObjCPy(objc._C_ULNG_LNG, long(ULLONG_MAX)))
185        self.assertEqual(0, pyObjCPy(objc._C_ULNG_LNG, float(0)))
186
187        with filterWarnings('error', DeprecationWarning):
188            try:
189                pyObjCPy(objc._C_ULNG_LNG, LLONG_MIN+100)
190            except DeprecationWarning:
191                pass
192
193            else:
194                self.fail("No deprecation warning")
195
196        with filterWarnings('ignore', DeprecationWarning):
197            self.assertEqual(-LLONG_MIN+100, pyObjCPy(objc._C_ULNG_LNG, LLONG_MIN+100))
198
199        #self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG_LNG, LLONG_MIN)
200        self.assertRaises((ValueError, IndexError), pyObjCPy, objc._C_ULNG_LNG, LLONG_MIN - 1)
201
202        self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG_LNG, "1")
203        self.assertRaises(ValueError, pyObjCPy, objc._C_ULNG_LNG, b"1")
204
205    def test_long_long(self):
206        self.assertEqual(0, pyObjCPy(objc._C_LNG_LNG, 0))
207
208        if sys.maxsize < 2 ** 32:
209            self.assertEqual(LONG_MAX, pyObjCPy(objc._C_LNG_LNG, float(LONG_MAX)))
210        self.assertEqual(LLONG_MAX, pyObjCPy(objc._C_LNG_LNG, LLONG_MAX))
211        self.assertEqual(LLONG_MIN, pyObjCPy(objc._C_LNG_LNG, LLONG_MIN))
212
213        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG_LNG, LLONG_MAX + 1)
214        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG_LNG, LLONG_MIN - 1)
215
216        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG_LNG, "1")
217        self.assertRaises(ValueError, pyObjCPy, objc._C_LNG_LNG, b"1")
218
219    def test_double(self):
220        self.assertEqual(0, pyObjCPy(objc._C_DBL, 0))
221        self.assertEqual(float(INT_MAX), pyObjCPy(objc._C_DBL, INT_MAX))
222        self.assertEqual(DBL_MAX, pyObjCPy(objc._C_DBL, DBL_MAX))
223        self.assertEqual(DBL_MIN, pyObjCPy(objc._C_DBL, DBL_MIN))
224        self.assertEqual(-DBL_MAX, pyObjCPy(objc._C_DBL, -DBL_MAX))
225        self.assertEqual(-DBL_MIN, pyObjCPy(objc._C_DBL, -DBL_MIN))
226        self.assertEqual(DBL_EPSILON, pyObjCPy(objc._C_DBL, DBL_EPSILON))
227        self.assertEqual(-DBL_EPSILON, pyObjCPy(objc._C_DBL, -DBL_EPSILON))
228
229        self.assertRaises((OverflowError, ValueError), pyObjCPy, objc._C_DBL, 1 << 10000)
230
231        self.assertRaises(ValueError, pyObjCPy, objc._C_DBL, "1")
232        self.assertRaises(ValueError, pyObjCPy, objc._C_DBL, b"1")
233
234    def test_float(self):
235        self.assertEqual(0, pyObjCPy(objc._C_FLT, 0))
236        self.assertEqual(float(SHRT_MAX), pyObjCPy(objc._C_FLT, SHRT_MAX))
237        self.assertEqual(FLT_MAX, pyObjCPy(objc._C_FLT, FLT_MAX))
238        self.assertEqual(FLT_MIN, pyObjCPy(objc._C_FLT, FLT_MIN))
239        self.assertEqual(-FLT_MAX, pyObjCPy(objc._C_FLT, -FLT_MAX))
240        self.assertEqual(-FLT_MIN, pyObjCPy(objc._C_FLT, -FLT_MIN))
241        self.assertEqual(FLT_EPSILON, pyObjCPy(objc._C_FLT, FLT_EPSILON))
242        self.assertEqual(-FLT_EPSILON, pyObjCPy(objc._C_FLT, -FLT_EPSILON))
243
244        # Just in cause we do something stupid and convert to double instead
245        # of float
246        self.assertNotEqual(DBL_MAX, pyObjCPy(objc._C_FLT, DBL_MAX))
247
248        self.assertRaises((ValueError, OverflowError), pyObjCPy, objc._C_FLT, 1 << 10000)
249
250        self.assertRaises(ValueError, pyObjCPy, objc._C_FLT, "1")
251        self.assertRaises(ValueError, pyObjCPy, objc._C_FLT, b"1")
252
253
254class TestStruct (TestCase):
255    """
256    Structs are usually represented as tuples, but any sequence type is
257    accepted as input, as long as it has the right number of elements
258    """
259
260    def testSimple(self):
261        # struct Foo {
262        #    int;
263        #    int;
264        # };
265        signature = b"{Foo=ii}"
266
267        inval = (1, 2)
268
269        self.assertEqual(inval, pyObjCPy(signature, inval))
270        self.assertEqual(inval, pyObjCPy(signature, list(inval)))
271        self.assertEqual(inval, pyObjCPy(signature, iter(inval)))
272        self.assertEqual(inval, pyObjCPy(signature, iter(list(inval))))
273
274    def testHoles(self):
275        # This struct usually contains holes
276        #
277        # struct Foo {
278        #   short;
279        #   int;
280        #   short;
281        #   double;
282        #   short;
283        # };
284        signature = b"{Foo=sisds}"
285
286        inval = (1, 2, 3, 4.0, 5)
287
288        self.assertEqual(inval, pyObjCPy(signature, inval))
289        self.assertEqual(inval, pyObjCPy(signature, list(inval)))
290        self.assertEqual(inval, pyObjCPy(signature, iter(inval)))
291        self.assertEqual(inval, pyObjCPy(signature, iter(list(inval))))
292
293class TestArray (TestCase):
294    def test_simple(self):
295        signature = b"[10i]"
296        value = tuple(range(10))
297
298        self.assertEqual(value, tuple(pyObjCPy(signature, value)))
299        self.assertEqual(value, tuple(pyObjCPy(signature, list(value))))
300        self.assertEqual(value, tuple(pyObjCPy(signature, iter(value))))
301        self.assertEqual(value, tuple(pyObjCPy(signature, iter(list(value)))))
302
303        self.assertRaises(ValueError, pyObjCPy, signature, value + value[:1])
304        self.assertRaises(ValueError, pyObjCPy, signature, value[:9])
305        self.assertRaises(ValueError, pyObjCPy, signature, iter(value + value[:1]))
306        self.assertRaises(ValueError, pyObjCPy, signature, iter(value[:9]))
307        self.assertRaises(TypeError, pyObjCPy, signature, None)
308
309class TestCArray (TestCase):
310    # Tests for the PyObjC_PythonToCArray (C-)function, this function is
311    # used to build variable-length C Arrays from Python objects.
312
313    # TODO: "{_NSPoint=ff}", "{_NSRect={_NSPoint=ff}{_NSSize=ff}}"
314    #       "[4i]" "[4[4i]]" "[2{foo=ii}]" "{foo=[4i]}"
315    #       "{_Foo=fi}" (fail with array.array) + version with [{foo=if}]
316    #       - other simple types
317    def testShortTuple(self):
318        arr = (1,2,3,4,5)
319
320        res = carrayMaker(objc._C_SHT, arr, None)
321        self.assertEqual(res, arr)
322
323        res = carrayMaker(objc._C_SHT, arr, 2)
324        self.assertEqual(res, arr[:2])
325
326        self.assertRaises(ValueError, carrayMaker, objc._C_SHT, arr, 7)
327        self.assertRaises(ValueError, carrayMaker, objc._C_SHT, ["a", "b"], 1)
328
329    def testShortArray(self):
330        arr = array.array('h', [1,2,3,4,5])
331        arr2 = array.array('f', [1,2,3,4,5])
332
333        res = carrayMaker(objc._C_SHT, arr, None)
334        self.assertEqual(res, tuple(arr))
335
336        res = carrayMaker(objc._C_SHT, arr, 2)
337        self.assertEqual(res, tuple(arr)[:2])
338
339        self.assertRaises(ValueError, carrayMaker, objc._C_SHT, arr, 7)
340        self.assertRaises(ValueError, carrayMaker, objc._C_SHT, arr2, None)
341
342    def testIntTuple(self):
343        arr = (1,2,3,4,5)
344
345        res = carrayMaker(objc._C_INT, arr, None)
346        self.assertEqual(res, arr)
347
348        res = carrayMaker(objc._C_INT, arr, 2)
349        self.assertEqual(res, arr[:2])
350
351        self.assertRaises(ValueError, carrayMaker, objc._C_INT, arr, 7)
352        self.assertRaises(ValueError, carrayMaker, objc._C_INT, ["a", "b"], 1)
353
354    def testIntArray(self):
355        arr = array.array('i', [1,2,3,4,5])
356        arr2 = array.array('f', [1,2,3,4,5])
357        arr3 = array.array('h', [1,2,3,4,5])
358
359        res = carrayMaker(objc._C_INT, arr, None)
360        self.assertEqual(res, tuple(arr))
361
362        res = carrayMaker(objc._C_INT, arr, 2)
363        self.assertEqual(res, tuple(arr)[:2])
364
365        self.assertRaises(ValueError, carrayMaker, objc._C_INT, arr, 7)
366        self.assertRaises(ValueError, carrayMaker, objc._C_INT, arr2, None)
367        self.assertRaises(ValueError, carrayMaker, objc._C_INT, arr3, None)
368
369    def testFloatTuple(self):
370        arr = (1,2,3,4,5)
371
372        res = carrayMaker(objc._C_FLT, arr, None)
373        self.assertEqual(res, arr)
374
375        res = carrayMaker(objc._C_FLT, arr, 2)
376        self.assertEqual(res, arr[:2])
377
378        self.assertRaises(ValueError, carrayMaker, objc._C_INT, arr, 7)
379        self.assertRaises(ValueError, carrayMaker, objc._C_INT, ["a", "b"], 1)
380
381    def testFloatArray(self):
382        arr = array.array('f', [1.5,2.5,3.5,4.5,5.5])
383        arr2 = array.array('i', [1,2,3,4,5])
384
385        res = carrayMaker(objc._C_FLT, arr, None)
386        self.assertEqual(res, tuple(arr))
387
388        res = carrayMaker(objc._C_FLT, arr, 2)
389        self.assertEqual(res, tuple(arr)[:2])
390
391        self.assertRaises(ValueError, carrayMaker, objc._C_FLT, arr, 7)
392        self.assertRaises(ValueError, carrayMaker, objc._C_FLT, arr2, None)
393
394    def testPointTuple(self):
395        arr = ((1.0, 1.5), (2.0, 2.5), (3.0, 3.5), (4.0, 4.5), (5.0, 5.5))
396        arr2 = (1.5,2.5,3.5,4.5,5.5)
397
398        res = carrayMaker(b'{Point=ff}', arr, None)
399        self.assertEqual(res, arr)
400
401        res = carrayMaker(b'{Point=ff}', arr, 2)
402        self.assertEqual(res, arr[:2])
403
404        self.assertRaises(ValueError, carrayMaker, b'{Point=ff}', arr, 7)
405        self.assertRaises(ValueError, carrayMaker, b'{Point=ff}', ["a", "b"], 1)
406        self.assertRaises(TypeError, carrayMaker, b'{Point=ff}', arr2, None)
407
408    def testPointArray(self):
409        arr = array.array('f', [
410            1.0, 1.5,
411            2.0, 2.5,
412            3.0, 3.5,
413            4.0, 4.5,
414            5.0, 5.5])
415        lst = ((1.0, 1.5), (2.0, 2.5), (3.0, 3.5), (4.0, 4.5), (5.0, 5.5))
416
417        arr2 = array.array('i', [
418            1, 1,
419            2, 2,
420            3, 3,
421            4, 4,
422            5, 5])
423
424        res = carrayMaker(b'{Point=ff}', arr, None)
425        self.assertEqual(res, lst)
426
427        res = carrayMaker(b'{Point=ff}', arr, 2)
428        self.assertEqual(res, lst[:2])
429
430        self.assertRaises(ValueError, carrayMaker, b'{Point=ff}', arr2, None)
431
432    def testRectArray(self):
433        arr = array.array('f', [
434            1.0, 1.5, -1.0, -1.5,
435            2.0, 2.5, -2.0, -2.5,
436            3.0, 3.5, -3.0, -3.5,
437            4.0, 4.5, -4.0, -4.5,
438            5.0, 5.5, -5.0, -5.5])
439        lst = (
440                ((1.0, 1.5),  (-1.0, -1.5)),
441                ((2.0, 2.5),  (-2.0, -2.5)),
442                ((3.0, 3.5),  (-3.0, -3.5)),
443                ((4.0, 4.5),  (-4.0, -4.5)),
444                ((5.0, 5.5),  (-5.0, -5.5)),
445            )
446
447        arr2 = array.array('i', [
448            1, 1, 1, 1,
449            2, 2, 2, 2,
450            3, 3, 3, 3,
451            4, 4, 4, 4,
452            5, 5, 5, 5])
453
454        res = carrayMaker(b'{Rect={P=ff}{S=ff}}', arr, None)
455        self.assertEqual(res, lst)
456
457        res = carrayMaker(b'{Rect={P=ff}{S=ff}}', arr, 2)
458        self.assertEqual(res, lst[:2])
459
460        res = carrayMaker(b'{Rect=[2f][2f]}', arr, None)
461        self.assertEqual(res, lst)
462
463        res = carrayMaker(b'[2[2f]]}', arr, None)
464        self.assertEqual(res, lst)
465
466        self.assertRaises(ValueError, carrayMaker, b'{Rect={P=ff}{S=ff}}', arr2, None)
467
468    def testMixedArray(self):
469        arr = array.array('f', [
470            1.0, 1.5, -1.0, -1.5,
471            2.0, 2.5, -2.0, -2.5,
472            3.0, 3.5, -3.0, -3.5,
473            4.0, 4.5, -4.0, -4.5,
474            5.0, 5.5, -5.0, -5.5])
475
476        self.assertRaises(ValueError, carrayMaker, b'{M={P=ff}{S=ii}}', arr, 4)
477        self.assertRaises(ValueError, carrayMaker, b'{M=if{S=ii}}', arr, None)
478        self.assertRaises(ValueError, carrayMaker, b'{M=fi{S=ff}}', arr, None)
479
480
481
482class PyOCTestTypeStr(TestCase):
483    #
484    # Check that typestrings have the expected values.
485    # We currently depend on these values in this file as wel as in the
486    # modules that set method signatures to 'better' values.
487    #
488    def testAll(self):
489        self.assertEqual(objc._C_BOOL, b"B")
490        self.assertEqual(objc._C_ID, b"@")
491        self.assertEqual(objc._C_CLASS, b"#")
492        self.assertEqual(objc._C_SEL, b":")
493        self.assertEqual(objc._C_CHR, b"c")
494        self.assertEqual(objc._C_UCHR, b"C")
495        self.assertEqual(objc._C_SHT, b"s")
496        self.assertEqual(objc._C_USHT, b"S")
497        self.assertEqual(objc._C_INT, b"i")
498        self.assertEqual(objc._C_UINT, b"I")
499        self.assertEqual(objc._C_LNG, b"l")
500        self.assertEqual(objc._C_ULNG, b"L")
501        self.assertEqual(objc._C_LNG_LNG, b"q")
502        self.assertEqual(objc._C_ULNG_LNG, b"Q")
503        self.assertEqual(objc._C_FLT, b"f")
504        self.assertEqual(objc._C_DBL, b"d")
505        self.assertEqual(objc._C_VOID, b"v")
506        self.assertEqual(objc._C_CHARPTR, b"*")
507        self.assertEqual(objc._C_PTR, b"^")
508        self.assertEqual(objc._C_UNDEF, b"?")
509        self.assertEqual(objc._C_ARY_B, b"[")
510        self.assertEqual(objc._C_ARY_E, b"]")
511        self.assertEqual(objc._C_UNION_B, b"(")
512        self.assertEqual(objc._C_UNION_E, b")")
513        self.assertEqual(objc._C_STRUCT_B, b"{")
514        self.assertEqual(objc._C_STRUCT_E, b"}")
515        self.assertEqual(objc._C_IN, b"n")
516        self.assertEqual(objc._C_OUT, b"o")
517        self.assertEqual(objc._C_INOUT, b"N")
518
519if __name__ == "__main__":
520    main()
521