1""" 2Tests for the new-style metadata format interface. 3 4Note: Tests for calling from ObjC into python are in test_metadata_py.py 5 6TODO: 7- Add tests for calling functions instead of methods 8- The python->C interface (that is the contents of the metadata object) is 9 likely to change when the bridge is feature-complete. 10- Probably need special-casing for arrays (numarray and array.array)! 11""" 12from __future__ import unicode_literals 13import objc 14from PyObjCTools.TestSupport import * 15import warnings 16import array 17import sys 18 19from PyObjCTest.metadata import * 20 21if sys.version_info[0] == 3: 22 unicode = str 23 24make_array = array.array 25if sys.version_info[0] == 2: 26 def make_array(fmt, *args): 27 # With unicode_literals the first argument to make_array 28 # in the tests below is a unicode string and array.array 29 # in python2 doesn't grog that. 30 return array.array(fmt.encode('ascii'), *args) 31 32def setupMetaData(): 33 # Note to self: what we think of as the first argument of a method is 34 # actually the third one, the objc runtime implicitly passed 'self' and 35 # the selector as well. Therefore we need to start counting at 2 instead 36 # of 0. 37 # 38 # Note2: the code below would normally be done using a metadata file 39 # instead of hardcoding. 40 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"boolClassMethod", 41 dict( 42 retval=dict(type=objc._C_NSBOOL) 43 )) 44 45 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"unknownLengthArray", 46 dict( 47 retval=dict(c_array_of_variable_length=True), 48 )) 49 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"unknownLengthMutable", 50 dict( 51 retval=dict(c_array_of_variable_length=True), 52 )) 53 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeVariableLengthArray:halfCount:", 54 dict( 55 arguments={ 56 2+0: dict(c_array_of_variable_length=True, type_modifier=objc._C_IN), 57 } 58 )) 59 60 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"varargsMethodWithObjects:", 61 dict( 62 variadic=True, 63 )) 64 65 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"ignoreMethod", 66 dict( 67 suggestion='please ignore me', 68 )) 69 70 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeArrayWithFormat:", 71 dict( 72 variadic=True, 73 arguments={ 74 2+0: dict(printf_format=True), 75 } 76 )) 77 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeArrayWithCFormat:", 78 dict( 79 variadic=True, 80 arguments={ 81 2+0: dict(printf_format=True), 82 } 83 )) 84 85 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeArrayWithArguments:", 86 dict( 87 variadic=True, 88 c_array_delimited_by_null=True 89 )) 90 91 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"make4Tuple:", 92 dict( 93 arguments={ 94 2+0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=False), 95 } 96 ) 97 ) 98 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"null4Tuple:", 99 dict( 100 arguments={ 101 2+0: dict(type_modifier=objc._C_IN, c_array_of_fixed_length=4, null_accepted=True), 102 } 103 ) 104 ) 105 106 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeObjectArray:", 107 dict( 108 arguments={ 109 2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False), 110 } 111 ) 112 ) 113 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeStringArray:", 114 dict( 115 arguments={ 116 2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=False), 117 } 118 ) 119 ) 120 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullStringArray:", 121 dict( 122 arguments={ 123 2+0: dict(type_modifier=objc._C_IN, c_array_delimited_by_null=True, null_accepted=True), 124 } 125 ) 126 ) 127 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeIntArray:count:", 128 dict( 129 arguments={ 130 2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False), 131 } 132 ) 133 ) 134 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeIntArray:halfCount:", 135 dict( 136 arguments={ 137 2+0: dict(type_modifier=objc._C_IN, c_array_of_variable_length=True, null_accepted=False), 138 } 139 ) 140 ) 141 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeIntArray:countPtr:", 142 dict( 143 arguments={ 144 2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False), 145 2+1: dict(type_modifier=objc._C_IN, null_accepted=False), 146 } 147 ) 148 ) 149 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullIntArray:count:", 150 dict( 151 arguments={ 152 2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=True), 153 } 154 ) 155 ) 156 157 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fillArray:uptoCount:", 158 dict( 159 arguments={ 160 2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, c_array_length_in_result=True, null_accepted=False), 161 } 162 ) 163 ) 164 165 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fillArray:count:", 166 dict( 167 arguments={ 168 2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=False), 169 } 170 ) 171 ) 172 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullfillArray:count:", 173 dict( 174 arguments={ 175 2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=True), 176 } 177 ) 178 ) 179 180 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"maybeFillArray:", 181 dict( 182 arguments={ 183 2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, c_array_length_in_result=True, null_accepted=False), 184 } 185 ) 186 ) 187 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fill4Tuple:", 188 dict( 189 arguments={ 190 2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=False), 191 } 192 ) 193 ) 194 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullfill4Tuple:", 195 dict( 196 arguments={ 197 2+0: dict(type_modifier=objc._C_OUT, c_array_of_fixed_length=4, null_accepted=True), 198 } 199 ) 200 ) 201 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fillStringArray:", 202 dict( 203 arguments={ 204 2+0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=False), 205 } 206 ) 207 ) 208 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullfillStringArray:", 209 dict( 210 arguments={ 211 2+0: dict(type_modifier=objc._C_OUT, c_array_delimited_by_null=True, null_accepted=True), 212 } 213 ) 214 ) 215 216 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"reverseArray:uptoCount:", 217 dict( 218 arguments={ 219 2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, c_array_length_in_result=True, null_accepted=False), 220 } 221 ) 222 ) 223 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"reverseArray:count:", 224 dict( 225 arguments={ 226 2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=False), 227 } 228 ) 229 ) 230 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullreverseArray:count:", 231 dict( 232 arguments={ 233 2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=True), 234 } 235 ) 236 ) 237 238 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"reverseStrings:", 239 dict( 240 arguments={ 241 2+0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=False), 242 } 243 ) 244 ) 245 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullreverseStrings:", 246 dict( 247 arguments={ 248 2+0: dict(type_modifier=objc._C_INOUT, c_array_delimited_by_null=True, null_accepted=True), 249 } 250 ) 251 ) 252 253 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"maybeReverseArray:", 254 dict( 255 arguments={ 256 2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, c_array_length_in_result=True, null_accepted=False), 257 } 258 ) 259 ) 260 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"reverse4Tuple:", 261 dict( 262 arguments={ 263 2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=False), 264 } 265 ) 266 ) 267 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullreverse4Tuple:", 268 dict( 269 arguments={ 270 2+0: dict(type_modifier=objc._C_INOUT, c_array_of_fixed_length=4, null_accepted=True), 271 } 272 ) 273 ) 274 275 276 277 278 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeIntArrayOf5", 279 dict( 280 retval=dict(c_array_of_fixed_length=5) 281 ), 282 ) 283 284 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeStringArray", 285 dict( 286 retval=dict(c_array_delimited_by_null=True), 287 ), 288 ) 289 290 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeIntArrayOf:", 291 dict( 292 retval=dict(c_array_length_in_arg=2+0) 293 ), 294 ) 295 296 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullIntArrayOf5", 297 dict( 298 retval=dict(c_array_of_fixed_length=5) 299 ), 300 ) 301 302 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullStringArray", 303 dict( 304 retval=dict(c_array_delimited_by_null=True), 305 ), 306 ) 307 308 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"nullIntArrayOf:", 309 dict( 310 retval=dict(c_array_length_in_arg=2+0) 311 ), 312 ) 313 314 315 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"sumX:andY:", 316 dict(arguments={ 317 2+0: dict(type_modifier=objc._C_IN, null_accepted=False), 318 2+1: dict(type_modifier=objc._C_IN, null_accepted=False), 319 })) 320 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"divBy5:remainder:", 321 dict(arguments={ 322 2+1: dict(type_modifier=objc._C_OUT, null_accepted=False), 323 })) 324 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"swapX:andY:", 325 dict(arguments={ 326 2+0: dict(type_modifier=objc._C_INOUT, null_accepted=False), 327 2+1: dict(type_modifier=objc._C_INOUT, null_accepted=False), 328 })) 329 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"input:output:inputAndOutput:", 330 dict(arguments={ 331 2+0: dict(type_modifier=objc._C_IN, null_accepted=True), 332 2+1: dict(type_modifier=objc._C_OUT, null_accepted=True), 333 2+2: dict(type_modifier=objc._C_INOUT, null_accepted=True), 334 })) 335 336 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeDataForBytes:count:", 337 dict(arguments={ 338 2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False), 339 })) 340 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"makeDataForVoids:count:", 341 dict(arguments={ 342 2+0: dict(type_modifier=objc._C_IN, c_array_length_in_arg=2+1, null_accepted=False), 343 })) 344 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"addOneToBytes:count:", 345 dict(arguments={ 346 2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=False), 347 })) 348 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"addOneToVoids:count:", 349 dict(arguments={ 350 2+0: dict(type_modifier=objc._C_INOUT, c_array_length_in_arg=2+1, null_accepted=False), 351 })) 352 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fillBuffer:count:", 353 dict(arguments={ 354 2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=False), 355 })) 356 objc.registerMetaDataForSelector(b"OC_MetaDataTest", b"fillVoids:count:", 357 dict(arguments={ 358 2+0: dict(type_modifier=objc._C_OUT, c_array_length_in_arg=2+1, null_accepted=False), 359 })) 360 361 362setupMetaData() 363 364class TestArrayDefault (TestCase): 365 # TODO: what is the default anyway? 366 pass 367 368class TestArraysOut (TestCase): 369 def testFixedSize(self): 370 o = OC_MetaDataTest.new() 371 372 v = o.fill4Tuple_(None) 373 self.assertEqual(list(v), [0, -1, -8, -27]) 374 375 self.assertRaises(ValueError, o.fill4Tuple_, objc.NULL) 376 377 n, v = o.nullfill4Tuple_(None) 378 self.assertEqual(n, 1) 379 self.assertEqual(list(v), [0, -1, -8, -27]) 380 381 n, v = o.nullfill4Tuple_(objc.NULL) 382 self.assertEqual(n, 0) 383 self.assertIs(v, objc.NULL) 384 385 a = make_array('i', [0]* 4) 386 v = o.fill4Tuple_(a); 387 self.assertIs(a, v) 388 self.assertEqual(list(a), [0, -1, -8, -27]) 389 390 a = make_array('i', [0]* 5) 391 self.assertRaises(ValueError, o.fill4Tuple_, a) 392 a = make_array('i', [0]* 3) 393 self.assertRaises(ValueError, o.fill4Tuple_, a) 394 395 def testNullTerminated(self): 396 o = OC_MetaDataTest.new() 397 398 # Output only arrays of null-terminated arrays cannot be 399 # wrapped automaticly. How is the bridge supposed to know 400 # how much memory it should allocate for the C-array? 401 self.assertRaises(TypeError, o.fillStringArray_, None) 402 self.assertRaises(ValueError, o.fillStringArray_, objc.NULL) 403 404 self.assertRaises(TypeError, o.nullfillStringArray_) 405 self.assertRaises(TypeError, o.nullfillStringArray_, None) 406 n, v = o.nullfillStringArray_(objc.NULL) 407 self.assertEqual(n, 0) 408 self.assertIs(v, objc.NULL) 409 410 def testWithCount(self): 411 o = OC_MetaDataTest.new() 412 413 v = o.fillArray_count_(None, 3) 414 self.assertEqual(list(v), [0,1,4]) 415 416 v = o.fillArray_count_(None, 3) 417 self.assertEqual(list(v), [0,1,4]) 418 419 v = o.fillArray_count_(None, 5) 420 self.assertEqual(list(v), [0,1,4,9,16]) 421 422 v = o.fillArray_count_(None, 0) 423 self.assertEqual(list(v), []) 424 425 self.assertRaises(ValueError, o.fillArray_count_, objc.NULL, 0) 426 427 n, v = o.nullfillArray_count_(None, 4) 428 self.assertEqual(n, 1) 429 self.assertEqual(list(v), [0,1,4,9]) 430 n, v = o.nullfillArray_count_(None, 3) 431 self.assertEqual(n, 1) 432 self.assertEqual(list(v), [0,1,4]) 433 434 n, v = o.nullfillArray_count_(objc.NULL, 3) 435 self.assertEqual(n, 0) 436 self.assertIs(v, objc.NULL) 437 438 a = make_array('i', [0]* 10) 439 v = o.fillArray_count_(a, 10); 440 self.assertIs(a, v) 441 self.assertEqual(list(a), [0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]) 442 443 def testWithCountInResult(self): 444 o = OC_MetaDataTest.new() 445 446 c, v = o.fillArray_uptoCount_(None, 20) 447 self.assertEqual(c, 10) 448 self.assertEqual(list(v), [i+2 for i in range(10)]) 449 450 c, v = o.maybeFillArray_(None) 451 self.assertEqual(c, 2) 452 self.assertEqual(list(v), [10, 11]) 453 454 455class TestArraysInOut (TestCase): 456 def testFixedSize(self): 457 o = OC_MetaDataTest.new() 458 459 a = (1,2,3,4) 460 v = o.reverse4Tuple_(a) 461 self.assertEqual(a, (1,2,3,4)) 462 self.assertEqual(v, (4,3,2,1)) 463 464 self.assertRaises(ValueError, o.reverse4Tuple_, (1,2,3)) 465 self.assertRaises(ValueError, o.reverse4Tuple_, (1,2,3,4,5)) 466 self.assertRaises(ValueError, o.reverse4Tuple_, objc.NULL) 467 468 a = (1,2,3,4) 469 n, v = o.nullreverse4Tuple_(a) 470 self.assertEqual(n, 1) 471 self.assertEqual(a, (1,2,3,4)) 472 self.assertEqual(v, (4,3,2,1)) 473 474 n, v = o.nullreverse4Tuple_(objc.NULL) 475 self.assertEqual(n, 0) 476 self.assertIs(v, objc.NULL) 477 478 a = make_array('h', [1, 2, 3, 4]) 479 v = o.reverse4Tuple_(a) 480 self.assertIs(v, a) 481 self.assertEqual(list(a), [4,3,2,1]) 482 483 a = make_array('h', [1, 2, 3, 4, 5]) 484 self.assertRaises(ValueError, o.reverse4Tuple_, a) 485 a = make_array('h', [1, 2, 3]) 486 self.assertRaises(ValueError, o.reverse4Tuple_, a) 487 488 def testNullTerminated(self): 489 o = OC_MetaDataTest.new() 490 491 a = (b'a', b'b', b'c') 492 v = o.reverseStrings_(a) 493 self.assertEqual(a, (b'a', b'b', b'c')) 494 self.assertEqual(v, (b'c', b'b', b'a')) 495 496 self.assertRaises(ValueError, o.reverseStrings_, (1,2)) 497 self.assertRaises(ValueError, o.reverseStrings_, objc.NULL) 498 499 a = (b'a', b'b', b'c') 500 n, v = o.nullreverseStrings_(a) 501 self.assertEqual(n, 1) 502 self.assertEqual(a, (b'a', b'b', b'c')) 503 self.assertEqual(v, (b'c', b'b', b'a')) 504 505 n, v = o.nullreverseStrings_(objc.NULL) 506 self.assertEqual(n, 0) 507 self.assertIs(v, objc.NULL) 508 509 def testWithCount(self): 510 o = OC_MetaDataTest.new() 511 512 a = (1.0, 2.0, 3.0, 4.0, 5.0) 513 v = o.reverseArray_count_(a, 4) 514 self.assertEqual(a, (1.0, 2.0, 3.0, 4.0, 5.0)) 515 self.assertEqual(v, (4.0, 3.0, 2.0, 1.0)) 516 517 a = (1.0, 2.0, 3.0, 4.0, 5.0) 518 v = o.reverseArray_count_(a, 5) 519 self.assertEqual(a, (1.0, 2.0, 3.0, 4.0, 5.0)) 520 self.assertEqual(v, (5.0, 4.0, 3.0, 2.0, 1.0)) 521 522 # Nice to have, but doesn't work without major 523 # surgery: 524 #a = (1.0, 2.0, 3.0, 4.0, 5.0) 525 #v = o.reverseArray_count_(a, None) 526 #self.assertEqual(a, (1.0, 2.0, 3.0, 4.0, 5.0)) 527 #self.assertEqual(v, (5.0, 4.0, 3.0, 2.0, 1.0)) 528 529 self.assertRaises(ValueError, o.reverseArray_count_, (1.0, 2.0), 5) 530 self.assertRaises(ValueError, o.reverseArray_count_, objc.NULL, 0) 531 532 a = (1.0, 2.0, 3.0, 4.0, 5.0) 533 n, v = o.nullreverseArray_count_(a, 4) 534 self.assertEqual(n, 1) 535 self.assertEqual(a, (1.0, 2.0, 3.0, 4.0, 5.0)) 536 self.assertEqual(v, (4.0, 3.0, 2.0, 1.0)) 537 538 a = (1.0, 2.0, 3.0, 4.0, 5.0) 539 n, v = o.nullreverseArray_count_(a, 5) 540 self.assertEqual(n, 1) 541 self.assertEqual(a, (1.0, 2.0, 3.0, 4.0, 5.0)) 542 self.assertEqual(v, (5.0, 4.0, 3.0, 2.0, 1.0)) 543 544 n, v = o.nullreverseArray_count_(objc.NULL, 0) 545 self.assertEqual(n, 0) 546 self.assertIs(v, objc.NULL) 547 548 a = make_array('f', [5.0, 7.0, 9.0, 11.0, 13.0]) 549 v = o.reverseArray_count_(a, 5) 550 self.assertIs(a, v) 551 self.assertEqual(list(a), [13.0, 11.0, 9.0, 7.0, 5.0]) 552 553 def testWithCountInResult(self): 554 o = OC_MetaDataTest.new() 555 556 c, v = o.reverseArray_uptoCount_(range(10), 10) 557 self.assertEqual(c, 5) 558 self.assertEqual(len(v), 5) 559 self.assertEqual(list(v), [9, 8, 7, 6, 5]) 560 561 c, v = o.maybeReverseArray_([1,2,3,4]) 562 self.assertEqual(c, 2) 563 self.assertEqual(len(v), 2) 564 self.assertEqual(list(v), [4, 3]) 565 566 567class TestArraysIn (TestCase): 568 def testFixedSize(self): 569 o = OC_MetaDataTest.new() 570 571 v = o.make4Tuple_((1.0, 4.0, 8.0, 12.5)) 572 self.assertEqual(len(v), 4) 573 self.assertEqual(list(v), [1.0, 4.0, 8.0, 12.5]) 574 575 v = o.make4Tuple_((1, 2, 3, 4)) 576 self.assertEqual(len(v), 4) 577 self.assertEqual(list(v), [1.0, 2.0, 3.0, 4.0]) 578 579 self.assertRaises(ValueError, o.make4Tuple_, (1, 2, 3)) 580 self.assertRaises(ValueError, o.make4Tuple_, (1, 2, 3, 4, 5)) 581 self.assertRaises(ValueError, o.make4Tuple_, objc.NULL) 582 583 v = o.null4Tuple_(objc.NULL) 584 self.assertIsNone(v) 585 586 a = make_array('d', [2.5, 3.5, 4.5, 5.5]) 587 v = o.make4Tuple_(a) 588 self.assertEqual(list(v), [2.5, 3.5, 4.5, 5.5]) 589 590 def testNullTerminated(self): 591 o = OC_MetaDataTest.new() 592 593 v = o.makeStringArray_((b"hello", b"world", b"there")) 594 self.assertEqual(len(v), 3) 595 self.assertEqual(list(v), ["hello", "world", "there"]) 596 self.assertIsInstance(v, objc.lookUpClass("NSArray")) 597 self.assertIsInstance(v[0], unicode) 598 599 NSObject = objc.lookUpClass('NSObject') 600 p, q, r = NSObject.new(), NSObject.new(), NSObject.new() 601 v = o.makeObjectArray_((p, q, r)) 602 self.assertEqual(len(v), 3) 603 self.assertIs(v[0], p) 604 self.assertIs(v[1], q) 605 self.assertIs(v[2], r) 606 607 608 v = o.makeStringArray_(()) 609 self.assertEqual(len(v), 0) 610 611 self.assertRaises(ValueError, o.makeStringArray_, [1,2]) 612 self.assertRaises(ValueError, o.makeStringArray_, objc.NULL) 613 614 v = o.nullStringArray_(objc.NULL) 615 self.assertEqual(v, None) 616 617 def testWithCount(self): 618 o = OC_MetaDataTest.new() 619 620 v = o.makeIntArray_count_((1,2,3,4), 3) 621 self.assertEqual(len(v), 3) 622 self.assertEqual(list(v), [1,2,3]) 623 624 # XXX: This one would be nice to have, but not entirely trivial 625 #v = o.makeIntArray_count_((1,2,3,4), None) 626 #self.assertEqual(len(v), 3) 627 #self.assertEqual(list(v), [1,2,3,4]) 628 629 self.assertRaises(ValueError, o.makeIntArray_count_, [1,2,3], 4) 630 self.assertRaises(ValueError, o.makeIntArray_count_, objc.NULL, 0) 631 self.assertRaises(ValueError, o.makeIntArray_count_, objc.NULL, 1) 632 633 v = o.nullIntArray_count_(objc.NULL, 0) 634 self.assertEqual(v, None) 635 636 self.assertRaises(ValueError, o.makeIntArray_count_, objc.NULL, 1) 637 638 # Make sure this also works when the length is in a pass-by-reference argument 639 v = o.makeIntArray_countPtr_((1,2,3,4), 4) 640 self.assertEqual(len(v), 4) 641 self.assertEqual(list(v), [1,2,3,4]) 642 643 a = make_array('i', range(20)) 644 v = o.makeIntArray_count_(a, 7) 645 self.assertEqual(list(v), list(range(7))) 646 647 self.assertRaises(ValueError, o.makeIntArray_count_, a, 21) 648 649 650class TestArrayReturns (TestCase): 651 # TODO: 652 # - Add null-terminated arrays of various supported types: 653 # -> integers 654 # -> CF-types 655 656 def testFixedSize(self): 657 o = OC_MetaDataTest.new() 658 659 v = o.makeIntArrayOf5() 660 self.assertEqual( len(v), 5 ) 661 self.assertEqual( v[0], 0 ) 662 self.assertEqual( v[1], 1 ) 663 self.assertEqual( v[2], 4 ) 664 self.assertEqual( v[3], 9 ) 665 self.assertEqual( v[4], 16 ) 666 667 v = o.nullIntArrayOf5() 668 self.assertEqual(v, objc.NULL) 669 670 def testSizeInArgument(self): 671 o = OC_MetaDataTest.new() 672 v = o.makeIntArrayOf_(3) 673 self.assertEqual(len(v), 3) 674 self.assertEqual(v[0], 0) 675 self.assertEqual(v[1], 1) 676 self.assertEqual(v[2], 8) 677 678 v = o.makeIntArrayOf_(10) 679 self.assertEqual(len(v), 10) 680 for i in range(10): 681 self.assertEqual(v[i], i**3) 682 683 v = o.nullIntArrayOf_(100) 684 self.assertEqual(v, objc.NULL) 685 686 def testNULLterminated(self): 687 o = OC_MetaDataTest.new() 688 689 v = o.makeStringArray() 690 self.assertEqual(len(v), 4) 691 self.assertEqual(list(v), [b"hello", b"world", b"out", b"there"]) 692 693 v = o.nullStringArray() 694 self.assertEqual(v, objc.NULL) 695 696class TestByReference (TestCase): 697 # Pass by reference arguments. 698 # Note that these tests aren't exhaustive, we have test_methods and 699 # test_methods2 for that :-) 700 701 def testInput(self): 702 o = OC_MetaDataTest.new() 703 704 r = o.sumX_andY_(1, 2) 705 self.assertEqual(r, 1+2) 706 707 r = o.sumX_andY_(2535, 5325) 708 self.assertEqual(r, 2535 + 5325) 709 710 self.assertRaises(ValueError, o.sumX_andY_, 42, objc.NULL) 711 712 def testOutput(self): 713 o = OC_MetaDataTest.new() 714 715 div, rem = o.divBy5_remainder_(55, None) 716 self.assertEqual(div, 11) 717 self.assertEqual(rem, 0) 718 719 div, rem = o.divBy5_remainder_(13, None) 720 self.assertEqual(div, 2) 721 self.assertEqual(rem, 3) 722 723 self.assertRaises(ValueError, o.divBy5_remainder_, 42, objc.NULL) 724 725 def testInputOutput(self): 726 o = OC_MetaDataTest.new() 727 x, y = o.swapX_andY_(42, 284) 728 self.assertEqual(x, 284) 729 self.assertEqual(y, 42) 730 731 self.assertRaises(ValueError, o.swapX_andY_, 42, objc.NULL) 732 733 def testNullAccepted(self): 734 o = OC_MetaDataTest.new(); 735 736 def makeNum(value): 737 return int(value, 0) 738 739 # All arguments present 740 r, y, z = o.input_output_inputAndOutput_(1, None, 2) 741 self.assertEqual(len(r), 3) 742 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 3) 743 self.assertEqual(y, 3) 744 self.assertEqual(z, -1) 745 746 r, y, z = o.input_output_inputAndOutput_(1, None, 2) 747 self.assertEqual(len(r), 3) 748 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 3) 749 self.assertEqual(y, 3) 750 self.assertEqual(z, -1) 751 752 # Argument 1 is NULL 753 r, y, z = o.input_output_inputAndOutput_(objc.NULL, None, 2) 754 self.assertEqual(len(r), 3) 755 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 2) 756 self.assertEqual(y, 40) 757 self.assertEqual(z, -2) 758 759 r, y, z = o.input_output_inputAndOutput_(objc.NULL, None, 2) 760 self.assertEqual(len(r), 3) 761 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 2) 762 self.assertEqual(y, 40) 763 self.assertEqual(z, -2) 764 765 # Argument 2 is NULL 766 r, y, z = o.input_output_inputAndOutput_(1, objc.NULL, 2) 767 self.assertEqual(len(r), 3) 768 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 2) 769 self.assertEqual(y, objc.NULL) 770 self.assertEqual(z, -1) 771 772 # Argument 3 is NULL 773 r, y, z = o.input_output_inputAndOutput_(1, None, objc.NULL) 774 self.assertEqual(len(r), 3) 775 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 2) 776 self.assertEqual(y, 43) 777 self.assertEqual(z, objc.NULL) 778 779 r, y, z = o.input_output_inputAndOutput_(1, None, objc.NULL) 780 self.assertEqual(len(r), 3) 781 self.assertEqual(len(list(filter(None, map(makeNum, r)))), 2) 782 self.assertEqual(y, 43) 783 self.assertEqual(z, objc.NULL) 784 785class TestPrintfFormat (TestCase): 786 def test_nsformat(self): 787 o = OC_MetaDataTest.new() 788 789 v = o.makeArrayWithFormat_("%3d", 10) 790 self.assertEqual(list(v), [ "%3d", " 10"]) 791 792 v = o.makeArrayWithFormat_("%s", b"foo") 793 self.assertEqual(list(v), [ "%s", "foo"]) 794 795 v = o.makeArrayWithFormat_("hello %s", b"world") 796 self.assertEqual(list(v), [ "hello %s", "hello world"]) 797 798 v = o.makeArrayWithFormat_("hello %s", b"world") 799 self.assertEqual(list(v), [ "hello %s", "hello world"]) 800 801 self.assertRaises(ValueError, o.makeArrayWithFormat_, "%s") 802 803 def test_cformat(self): 804 o = OC_MetaDataTest.new() 805 806 v = o.makeArrayWithCFormat_(b"%3d", 10) 807 self.assertEqual(list(v), [ "%3d", " 10"]) 808 809 v = o.makeArrayWithCFormat_(b"hello %s", b"world") 810 self.assertEqual(list(v), [ "hello %s", "hello world"]) 811 812 v = o.makeArrayWithCFormat_(b"hello %s x %d", b"world", 42) 813 self.assertEqual(list(v), [ "hello %s x %d", "hello world x 42"]) 814 815 # As we implement a format string parser we'd better make sure that 816 # that code is correct... 817 818 # Generic table below doesn't work for these 819 for fmt, args in [ 820 ( b'%#+x', (99,)), 821 ( b'%+#x', (99,)), 822 ( b'% #x', (99,)), 823 ]: 824 825 v = o.makeArrayWithCFormat_(fmt, *args) 826 self.assertEqual(list(map(unicode, list(v))), [fmt.decode('latin'), (fmt.decode('latin')%args)[1:]] ) 827 828 # Insert thousands seperator, the one in the C locale is '' 829 v = o.makeArrayWithCFormat_(b"%'d", 20000) 830 self.assertEqual(list(v), [ "%'d", '20000']) 831 v = o.makeArrayWithCFormat_(b"%hhd", 20) 832 self.assertEqual(list(v), [ "%hhd", '20']) 833 v = o.makeArrayWithCFormat_(b"%lld", 20) 834 self.assertEqual(list(v), [ "%lld", '20']) 835 v = o.makeArrayWithCFormat_(b"%lld", -20) 836 self.assertEqual(list(v), [ "%lld", '-20']) 837 v = o.makeArrayWithCFormat_(b"%zd", 20) 838 self.assertEqual(list(v), [ "%zd", '20']) 839 v = o.makeArrayWithCFormat_(b"%td", 20) 840 self.assertEqual(list(v), [ "%td", '20']) 841 v = o.makeArrayWithCFormat_(b"%qd", 20) 842 self.assertEqual(list(v), [ "%qd", '20']) 843 v = o.makeArrayWithCFormat_(b"%qd", -20) 844 self.assertEqual(list(v), [ "%qd", '-20']) 845 v = o.makeArrayWithCFormat_(b"%D", -20) 846 self.assertEqual(list(v), [ "%D", '-20']) 847 v = o.makeArrayWithCFormat_(b"%O", 8) 848 self.assertEqual(list(v), [ "%O", '10']) 849 v = o.makeArrayWithCFormat_(b"%U", 8) 850 self.assertEqual(list(v), [ "%U", '8']) 851 852 obj = object() 853 v = o.makeArrayWithCFormat_(b"%p", obj) 854 self.assertEqual(list(v), [ "%p", '%#x'%(id(obj),)]) 855 856 v = o.makeArrayWithCFormat_(b"%lc%lc", 'd', 'e') 857 self.assertEqual(list(v), [ "%lc%lc", 'de']) 858 859 v = o.makeArrayWithCFormat_(b"%C", 'A') 860 self.assertEqual(list(v), [ "%C", 'A']) 861 862 v = o.makeArrayWithCFormat_(b"%C%C%c", 'A', 90, 'b') 863 self.assertEqual(list(v), [ "%C%C%c", 'A%cb'%(90,)]) 864 865 v = o.makeArrayWithCFormat_(b"%S", 'hello world') 866 self.assertEqual(list(v), [ "%S", 'hello world']) 867 v = o.makeArrayWithCFormat_(b"%S", 'hello world') 868 self.assertEqual(list(v), [ "%S", 'hello world']) 869 870 v = o.makeArrayWithCFormat_(b"%ls", 'hello world') 871 self.assertEqual(list(v), [ "%ls", 'hello world']) 872 v = o.makeArrayWithCFormat_(b"%ls", 'hello world') 873 self.assertEqual(list(v), [ "%ls", 'hello world']) 874 875 TEST_TAB = [ 876 ( b'% #d', (99,)), 877 ( b'%0#4x', (99,)), 878 ( b'%#+d', (99,)), 879 ( b'%+#d', (99,)), 880 ( b'%o', (20,) ), 881 ( b'%10o', (9,) ), 882 ( b'%d %.*o', (2, 5, 7,) ), 883 ( b'%*o', (5, 7,) ), 884 ( b'%.*o', (5, 7,) ), 885 ( b'%.*f', (3, 0.23424)), 886 ( b'%*.*f', (12, 3, 0.23424)), 887 ( b'%F', (-4.6,)), 888 ( b'%f', (2.7,)), 889 ( b'%e', (2.7,)), 890 ( b'%E', (-4.6,)), 891 ( b'%g', (2.7,)), 892 ( b'%G', (-4.6,)), 893 ( b'%.9f', (0.249,)), 894 ( b'%ld', (42,)), 895 ( b'%c', (42,)), 896 ( b'%hd', (42,)), 897 ( b'%lx', (42,)), 898 ( b'%%%d%%', (99,)), 899 ( b'%c', ('a',) ), 900 ( b'%c%c', ('c', 'd')), 901 ( b'%c%c', (90, 'd')), 902 ( b'%f %f %f %f %f %f %f %f', (1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5)) 903 904 # We don't have long double support at all 905 #( '%Lg', (42.0,)), 906 ] 907 908 for fmt, args in TEST_TAB: 909 v = o.makeArrayWithCFormat_(fmt, *args) 910 self.assertEqual(list(v), [ fmt.decode('latin1'), fmt.decode('latin1')%args ]) 911 912 913class TestVariadic (TestCase): 914 def testRaises(self): 915 o = OC_MetaDataTest.new() 916 917 self.assertRaises(TypeError, o.varargsMethodWithObjects_, 1) 918 self.assertRaises(TypeError, o.varargsMethodWithObjects_, 1, 2, 3) 919 920class TestIgnore (TestCase): 921 def testRaises(self): 922 o = OC_MetaDataTest.new() 923 924 self.assertRaises(TypeError, o.ignoreMethod) 925 926 def testClassmethods(self): 927 self.assertResultIsBOOL(OC_MetaDataTest.boolClassMethod) 928 929class TestMetaDataAccess (TestCase): 930 def testNew(self): 931 self.assertResultIsRetained(OC_MetaDataTest.new) 932 933 def testSuggestions(self): 934 meta = OC_MetaDataTest.varargsMethodWithObjects_.__metadata__() 935 self.assertIsInstance(meta, dict) 936 self.assertIn('suggestion', meta) 937 self.assertEqual(meta['suggestion'], "Variadic functions/methods are not supported") 938 939 meta = OC_MetaDataTest.ignoreMethod.__metadata__() 940 self.assertIsInstance(meta, dict) 941 self.assertIn('suggestion', meta) 942 self.assertEqual(meta['suggestion'], "please ignore me") 943 944 def testPrintfFormat(self): 945 meta = OC_MetaDataTest.makeArrayWithFormat_.__metadata__() 946 self.assertEqual(meta['variadic'], True) 947 self.assertNotIn('printf_format', meta['arguments'][0]) 948 self.assertEqual(meta['arguments'][2]['printf_format'], True) 949 950 def testVariadic(self): 951 meta = OC_MetaDataTest.makeArrayWithFormat_.__metadata__() 952 self.assertEqual(meta['variadic'], True) 953 954 meta = OC_MetaDataTest.ignoreMethod.__metadata__() 955 self.assertEqual(meta['variadic'], False) 956 957 def testTypes(self): 958 meta = OC_MetaDataTest.ignoreMethod.__metadata__() 959 self.assertEqual(meta['retval']['type'], objc._C_INT) 960 self.assertEqual(meta['arguments'][0]['type'], objc._C_ID) 961 self.assertEqual(meta['arguments'][1]['type'], objc._C_SEL) 962 963 964 meta = OC_MetaDataTest.make4Tuple_.__metadata__() 965 self.assertEqual(meta['retval']['type'], objc._C_ID) 966 self.assertEqual(meta['arguments'][0]['type'], objc._C_ID) 967 self.assertEqual(meta['arguments'][1]['type'], objc._C_SEL) 968 self.assertEqual(meta['arguments'][2]['type'], objc._C_IN + objc._C_PTR + objc._C_DBL) 969 970 def testAllowNull(self): 971 meta = OC_MetaDataTest.make4Tuple_.__metadata__() 972 self.assertNotIn('null_accepted', meta['retval']) 973 self.assertNotIn( 'null_accepted', meta['arguments'][0]) 974 975 meta = OC_MetaDataTest.make4Tuple_.__metadata__() 976 self.assertEqual(meta['arguments'][2]['null_accepted'], False) 977 978 meta = OC_MetaDataTest.null4Tuple_.__metadata__() 979 self.assertEqual(meta['arguments'][2]['null_accepted'], True) 980 981 def alreadyRetained(self): 982 meta = OC_MetaDataTest.null4Tuple_.__metadata__() 983 self.assertEqual(meta['already_retained'], False) 984 985 meta = OC_MetaDataTest.alloc.__metadata__() 986 self.assertEqual(meta['already_retained'], True) 987 988 def testClassMethod(self): 989 meta = OC_MetaDataTest.alloc.__metadata__() 990 self.assertEqual(meta['classmethod'], True) 991 992 meta = OC_MetaDataTest.pyobjc_instanceMethods.init.__metadata__() 993 self.assertEqual(meta['classmethod'], False) 994 995if sys.version_info[0] == 3: 996 def buffer_as_bytes(v): 997 if isinstance(v, bytes): 998 return v 999 return bytes(v) 1000else: 1001 def buffer_as_bytes(v): 1002 return str(buffer(v)) 1003 1004class TestBuffers (TestCase): 1005 # Some tests that check if buffer APIs get sane treatment 1006 1007 def testInChars(self): 1008 o = OC_MetaDataTest.alloc().init() 1009 1010 v = o.makeDataForBytes_count_(b"hello world", len(b"hello world")) 1011 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1012 1013 self.assertEqual(v.length(), len(b"hello world")) 1014 self.assertEqual(buffer_as_bytes(v), b"hello world") 1015 1016 v = o.makeDataForBytes_count_(b"hello\0world", len(b"hello\0world")) 1017 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1018 1019 self.assertEqual(v.length(), len(b"hello\0world")) 1020 self.assertEqual(buffer_as_bytes(v), b"hello\0world") 1021 1022 a = make_array('b', b'foobar monday') 1023 v = o.makeDataForBytes_count_(a, len(a)) 1024 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1025 1026 self.assertEqual(v.length(), len(a)) 1027 self.assertEqual(buffer_as_bytes(v), buffer_as_bytes(a)) 1028 1029 def testInVoids(self): 1030 o = OC_MetaDataTest.alloc().init() 1031 1032 v = o.makeDataForBytes_count_(b"hello world", len(b"hello world")) 1033 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1034 1035 self.assertEqual(v.length(), len(b"hello world")) 1036 self.assertEqual(buffer_as_bytes(v), b"hello world") 1037 1038 v = o.makeDataForBytes_count_(b"hello\0world", len(b"hello\0world")) 1039 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1040 1041 self.assertEqual(v.length(), len(b"hello\0world")) 1042 self.assertEqual(buffer_as_bytes(v), b"hello\0world") 1043 1044 a = make_array('b', b'foobar monday') 1045 v = o.makeDataForBytes_count_(a, len(a)) 1046 self.assertIsInstance(v, objc.lookUpClass("NSData")) 1047 1048 self.assertEqual(v.length(), len(a)) 1049 self.assertEqual(buffer_as_bytes(v), buffer_as_bytes(a)) 1050 1051 def testInOutChars(self): 1052 o = OC_MetaDataTest.alloc().init() 1053 1054 input = b"hello " + b"world" 1055 v = o.addOneToBytes_count_(input, len(input)) 1056 self.assertIsInstance(v, bytes) 1057 1058 self.assertEqual(input, b"hello world") 1059 self.assertEqual(input[0:5], b"hello") 1060 if sys.version_info[0] == 2: 1061 self.assertEqual( 1062 [ ord(x)+1 for x in input ], 1063 [ ord(x) for x in v ]) 1064 else: 1065 self.assertEqual( 1066 [ x+1 for x in input ], 1067 [ x for x in v ]) 1068 1069 input = make_array('b', b"hello\0world") 1070 v = o.addOneToBytes_count_(input, len(input)) 1071 self.assertIs(v, input) 1072 self.assertNotEqual(input[0:5], b"hello") 1073 if sys.version_info[0] == 2: 1074 self.assertEqual( 1075 [ ord(x)+1 for x in "hello\0world" ], 1076 [ x for x in v ]) 1077 else: 1078 self.assertEqual( 1079 [ x+1 for x in b"hello\0world" ], 1080 [ x for x in v ]) 1081 1082 1083 def testInOutVoids(self): 1084 o = OC_MetaDataTest.alloc().init() 1085 1086 input = b"hello " + b"world" 1087 v = o.addOneToVoids_count_(input, len(input)) 1088 self.assertIsInstance(v, type(b"")) 1089 1090 self.assertEqual(input, b"hello world") 1091 self.assertEqual(input[0:5], b"hello") 1092 1093 if sys.version_info[0] == 2: 1094 self.assertEqual( 1095 [ ord(x)+2 for x in input ], 1096 [ ord(x) for x in v ]) 1097 else: 1098 self.assertEqual( 1099 [ x+2 for x in input ], 1100 [ x for x in v ]) 1101 1102 input = make_array('b', b"hello\0world") 1103 v = o.addOneToVoids_count_(input, len(input)) 1104 self.assertIs(v, input) 1105 self.assertNotEqual(input[0:5], b"hello") 1106 if sys.version_info[0] == 2: 1107 self.assertEqual( 1108 [ ord(x)+2 for x in b"hello\0world" ], 1109 [ x for x in v ]) 1110 else: 1111 self.assertEqual( 1112 [ x+2 for x in b"hello\0world" ], 1113 [ x for x in v ]) 1114 1115 def testOutChars(self): 1116 o = OC_MetaDataTest.alloc().init() 1117 1118 v = o.fillBuffer_count_(None, 44); 1119 self.assertEqual(v, b'\xfe'*44); 1120 1121 a = make_array('b', b'0' * 44) 1122 v = o.fillBuffer_count_(a, 44); 1123 self.assertEqual(buffer_as_bytes(v), b'\xfe'*44); 1124 self.assertIs(v, a) 1125 1126 def testOutVoids(self): 1127 o = OC_MetaDataTest.alloc().init() 1128 1129 v = o.fillVoids_count_(None, 44); 1130 self.assertEqual(v, b'\xab'*44); 1131 1132 if sys.version_info[0] == 2: 1133 a = make_array('c', b'0' * 44) 1134 else: 1135 a = make_array('b', (0,) * 44) 1136 v = o.fillVoids_count_(a, 44); 1137 self.assertEqual(buffer_as_bytes(v), b'\xab'*44); 1138 self.assertIs(v, a) 1139 1140class TestVariableLengthValue (TestCase): 1141 1142 def testResult(self): 1143 o = OC_MetaDataTest.alloc().init() 1144 1145 v = o.unknownLengthArray() 1146 self.assertIsInstance(v, objc.varlist) 1147 1148 self.assertEqual(v[0], 1) 1149 self.assertEqual(v[1], 3) 1150 self.assertEqual(v[5], 13) 1151 1152 #self.fail((type(v), v)) 1153 #self.fail((v[0:2], type(v[0:2]))) 1154 self.assertEqual(v[0:2], (1,3)) 1155 1156 self.assertEqual(v.as_tuple(5), (1, 3, 5, 7, 11)) 1157 self.assertEqual(v.as_tuple(0), ()) 1158 self.assertEqual(v.as_tuple(8), (1, 3, 5, 7, 11, 13, 17, 19)) 1159 1160 v = o.unknownLengthMutable() 1161 self.assertIsInstance(v, objc.varlist) 1162 1163 v[1] = 42 1164 self.assertEqual(v[1], 42) 1165 v[0:10] = range(10) 1166 self.assertEqual(v[0], 0) 1167 self.assertEqual(v[5], 5) 1168 self.assertEqual(v[8], 8) 1169 1170 def testInput(self): 1171 o = OC_MetaDataTest.alloc().init() 1172 1173 v = o.makeIntArray_halfCount_((1,2,3,4,5,6), 2) 1174 self.assertEqual(list(v), [1,2,3,4]) 1175 1176 # XXX: Hard crash when using o.makeVariableLengthArray_halfCount_??? 1177 1178class TestVariadicArray (TestCase): 1179 def testObjects(self): 1180 o = OC_MetaDataTest.alloc().init() 1181 1182 v = o.makeArrayWithArguments_() 1183 self.assertEqual(v, []) 1184 1185 v = o.makeArrayWithArguments_(1, 2, 3) 1186 self.assertEqual(v, [1, 2, 3]) 1187 1188 v = o.makeArrayWithArguments_(4, None, 5) 1189 self.assertEqual(v, [4]) 1190 1191 v = o.makeArrayWithArguments_(*range(40)) 1192 self.assertEqual(v, list(range(40))) 1193 1194if __name__ == "__main__": 1195 main() 1196