1from PyObjCTools.TestSupport import *
2import array
3from CoreFoundation import *
4import CoreFoundation
5import sys
6import AppKit
7
8try:
9    unicode
10except NameError:
11    unicode = str
12
13
14try:
15    long
16except NameError:
17    long = int
18
19try:
20    unichr
21except NameError:
22    unichr = chr
23
24try:
25    from Foundation import __NSCFString as NSCFString
26except ImportError:
27    from Foundation import NSCFString
28
29
30class TestString (TestCase):
31    def testType(self):
32        self.assertTrue(issubclass(CFStringRef, NSString))
33
34    def testTypeID(self):
35        v = CFStringGetTypeID()
36        self.assertIsInstance(v, (int, long))
37
38    def testNoPascalStrings(self):
39        self.assertNotHasAttr(CoreFoundation, 'CFStringCreateWithPascalString')
40        self.assertNotHasAttr(CoreFoundation, 'CFStringCreateWithPascalStringNoCopy')
41        self.assertNotHasAttr(CoreFoundation, 'CFStringGetPascalString')
42        self.assertNotHasAttr(CoreFoundation, 'CFStringGetPascalStringPtr')
43        self.assertNotHasAttr(CoreFoundation, 'CFStringAppendPascalString')
44
45    def testCreation(self):
46        s = CFStringCreateWithCString(None, b"hello world", kCFStringEncodingASCII)
47        self.assertIsInstance(s, objc.pyobjc_unicode)
48        self.assertIsInstance(s, unicode)
49        self.assertEqual(s, b"hello world".decode('ascii'))
50
51        s = CFStringCreateWithBytes(None, b"hello world", 5, kCFStringEncodingASCII, False)
52        self.assertIsInstance(s, objc.pyobjc_unicode)
53        self.assertIsInstance(s, unicode)
54        self.assertEqual(s, b"hello".decode('ascii'))
55
56        s = CFStringCreateWithCharacters(None, b"HELLO".decode('ascii'), 5)
57        self.assertIsInstance(s, objc.pyobjc_unicode)
58        self.assertIsInstance(s, unicode)
59        self.assertEqual(s, b"HELLO".decode('ascii'))
60
61        # NOTE: the deallocator must be kCFAllocatorNull
62        s = CFStringCreateWithCStringNoCopy(None, b"hello world",
63                kCFStringEncodingASCII, kCFAllocatorNull)
64        self.assertIsInstance(s, objc.pyobjc_unicode)
65        self.assertIsInstance(s, unicode)
66        self.assertEqual(s, b"hello world".decode('ascii'))
67
68
69        s = CFStringCreateWithBytesNoCopy(None, b"hello world", 5, kCFStringEncodingASCII, False, kCFAllocatorNull)
70        self.assertIsInstance(s, objc.pyobjc_unicode)
71        self.assertIsInstance(s, unicode)
72        self.assertEqual(s, b"hello".decode('ascii'))
73
74        s = CFStringCreateWithCharactersNoCopy(None, b"HELLO".decode('ascii'), 5, kCFAllocatorNull)
75        self.assertIsInstance(s, objc.pyobjc_unicode)
76        self.assertIsInstance(s, unicode)
77        self.assertEqual(s, b"HELLO".decode('ascii'))
78
79        del s
80
81        s = CFStringCreateWithSubstring(None,
82                b"Hello world".decode('ascii'), CFRange(2, 4))
83        self.assertIsInstance(s, objc.pyobjc_unicode)
84        self.assertEqual(s, b"Hello world".decode('ascii')[2:6])
85
86        s = CFStringCreateCopy(None, b"foo the bar".decode('ascii'))
87        self.assertIsInstance(s, objc.pyobjc_unicode)
88        self.assertEqual(s, b"foo the bar".decode('ascii'))
89
90        s = CFStringCreateWithFormat(None, None, "hello %s = %d",
91                b"foo", 52)
92        self.assertIsInstance(s, objc.pyobjc_unicode)
93        self.assertEqual(s, b"hello foo = 52".decode('ascii'))
94
95        self.assertFalse(hasattr(CoreFoundation,
96            "CFStringCreateWithFormatAndArguments"))
97
98    def testCreateMutable(self):
99        s = CFStringCreateMutable(None, 0)
100        self.assertIsInstance(s, objc.pyobjc_unicode)
101        self.assertEqual(s, b"".decode('ascii'))
102
103        s = CFStringCreateMutableCopy(None, 0, b"foobar".decode('ascii'))
104        self.assertIsInstance(s, objc.pyobjc_unicode)
105        self.assertEqual(s, b"foobar".decode('ascii'))
106
107        if sys.version_info[:2] < (3,3):
108            # See issue15035 on Python's tracker. There currently is
109            # no array format code for UCS2 storage (Python 3.3 or later)
110            # Therefore these tests can only work for earlier versions
111            # of Python.
112
113            b = array.array('u', b"hello world".decode('latin1'))
114            s = CFStringCreateMutableWithExternalCharactersNoCopy(
115                    None, b, len(b), len(b), kCFAllocatorNull)
116            self.assertIsInstance(s, objc.pyobjc_unicode)
117            self.assertEqual(s, b"hello world".decode('ascii'))
118
119            b[0] = b'H'.decode('ascii')
120
121
122            # The objc_unicode proxy is immutable
123            self.assertEqual(s, b"hello world".decode('ascii'))
124
125            # The changed string can be accessed directly though:
126            s = s.nsstring()
127            self.assertEqual(s, b"Hello world".decode('ascii'))
128
129            b2 = array.array('u', b" ".decode('ascii') * 40)
130            CFStringSetExternalCharactersNoCopy(s, b2, len(s), 40)
131            self.assertEqual(s, ' ' * len(b))
132            b2[0] = b'X'.decode('ascii')
133            self.assertEqual(s, 'X' + (' ' * (len(b)-1)))
134
135    def testFunctions(self):
136        v = CFStringGetLength(b"bla bla".decode('ascii'))
137        self.assertEqual(v, 7)
138
139        v = CFStringGetCharacterAtIndex(b"zing".decode('ascii'), 2)
140        self.assertIsInstance(v, unicode)
141        self.assertIsNotInstance(v, objc.pyobjc_unicode)
142        self.assertEqual(v, b'n'.decode('ascii'))
143
144        v = CFStringGetCharacters(b"foo".decode('ascii'), CFRange(0, 3), None)
145        self.assertIsInstance(v, unicode)
146        self.assertIsNotInstance(v, objc.pyobjc_unicode)
147        self.assertEqual(v, b'foo'.decode('ascii'))
148
149        ok, buf = CFStringGetCString(b"sing along".decode('ascii'), None, 100, kCFStringEncodingUTF8)
150        self.assertTrue(ok)
151
152        # Annoyingly metadata cannot represent the exact interface
153        self.assertIsInstance(buf, bytes)
154        if b'\0' in buf:
155            buf = buf[:buf.index(b'\0')]
156        self.assertEqual(buf, b'sing along')
157        s = CFStringGetCStringPtr(b"apenootjes".decode('ascii'), kCFStringEncodingASCII)
158        if s is not objc.NULL:
159            self.assertEqual(s, b"apenootjes")
160            self.assertIsInstance(s, str)
161        s = CFStringGetCharactersPtr(b"apenootjes".decode('ascii'))
162        if s is not objc.NULL:
163            self.assertEqual(s, "apenootjes")
164            self.assertIsInstance(s, unicode)
165        idx, buf, used = CFStringGetBytes(b"apenootjes".decode('ascii'),
166                CFRange(1, 4), kCFStringEncodingASCII,
167                b'\0', True, None, 50, None)
168        self.assertEqual(idx, 4)
169        self.assertIsInstance(buf, bytes)
170        self.assertEqual(buf, b'peno')
171        self.assertEqual(used, 4)
172
173        if sys.version_info[0] == 2:
174            s = CFStringCreateFromExternalRepresentation(None,
175                    buffer('hello world'), kCFStringEncodingUTF8)
176        else:
177            s = CFStringCreateFromExternalRepresentation(None,
178                    b'hello world', kCFStringEncodingUTF8)
179        self.assertIsInstance(s, objc.pyobjc_unicode)
180        self.assertEqual(s, b"hello world".decode('ascii'))
181
182        data = CFStringCreateExternalRepresentation(None, s,
183                kCFStringEncodingUTF16BE, b'\0')
184        self.assertIsInstance(data, CFDataRef)
185        val = CFDataGetBytes(data, (0, CFDataGetLength(data)), None)
186        self.assertEqual(val,
187                b'\0h\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d')
188
189        v = CFStringGetSmallestEncoding(s)
190        self.assertIsInstance(v, (int, long))
191        v = CFStringGetFastestEncoding(s)
192        self.assertIsInstance(v, (int, long))
193        v = CFStringGetSystemEncoding()
194        self.assertIsInstance(v, (int, long))
195        v = CFStringGetMaximumSizeForEncoding(100, kCFStringEncodingUTF8)
196        self.assertIsInstance(v, (int, long))
197        ok, buf = CFStringGetFileSystemRepresentation(b"/path/to/nowhere.txt".decode('ascii'),
198                None, 100)
199        self.assertTrue(ok)
200        if b'\0' in buf:
201            buf = buf[:buf.index(b'\0')]
202        self.assertEqual(buf, b'/path/to/nowhere.txt')
203        self.assertIsInstance(buf, bytes)
204        idx = CFStringGetMaximumSizeOfFileSystemRepresentation(b"/tmp".decode('ascii'))
205        self.assertIsInstance(idx, (int, long))
206        s = CFStringCreateWithFileSystemRepresentation(None, b"/tmp")
207        self.assertIsInstance(s, objc.pyobjc_unicode)
208        self.assertEqual(s, b"/tmp".decode('ascii'))
209        self.assertRaises((TypeError, ValueError),
210                CFStringCreateWithFileSystemRepresentation, None, b"/tmp".decode('ascii'))
211
212        r = CFStringCompareWithOptionsAndLocale(
213                b"aas".decode('ascii'), b"noot".decode('ascii'),
214                CFRange(0, 3),
215                kCFCompareBackwards, CFLocaleCopyCurrent())
216        self.assertEqual(r, kCFCompareLessThan)
217
218        r = CFStringCompareWithOptions(b"aap".decode('ascii'), b"noot".decode('ascii'), CFRange(0, 3), 0)
219        self.assertEqual(r, kCFCompareLessThan)
220
221        r = CFStringCompare(b"aap".decode('ascii'), b"AAP".decode('ascii'), kCFCompareCaseInsensitive)
222        self.assertEqual(r, kCFCompareEqualTo)
223
224        found, rng = CFStringFindWithOptionsAndLocale(
225                b"the longer string".decode('ascii'), b"longer".decode('ascii'),
226                CFRange(0, 17), 0, CFLocaleCopyCurrent(), None)
227        self.assertIs(found, True)
228        self.assertIsInstance(rng, CFRange)
229        self.assertEqual(rng, CFRange(4, 6))
230
231        found, rng = CFStringFindWithOptions(
232                b"the longer string".decode('ascii'), b"longer".decode('ascii'),
233                CFRange(0, 17), 0, None)
234        self.assertIs(found, True)
235        self.assertIsInstance(rng, CFRange)
236        self.assertEqual(rng, CFRange(4, 6))
237
238        arr = CFStringCreateArrayWithFindResults(
239                None, b"word a world a world".decode('ascii'),
240                b"world".decode('ascii'), CFRange(0, 20), 0)
241        self.assertIsInstance(arr, CFArrayRef)
242        self.assertEqual(len(arr), 2)
243
244        rng = CFStringFind("hello world", "world", 0)
245        self.assertEqual(rng, CFRange(6, 5))
246
247        ok = CFStringHasPrefix(b"hello".decode('ascii'), b"he".decode('ascii'))
248        self.assertIs(ok, True)
249        ok = CFStringHasPrefix(b"hello".decode('ascii'), b"ge".decode('ascii'))
250        self.assertIs(ok, False)
251        ok = CFStringHasSuffix(b"hello".decode('ascii'), "lo")
252        self.assertIs(ok, True)
253        rng = CFStringGetRangeOfComposedCharactersAtIndex(
254                b"hello world".decode('ascii'), 5)
255        self.assertIsInstance(rng, CFRange)
256        found, rng = CFStringFindCharacterFromSet("hello  world",
257                CFCharacterSetGetPredefined(kCFCharacterSetWhitespace),
258                CFRange(0, 12), 0, None)
259        self.assertIs(found, True)
260        self.assertIsInstance(rng, CFRange)
261        lineBeginIndex, lineEndIndex, contentsEndIndex = CFStringGetLineBounds(
262                b"hello\n\nworld".decode('ascii'), CFRange(0, 12), None, None, None)
263        self.assertEqual(lineBeginIndex, 0)
264        self.assertEqual(lineEndIndex, 12)
265        self.assertEqual(contentsEndIndex, 12)
266
267        paraBeginIndex, paraEndIndex, contentsEndIndex = CFStringGetParagraphBounds(
268                b"hello\n\nworld".decode('ascii'), CFRange(0, 12), None, None, None)
269        self.assertEqual(paraBeginIndex, 0)
270        self.assertEqual(paraEndIndex, 12)
271        self.assertEqual(contentsEndIndex, 12)
272
273        result = CFStringCreateByCombiningStrings(None,
274                [b"hello".decode('ascii'), b"world".decode('ascii')], "//")
275        self.assertEqual(result, b"hello//world".decode('ascii'))
276
277        result = CFStringCreateArrayBySeparatingStrings(None,
278                "hello world", " ")
279        self.assertEqual(result, ["hello", "world"])
280
281        v = CFStringGetIntValue(b"1000".decode('ascii'))
282        self.assertEqual(v, 1000)
283
284        v = CFStringGetDoubleValue(b"1000".decode('ascii'))
285        self.assertEqual(v, 1000.0)
286
287        v = CFStringGetDoubleValue(b"1000.5".decode('ascii'))
288        self.assertEqual(v, 1000.5)
289
290    def testMutableFunctions(self):
291        s = CFStringCreateMutable(None, 0)
292        # Ensure that we actually see updates:
293        s = s.nsstring()
294
295        CFStringAppendCharacters(s, b"hel".decode('ascii'), 3)
296        self.assertEqual(s, b"hel".decode('ascii'))
297
298        CFStringAppendCString(s, b"lo world", kCFStringEncodingUTF8)
299        self.assertEqual(s, b"hello world".decode('ascii'))
300
301        CFStringAppendFormat(s, None, ": %s = %d", b"x", 99)
302        self.assertEqual(s, b"hello world: x = 99".decode('ascii'))
303
304        self.assertNotHasAttr(CoreFoundation, 'CFStringAppendFormatAndArguments')
305        CFStringInsert(s, 2, "--")
306        self.assertEqual(s, b"he--llo world: x = 99".decode('ascii'))
307
308        CFStringDelete(s, CFRange(0, 8))
309        self.assertEqual(s, b"world: x = 99".decode('ascii'))
310
311        CFStringReplace(s, CFRange(0, 4), "WOR")
312        self.assertEqual(s, b"WORd: x = 99".decode('ascii'))
313
314        CFStringReplaceAll(s, "WHOOPS")
315        self.assertEqual(s, b"WHOOPS".decode('ascii'))
316
317        CFStringReplaceAll(s, b"BLAblaBLAblaBLA".decode('ascii'))
318        self.assertEqual(s, b"BLAblaBLAblaBLA".decode('ascii'))
319
320        CFStringFindAndReplace(s, "BL", " fo ", CFRange(0, 15), 0)
321        self.assertEqual(s, " fo Abla fo Abla fo A")
322
323        CFStringReplaceAll(s, b"abc".decode('ascii'))
324        CFStringPad(s, " ", 9, 0)
325        self.assertEqual(s, b"abc      ".decode('ascii'))
326
327        CFStringReplaceAll(s, b"abc".decode('ascii'))
328        CFStringPad(s, ". ", 9, 1)
329        self.assertEqual(s, b"abc . . .".decode('ascii'))
330
331        CFStringReplaceAll(s, b"abcdef".decode('ascii'))
332        CFStringPad(s, ". ", 3, 0)
333        self.assertEqual(s, b"abc".decode('ascii'))
334
335        CFStringReplaceAll(s, b"aHelloaaa".decode('ascii'))
336        trim_chars = b'a'.decode('ascii')
337
338        #print s
339        CFStringTrim(s, trim_chars)
340        #print s
341        self.assertEqual(s, b"Hello".decode('ascii'))
342
343        CFStringReplaceAll(s, b"* * * *abc * ".decode('ascii'))
344        trim_chars = b'* '.decode('ascii')
345
346        trim_chars = CFStringCreateWithCString(None, b"* ", kCFStringEncodingASCII)
347        CFStringTrim(s, trim_chars)
348        self.assertEqual(s, b"*abc ".decode('ascii'))
349
350
351        CFStringReplaceAll(s, b" \tHello world  \t ".decode('ascii'))
352        CFStringTrimWhitespace(s)
353        self.assertEqual(s, b"Hello world".decode('ascii'))
354
355
356        CFStringReplaceAll(s, b"AbC".decode('ascii'))
357        CFStringLowercase(s, CFLocaleCopyCurrent())
358        self.assertEqual(s, b'abc'.decode('ascii'))
359
360        CFStringReplaceAll(s, b"AbC".decode('ascii'))
361        CFStringUppercase(s, CFLocaleCopyCurrent())
362        self.assertEqual(s, b'ABC'.decode('ascii'))
363
364        CFStringReplaceAll(s, b"hello world".decode('ascii'))
365        CFStringCapitalize(s, CFLocaleCopyCurrent())
366        self.assertEqual(s, b'Hello World'.decode('ascii'))
367
368        CFStringNormalize(s, kCFStringNormalizationFormKD)
369        self.assertEqual(s, b'Hello World'.decode('ascii'))
370
371        CFStringFold(s, kCFCompareCaseInsensitive, CFLocaleCopyCurrent())
372        self.assertEqual(s, b'hello world'.decode('ascii'))
373
374        CFStringReplaceAll(s, b"A C".decode('ascii'))
375        ok, rng = CFStringTransform(s, CFRange(0, 3), kCFStringTransformToXMLHex,
376                                        False)
377        self.assertEqual(s, 'A C')
378        self.assertIs(ok, True)
379        self.assertEqual(rng, CFRange(0, 3))
380
381    def testStringEncoding(self):
382        ok = CFStringIsEncodingAvailable(kCFStringEncodingUTF8)
383        self.assertIs(ok, True)
384        encodings = CFStringGetListOfAvailableEncodings()
385        self.assertIsInstance(encodings, objc.varlist)
386        for e in encodings:
387            if e == kCFStringEncodingInvalidId:
388                break
389            self.assertIsInstance(e, (int, long))
390        s = CFStringGetNameOfEncoding(kCFStringEncodingUTF8)
391        self.assertEqual(s, 'Unicode (UTF-8)')
392
393        v = CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingUTF8)
394        self.assertIsInstance(v, (int, long))
395        t = CFStringConvertNSStringEncodingToEncoding(v)
396        self.assertEqual(t, kCFStringEncodingUTF8)
397
398        v = CFStringConvertEncodingToWindowsCodepage(kCFStringEncodingISOLatin1)
399        self.assertIsInstance(v, (int, long))
400        t = CFStringConvertWindowsCodepageToEncoding(v)
401        self.assertEqual(t, kCFStringEncodingISOLatin1)
402
403        v = CFStringConvertEncodingToIANACharSetName(kCFStringEncodingUTF8)
404        self.assertIsInstance(v, unicode)
405        self.assertIn(v, ('UTF-8', 'utf-8'))
406
407        t = CFStringConvertIANACharSetNameToEncoding(v)
408        self.assertEqual(t, kCFStringEncodingUTF8)
409
410        v = CFStringGetMostCompatibleMacStringEncoding(kCFStringEncodingWindowsLatin1)
411        self.assertEqual(v, kCFStringEncodingMacRoman)
412
413    def testNoInlineBuffer(self):
414        self.assertNotHasAttr(CoreFoundation, 'CFStringInlineBuffer')
415        self.assertNotHasAttr(CoreFoundation, 'CFStringInitInlineBuffer')
416        self.assertNotHasAttr(CoreFoundation, 'CFStringGetCharacterFromInlineBuffer')
417
418    def testConstants(self):
419        self.assertEqual(kCFStringEncodingInvalidId , 0xffffffff)
420        self.assertEqual(kCFStringEncodingMacRoman , 0)
421        self.assertEqual(kCFStringEncodingWindowsLatin1 , 0x0500)
422        self.assertEqual(kCFStringEncodingISOLatin1 , 0x0201)
423        self.assertEqual(kCFStringEncodingNextStepLatin , 0x0B01)
424        self.assertEqual(kCFStringEncodingASCII , 0x0600)
425        self.assertEqual(kCFStringEncodingUnicode , 0x0100)
426        self.assertEqual(kCFStringEncodingUTF8 , 0x08000100)
427        self.assertEqual(kCFStringEncodingNonLossyASCII , 0x0BFF)
428        self.assertEqual(kCFStringEncodingUTF16 , 0x0100)
429        self.assertEqual(kCFStringEncodingUTF16BE , 0x10000100)
430        self.assertEqual(kCFStringEncodingUTF16LE , 0x14000100)
431        self.assertEqual(kCFStringEncodingUTF32 , 0x0c000100)
432        self.assertEqual(kCFStringEncodingUTF32BE , 0x18000100)
433        self.assertEqual(kCFStringEncodingUTF32LE , 0x1c000100)
434        self.assertEqual(kCFCompareCaseInsensitive , 1)
435        self.assertEqual(kCFCompareBackwards , 4)
436        self.assertEqual(kCFCompareAnchored , 8)
437        self.assertEqual(kCFCompareNonliteral , 16)
438        self.assertEqual(kCFCompareLocalized , 32)
439        self.assertEqual(kCFCompareNumerically , 64)
440        self.assertEqual(kCFCompareDiacriticInsensitive , 128)
441        self.assertEqual(kCFCompareWidthInsensitive , 256)
442        self.assertEqual(kCFCompareForcedOrdering , 512)
443        self.assertEqual(kCFStringNormalizationFormD , 0)
444        self.assertEqual(kCFStringNormalizationFormKD , 1)
445        self.assertEqual(kCFStringNormalizationFormC , 2)
446        self.assertEqual(kCFStringNormalizationFormKC , 3)
447        self.assertIsInstance(kCFStringTransformStripCombiningMarks, unicode)
448        self.assertIsInstance(kCFStringTransformToLatin, unicode)
449        self.assertIsInstance(kCFStringTransformFullwidthHalfwidth, unicode)
450        self.assertIsInstance(kCFStringTransformLatinKatakana, unicode)
451        self.assertIsInstance(kCFStringTransformLatinHiragana, unicode)
452        self.assertIsInstance(kCFStringTransformHiraganaKatakana, unicode)
453        self.assertIsInstance(kCFStringTransformMandarinLatin, unicode)
454        self.assertIsInstance(kCFStringTransformLatinHangul, unicode)
455        self.assertIsInstance(kCFStringTransformLatinArabic, unicode)
456        self.assertIsInstance(kCFStringTransformLatinHebrew, unicode)
457        self.assertIsInstance(kCFStringTransformLatinThai, unicode)
458        self.assertIsInstance(kCFStringTransformLatinCyrillic, unicode)
459        self.assertIsInstance(kCFStringTransformLatinGreek, unicode)
460        self.assertIsInstance(kCFStringTransformToXMLHex, unicode)
461        self.assertIsInstance(kCFStringTransformToUnicodeName, unicode)
462        self.assertIsInstance(kCFStringTransformStripDiacritics, unicode)
463
464    def testNoPrivate(self):
465        self.assertNotHasAttr(CoreFoundation, '__CFStringMakeConstantString')
466
467    def testCFSTR(self):
468        v = CFSTR(b"hello".decode('ascii'))
469        self.assertIsInstance(v, unicode)
470
471class TestStringEncodingExt (TestCase):
472    @min_os_level('10.6')
473    def testConstants10_6(self):
474        self.assertEqual(kCFStringEncodingUTF7, 0x04000100)
475        self.assertEqual(kCFStringEncodingUTF7_IMAP, 0x0A10)
476
477    def testConstants(self):
478        self.assertEqual(kCFStringEncodingMacJapanese , 1 )
479        self.assertEqual(kCFStringEncodingMacChineseTrad , 2 )
480        self.assertEqual(kCFStringEncodingMacKorean , 3 )
481        self.assertEqual(kCFStringEncodingMacArabic , 4 )
482        self.assertEqual(kCFStringEncodingMacHebrew , 5 )
483        self.assertEqual(kCFStringEncodingMacGreek , 6 )
484        self.assertEqual(kCFStringEncodingMacCyrillic , 7 )
485        self.assertEqual(kCFStringEncodingMacDevanagari , 9 )
486        self.assertEqual(kCFStringEncodingMacGurmukhi , 10 )
487        self.assertEqual(kCFStringEncodingMacGujarati , 11 )
488        self.assertEqual(kCFStringEncodingMacOriya , 12 )
489        self.assertEqual(kCFStringEncodingMacBengali , 13 )
490        self.assertEqual(kCFStringEncodingMacTamil , 14 )
491        self.assertEqual(kCFStringEncodingMacTelugu , 15 )
492        self.assertEqual(kCFStringEncodingMacKannada , 16 )
493        self.assertEqual(kCFStringEncodingMacMalayalam , 17 )
494        self.assertEqual(kCFStringEncodingMacSinhalese , 18 )
495        self.assertEqual(kCFStringEncodingMacBurmese , 19 )
496        self.assertEqual(kCFStringEncodingMacKhmer , 20 )
497        self.assertEqual(kCFStringEncodingMacThai , 21 )
498        self.assertEqual(kCFStringEncodingMacLaotian , 22 )
499        self.assertEqual(kCFStringEncodingMacGeorgian , 23 )
500        self.assertEqual(kCFStringEncodingMacArmenian , 24 )
501        self.assertEqual(kCFStringEncodingMacChineseSimp , 25 )
502        self.assertEqual(kCFStringEncodingMacTibetan , 26 )
503        self.assertEqual(kCFStringEncodingMacMongolian , 27 )
504        self.assertEqual(kCFStringEncodingMacEthiopic , 28 )
505        self.assertEqual(kCFStringEncodingMacCentralEurRoman , 29 )
506        self.assertEqual(kCFStringEncodingMacVietnamese , 30 )
507        self.assertEqual(kCFStringEncodingMacExtArabic , 31 )
508        self.assertEqual(kCFStringEncodingMacSymbol , 33 )
509        self.assertEqual(kCFStringEncodingMacDingbats , 34 )
510        self.assertEqual(kCFStringEncodingMacTurkish , 35 )
511        self.assertEqual(kCFStringEncodingMacCroatian , 36 )
512        self.assertEqual(kCFStringEncodingMacIcelandic , 37 )
513        self.assertEqual(kCFStringEncodingMacRomanian , 38 )
514        self.assertEqual(kCFStringEncodingMacCeltic , 39 )
515        self.assertEqual(kCFStringEncodingMacGaelic , 40, )
516        self.assertEqual(kCFStringEncodingMacFarsi , 0x8C )
517        self.assertEqual(kCFStringEncodingMacUkrainian , 0x98 )
518        self.assertEqual(kCFStringEncodingMacInuit , 0xEC )
519        self.assertEqual(kCFStringEncodingMacVT100 , 0xFC )
520        self.assertEqual(kCFStringEncodingMacHFS , 0xFF )
521        self.assertEqual(kCFStringEncodingISOLatin2 , 0x0202 )
522        self.assertEqual(kCFStringEncodingISOLatin3 , 0x0203 )
523        self.assertEqual(kCFStringEncodingISOLatin4 , 0x0204 )
524        self.assertEqual(kCFStringEncodingISOLatinCyrillic , 0x0205 )
525        self.assertEqual(kCFStringEncodingISOLatinArabic , 0x0206 )
526        self.assertEqual(kCFStringEncodingISOLatinGreek , 0x0207 )
527        self.assertEqual(kCFStringEncodingISOLatinHebrew , 0x0208 )
528        self.assertEqual(kCFStringEncodingISOLatin5 , 0x0209 )
529        self.assertEqual(kCFStringEncodingISOLatin6 , 0x020A )
530        self.assertEqual(kCFStringEncodingISOLatinThai , 0x020B )
531        self.assertEqual(kCFStringEncodingISOLatin7 , 0x020D )
532        self.assertEqual(kCFStringEncodingISOLatin8 , 0x020E )
533        self.assertEqual(kCFStringEncodingISOLatin9 , 0x020F )
534        self.assertEqual(kCFStringEncodingISOLatin10 , 0x0210 )
535        self.assertEqual(kCFStringEncodingDOSLatinUS , 0x0400 )
536        self.assertEqual(kCFStringEncodingDOSGreek , 0x0405 )
537        self.assertEqual(kCFStringEncodingDOSBalticRim , 0x0406 )
538        self.assertEqual(kCFStringEncodingDOSLatin1 , 0x0410 )
539        self.assertEqual(kCFStringEncodingDOSGreek1 , 0x0411 )
540        self.assertEqual(kCFStringEncodingDOSLatin2 , 0x0412 )
541        self.assertEqual(kCFStringEncodingDOSCyrillic , 0x0413 )
542        self.assertEqual(kCFStringEncodingDOSTurkish , 0x0414 )
543        self.assertEqual(kCFStringEncodingDOSPortuguese , 0x0415 )
544        self.assertEqual(kCFStringEncodingDOSIcelandic , 0x0416 )
545        self.assertEqual(kCFStringEncodingDOSHebrew , 0x0417 )
546        self.assertEqual(kCFStringEncodingDOSCanadianFrench , 0x0418 )
547        self.assertEqual(kCFStringEncodingDOSArabic , 0x0419 )
548        self.assertEqual(kCFStringEncodingDOSNordic , 0x041A )
549        self.assertEqual(kCFStringEncodingDOSRussian , 0x041B )
550        self.assertEqual(kCFStringEncodingDOSGreek2 , 0x041C )
551        self.assertEqual(kCFStringEncodingDOSThai , 0x041D )
552        self.assertEqual(kCFStringEncodingDOSJapanese , 0x0420 )
553        self.assertEqual(kCFStringEncodingDOSChineseSimplif , 0x0421 )
554        self.assertEqual(kCFStringEncodingDOSKorean , 0x0422 )
555        self.assertEqual(kCFStringEncodingDOSChineseTrad , 0x0423 )
556        self.assertEqual(kCFStringEncodingWindowsLatin2 , 0x0501 )
557        self.assertEqual(kCFStringEncodingWindowsCyrillic , 0x0502 )
558        self.assertEqual(kCFStringEncodingWindowsGreek , 0x0503 )
559        self.assertEqual(kCFStringEncodingWindowsLatin5 , 0x0504 )
560        self.assertEqual(kCFStringEncodingWindowsHebrew , 0x0505 )
561        self.assertEqual(kCFStringEncodingWindowsArabic , 0x0506 )
562        self.assertEqual(kCFStringEncodingWindowsBalticRim , 0x0507 )
563        self.assertEqual(kCFStringEncodingWindowsVietnamese , 0x0508 )
564        self.assertEqual(kCFStringEncodingWindowsKoreanJohab , 0x0510 )
565        self.assertEqual(kCFStringEncodingANSEL , 0x0601 )
566        self.assertEqual(kCFStringEncodingJIS_X0201_76 , 0x0620 )
567        self.assertEqual(kCFStringEncodingJIS_X0208_83 , 0x0621 )
568        self.assertEqual(kCFStringEncodingJIS_X0208_90 , 0x0622 )
569        self.assertEqual(kCFStringEncodingJIS_X0212_90 , 0x0623 )
570        self.assertEqual(kCFStringEncodingJIS_C6226_78 , 0x0624 )
571        self.assertEqual(kCFStringEncodingShiftJIS_X0213 , 0x0628 )
572        self.assertEqual(kCFStringEncodingShiftJIS_X0213_MenKuTen , 0x0629 )
573        self.assertEqual(kCFStringEncodingGB_2312_80 , 0x0630 )
574        self.assertEqual(kCFStringEncodingGBK_95 , 0x0631 )
575        self.assertEqual(kCFStringEncodingGB_18030_2000 , 0x0632 )
576        self.assertEqual(kCFStringEncodingKSC_5601_87 , 0x0640 )
577        self.assertEqual(kCFStringEncodingKSC_5601_92_Johab , 0x0641 )
578        self.assertEqual(kCFStringEncodingCNS_11643_92_P1 , 0x0651 )
579        self.assertEqual(kCFStringEncodingCNS_11643_92_P2 , 0x0652 )
580        self.assertEqual(kCFStringEncodingCNS_11643_92_P3 , 0x0653 )
581        self.assertEqual(kCFStringEncodingISO_2022_JP , 0x0820 )
582        self.assertEqual(kCFStringEncodingISO_2022_JP_2 , 0x0821 )
583        self.assertEqual(kCFStringEncodingISO_2022_JP_1 , 0x0822 )
584        self.assertEqual(kCFStringEncodingISO_2022_JP_3 , 0x0823 )
585        self.assertEqual(kCFStringEncodingISO_2022_CN , 0x0830 )
586        self.assertEqual(kCFStringEncodingISO_2022_CN_EXT , 0x0831 )
587        self.assertEqual(kCFStringEncodingISO_2022_KR , 0x0840 )
588        self.assertEqual(kCFStringEncodingEUC_JP , 0x0920 )
589        self.assertEqual(kCFStringEncodingEUC_CN , 0x0930 )
590        self.assertEqual(kCFStringEncodingEUC_TW , 0x0931 )
591        self.assertEqual(kCFStringEncodingEUC_KR , 0x0940 )
592        self.assertEqual(kCFStringEncodingShiftJIS , 0x0A01 )
593        self.assertEqual(kCFStringEncodingKOI8_R , 0x0A02 )
594        self.assertEqual(kCFStringEncodingBig5 , 0x0A03 )
595        self.assertEqual(kCFStringEncodingMacRomanLatin1 , 0x0A04 )
596        self.assertEqual(kCFStringEncodingHZ_GB_2312 , 0x0A05 )
597        self.assertEqual(kCFStringEncodingBig5_HKSCS_1999 , 0x0A06 )
598        self.assertEqual(kCFStringEncodingVISCII , 0x0A07 )
599        self.assertEqual(kCFStringEncodingKOI8_U , 0x0A08 )
600        self.assertEqual(kCFStringEncodingBig5_E , 0x0A09 )
601        self.assertEqual(kCFStringEncodingNextStepJapanese , 0x0B02 )
602        self.assertEqual(kCFStringEncodingEBCDIC_US , 0x0C01 )
603        self.assertEqual(kCFStringEncodingEBCDIC_CP037 , 0x0C02 )
604        self.assertEqual(kCFStringEncodingShiftJIS_X0213_00 , 0x0628 )
605
606    @min_os_level('10.6')
607    def testFunctions10_6(self):
608        self.assertResultIsBOOL(CFStringIsSurrogateHighCharacter)
609        self.assertTrue(CFStringIsSurrogateHighCharacter(unichr(0xD800)))
610        self.assertFalse(CFStringIsSurrogateHighCharacter(unichr(0x0600)))
611        self.assertTrue(CFStringIsSurrogateLowCharacter(unichr(0xDC00)))
612        self.assertFalse(CFStringIsSurrogateLowCharacter(unichr(0x0600)))
613        v = CFStringGetLongCharacterForSurrogatePair(
614                unichr(0xD801), unichr(0xDC01))
615        #self.assertEqual(v, ((1 << 10) | 1) + 0x0010000)
616        self.assertEqual(v, 66561)
617
618        self.assertResultIsBOOL(CFStringGetSurrogatePairForLongCharacter)
619        ok, chars = CFStringGetSurrogatePairForLongCharacter(v, None)
620        self.assertTrue(ok)
621
622        if sys.version_info[:2] < (3,3) == 65535:
623            # ucs2 build of python 3.2 or earlier:
624            self.assertEqual(len(chars), 2)
625            self.assertEqual(chars[0], unichr(0xD801))
626            self.assertEqual(chars[1], unichr(0xDC01))
627
628        else:
629            # ucs4 build of python 3.2 or earlier; or
630            # python 3.3
631            #
632            # In both cases this function is useless because
633            # Python can represent unicode codepoints without using
634            # surrogate pairs, and will do so when converting
635            # an array of UCS2 codepoints to a Pytho unicode object
636            pass
637
638    @min_os_level('10.7')
639    def testFunctions10_7(self):
640        loc = CFLocaleCopyCurrent()
641
642        self.assertArgIsOut(CFStringGetHyphenationLocationBeforeIndex, 5)
643        v, ch = CFStringGetHyphenationLocationBeforeIndex(b"hello world".decode('ascii'), 5, CFRange(0, 10), 0, loc, None)
644        self.assertIsInstance(v, (int, long))
645        self.assertIsInstance(ch, (int, long))
646
647        self.assertResultIsBOOL(CFStringIsHyphenationAvailableForLocale)
648        v = CFStringIsHyphenationAvailableForLocale(loc)
649        self.assertIsInstance(v, bool)
650
651
652
653
654if __name__ == "__main__":
655    main()
656