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