1from PyObjCTools.TestSupport import *
2import objc
3import pickle
4import collections
5import sys
6
7NSObject = objc.lookUpClass('NSObject')
8NSIndexSet = objc.lookUpClass('NSIndexSet')
9NSMutableIndexSet = objc.lookUpClass('NSMutableIndexSet')
10
11class TestArrayPropertyHelper (NSObject):
12    array = objc.array_property()
13    array2 = objc.array_property()
14    roArray = objc.array_property(read_only=True)
15
16from PyObjCTest.test_object_property import OCObserve
17
18class TestArrayProperty (TestCase):
19    def _testMissing(self):
20        self.fail("Implement tests")
21
22    def testGetting(self):
23        # Check that default value is an empty value
24        # Check that value is a proxy object
25        o = TestArrayPropertyHelper.alloc().init()
26
27        v = o.array
28        self.assertIsInstance(v, collections.MutableSequence)
29
30        self.assertEqual(len(v), 0)
31
32        v.append(1)
33        self.assertEqual(len(v), 1)
34
35        self.assertEqual(type(v).__name__, 'array_proxy')
36
37    def testSetting(self):
38        # Set value, check that
39        # (1) value gets copied
40        # (2) accessing the property result in proxy
41        observer = OCObserve.alloc().init()
42        l = [1, 2, 3]
43        o = TestArrayPropertyHelper.alloc().init()
44        observer.register(o, 'array')
45        try:
46            self.assertEqual(observer.seen, {})
47            self.assertEqual(len(o.array), 0)
48            self.assertEqual(observer.seen, {'array': []})
49            o.array = l
50            self.assertEqual(observer.seen, {'array': l})
51
52
53            self.assertEqual(len(o.array), 3)
54
55            # This shouldn't affect the property
56            l.append(4)
57            self.assertEqual(len(o.array), 3)
58
59            self.assertEqual(len(l), 4)
60            o.array.append(5)
61            self.assertEqual(len(l), 4)
62            self.assertEqual(len(o.array), 4)
63
64        finally:
65            observer.unregister(o, 'array')
66
67        l = [1,2]
68        o.array2 = l
69        self.assertIsNot(o._array2, l)
70
71        o.array2 = o.array
72        self.assertEqual(o.array2, [1, 2, 3, 5])
73        o.array2.append(1)
74        self.assertEqual(o.array2, [1, 2, 3, 5, 1])
75        self.assertEqual(o.array, [1, 2, 3, 5])
76
77
78        arr = o.array2
79        o._array2 = None
80        self.assertEqual(arr, [])
81
82
83    def testGetSetItem(self):
84        # Use __getitem__, __setitem__ interface and check
85        # that the correct KVO events get emitted.
86        observer = OCObserve.alloc().init()
87        l = [1, 2, 3]
88        o = TestArrayPropertyHelper.alloc().init()
89        observer.register(o, 'array')
90
91        # FIXME: the call to len shouldn't be necessary
92        len(o.array)
93        try:
94            IS = NSIndexSet.alloc().initWithIndex_(0)
95            self.assertEqual(observer.seen, {'array': []})
96
97            o.array.append(1)
98
99            self.assertEqual(observer.seen, {'array': [1]})
100            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
101            self.assertEqual(observer.values[-1][-1]['new'], [1])
102
103            o.array.append(2)
104            o.array.append(3)
105
106
107            self.assertEqual(o.array[0], 1)
108            o.array[0] = 4
109            self.assertEqual(o.array[0], 4)
110            self.assertEqual(observer.seen, { 'array': [4] })
111            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
112            self.assertEqual(observer.values[-1][-1]['old'], [1])
113            self.assertEqual(observer.values[-1][-1]['new'], [4])
114
115            o.array[-1] = 9
116            self.assertEqual(o.array[2], 9)
117            IS = NSIndexSet.alloc().initWithIndex_(2)
118            self.assertEqual(observer.seen, { 'array': [9] })
119            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
120            self.assertEqual(observer.values[-1][-1]['old'], [3])
121            self.assertEqual(observer.values[-1][-1]['new'], [9])
122
123            self.assertEqual(o.array[-1], 9)
124
125            try:
126                o.array[-20] = 4
127            except IndexError:
128                pass
129
130            else:
131                self.fail("IndexError not raised")
132
133        finally:
134            observer.unregister(o, 'array')
135
136    def testGetSetSlice(self):
137        # Same as testGetSetItem, but using slice
138        observer = OCObserve.alloc().init()
139        l = [1, 2, 3]
140        o = TestArrayPropertyHelper.alloc().init()
141        observer.register(o, 'array')
142
143        try:
144            IS = NSIndexSet.alloc().initWithIndexesInRange_((0, 3))
145            IS2 = NSIndexSet.alloc().initWithIndexesInRange_((1, 2))
146            IS3 = NSMutableIndexSet.alloc().init()
147            IS3.addIndex_(0)
148            IS3.addIndex_(2)
149            self.assertEqual(observer.seen, {})
150
151            o.array = l
152
153            self.assertEqual(observer.seen, {'array': l})
154            self.assertNotIn('indexes', observer.values[-1][-1])
155            self.assertEqual(observer.values[-1][-1]['new'], [1, 2, 3])
156
157
158            o.array[1:3] = [4, 5]
159            self.assertEqual(o.array[0], 1)
160            self.assertEqual(o.array[1], 4)
161            self.assertEqual(o.array[2], 5)
162            self.assertEqual(o.array,[1, 4, 5])
163            self.assertEqual(observer.seen, {'array': [4, 5]})
164            self.assertEqual(observer.values[-1][-1]['indexes'], IS2)
165            self.assertEqual(observer.values[-1][-1]['old'], [2, 3])
166            self.assertEqual(observer.values[-1][-1]['new'], [4, 5])
167
168            self.assertEqual(o.array[0], 1)
169            o.array[0:3:2] = [9, 10]
170            self.assertEqual(o.array[0], 9)
171            self.assertEqual(o.array[1], 4)
172            self.assertEqual(o.array[2], 10)
173            self.assertEqual(observer.seen, { 'array': [9, 10]})
174            self.assertEqual(observer.values[-1][-1]['indexes'], IS3)
175            self.assertEqual(observer.values[-1][-1]['old'], [1, 5])
176            self.assertEqual(observer.values[-1][-1]['new'], [9, 10])
177
178        finally:
179            observer.unregister(o, 'array')
180
181    def testInsert(self):
182        # Use insert method and check that the correct
183        # KVO events get emitted
184        # Same as testGetSetItem, but using slice
185        observer = OCObserve.alloc().init()
186        l = [1, 2, 3]
187        o = TestArrayPropertyHelper.alloc().init()
188        observer.register(o, 'array')
189
190        self.assertEqual(o.array, [])
191
192        try:
193            IS = NSIndexSet.alloc().initWithIndex_(0)
194            IS1 = NSIndexSet.alloc().initWithIndex_(4)
195            self.assertEqual(observer.seen, {'array': []})
196
197            o.array = l
198
199            self.assertEqual(observer.seen, {'array': l})
200            self.assertNotIn('indexes', observer.values[-1][-1])
201
202            self.assertEqual(o.array[0], 1)
203
204
205            o.array.insert(0, 'a')
206            self.assertEqual(o.array[0], 'a')
207            self.assertEqual(len(o.array), 4)
208
209            self.assertEqual(observer.seen, {'array': ['a']})
210            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
211            self.assertNotIn('old', observer.values[-1][-1])
212            self.assertEqual(observer.values[-1][-1]['new'], ['a'])
213
214            o.array.insert(4, 'b')
215            self.assertEqual(o.array[4], 'b')
216            self.assertEqual(len(o.array), 5)
217
218            self.assertEqual(observer.seen, {'array': ['b']})
219            self.assertEqual(observer.values[-1][-1]['indexes'], IS1)
220            self.assertNotIn('old', observer.values[-1][-1])
221            self.assertEqual(observer.values[-1][-1]['new'], ['b'])
222
223            self.assertRaises(TypeError, o.array.insert, slice(0,2), 4)
224            self.assertRaises(TypeError, o.array.insert, 'a', 4)
225            o.array.insert(0, 'a')
226
227        finally:
228            observer.unregister(o, 'array')
229
230    def testPop(self):
231        # Use pop method and check that the correct
232        # KVO events get emitted
233        observer = OCObserve.alloc().init()
234        l = [1, 2, 3, 4]
235        o = TestArrayPropertyHelper.alloc().init()
236        observer.register(o, 'array')
237
238        try:
239            IS = NSIndexSet.alloc().initWithIndex_(0)
240            IS2 = NSIndexSet.alloc().initWithIndex_(2)
241            self.assertEqual(observer.seen, {})
242
243            o.array = l
244
245            self.assertEqual(observer.seen, {'array': l})
246            self.assertNotIn('indexes', observer.values[-1][-1])
247
248            self.assertEqual(o.array[0], 1)
249
250
251            v = o.array.pop(0)
252            self.assertEqual(v, 1)
253            self.assertEqual(o.array[0], 2)
254            self.assertEqual(len(o.array), 3)
255
256            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
257            self.assertNotIn('new', observer.values[-1][-1])
258            self.assertEqual(observer.values[-1][-1]['old'], [1])
259
260            v = o.array.pop(2)
261            self.assertEqual(v, 4)
262            self.assertEqual(len(o.array), 2)
263
264            self.assertEqual(observer.values[-1][-1]['indexes'], IS2)
265            self.assertNotIn('new', observer.values[-1][-1])
266            self.assertEqual(observer.values[-1][-1]['old'], [4])
267
268            self.assertRaises(TypeError, o.array.pop, slice(0, 2))
269            self.assertRaises(TypeError, o.array.pop, 'a')
270
271        finally:
272            observer.unregister(o, 'array')
273
274    def testDelItem(self):
275        # Use __delitem__and check that the correct
276        # KVO events get emitted
277        observer = OCObserve.alloc().init()
278        l = [1, 2, 3, 4]
279        o = TestArrayPropertyHelper.alloc().init()
280        observer.register(o, 'array')
281
282        try:
283            IS = NSIndexSet.alloc().initWithIndex_(0)
284            IS2 = NSIndexSet.alloc().initWithIndex_(2)
285            self.assertEqual(observer.seen, {})
286
287            o.array = l
288
289            self.assertEqual(observer.seen, {'array': l})
290            self.assertNotIn('indexes', observer.values[-1][-1])
291
292            self.assertEqual(o.array[0], 1)
293
294
295            del o.array[0]
296            self.assertEqual(o.array[0], 2)
297            self.assertEqual(len(o.array), 3)
298
299            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
300            self.assertNotIn('new', observer.values[-1][-1])
301            self.assertEqual(observer.values[-1][-1]['old'], [1])
302
303            del o.array[2]
304            self.assertEqual(len(o.array), 2)
305
306            self.assertEqual(observer.values[-1][-1]['indexes'], IS2)
307            self.assertNotIn('new', observer.values[-1][-1])
308            self.assertEqual(observer.values[-1][-1]['old'], [4])
309
310        finally:
311            observer.unregister(o, 'array')
312
313    def testDelSlice(self):
314        # As testDelItem, but using slices
315        observer = OCObserve.alloc().init()
316        l = [1, 2, 3, 4]
317        o = TestArrayPropertyHelper.alloc().init()
318        observer.register(o, 'array')
319
320        try:
321            IS = NSMutableIndexSet.alloc().init()
322            IS.addIndex_(0)
323            IS.addIndex_(2)
324            self.assertEqual(len(observer.values), 0)
325
326            o.array = l
327
328            self.assertEqual(observer.seen, {'array': l})
329            self.assertNotIn('indexes', observer.values[-1][-1])
330
331            self.assertEqual(o.array[0], 1)
332
333
334            del o.array[0:4:2]
335            self.assertEqual(o.array[0], 2)
336            self.assertEqual(o.array[1], 4)
337            self.assertEqual(len(o.array), 2)
338
339            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
340            self.assertNotIn('new', observer.values[-1][-1])
341            self.assertEqual(observer.values[-1][-1]['old'], [1, 3])
342
343        finally:
344            observer.unregister(o, 'array')
345
346    def testExtend(self):
347        observer = OCObserve.alloc().init()
348        l = [1, 2, 3, 4]
349        l2 = ['a', 'b', 'c']
350        o = TestArrayPropertyHelper.alloc().init()
351        observer.register(o, 'array')
352
353        try:
354            o.array = l
355
356            self.assertEqual(observer.seen, {'array': l })
357            self.assertEqual(o.array[0], 1)
358
359            o.array.extend(l2)
360
361            self.assertEqual(len(o.array), 7)
362            self.assertEqual(o.array[4], 'a')
363
364            self.assertEqual(observer.seen, {'array': l2 })
365            self.assertEqual(observer.values[-1][-1]['indexes'], NSIndexSet.alloc().initWithIndexesInRange_((4, 3)))
366            self.assertNotIn('old', observer.values[-1][-1])
367            self.assertEqual(observer.values[-1][-1]['new'], l2)
368
369        finally:
370            observer.unregister(o, 'array')
371
372    def testIAdd(self):
373        observer = OCObserve.alloc().init()
374        l = [1, 2, 3, 4]
375        l2 = ['a', 'b', 'c']
376        o = TestArrayPropertyHelper.alloc().init()
377        observer.register(o, 'array')
378
379        try:
380            o.array = l
381
382            self.assertEqual(observer.seen, {'array': l})
383            self.assertEqual(o.array[0], 1)
384
385            o.array += l2
386
387            self.assertEqual(o.array, l + l2)
388            self.assertEqual(len(o.array), 7)
389            self.assertEqual(o.array[4], 'a')
390
391            self.assertEqual(observer.seen, {'array': l + l2})
392            self.assertEqual(observer.values[-2][-1]['indexes'], NSIndexSet.alloc().initWithIndexesInRange_((4, 3)))
393            self.assertNotIn('old', observer.values[-2][-1])
394            self.assertEqual(observer.values[-2][-1]['new'], l2)
395
396            self.assertNotIn('indexes', observer.values[-1][-1])
397
398            before = observer.values[:]
399            v = o.array + l2
400            self.assertEqual(observer.values, before)
401            self.assertEqual(v, l + l2 + l2)
402            self.assertIsInstance(v, list)
403
404        finally:
405            observer.unregister(o, 'array')
406
407
408    def testIMul(self):
409        observer = OCObserve.alloc().init()
410        l = [1, 2]
411        o = TestArrayPropertyHelper.alloc().init()
412        observer.register(o, 'array')
413
414        try:
415            o.array = l
416
417            self.assertEqual(observer.seen, {'array': l})
418            self.assertEqual(o.array[0], 1)
419
420            observer.values[:] = []
421            o.array *= 3
422
423            self.assertEqual(len(o.array), 6)
424            self.assertEqual(o.array[0], 1)
425            self.assertEqual(o.array[1], 2)
426            self.assertEqual(o.array[2], 1)
427            self.assertEqual(o.array[3], 2)
428            self.assertEqual(o.array[4], 1)
429            self.assertEqual(o.array[5], 2)
430
431            self.assertEqual(observer.seen, {'array': [ 1, 2, 1, 2, 1, 2]})
432            self.assertEqual(observer.values[-2][-1]['indexes'], NSIndexSet.alloc().initWithIndexesInRange_((2, 4)))
433            self.assertNotIn('old', observer.values[-2][-1])
434            self.assertEqual(observer.values[-2][-1]['new'], [ 1, 2, 1, 2])
435
436            self.assertEqual(len(observer.values), 2)
437            self.assertNotIn('indexes', observer.values[-1][-1])
438
439            before = observer.values[:]
440            n = o.array * 4
441            self.assertEqual(observer.values, before)
442            self.assertEqual(n, [1,2]* 3 * 4)
443            self.assertIsInstance(n, list)
444
445            try:
446                o.array *= 'a'
447            except TypeError:
448                pass
449
450            else:
451                self.fail("array * 'a' didn't raise exception")
452
453        finally:
454            observer.unregister(o, 'array')
455
456
457    def testSort(self):
458        # Use sort method and check that the correct
459        # KVO events get emitted
460        observer = OCObserve.alloc().init()
461        l = [2, 4, 1, 3]
462        o = TestArrayPropertyHelper.alloc().init()
463        observer.register(o, 'array')
464
465        try:
466            IS = NSIndexSet.alloc().initWithIndexesInRange_((0, 4))
467            self.assertEqual(observer.seen, {})
468
469            orig_l = l[:]
470            o.array = l
471
472
473            self.assertEqual(observer.seen, {'array': l })
474            self.assertNotIn('indexes', observer.values[-1][-1])
475
476            self.assertEqual(o.array[0], 2)
477
478            o.array.sort()
479
480            self.assertEqual(o.array[0], 1)
481            self.assertEqual(o.array[1], 2)
482            self.assertEqual(o.array[2], 3)
483            self.assertEqual(o.array[3], 4)
484            self.assertEqual(len(o.array), 4)
485
486            self.assertEqual(observer.seen, {'array': [1,2,3,4]})
487            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
488            self.assertEqual(observer.values[-1][-1]['old'], l)
489            self.assertEqual(observer.values[-1][-1]['new'], [1,2,3,4])
490            self.assertEqual(orig_l, l)
491
492        finally:
493            observer.unregister(o, 'array')
494
495    def testReverse(self):
496        # Use reverse method and check that the correct
497        # KVO events get emitted
498        observer = OCObserve.alloc().init()
499        l = [2, 4, 1, 3]
500        o = TestArrayPropertyHelper.alloc().init()
501        observer.register(o, 'array')
502
503        try:
504            IS = NSIndexSet.alloc().initWithIndexesInRange_((0, 4))
505            self.assertEqual(observer.seen, {})
506
507            orig_l = l[:]
508            o.array = l
509
510
511            self.assertEqual(observer.seen, {'array': l })
512            self.assertNotIn('indexes', observer.values[-1][-1])
513
514            self.assertEqual(o.array[0], 2)
515
516            o.array.reverse()
517
518            self.assertEqual(o.array[0], 3)
519            self.assertEqual(o.array[1], 1)
520            self.assertEqual(o.array[2], 4)
521            self.assertEqual(o.array[3], 2)
522            self.assertEqual(len(o.array), 4)
523
524            self.assertEqual(observer.seen, {'array': [3, 1, 4, 2]})
525            self.assertEqual(observer.values[-1][-1]['indexes'], IS)
526            self.assertEqual(observer.values[-1][-1]['old'], l)
527            self.assertEqual(observer.values[-1][-1]['new'], [3, 1, 4, 2])
528            self.assertEqual(orig_l, l)
529
530        finally:
531            observer.unregister(o, 'array')
532
533    def testObjCAccessors(self):
534        # Check that the right ObjC array accessors are defined and work properly
535        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"setArray:"))
536        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"array"))
537        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"countOfArray"))
538        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"objectInArrayAtIndex:"))
539        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"insertObject:inArrayAtIndex:"))
540        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"removeObjectFromArrayAtIndex:"))
541        self.assertTrue(TestArrayPropertyHelper.instancesRespondToSelector_(b"replaceObjectInArrayAtIndex:withObject:"))
542
543        o = TestArrayPropertyHelper.alloc().init()
544        self.assertEqual(0, o.pyobjc_instanceMethods.countOfArray())
545        self.assertRaises(AttributeError, getattr, o, 'countOfArray')
546
547        o.pyobjc_instanceMethods.insertObject_inArrayAtIndex_('a', 0)
548        self.assertEqual(1, o.pyobjc_instanceMethods.countOfArray())
549        self.assertEqual('a', o.array[0])
550        self.assertEqual('a', o.pyobjc_instanceMethods.objectInArrayAtIndex_(0))
551        o.pyobjc_instanceMethods.replaceObjectInArrayAtIndex_withObject_(0, 'b')
552        self.assertEqual('b', o.array[0])
553        o.pyobjc_instanceMethods.removeObjectFromArrayAtIndex_(0)
554        self.assertEqual(0, o.pyobjc_instanceMethods.countOfArray())
555
556
557    # Verify docs and/or implementation to check for other
558    # mutating methods
559
560    def testReadingMethods(self):
561        # Check that all read-only methods work as well
562
563        o = TestArrayPropertyHelper.alloc().init()
564        o.array = [1, 2, 3, 4]
565
566        self.assertIsNotInstance(o.array, list)
567
568        self.assertEqual(o.array, [1,2,3,4])
569        self.assertNotEqual(o.array, [1,2,3,4, 5])
570
571        self.assertEqual(o.array.count(1), 1)
572        self.assertEqual(o.array.index(4), 3)
573
574
575        self.assertTrue(o.array < [1,2,3,4,5])
576        self.assertTrue(o.array <= [1,2,3,4,5])
577        self.assertTrue(o.array <= [1,2,3,4])
578        self.assertTrue(o.array >= [1,2,3,4])
579        self.assertTrue(o.array > [1,2,3])
580
581
582    def testMutatingReadonlyProperty(self):
583        # Check that trying to mutate a read-only property
584        # will raise an exception
585        o = TestArrayPropertyHelper.alloc().init()
586
587        o._roArray = [1, 2, 3]
588
589        self.assertEqual(list(o.roArray), [1,2,3])
590
591        self.assertRaises(ValueError, o.roArray.append,1)
592        self.assertRaises(ValueError, o.roArray.extend, [1,2])
593        self.assertRaises(ValueError, o.roArray.sort)
594        self.assertRaises(ValueError, o.roArray.reverse)
595        self.assertRaises(ValueError, o.roArray.pop)
596        try:
597            o.roArray[0] = 2
598        except ValueError:
599            pass
600        else:
601            self.fail("ValueError not raised")
602
603        try:
604            del o.roArray[0]
605        except ValueError:
606            pass
607        else:
608            self.fail("ValueError not raised")
609
610        try:
611            o.roArray += [4]
612        except ValueError:
613            pass
614        else:
615            self.fail("ValueError not raised")
616
617        try:
618            o.roArray *= 4
619        except ValueError:
620            pass
621        else:
622            self.fail("TypeError not raised")
623
624
625    def testMutatingReadonlyPropertyObjC(self):
626        # Check that trying to mutate a read-only property
627        # from ObjC will raise an exception
628        o = TestArrayPropertyHelper.alloc().init()
629        o._roArray = [1,2,3]
630        self.assertEqual(3, o.pyobjc_instanceMethods.countOfRoArray())
631        self.assertRaises(AttributeError, getattr, o, 'countOfRoArray')
632
633        try:
634            o.pyobjc_instanceMethods.insertObject_inRoArrayAtIndex_('a', 0)
635        except ValueError:
636            pass
637        else:
638            self.fail("ValueError not raised")
639
640        self.assertEqual(3, o.pyobjc_instanceMethods.countOfRoArray())
641        self.assertEqual(1, o.pyobjc_instanceMethods.objectInRoArrayAtIndex_(0))
642        try:
643            o.pyobjc_instanceMethods.replaceObjectInRoArrayAtIndex_withObject_(0, 'b')
644        except ValueError:
645            pass
646        else:
647            self.fail("ValueError not raised")
648
649        try:
650            o.pyobjc_instanceMethods.removeObjectFromRoArrayAtIndex_(0)
651        except ValueError:
652            pass
653        else:
654            self.fail("ValueError not raised")
655
656
657    def testAssingmentInteraction(self):
658        o = TestArrayPropertyHelper.alloc().init()
659        array = o.array
660
661        o.array.append(1)
662        self.assertEqual(len(o.array), 1)
663        self.assertEqual(len(array), 1)
664
665    def testPickling(self):
666        o = TestArrayPropertyHelper.alloc().init()
667        o.array.extend([3,4,5])
668
669        self.assertFalse(isinstance(o.array, list))
670
671        p = pickle.dumps(o.array)
672        v = pickle.loads(p)
673        self.assertEqual(v, o.array)
674        self.assertTrue(isinstance(v, list))
675
676    def testRepr(self):
677        o = TestArrayPropertyHelper.alloc().init()
678        o.array.extend([3,4,5])
679
680        self.assertFalse(isinstance(o.array, list))
681
682        self.assertEqual(repr(o.array), '<array proxy for property array %r>'%([3,4,5],))
683
684    def testFinding(self):
685        o = TestArrayPropertyHelper.alloc().init()
686        o.array.extend([3,4,5,4])
687
688        self.assertEqual(0, o.array.index(3))
689        self.assertEqual(2, o.array.count(4))
690
691    def testCompare(self):
692        o = TestArrayPropertyHelper.alloc().init()
693        o.array.extend([3,4,5])
694        o.array2.extend([4,5])
695
696        self.assertFalse(o.array == o.array2)
697        self.assertFalse(o.array ==  [4,5])
698        self.assertTrue(o.array ==  [3,4,5])
699
700        self.assertTrue(o.array != o.array2)
701        self.assertTrue(o.array !=  [4,5])
702        self.assertFalse(o.array !=  [3,4,5])
703
704        o.array2.insert(0, 3)
705        self.assertFalse(o.array != o.array2)
706        self.assertTrue(o.array == o.array2)
707
708        o.array2 = [4,5]
709        self.assertTrue(o.array < o.array2)
710        self.assertTrue(o.array < [4,5])
711        self.assertFalse(o.array2 < o.array)
712        self.assertFalse(o.array2 < [4,5])
713        self.assertTrue(o.array2 <= o.array2)
714        self.assertTrue(o.array2 <= [4,5])
715
716        self.assertTrue(o.array <= o.array2)
717        self.assertTrue(o.array <= [4,5])
718        self.assertFalse(o.array2 <= o.array)
719
720        self.assertFalse(o.array > o.array2)
721        self.assertFalse(o.array > [4,5])
722        self.assertTrue(o.array2 > o.array)
723        self.assertFalse(o.array2 > [4,5])
724
725        self.assertFalse(o.array >= o.array2)
726        self.assertFalse(o.array >= [4,5])
727        self.assertTrue(o.array2 >= o.array)
728        self.assertTrue(o.array2 >= [4,5])
729        self.assertTrue(o.array2 >= o.array2)
730
731        if sys.version_info[0] == 2:
732            n = cmp(o.array2, o.array)
733            self.assertEqual(n, 1)
734
735            n = cmp(o.array2, [3,4,5])
736            self.assertEqual(n, 1)
737
738            n = cmp([3,4,5], o.array2)
739            self.assertEqual(n, -1)
740
741            n = o.array2.__cmp__(o.array)
742            self.assertEqual(n, 1)
743
744            n = o.array2.__cmp__([3,4,5])
745            self.assertEqual(n, 1)
746
747
748    def testGetAttr(self):
749        o = TestArrayPropertyHelper.alloc().init()
750        o.array = [1,2,3]
751        v = o.array
752        self.assertEqual(v.count('a'), 0)
753        self.assertEqual(list(v.__reversed__()), [3,2,1])
754
755        self.assertRaises(AttributeError, getattr, o.array, 'nosuchattribute')
756
757
758
759if __name__ == "__main__":
760    main()
761