Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(379)

Side by Side Diff: source/test/cintltst/cbiditst.c

Issue 845603002: Update ICU to 54.1 step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@master
Patch Set: remove unusued directories Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « source/test/cintltst/capitst.c ('k') | source/test/cintltst/ccaltst.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /******************************************************************** 1 /********************************************************************
2 * COPYRIGHT: 2 * COPYRIGHT:
3 * Copyright (c) 1997-2013, International Business Machines Corporation and 3 * Copyright (c) 1997-2014, International Business Machines Corporation and
4 * others. All Rights Reserved. 4 * others. All Rights Reserved.
5 ********************************************************************/ 5 ********************************************************************/
6 /* file name: cbiditst.c 6 /* file name: cbiditst.c
7 * encoding: US-ASCII 7 * encoding: US-ASCII
8 * tab size: 8 (not used) 8 * tab size: 8 (not used)
9 * indentation:4 9 * indentation:4
10 * 10 *
11 * created on: 1999sep27 11 * created on: 1999sep27
12 * created by: Markus W. Scherer, updated by Matitiahu Allouche 12 * created by: Markus W. Scherer, updated by Matitiahu Allouche
13 */ 13 */
14 14
15 #include "cintltst.h" 15 #include "cintltst.h"
16 #include "unicode/utypes.h" 16 #include "unicode/utypes.h"
17 #include "unicode/uchar.h" 17 #include "unicode/uchar.h"
18 #include "unicode/ustring.h" 18 #include "unicode/ustring.h"
19 #include "unicode/ubidi.h" 19 #include "unicode/ubidi.h"
20 #include "unicode/ushape.h" 20 #include "unicode/ushape.h"
21 #include "cbiditst.h" 21 #include "cbiditst.h"
22 #include "cstring.h" 22 #include "cstring.h"
23 /* the following include is needed for sprintf */ 23 /* the following include is needed for sprintf */
24 #include <stdio.h> 24 #include <stdio.h>
25 25
26 #define MAXLEN MAX_STRING_LENGTH 26 #define MAXLEN MAX_STRING_LENGTH
27 #define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
28 27
29 /* prototypes ---------------------------------------------------------------*/ 28 /* prototypes ---------------------------------------------------------------*/
30 29
31 void addComplexTest(TestNode** root); 30 void addComplexTest(TestNode** root);
32 31
33 static void testCharFromDirProp(void); 32 static void testCharFromDirProp(void);
34 33
35 static void testBidi(void); 34 static void testBidi(void);
36 35
37 static void doTests(UBiDi *pBiDi, UBiDi *pLine, UBool countRunsFirst); 36 static void doTests(UBiDi *pBiDi, UBiDi *pLine, UBool countRunsFirst);
(...skipping 25 matching lines...) Expand all
63 static void doTashkeelSpecialVLTRArabicShapingTest(void); 62 static void doTashkeelSpecialVLTRArabicShapingTest(void);
64 63
65 static void doLOGICALArabicDeShapingTest(void); 64 static void doLOGICALArabicDeShapingTest(void);
66 65
67 static void doArabicShapingTestForBug5421(void); 66 static void doArabicShapingTestForBug5421(void);
68 67
69 static void doArabicShapingTestForBug8703(void); 68 static void doArabicShapingTestForBug8703(void);
70 69
71 static void doArabicShapingTestForBug9024(void); 70 static void doArabicShapingTestForBug9024(void);
72 71
72 static void _testPresentationForms(const UChar *in);
73
74 static void doArabicShapingTestForNewCharacters(void);
75
73 static void testReorder(void); 76 static void testReorder(void);
74 77
75 static void testReorderArabicMathSymbols(void); 78 static void testReorderArabicMathSymbols(void);
76 79
77 static void testFailureRecovery(void); 80 static void testFailureRecovery(void);
78 81
79 static void testMultipleParagraphs(void); 82 static void testMultipleParagraphs(void);
80 83
81 static void testGetBaseDirection(void); 84 static void testGetBaseDirection(void);
82 85
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
136 139
137 addTest(root, doArabicShapingTest, "complex/arabic-shaping/ArabicShapingTest "); 140 addTest(root, doArabicShapingTest, "complex/arabic-shaping/ArabicShapingTest ");
138 addTest(root, doLamAlefSpecialVLTRArabicShapingTest, "complex/arabic-shaping /lamalef"); 141 addTest(root, doLamAlefSpecialVLTRArabicShapingTest, "complex/arabic-shaping /lamalef");
139 addTest(root, doTashkeelSpecialVLTRArabicShapingTest, "complex/arabic-shapin g/tashkeel"); 142 addTest(root, doTashkeelSpecialVLTRArabicShapingTest, "complex/arabic-shapin g/tashkeel");
140 addTest(root, doLOGICALArabicDeShapingTest, "complex/arabic-shaping/unshapin g"); 143 addTest(root, doLOGICALArabicDeShapingTest, "complex/arabic-shaping/unshapin g");
141 addTest(root, doArabicShapingTestForBug5421, "complex/arabic-shaping/bug-542 1"); 144 addTest(root, doArabicShapingTestForBug5421, "complex/arabic-shaping/bug-542 1");
142 addTest(root, doTailTest, "complex/arabic-shaping/tailtest"); 145 addTest(root, doTailTest, "complex/arabic-shaping/tailtest");
143 addTest(root, doArabicShapingTestForBug8703, "complex/arabic-shaping/bug-870 3"); 146 addTest(root, doArabicShapingTestForBug8703, "complex/arabic-shaping/bug-870 3");
144 addTest(root, testReorderArabicMathSymbols, "complex/bidi/bug-9024"); 147 addTest(root, testReorderArabicMathSymbols, "complex/bidi/bug-9024");
145 addTest(root, doArabicShapingTestForBug9024, "complex/arabic-shaping/bug-902 4"); 148 addTest(root, doArabicShapingTestForBug9024, "complex/arabic-shaping/bug-902 4");
149 addTest(root, doArabicShapingTestForNewCharacters, "complex/arabic-shaping/s haping2");
146 } 150 }
147 151
148 static void 152 static void
149 testCharFromDirProp(void) { 153 testCharFromDirProp(void) {
150 /* verify that the exemplar characters have the expected bidi classes */ 154 /* verify that the exemplar characters have the expected bidi classes */
151 int32_t i; 155 int32_t i;
152 156
153 log_verbose("\nEntering TestCharFromDirProp\n\n"); 157 log_verbose("\nEntering TestCharFromDirProp\n\n");
154 initCharFromDirProps(); 158 initCharFromDirProps();
155 159
(...skipping 565 matching lines...) Expand 10 before | Expand all | Expand 10 after
721 "helloGEMPD", 725 "helloGEMPD",
722 "hello ZYXW" 726 "hello ZYXW"
723 }; 727 };
724 char formatChars[MAXLEN]; 728 char formatChars[MAXLEN];
725 UErrorCode ec = U_ZERO_ERROR; 729 UErrorCode ec = U_ZERO_ERROR;
726 UBiDi* bidi = ubidi_open(); 730 UBiDi* bidi = ubidi_open();
727 int i; 731 int i;
728 732
729 log_verbose("\nEntering TestReorder\n\n"); 733 log_verbose("\nEntering TestReorder\n\n");
730 734
731 for(i=0;i<LENGTHOF(logicalOrder);i++){ 735 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
732 int32_t srcSize = (int32_t)strlen(logicalOrder[i]); 736 int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
733 int32_t destSize = srcSize*2; 737 int32_t destSize = srcSize*2;
734 UChar src[MAXLEN]; 738 UChar src[MAXLEN];
735 UChar dest[MAXLEN]; 739 UChar dest[MAXLEN];
736 char chars[MAXLEN]; 740 char chars[MAXLEN];
737 log_verbose("Testing L2V #1 for case %d\n", i); 741 log_verbose("Testing L2V #1 for case %d\n", i);
738 pseudoToU16(srcSize,logicalOrder[i],src); 742 pseudoToU16(srcSize,logicalOrder[i],src);
739 ec = U_ZERO_ERROR; 743 ec = U_ZERO_ERROR;
740 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec); 744 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
741 if(U_FAILURE(ec)){ 745 if(U_FAILURE(ec)){
(...skipping 14 matching lines...) Expand all
756 if(destSize!=srcSize){ 760 if(destSize!=srcSize){
757 log_err("ubidi_writeReordered() destSize and srcSize do not match\n" ); 761 log_err("ubidi_writeReordered() destSize and srcSize do not match\n" );
758 }else if(strcmp(visualOrder[i],chars)!=0){ 762 }else if(strcmp(visualOrder[i],chars)!=0){
759 log_err("ubidi_writeReordered() did not give expected results for UB IDI_DO_MIRRORING.\n" 763 log_err("ubidi_writeReordered() did not give expected results for UB IDI_DO_MIRRORING.\n"
760 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n", 764 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n",
761 logicalOrder[i],visualOrder[i],chars,formatLevels(bidi, form atChars),i); 765 logicalOrder[i],visualOrder[i],chars,formatLevels(bidi, form atChars),i);
762 } 766 }
763 checkWhatYouCan(bidi, logicalOrder[i], chars); 767 checkWhatYouCan(bidi, logicalOrder[i], chars);
764 } 768 }
765 769
766 for(i=0;i<LENGTHOF(logicalOrder);i++){ 770 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
767 int32_t srcSize = (int32_t)strlen(logicalOrder[i]); 771 int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
768 int32_t destSize = srcSize*2; 772 int32_t destSize = srcSize*2;
769 UChar src[MAXLEN]; 773 UChar src[MAXLEN];
770 UChar dest[MAXLEN]; 774 UChar dest[MAXLEN];
771 char chars[MAXLEN]; 775 char chars[MAXLEN];
772 log_verbose("Testing L2V #2 for case %d\n", i); 776 log_verbose("Testing L2V #2 for case %d\n", i);
773 pseudoToU16(srcSize,logicalOrder[i],src); 777 pseudoToU16(srcSize,logicalOrder[i],src);
774 ec = U_ZERO_ERROR; 778 ec = U_ZERO_ERROR;
775 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec); 779 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
776 if(U_FAILURE(ec)){ 780 if(U_FAILURE(ec)){
(...skipping 13 matching lines...) Expand all
790 u16ToPseudo(destSize,dest,chars); 794 u16ToPseudo(destSize,dest,chars);
791 if(destSize!=srcSize){ 795 if(destSize!=srcSize){
792 log_err("ubidi_writeReordered() destSize and srcSize do not match\n" ); 796 log_err("ubidi_writeReordered() destSize and srcSize do not match\n" );
793 }else if(strcmp(visualOrder1[i],chars)!=0){ 797 }else if(strcmp(visualOrder1[i],chars)!=0){
794 log_err("ubidi_writeReordered() did not give expected results for UB IDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE.\n" 798 log_err("ubidi_writeReordered() did not give expected results for UB IDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE.\n"
795 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n", 799 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n",
796 logicalOrder[i],visualOrder1[i],chars,formatLevels(bidi, for matChars),i); 800 logicalOrder[i],visualOrder1[i],chars,formatLevels(bidi, for matChars),i);
797 } 801 }
798 } 802 }
799 803
800 for(i=0;i<LENGTHOF(logicalOrder);i++){ 804 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
801 int32_t srcSize = (int32_t)strlen(logicalOrder[i]); 805 int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
802 int32_t destSize = srcSize*2; 806 int32_t destSize = srcSize*2;
803 UChar src[MAXLEN]; 807 UChar src[MAXLEN];
804 UChar dest[MAXLEN]; 808 UChar dest[MAXLEN];
805 char chars[MAXLEN]; 809 char chars[MAXLEN];
806 log_verbose("Testing V2L #3 for case %d\n", i); 810 log_verbose("Testing V2L #3 for case %d\n", i);
807 pseudoToU16(srcSize,logicalOrder[i],src); 811 pseudoToU16(srcSize,logicalOrder[i],src);
808 ec = U_ZERO_ERROR; 812 ec = U_ZERO_ERROR;
809 ubidi_setInverse(bidi,TRUE); 813 ubidi_setInverse(bidi,TRUE);
810 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec); 814 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
(...skipping 10 matching lines...) Expand all
821 } 825 }
822 destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_INSERT_LRM_FOR_ NUMERIC+UBIDI_OUTPUT_REVERSE,&ec); 826 destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_INSERT_LRM_FOR_ NUMERIC+UBIDI_OUTPUT_REVERSE,&ec);
823 u16ToPseudo(destSize,dest,chars); 827 u16ToPseudo(destSize,dest,chars);
824 if(strcmp(visualOrder2[i],chars)!=0){ 828 if(strcmp(visualOrder2[i],chars)!=0){
825 log_err("ubidi_writeReordered() did not give expected results for UB IDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE.\n" 829 log_err("ubidi_writeReordered() did not give expected results for UB IDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE.\n"
826 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n", 830 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n",
827 logicalOrder[i],visualOrder2[i],chars,formatLevels(bidi, for matChars),i); 831 logicalOrder[i],visualOrder2[i],chars,formatLevels(bidi, for matChars),i);
828 } 832 }
829 } 833 }
830 /* Max Explicit level */ 834 /* Max Explicit level */
831 for(i=0;i<LENGTHOF(logicalOrder);i++){ 835 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
832 int32_t srcSize = (int32_t)strlen(logicalOrder[i]); 836 int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
833 int32_t destSize = srcSize*2; 837 int32_t destSize = srcSize*2;
834 UChar src[MAXLEN]; 838 UChar src[MAXLEN];
835 UChar dest[MAXLEN]; 839 UChar dest[MAXLEN];
836 char chars[MAXLEN]; 840 char chars[MAXLEN];
837 UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10}; 841 UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
838 log_verbose("Testing V2L #4 for case %d\n", i); 842 log_verbose("Testing V2L #4 for case %d\n", i);
839 pseudoToU16(srcSize,logicalOrder[i],src); 843 pseudoToU16(srcSize,logicalOrder[i],src);
840 ec = U_ZERO_ERROR; 844 ec = U_ZERO_ERROR;
841 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec); 845 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
(...skipping 13 matching lines...) Expand all
855 destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_OUTPUT_REVERSE, &ec); 859 destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_OUTPUT_REVERSE, &ec);
856 u16ToPseudo(destSize,dest,chars); 860 u16ToPseudo(destSize,dest,chars);
857 if(destSize!=srcSize){ 861 if(destSize!=srcSize){
858 log_err("ubidi_writeReordered() destSize and srcSize do not match. D est Size = %d Source Size = %d\n",destSize,srcSize ); 862 log_err("ubidi_writeReordered() destSize and srcSize do not match. D est Size = %d Source Size = %d\n",destSize,srcSize );
859 }else if(strcmp(visualOrder3[i],chars)!=0){ 863 }else if(strcmp(visualOrder3[i],chars)!=0){
860 log_err("ubidi_writeReordered() did not give expected results for UB IDI_OUTPUT_REVERSE.\n" 864 log_err("ubidi_writeReordered() did not give expected results for UB IDI_OUTPUT_REVERSE.\n"
861 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n", 865 "Input : %s\nExpected: %s\nGot : %s\nLevels : %s\nAt Index: %d\n",
862 logicalOrder[i],visualOrder3[i],chars,formatLevels(bidi, for matChars),i); 866 logicalOrder[i],visualOrder3[i],chars,formatLevels(bidi, for matChars),i);
863 } 867 }
864 } 868 }
865 for(i=0;i<LENGTHOF(logicalOrder);i++){ 869 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
866 int32_t srcSize = (int32_t)strlen(logicalOrder[i]); 870 int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
867 int32_t destSize = srcSize*2; 871 int32_t destSize = srcSize*2;
868 UChar src[MAXLEN]; 872 UChar src[MAXLEN];
869 UChar dest[MAXLEN]; 873 UChar dest[MAXLEN];
870 char chars[MAXLEN]; 874 char chars[MAXLEN];
871 UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10}; 875 UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
872 log_verbose("Testing V2L #5 for case %d\n", i); 876 log_verbose("Testing V2L #5 for case %d\n", i);
873 pseudoToU16(srcSize,logicalOrder[i],src); 877 pseudoToU16(srcSize,logicalOrder[i],src);
874 ec = U_ZERO_ERROR; 878 ec = U_ZERO_ERROR;
875 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec); 879 ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after
983 0xD83B, 0xDE4F, 0xD83B, 0xDE4E, 0xD83B, 0xDE4D, 0x20, 987 0xD83B, 0xDE4F, 0xD83B, 0xDE4E, 0xD83B, 0xDE4D, 0x20,
984 0xD83B, 0xDE4B, 0xD83B, 0xDE49, 0xD83B, 0xDE47, 0xD83B, 0xDE42} 988 0xD83B, 0xDE4B, 0xD83B, 0xDE49, 0xD83B, 0xDE47, 0xD83B, 0xDE42}
985 }; 989 };
986 char formatChars[MAXLEN]; 990 char formatChars[MAXLEN];
987 UErrorCode ec = U_ZERO_ERROR; 991 UErrorCode ec = U_ZERO_ERROR;
988 UBiDi* bidi = ubidi_open(); 992 UBiDi* bidi = ubidi_open();
989 int i; 993 int i;
990 994
991 log_verbose("\nEntering TestReorderArabicMathSymbols\n\n"); 995 log_verbose("\nEntering TestReorderArabicMathSymbols\n\n");
992 996
993 for(i=0;i<LENGTHOF(logicalOrder);i++){ 997 for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
994 int32_t srcSize = u_strlen(logicalOrder[i]); 998 int32_t srcSize = u_strlen(logicalOrder[i]);
995 int32_t destSize = srcSize*2; 999 int32_t destSize = srcSize*2;
996 UChar dest[MAXLEN]; 1000 UChar dest[MAXLEN];
997 log_verbose("Testing L2V #1 for case %d\n", i); 1001 log_verbose("Testing L2V #1 for case %d\n", i);
998 ec = U_ZERO_ERROR; 1002 ec = U_ZERO_ERROR;
999 ubidi_setPara(bidi,logicalOrder[i],srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec); 1003 ubidi_setPara(bidi,logicalOrder[i],srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
1000 if(U_FAILURE(ec)){ 1004 if(U_FAILURE(ec)){
1001 log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCod e %s\n", 1005 log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCod e %s\n",
1002 i, UBIDI_DEFAULT_LTR, u_errorName(ec)); 1006 i, UBIDI_DEFAULT_LTR, u_errorName(ec));
1003 } 1007 }
(...skipping 271 matching lines...) Expand 10 before | Expand all | Expand 10 after
1275 } 1279 }
1276 } 1280 }
1277 } 1281 }
1278 1282
1279 #define RETURN_IF_BAD_ERRCODE(x) \ 1283 #define RETURN_IF_BAD_ERRCODE(x) \
1280 if (U_FAILURE(errorCode)) { \ 1284 if (U_FAILURE(errorCode)) { \
1281 log_err("\nbad errorCode %d at %s\n", errorCode, (x)); \ 1285 log_err("\nbad errorCode %d at %s\n", errorCode, (x)); \
1282 return; \ 1286 return; \
1283 } \ 1287 } \
1284 1288
1285 #define STRING_TEST_CASE(s) { (s), LENGTHOF(s) } 1289 #define STRING_TEST_CASE(s) { (s), UPRV_LENGTHOF(s) }
1286 1290
1287 static void testGetBaseDirection(void) { 1291 static void testGetBaseDirection(void) {
1288 UBiDiDirection dir; 1292 UBiDiDirection dir;
1289 int i; 1293 int i;
1290 1294
1291 /* Test Data */ 1295 /* Test Data */
1292 static const UChar 1296 static const UChar
1293 /*Mixed Start with L*/ 1297 /*Mixed Start with L*/
1294 stringMixedEnglishFirst[]={ 0x61, 0x627, 0x32, 0x6f3, 0x61, 0x34, 0 }, 1298 stringMixedEnglishFirst[]={ 0x61, 0x627, 0x32, 0x6f3, 0x61, 0x34, 0 },
1295 /*Mixed Start with AL*/ 1299 /*Mixed Start with AL*/
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
1345 /* Expected results */ 1349 /* Expected results */
1346 static const UBiDiDirection expectedDir[] ={ 1350 static const UBiDiDirection expectedDir[] ={
1347 UBIDI_LTR, UBIDI_RTL, UBIDI_RTL, 1351 UBIDI_LTR, UBIDI_RTL, UBIDI_RTL,
1348 UBIDI_RTL, UBIDI_RTL, UBIDI_LTR, 1352 UBIDI_RTL, UBIDI_RTL, UBIDI_LTR,
1349 UBIDI_LTR, UBIDI_RTL, UBIDI_NEUTRAL, 1353 UBIDI_LTR, UBIDI_RTL, UBIDI_NEUTRAL,
1350 UBIDI_LTR, UBIDI_NEUTRAL, UBIDI_NEUTRAL, 1354 UBIDI_LTR, UBIDI_NEUTRAL, UBIDI_NEUTRAL,
1351 UBIDI_NEUTRAL, UBIDI_LTR, UBIDI_RTL 1355 UBIDI_NEUTRAL, UBIDI_LTR, UBIDI_RTL
1352 }; 1356 };
1353 1357
1354 log_verbose("testGetBaseDirection() with %u test cases ---\n", 1358 log_verbose("testGetBaseDirection() with %u test cases ---\n",
1355 LENGTHOF(testCases)); 1359 UPRV_LENGTHOF(testCases));
1356 /* Run Tests */ 1360 /* Run Tests */
1357 for(i=0; i<LENGTHOF(testCases); ++i) { 1361 for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
1358 dir = ubidi_getBaseDirection(testCases[i].s, testCases[i].length ); 1362 dir = ubidi_getBaseDirection(testCases[i].s, testCases[i].length );
1359 log_verbose("Testing case %d\tReceived dir %d\n", i, dir); 1363 log_verbose("Testing case %d\tReceived dir %d\n", i, dir);
1360 if (dir != expectedDir[i]) 1364 if (dir != expectedDir[i])
1361 log_err("\nFailed getBaseDirection case %d Expected %d \tReceived % d\n", 1365 log_err("\nFailed getBaseDirection case %d Expected %d \tReceived % d\n",
1362 i, expectedDir[i], dir); 1366 i, expectedDir[i], dir);
1363 } 1367 }
1364 1368
1365 /* Misc. tests */ 1369 /* Misc. tests */
1366 /* NULL string */ 1370 /* NULL string */
1367 dir = ubidi_getBaseDirection(NULL, 3); 1371 dir = ubidi_getBaseDirection(NULL, 3);
(...skipping 754 matching lines...) Expand 10 before | Expand all | Expand 10 after
2122 } 2126 }
2123 2127
2124 ubidi_close(pLine); 2128 ubidi_close(pLine);
2125 ubidi_close(pBidi); 2129 ubidi_close(pBidi);
2126 log_verbose("\nExiting TestMultipleParagraphs\n\n"); 2130 log_verbose("\nExiting TestMultipleParagraphs\n\n");
2127 2131
2128 /* check levels in multiple paragraphs with default para level 2132 /* check levels in multiple paragraphs with default para level
2129 */ 2133 */
2130 pBidi = ubidi_open(); 2134 pBidi = ubidi_open();
2131 errorCode = U_ZERO_ERROR; 2135 errorCode = U_ZERO_ERROR;
2132 ubidi_setPara(pBidi, multiparaTestString, LENGTHOF(multiparaTestString), 2136 ubidi_setPara(pBidi, multiparaTestString, UPRV_LENGTHOF(multiparaTestString) ,
2133 UBIDI_DEFAULT_LTR, NULL, &errorCode); 2137 UBIDI_DEFAULT_LTR, NULL, &errorCode);
2134 if (U_FAILURE(errorCode)) { 2138 if (U_FAILURE(errorCode)) {
2135 log_err("ubidi_setPara failed for multiparaTestString\n"); 2139 log_err("ubidi_setPara failed for multiparaTestString\n");
2136 ubidi_close(pBidi); 2140 ubidi_close(pBidi);
2137 return; 2141 return;
2138 } 2142 }
2139 gotLevels = ubidi_getLevels(pBidi, &errorCode); 2143 gotLevels = ubidi_getLevels(pBidi, &errorCode);
2140 if (U_FAILURE(errorCode)) { 2144 if (U_FAILURE(errorCode)) {
2141 log_err("ubidi_getLevels failed for multiparaTestString\n"); 2145 log_err("ubidi_getLevels failed for multiparaTestString\n");
2142 ubidi_close(pBidi); 2146 ubidi_close(pBidi);
2143 return; 2147 return;
2144 } 2148 }
2145 for (i = 0; i < LENGTHOF(multiparaTestString); i++) { 2149 for (i = 0; i < UPRV_LENGTHOF(multiparaTestString); i++) {
2146 if (gotLevels[i] != multiparaTestLevels[i]) { 2150 if (gotLevels[i] != multiparaTestLevels[i]) {
2147 log_err("Error on level for multiparaTestString at index %d, " 2151 log_err("Error on level for multiparaTestString at index %d, "
2148 "expected=%d, actual=%d\n", 2152 "expected=%d, actual=%d\n",
2149 i, multiparaTestLevels[i], gotLevels[i]); 2153 i, multiparaTestLevels[i], gotLevels[i]);
2150 } 2154 }
2151 } 2155 }
2152 ubidi_close(pBidi); 2156 ubidi_close(pBidi);
2153 2157
2154 } 2158 }
2155 2159
2156 2160
2157 /* inverse BiDi ------------------------------------------------------------- */ 2161 /* inverse BiDi ------------------------------------------------------------- */
2158 2162
2159 static int countRoundtrips=0, countNonRoundtrips=0; 2163 static int countRoundtrips=0, countNonRoundtrips=0;
2160 2164
2161 #define STRING_TEST_CASE(s) { (s), LENGTHOF(s) } 2165 #define STRING_TEST_CASE(s) { (s), UPRV_LENGTHOF(s) }
2162 2166
2163 static void 2167 static void
2164 testInverse(void) { 2168 testInverse(void) {
2165 static const UChar 2169 static const UChar
2166 string0[]={ 0x6c, 0x61, 0x28, 0x74, 0x69, 0x6e, 0x20, 0x5d0, 0x5d1, 0x29 , 0x5d2, 0x5d3 }, 2170 string0[]={ 0x6c, 0x61, 0x28, 0x74, 0x69, 0x6e, 0x20, 0x5d0, 0x5d1, 0x29 , 0x5d2, 0x5d3 },
2167 string1[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x31, 0x3 2, 0x33 }, 2171 string1[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x31, 0x3 2, 0x33 },
2168 string2[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x28, 0x5d1, 0x5d2, 0x20, 0x3 1, 0x29, 0x32, 0x33 }, 2172 string2[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x28, 0x5d1, 0x5d2, 0x20, 0x3 1, 0x29, 0x32, 0x33 },
2169 string3[]={ 0x31, 0x32, 0x33, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x34, 0x3 5, 0x36 }, 2173 string3[]={ 0x31, 0x32, 0x33, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x34, 0x3 5, 0x36 },
2170 string4[]={ 0x61, 0x62, 0x20, 0x61, 0x62, 0x20, 0x661, 0x662 }; 2174 string4[]={ 0x61, 0x62, 0x20, 0x61, 0x62, 0x20, 0x661, 0x662 };
2171 2175
(...skipping 12 matching lines...) Expand all
2184 UErrorCode errorCode; 2188 UErrorCode errorCode;
2185 int i; 2189 int i;
2186 2190
2187 log_verbose("\nEntering TestInverse\n\n"); 2191 log_verbose("\nEntering TestInverse\n\n");
2188 pBiDi=ubidi_open(); 2192 pBiDi=ubidi_open();
2189 if(pBiDi==NULL) { 2193 if(pBiDi==NULL) {
2190 log_err("unable to open a UBiDi object (out of memory)\n"); 2194 log_err("unable to open a UBiDi object (out of memory)\n");
2191 return; 2195 return;
2192 } 2196 }
2193 2197
2194 log_verbose("inverse Bidi: testInverse(L) with %u test cases ---\n", LENGTHO F(testCases)); 2198 log_verbose("inverse Bidi: testInverse(L) with %u test cases ---\n", UPRV_LE NGTHOF(testCases));
2195 for(i=0; i<LENGTHOF(testCases); ++i) { 2199 for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
2196 log_verbose("Testing case %d\n", i); 2200 log_verbose("Testing case %d\n", i);
2197 errorCode=U_ZERO_ERROR; 2201 errorCode=U_ZERO_ERROR;
2198 _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 0, &errorCo de); 2202 _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 0, &errorCo de);
2199 } 2203 }
2200 2204
2201 log_verbose("inverse Bidi: testInverse(R) with %u test cases ---\n", LENGTHO F(testCases)); 2205 log_verbose("inverse Bidi: testInverse(R) with %u test cases ---\n", UPRV_LE NGTHOF(testCases));
2202 for(i=0; i<LENGTHOF(testCases); ++i) { 2206 for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
2203 log_verbose("Testing case %d\n", i); 2207 log_verbose("Testing case %d\n", i);
2204 errorCode=U_ZERO_ERROR; 2208 errorCode=U_ZERO_ERROR;
2205 _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 1, &errorCo de); 2209 _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 1, &errorCo de);
2206 } 2210 }
2207 2211
2208 _testManyInverseBidi(pBiDi, 0); 2212 _testManyInverseBidi(pBiDi, 0);
2209 _testManyInverseBidi(pBiDi, 1); 2213 _testManyInverseBidi(pBiDi, 1);
2210 2214
2211 ubidi_close(pBiDi); 2215 ubidi_close(pBiDi);
2212 2216
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
2269 2273
2270 /* convert visual to logical */ 2274 /* convert visual to logical */
2271 ubidi_setInverse(pBiDi, TRUE); 2275 ubidi_setInverse(pBiDi, TRUE);
2272 if (!ubidi_isInverse(pBiDi)) { 2276 if (!ubidi_isInverse(pBiDi)) {
2273 log_err("Error while doing ubidi_setInverse(TRUE)\n"); 2277 log_err("Error while doing ubidi_setInverse(TRUE)\n");
2274 } 2278 }
2275 ubidi_setPara(pBiDi, src, srcLength, 0, NULL, pErrorCode); 2279 ubidi_setPara(pBiDi, src, srcLength, 0, NULL, pErrorCode);
2276 if (src != ubidi_getText(pBiDi)) { 2280 if (src != ubidi_getText(pBiDi)) {
2277 log_err("Wrong value returned by ubidi_getText\n"); 2281 log_err("Wrong value returned by ubidi_getText\n");
2278 } 2282 }
2279 logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalD est), 2283 logicalLength=ubidi_writeReordered(pBiDi, logicalDest, UPRV_LENGTHOF(log icalDest),
2280 UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_F OR_NUMERIC, pErrorCode); 2284 UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_F OR_NUMERIC, pErrorCode);
2281 log_verbose(" v "); 2285 log_verbose(" v ");
2282 printUnicode(src, srcLength, ubidi_getLevels(pBiDi, pErrorCode)); 2286 printUnicode(src, srcLength, ubidi_getLevels(pBiDi, pErrorCode));
2283 log_verbose("\n"); 2287 log_verbose("\n");
2284 2288
2285 /* convert back to visual LTR */ 2289 /* convert back to visual LTR */
2286 ubidi_setInverse(pBiDi, FALSE); 2290 ubidi_setInverse(pBiDi, FALSE);
2287 if (ubidi_isInverse(pBiDi)) { 2291 if (ubidi_isInverse(pBiDi)) {
2288 log_err("Error while doing ubidi_setInverse(FALSE)\n"); 2292 log_err("Error while doing ubidi_setInverse(FALSE)\n");
2289 } 2293 }
2290 ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode); 2294 ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
2291 visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest ), 2295 visualLength=ubidi_writeReordered(pBiDi, visualDest, UPRV_LENGTHOF(visua lDest),
2292 UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_C ONTROLS, pErrorCode); 2296 UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_C ONTROLS, pErrorCode);
2293 } else { 2297 } else {
2294 log_verbose("inverse Bidi: testInverse(R)\n"); 2298 log_verbose("inverse Bidi: testInverse(R)\n");
2295 2299
2296 /* reverse visual from RTL to LTR */ 2300 /* reverse visual from RTL to LTR */
2297 ltrLength=ubidi_writeReverse(src, srcLength, visualLTR, LENGTHOF(visualL TR), 0, pErrorCode); 2301 ltrLength=ubidi_writeReverse(src, srcLength, visualLTR, UPRV_LENGTHOF(vi sualLTR), 0, pErrorCode);
2298 log_verbose(" vr"); 2302 log_verbose(" vr");
2299 printUnicode(src, srcLength, NULL); 2303 printUnicode(src, srcLength, NULL);
2300 log_verbose("\n"); 2304 log_verbose("\n");
2301 2305
2302 /* convert visual RTL to logical */ 2306 /* convert visual RTL to logical */
2303 ubidi_setInverse(pBiDi, TRUE); 2307 ubidi_setInverse(pBiDi, TRUE);
2304 ubidi_setPara(pBiDi, visualLTR, ltrLength, 0, NULL, pErrorCode); 2308 ubidi_setPara(pBiDi, visualLTR, ltrLength, 0, NULL, pErrorCode);
2305 logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalD est), 2309 logicalLength=ubidi_writeReordered(pBiDi, logicalDest, UPRV_LENGTHOF(log icalDest),
2306 UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_F OR_NUMERIC, pErrorCode); 2310 UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_F OR_NUMERIC, pErrorCode);
2307 log_verbose(" vl"); 2311 log_verbose(" vl");
2308 printUnicode(visualLTR, ltrLength, ubidi_getLevels(pBiDi, pErrorCode)); 2312 printUnicode(visualLTR, ltrLength, ubidi_getLevels(pBiDi, pErrorCode));
2309 log_verbose("\n"); 2313 log_verbose("\n");
2310 2314
2311 /* convert back to visual RTL */ 2315 /* convert back to visual RTL */
2312 ubidi_setInverse(pBiDi, FALSE); 2316 ubidi_setInverse(pBiDi, FALSE);
2313 ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode); 2317 ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
2314 visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest ), 2318 visualLength=ubidi_writeReordered(pBiDi, visualDest, UPRV_LENGTHOF(visua lDest),
2315 UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_C ONTROLS|UBIDI_OUTPUT_REVERSE, pErrorCode); 2319 UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_C ONTROLS|UBIDI_OUTPUT_REVERSE, pErrorCode);
2316 } 2320 }
2317 log_verbose(" l "); 2321 log_verbose(" l ");
2318 printUnicode(logicalDest, logicalLength, ubidi_getLevels(pBiDi, pErrorCode)) ; 2322 printUnicode(logicalDest, logicalLength, ubidi_getLevels(pBiDi, pErrorCode)) ;
2319 log_verbose("\n"); 2323 log_verbose("\n");
2320 log_verbose(" v "); 2324 log_verbose(" v ");
2321 printUnicode(visualDest, visualLength, NULL); 2325 printUnicode(visualDest, visualLength, NULL);
2322 log_verbose("\n"); 2326 log_verbose("\n");
2323 2327
2324 /* check and print results */ 2328 /* check and print results */
(...skipping 20 matching lines...) Expand all
2345 0x29, 0x31, 0x28, 0x20, 0x627, 0x64e, 0x650, 0x200f 2349 0x29, 0x31, 0x28, 0x20, 0x627, 0x64e, 0x650, 0x200f
2346 }, reverseRemoveControlsKeepCombiningDoMirror[]={ 2350 }, reverseRemoveControlsKeepCombiningDoMirror[]={
2347 0x28, 0x31, 0x29, 0x20, 0x627, 0x64e, 0x650 2351 0x28, 0x31, 0x29, 0x20, 0x627, 0x64e, 0x650
2348 }; 2352 };
2349 UChar reverse[10]; 2353 UChar reverse[10];
2350 UErrorCode errorCode; 2354 UErrorCode errorCode;
2351 int32_t length; 2355 int32_t length;
2352 2356
2353 /* test ubidi_writeReverse() with "interesting" options */ 2357 /* test ubidi_writeReverse() with "interesting" options */
2354 errorCode=U_ZERO_ERROR; 2358 errorCode=U_ZERO_ERROR;
2355 length=ubidi_writeReverse(forward, LENGTHOF(forward), 2359 length=ubidi_writeReverse(forward, UPRV_LENGTHOF(forward),
2356 reverse, LENGTHOF(reverse), 2360 reverse, UPRV_LENGTHOF(reverse),
2357 UBIDI_KEEP_BASE_COMBINING, 2361 UBIDI_KEEP_BASE_COMBINING,
2358 &errorCode); 2362 &errorCode);
2359 if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseKeepCombining) || memcmp( reverse, reverseKeepCombining, length*U_SIZEOF_UCHAR)!=0) { 2363 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(reverseKeepCombining) || me mcmp(reverse, reverseKeepCombining, length*U_SIZEOF_UCHAR)!=0) {
2360 log_err("failure in ubidi_writeReverse(UBIDI_KEEP_BASE_COMBINING): lengt h=%d (should be %d), error code %s\n", 2364 log_err("failure in ubidi_writeReverse(UBIDI_KEEP_BASE_COMBINING): lengt h=%d (should be %d), error code %s\n",
2361 length, LENGTHOF(reverseKeepCombining), u_errorName(errorCode)); 2365 length, UPRV_LENGTHOF(reverseKeepCombining), u_errorName(errorCo de));
2362 } 2366 }
2363 2367
2364 memset(reverse, 0xa5, LENGTHOF(reverse)*U_SIZEOF_UCHAR); 2368 memset(reverse, 0xa5, UPRV_LENGTHOF(reverse)*U_SIZEOF_UCHAR);
2365 errorCode=U_ZERO_ERROR; 2369 errorCode=U_ZERO_ERROR;
2366 length=ubidi_writeReverse(forward, LENGTHOF(forward), 2370 length=ubidi_writeReverse(forward, UPRV_LENGTHOF(forward),
2367 reverse, LENGTHOF(reverse), 2371 reverse, UPRV_LENGTHOF(reverse),
2368 UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBID I_KEEP_BASE_COMBINING, 2372 UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBID I_KEEP_BASE_COMBINING,
2369 &errorCode); 2373 &errorCode);
2370 if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseRemoveControlsKeepCombini ngDoMirror) || memcmp(reverse, reverseRemoveControlsKeepCombiningDoMirror, lengt h*U_SIZEOF_UCHAR)!=0) { 2374 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(reverseRemoveControlsKeepCo mbiningDoMirror) || memcmp(reverse, reverseRemoveControlsKeepCombiningDoMirror, length*U_SIZEOF_UCHAR)!=0) {
2371 log_err("failure in ubidi_writeReverse(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_ DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING):\n" 2375 log_err("failure in ubidi_writeReverse(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_ DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING):\n"
2372 " length=%d (should be %d), error code %s\n", 2376 " length=%d (should be %d), error code %s\n",
2373 length, LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror), u_ errorName(errorCode)); 2377 length, UPRV_LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror ), u_errorName(errorCode));
2374 } 2378 }
2375 } 2379 }
2376 2380
2377 static void _testManyAddedPoints(void) { 2381 static void _testManyAddedPoints(void) {
2378 UErrorCode errorCode = U_ZERO_ERROR; 2382 UErrorCode errorCode = U_ZERO_ERROR;
2379 UBiDi *bidi = ubidi_open(); 2383 UBiDi *bidi = ubidi_open();
2380 UChar text[90], dest[MAXLEN], expected[120]; 2384 UChar text[90], dest[MAXLEN], expected[120];
2381 int destLen, i; 2385 int destLen, i;
2382 for (i = 0; i < LENGTHOF(text); i+=3) { 2386 for (i = 0; i < UPRV_LENGTHOF(text); i+=3) {
2383 text[i] = 0x0061; /* 'a' */ 2387 text[i] = 0x0061; /* 'a' */
2384 text[i+1] = 0x05d0; 2388 text[i+1] = 0x05d0;
2385 text[i+2] = 0x0033; /* '3' */ 2389 text[i+2] = 0x0033; /* '3' */
2386 } 2390 }
2387 ubidi_setReorderingMode(bidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT); 2391 ubidi_setReorderingMode(bidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
2388 ubidi_setReorderingOptions(bidi, UBIDI_OPTION_INSERT_MARKS); 2392 ubidi_setReorderingOptions(bidi, UBIDI_OPTION_INSERT_MARKS);
2389 ubidi_setPara(bidi, text, LENGTHOF(text), UBIDI_LTR, NULL, &errorCode); 2393 ubidi_setPara(bidi, text, UPRV_LENGTHOF(text), UBIDI_LTR, NULL, &errorCode);
2390 destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode); 2394 destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
2391 for (i = 0; i < LENGTHOF(expected); i+=4) { 2395 for (i = 0; i < UPRV_LENGTHOF(expected); i+=4) {
2392 expected[i] = 0x0061; /* 'a' */ 2396 expected[i] = 0x0061; /* 'a' */
2393 expected[i+1] = 0x05d0; 2397 expected[i+1] = 0x05d0;
2394 expected[i+2] = 0x200e; 2398 expected[i+2] = 0x200e;
2395 expected[i+3] = 0x0033; /* '3' */ 2399 expected[i+3] = 0x0033; /* '3' */
2396 } 2400 }
2397 if (memcmp(dest, expected, destLen * sizeof(UChar))) { 2401 if (memcmp(dest, expected, destLen * sizeof(UChar))) {
2398 log_err("\nInvalid output with many added points, " 2402 log_err("\nInvalid output with many added points, "
2399 "expected '%s', got '%s'\n", 2403 "expected '%s', got '%s'\n",
2400 aescstrdup(expected, LENGTHOF(expected)), 2404 aescstrdup(expected, UPRV_LENGTHOF(expected)),
2401 aescstrdup(dest, destLen)); 2405 aescstrdup(dest, destLen));
2402 } 2406 }
2403 ubidi_close(bidi); 2407 ubidi_close(bidi);
2404 } 2408 }
2405 2409
2406 static void _testMisc(void) { 2410 static void _testMisc(void) {
2407 UErrorCode errorCode = U_ZERO_ERROR; 2411 UErrorCode errorCode = U_ZERO_ERROR;
2408 UBiDi *bidi = ubidi_open(); 2412 UBiDi *bidi = ubidi_open();
2409 UChar src[3], dest[MAXLEN], expected[5]; 2413 UChar src[3], dest[MAXLEN], expected[5];
2410 int destLen; 2414 int destLen;
2411 ubidi_setInverse(bidi, TRUE); 2415 ubidi_setInverse(bidi, TRUE);
2412 src[0] = src[1] = src[2] = 0x0020; 2416 src[0] = src[1] = src[2] = 0x0020;
2413 ubidi_setPara(bidi, src, LENGTHOF(src), UBIDI_RTL, NULL, &errorCode); 2417 ubidi_setPara(bidi, src, UPRV_LENGTHOF(src), UBIDI_RTL, NULL, &errorCode);
2414 destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 2418 destLen = ubidi_writeReordered(bidi, dest, MAXLEN,
2415 UBIDI_OUTPUT_REVERSE | UBIDI_INSERT_LRM_FOR_NUMERIC, 2419 UBIDI_OUTPUT_REVERSE | UBIDI_INSERT_LRM_FOR_NUMERIC,
2416 &errorCode); 2420 &errorCode);
2417 u_unescape("\\u200f \\u200f", expected, 5); 2421 u_unescape("\\u200f \\u200f", expected, 5);
2418 if (memcmp(dest, expected, destLen * sizeof(UChar))) { 2422 if (memcmp(dest, expected, destLen * sizeof(UChar))) {
2419 log_err("\nInvalid output with RLM at both sides, " 2423 log_err("\nInvalid output with RLM at both sides, "
2420 "expected '%s', got '%s'\n", 2424 "expected '%s', got '%s'\n",
2421 aescstrdup(expected, LENGTHOF(expected)), 2425 aescstrdup(expected, UPRV_LENGTHOF(expected)),
2422 aescstrdup(dest, destLen)); 2426 aescstrdup(dest, destLen));
2423 } 2427 }
2424 ubidi_close(bidi); 2428 ubidi_close(bidi);
2425 } 2429 }
2426 2430
2427 /* arabic shaping ----------------------------------------------------------- */ 2431 /* arabic shaping ----------------------------------------------------------- */
2428 2432
2429 static void 2433 static void
2430 doArabicShapingTest(void) { 2434 doArabicShapingTest(void) {
2431 static const UChar 2435 static const UChar
(...skipping 21 matching lines...) Expand all
2453 0xfefb, 0 2457 0xfefb, 0
2454 }; 2458 };
2455 UChar dest[8]; 2459 UChar dest[8];
2456 UErrorCode errorCode; 2460 UErrorCode errorCode;
2457 int32_t length; 2461 int32_t length;
2458 2462
2459 /* test number shaping */ 2463 /* test number shaping */
2460 2464
2461 /* european->arabic */ 2465 /* european->arabic */
2462 errorCode=U_ZERO_ERROR; 2466 errorCode=U_ZERO_ERROR;
2463 length=u_shapeArabic(source, LENGTHOF(source), 2467 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2464 dest, LENGTHOF(dest), 2468 dest, UPRV_LENGTHOF(dest),
2465 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2469 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2466 &errorCode); 2470 &errorCode);
2467 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, en2an, l ength*U_SIZEOF_UCHAR)!=0) { 2471 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, en2 an, length*U_SIZEOF_UCHAR)!=0) {
2468 log_err("failure in u_shapeArabic(en2an)\n"); 2472 log_err("failure in u_shapeArabic(en2an)\n");
2469 } 2473 }
2470 2474
2471 /* arabic->european */ 2475 /* arabic->european */
2472 errorCode=U_ZERO_ERROR; 2476 errorCode=U_ZERO_ERROR;
2473 length=u_shapeArabic(source, -1, 2477 length=u_shapeArabic(source, -1,
2474 dest, LENGTHOF(dest), 2478 dest, UPRV_LENGTHOF(dest),
2475 U_SHAPE_DIGITS_AN2EN|U_SHAPE_DIGIT_TYPE_AN_EXTENDED, 2479 U_SHAPE_DIGITS_AN2EN|U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
2476 &errorCode); 2480 &errorCode);
2477 if(U_FAILURE(errorCode) || length!=u_strlen(source) || memcmp(dest, an2en, l ength*U_SIZEOF_UCHAR)!=0) { 2481 if(U_FAILURE(errorCode) || length!=u_strlen(source) || memcmp(dest, an2en, l ength*U_SIZEOF_UCHAR)!=0) {
2478 log_err("failure in u_shapeArabic(an2en)\n"); 2482 log_err("failure in u_shapeArabic(an2en)\n");
2479 } 2483 }
2480 2484
2481 /* european->arabic with context, logical order, initial state not AL */ 2485 /* european->arabic with context, logical order, initial state not AL */
2482 errorCode=U_ZERO_ERROR; 2486 errorCode=U_ZERO_ERROR;
2483 length=u_shapeArabic(source, LENGTHOF(source), 2487 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2484 dest, LENGTHOF(dest), 2488 dest, UPRV_LENGTHOF(dest),
2485 U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN, 2489 U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN,
2486 &errorCode); 2490 &errorCode);
2487 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_ alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) { 2491 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, log ical_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
2488 log_err("failure in u_shapeArabic(logical_alen2an_init_lr)\n"); 2492 log_err("failure in u_shapeArabic(logical_alen2an_init_lr)\n");
2489 } 2493 }
2490 2494
2491 /* european->arabic with context, logical order, initial state AL */ 2495 /* european->arabic with context, logical order, initial state AL */
2492 errorCode=U_ZERO_ERROR; 2496 errorCode=U_ZERO_ERROR;
2493 length=u_shapeArabic(source, LENGTHOF(source), 2497 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2494 dest, LENGTHOF(dest), 2498 dest, UPRV_LENGTHOF(dest),
2495 U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EX TENDED, 2499 U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EX TENDED,
2496 &errorCode); 2500 &errorCode);
2497 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_ alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) { 2501 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, log ical_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
2498 log_err("failure in u_shapeArabic(logical_alen2an_init_al)\n"); 2502 log_err("failure in u_shapeArabic(logical_alen2an_init_al)\n");
2499 } 2503 }
2500 2504
2501 /* european->arabic with context, reverse order, initial state not AL */ 2505 /* european->arabic with context, reverse order, initial state not AL */
2502 errorCode=U_ZERO_ERROR; 2506 errorCode=U_ZERO_ERROR;
2503 length=u_shapeArabic(source, LENGTHOF(source), 2507 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2504 dest, LENGTHOF(dest), 2508 dest, UPRV_LENGTHOF(dest),
2505 U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN|U_ SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2509 U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN|U_ SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2506 &errorCode); 2510 &errorCode);
2507 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_ alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) { 2511 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, rev erse_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
2508 log_err("failure in u_shapeArabic(reverse_alen2an_init_lr)\n"); 2512 log_err("failure in u_shapeArabic(reverse_alen2an_init_lr)\n");
2509 } 2513 }
2510 2514
2511 /* european->arabic with context, reverse order, initial state AL */ 2515 /* european->arabic with context, reverse order, initial state AL */
2512 errorCode=U_ZERO_ERROR; 2516 errorCode=U_ZERO_ERROR;
2513 length=u_shapeArabic(source, LENGTHOF(source), 2517 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2514 dest, LENGTHOF(dest), 2518 dest, UPRV_LENGTHOF(dest),
2515 U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EX TENDED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2519 U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EX TENDED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2516 &errorCode); 2520 &errorCode);
2517 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_ alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) { 2521 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, rev erse_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
2518 log_err("failure in u_shapeArabic(reverse_alen2an_init_al)\n"); 2522 log_err("failure in u_shapeArabic(reverse_alen2an_init_al)\n");
2519 } 2523 }
2520 2524
2521 /* test noop */ 2525 /* test noop */
2522 errorCode=U_ZERO_ERROR; 2526 errorCode=U_ZERO_ERROR;
2523 length=u_shapeArabic(source, LENGTHOF(source), 2527 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2524 dest, LENGTHOF(dest), 2528 dest, UPRV_LENGTHOF(dest),
2525 0, 2529 0,
2526 &errorCode); 2530 &errorCode);
2527 if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, source, length*U_SIZEOF_UCHAR)!=0) { 2531 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, sou rce, length*U_SIZEOF_UCHAR)!=0) {
2528 log_err("failure in u_shapeArabic(noop)\n"); 2532 log_err("failure in u_shapeArabic(noop)\n");
2529 } 2533 }
2530 2534
2531 errorCode=U_ZERO_ERROR; 2535 errorCode=U_ZERO_ERROR;
2532 length=u_shapeArabic(source, 0, 2536 length=u_shapeArabic(source, 0,
2533 dest, LENGTHOF(dest), 2537 dest, UPRV_LENGTHOF(dest),
2534 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2538 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2535 &errorCode); 2539 &errorCode);
2536 if(U_FAILURE(errorCode) || length!=0) { 2540 if(U_FAILURE(errorCode) || length!=0) {
2537 log_err("failure in u_shapeArabic(en2an, sourceLength=0), returned %d/%s \n", u_errorName(errorCode), LENGTHOF(source)); 2541 log_err("failure in u_shapeArabic(en2an, sourceLength=0), returned %d/%s \n", u_errorName(errorCode), UPRV_LENGTHOF(source));
2538 } 2542 }
2539 2543
2540 /* preflight digit shaping */ 2544 /* preflight digit shaping */
2541 errorCode=U_ZERO_ERROR; 2545 errorCode=U_ZERO_ERROR;
2542 length=u_shapeArabic(source, LENGTHOF(source), 2546 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2543 NULL, 0, 2547 NULL, 0,
2544 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2548 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2545 &errorCode); 2549 &errorCode);
2546 if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=LENGTHOF(source)) { 2550 if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=UPRV_LENGTHOF(source)) {
2547 log_err("failure in u_shapeArabic(en2an preflighting), returned %d/%s in stead of %d/U_BUFFER_OVERFLOW_ERROR\n", 2551 log_err("failure in u_shapeArabic(en2an preflighting), returned %d/%s in stead of %d/U_BUFFER_OVERFLOW_ERROR\n",
2548 length, u_errorName(errorCode), LENGTHOF(source)); 2552 length, u_errorName(errorCode), UPRV_LENGTHOF(source));
2549 } 2553 }
2550 2554
2551 /* test illegal arguments */ 2555 /* test illegal arguments */
2552 errorCode=U_ZERO_ERROR; 2556 errorCode=U_ZERO_ERROR;
2553 length=u_shapeArabic(NULL, LENGTHOF(source), 2557 length=u_shapeArabic(NULL, UPRV_LENGTHOF(source),
2554 dest, LENGTHOF(dest), 2558 dest, UPRV_LENGTHOF(dest),
2555 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2559 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2556 &errorCode); 2560 &errorCode);
2557 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2561 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2558 log_err("failure in u_shapeArabic(source=NULL), returned %s instead of U _ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2562 log_err("failure in u_shapeArabic(source=NULL), returned %s instead of U _ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2559 } 2563 }
2560 2564
2561 errorCode=U_ZERO_ERROR; 2565 errorCode=U_ZERO_ERROR;
2562 length=u_shapeArabic(source, -2, 2566 length=u_shapeArabic(source, -2,
2563 dest, LENGTHOF(dest), 2567 dest, UPRV_LENGTHOF(dest),
2564 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2568 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2565 &errorCode); 2569 &errorCode);
2566 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2570 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2567 log_err("failure in u_shapeArabic(sourceLength=-2), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2571 log_err("failure in u_shapeArabic(sourceLength=-2), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2568 } 2572 }
2569 2573
2570 errorCode=U_ZERO_ERROR; 2574 errorCode=U_ZERO_ERROR;
2571 length=u_shapeArabic(source, LENGTHOF(source), 2575 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2572 NULL, LENGTHOF(dest), 2576 NULL, UPRV_LENGTHOF(dest),
2573 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2577 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2574 &errorCode); 2578 &errorCode);
2575 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2579 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2576 log_err("failure in u_shapeArabic(dest=NULL), returned %s instead of U_I LLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2580 log_err("failure in u_shapeArabic(dest=NULL), returned %s instead of U_I LLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2577 } 2581 }
2578 2582
2579 errorCode=U_ZERO_ERROR; 2583 errorCode=U_ZERO_ERROR;
2580 length=u_shapeArabic(source, LENGTHOF(source), 2584 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2581 dest, -1, 2585 dest, -1,
2582 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2586 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2583 &errorCode); 2587 &errorCode);
2584 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2588 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2585 log_err("failure in u_shapeArabic(destSize=-1), returned %s instead of U _ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2589 log_err("failure in u_shapeArabic(destSize=-1), returned %s instead of U _ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2586 } 2590 }
2587 2591
2588 errorCode=U_ZERO_ERROR; 2592 errorCode=U_ZERO_ERROR;
2589 length=u_shapeArabic(source, LENGTHOF(source), 2593 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2590 dest, LENGTHOF(dest), 2594 dest, UPRV_LENGTHOF(dest),
2591 U_SHAPE_DIGITS_RESERVED|U_SHAPE_DIGIT_TYPE_AN, 2595 U_SHAPE_DIGITS_RESERVED|U_SHAPE_DIGIT_TYPE_AN,
2592 &errorCode); 2596 &errorCode);
2593 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2597 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2594 log_err("failure in u_shapeArabic(U_SHAPE_DIGITS_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2598 log_err("failure in u_shapeArabic(U_SHAPE_DIGITS_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2595 } 2599 }
2596 2600
2597 errorCode=U_ZERO_ERROR; 2601 errorCode=U_ZERO_ERROR;
2598 length=u_shapeArabic(source, LENGTHOF(source), 2602 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2599 dest, LENGTHOF(dest), 2603 dest, UPRV_LENGTHOF(dest),
2600 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_RESERVED, 2604 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_RESERVED,
2601 &errorCode); 2605 &errorCode);
2602 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2606 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2603 log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2607 log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2604 } 2608 }
2605 2609
2606 errorCode=U_ZERO_ERROR; 2610 errorCode=U_ZERO_ERROR;
2607 length=u_shapeArabic(source, LENGTHOF(source), 2611 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2608 (UChar *)(source+2), LENGTHOF(dest), /* overlap source and destination */ 2612 (UChar *)(source+2), UPRV_LENGTHOF(dest), /* overlap so urce and destination */
2609 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN, 2613 U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2610 &errorCode); 2614 &errorCode);
2611 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) { 2615 if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2612 log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode)); 2616 log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2613 } 2617 }
2614 2618
2615 errorCode=U_ZERO_ERROR; 2619 errorCode=U_ZERO_ERROR;
2616 length=u_shapeArabic(lamalef, LENGTHOF(lamalef), 2620 length=u_shapeArabic(lamalef, UPRV_LENGTHOF(lamalef),
2617 dest, LENGTHOF(dest), 2621 dest, UPRV_LENGTHOF(dest),
2618 U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2622 U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2619 &errorCode); 2623 &errorCode);
2620 if(U_FAILURE(errorCode) || length == LENGTHOF(lamalef)) { 2624 if(U_FAILURE(errorCode) || length == UPRV_LENGTHOF(lamalef)) {
2621 log_err("failure in u_shapeArabic(U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENG TH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR)\n"); 2625 log_err("failure in u_shapeArabic(U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENG TH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR)\n");
2622 log_err("returned %s instead of U_ZERO_ERROR or returned length %d inste ad of 3\n", u_errorName(errorCode), length); 2626 log_err("returned %s instead of U_ZERO_ERROR or returned length %d inste ad of 3\n", u_errorName(errorCode), length);
2623 } 2627 }
2624 } 2628 }
2625 2629
2626 static void 2630 static void
2627 doLamAlefSpecialVLTRArabicShapingTest(void) { 2631 doLamAlefSpecialVLTRArabicShapingTest(void) {
2628 static const UChar 2632 static const UChar
2629 source[]={ 2633 source[]={
2630 /*a*/ 0x20 ,0x646,0x622,0x644,0x627,0x20, 2634 /*a*/ 0x20 ,0x646,0x622,0x644,0x627,0x20,
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
2670 0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,0 xfe8d, 2674 0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,0 xfe8d,
2671 0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb 2675 0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
2672 }; 2676 };
2673 2677
2674 UChar dest[38]; 2678 UChar dest[38];
2675 UErrorCode errorCode; 2679 UErrorCode errorCode;
2676 int32_t length; 2680 int32_t length;
2677 2681
2678 errorCode=U_ZERO_ERROR; 2682 errorCode=U_ZERO_ERROR;
2679 2683
2680 length=u_shapeArabic(source, LENGTHOF(source), 2684 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2681 dest, LENGTHOF(dest), 2685 dest, UPRV_LENGTHOF(dest),
2682 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR| 2686 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2683 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2687 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2684 &errorCode); 2688 &errorCode);
2685 2689
2686 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shap e_near, length*U_SIZEOF_UCHAR)!=0) { 2690 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
2687 log_err("failure in u_shapeArabic(LAMALEF shape_near)\n"); 2691 log_err("failure in u_shapeArabic(LAMALEF shape_near)\n");
2688 } 2692 }
2689 2693
2690 errorCode=U_ZERO_ERROR; 2694 errorCode=U_ZERO_ERROR;
2691 2695
2692 length=u_shapeArabic(source, LENGTHOF(source), 2696 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2693 dest, LENGTHOF(dest), 2697 dest, UPRV_LENGTHOF(dest),
2694 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_EN D| 2698 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_EN D|
2695 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2699 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2696 &errorCode); 2700 &errorCode);
2697 2701
2698 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_end) || memcmp(dest, sh ape_at_end, length*U_SIZEOF_UCHAR)!=0) { 2702 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_at_end) || memcmp(des t, shape_at_end, length*U_SIZEOF_UCHAR)!=0) {
2699 log_err("failure in u_shapeArabic(LAMALEF shape_at_end)\n"); 2703 log_err("failure in u_shapeArabic(LAMALEF shape_at_end)\n");
2700 } 2704 }
2701 2705
2702 errorCode=U_ZERO_ERROR; 2706 errorCode=U_ZERO_ERROR;
2703 2707
2704 length=u_shapeArabic(source, LENGTHOF(source), 2708 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2705 dest, LENGTHOF(dest), 2709 dest, UPRV_LENGTHOF(dest),
2706 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BE GINNING| 2710 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BE GINNING|
2707 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2711 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2708 &errorCode); 2712 &errorCode);
2709 2713
2710 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_begin) || memcmp(dest, shape_at_begin, length*U_SIZEOF_UCHAR)!=0) { 2714 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_at_begin) || memcmp(d est, shape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2711 log_err("failure in u_shapeArabic(LAMALEF shape_at_begin)\n"); 2715 log_err("failure in u_shapeArabic(LAMALEF shape_at_begin)\n");
2712 } 2716 }
2713 2717
2714 errorCode=U_ZERO_ERROR; 2718 errorCode=U_ZERO_ERROR;
2715 2719
2716 length=u_shapeArabic(source, LENGTHOF(source), 2720 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2717 dest, LENGTHOF(dest), 2721 dest, UPRV_LENGTHOF(dest),
2718 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_GROW_SHRINK| 2722 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
2719 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2723 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2720 &errorCode); 2724 &errorCode);
2721 2725
2722 if(U_FAILURE(errorCode) || memcmp(dest, shape_grow_shrink, length*U_SIZEOF_U CHAR)!=0) { 2726 if(U_FAILURE(errorCode) || memcmp(dest, shape_grow_shrink, length*U_SIZEOF_U CHAR)!=0) {
2723 log_err("failure in u_shapeArabic(LAMALEF shape_grow_shrink)\n"); 2727 log_err("failure in u_shapeArabic(LAMALEF shape_grow_shrink)\n");
2724 } 2728 }
2725 2729
2726 /* ==================== U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED ============ ======== */ 2730 /* ==================== U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED ============ ======== */
2727 2731
2728 errorCode=U_ZERO_ERROR; 2732 errorCode=U_ZERO_ERROR;
2729 2733
2730 length=u_shapeArabic(source, LENGTHOF(source), 2734 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2731 dest, LENGTHOF(dest), 2735 dest, UPRV_LENGTHOF(dest),
2732 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_NEAR| 2736 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_NEAR|
2733 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2737 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2734 &errorCode); 2738 &errorCode);
2735 2739
2736 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || me mcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) { 2740 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
2737 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_near)\n") ; 2741 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_near)\n") ;
2738 } 2742 }
2739 2743
2740 errorCode=U_ZERO_ERROR; 2744 errorCode=U_ZERO_ERROR;
2741 2745
2742 length=u_shapeArabic(source, LENGTHOF(source), 2746 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2743 dest, LENGTHOF(dest), 2747 dest, UPRV_LENGTHOF(dest),
2744 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_AT_END| 2748 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_AT_END|
2745 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2749 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2746 &errorCode); 2750 &errorCode);
2747 2751
2748 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_end) || memcmp(dest,shape_excepttashkeel_at_end , length*U_SIZEOF_UCHAR)!=0) { 2752 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_at_end ) || memcmp(dest,shape_excepttashkeel_at_end , length*U_SIZEOF_UCHAR)!=0) {
2749 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_end)\n "); 2753 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_end)\n ");
2750 } 2754 }
2751 2755
2752 errorCode=U_ZERO_ERROR; 2756 errorCode=U_ZERO_ERROR;
2753 2757
2754 length=u_shapeArabic(source, LENGTHOF(source), 2758 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2755 dest, LENGTHOF(dest), 2759 dest, UPRV_LENGTHOF(dest),
2756 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_AT_BEGINNING| 2760 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_AT_BEGINNING|
2757 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2761 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2758 &errorCode); 2762 &errorCode);
2759 2763
2760 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_begin) | | memcmp(dest, shape_excepttashkeel_at_begin, length*U_SIZEOF_UCHAR)!=0) { 2764 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_at_beg in) || memcmp(dest, shape_excepttashkeel_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2761 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_begin) \n"); 2765 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_begin) \n");
2762 } 2766 }
2763 2767
2764 errorCode=U_ZERO_ERROR; 2768 errorCode=U_ZERO_ERROR;
2765 2769
2766 length=u_shapeArabic(source, LENGTHOF(source), 2770 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2767 dest, LENGTHOF(dest), 2771 dest, UPRV_LENGTHOF(dest),
2768 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ GROW_SHRINK| 2772 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ GROW_SHRINK|
2769 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2773 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2770 &errorCode); 2774 &errorCode);
2771 2775
2772 if(U_FAILURE(errorCode) || memcmp(dest, shape_excepttashkeel_grow_shrink, le ngth*U_SIZEOF_UCHAR)!=0) { 2776 if(U_FAILURE(errorCode) || memcmp(dest, shape_excepttashkeel_grow_shrink, le ngth*U_SIZEOF_UCHAR)!=0) {
2773 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_grow_shri nk)\n"); 2777 log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_grow_shri nk)\n");
2774 } 2778 }
2775 } 2779 }
2776 2780
2777 static void 2781 static void
(...skipping 18 matching lines...) Expand all
2796 0x20,0xfe8f,0x653,0xfeae,0x653,0xfecb,0x20,0xfe8f,0x654,0xfeae,0x654,0xf ecb,0x20, 2800 0x20,0xfe8f,0x653,0xfeae,0x653,0xfecb,0x20,0xfe8f,0x654,0xfeae,0x654,0xf ecb,0x20,
2797 0xfe8f,0x655,0xfeae,0x655,0xfecb,0x20 2801 0xfe8f,0x655,0xfeae,0x655,0xfecb,0x20
2798 }; 2802 };
2799 2803
2800 UChar dest[43]; 2804 UChar dest[43];
2801 UErrorCode errorCode; 2805 UErrorCode errorCode;
2802 int32_t length; 2806 int32_t length;
2803 2807
2804 errorCode=U_ZERO_ERROR; 2808 errorCode=U_ZERO_ERROR;
2805 2809
2806 length=u_shapeArabic(source, LENGTHOF(source), 2810 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2807 dest, LENGTHOF(dest), 2811 dest, UPRV_LENGTHOF(dest),
2808 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR| 2812 U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2809 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2813 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2810 &errorCode); 2814 &errorCode);
2811 2815
2812 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shap e_near, length*U_SIZEOF_UCHAR)!=0) { 2816 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
2813 log_err("failure in u_shapeArabic(TASHKEEL shape_near)\n"); 2817 log_err("failure in u_shapeArabic(TASHKEEL shape_near)\n");
2814 } 2818 }
2815 2819
2816 errorCode=U_ZERO_ERROR; 2820 errorCode=U_ZERO_ERROR;
2817 2821
2818 length=u_shapeArabic(source, LENGTHOF(source), 2822 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2819 dest, LENGTHOF(dest), 2823 dest, UPRV_LENGTHOF(dest),
2820 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_NEAR| 2824 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_ FIXED_SPACES_NEAR|
2821 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, 2825 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2822 &errorCode); 2826 &errorCode);
2823 2827
2824 if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || me mcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) { 2828 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
2825 log_err("failure in u_shapeArabic(TASHKEEL shape_excepttashkeel_near)\n" ); 2829 log_err("failure in u_shapeArabic(TASHKEEL shape_excepttashkeel_near)\n" );
2826 } 2830 }
2827 } 2831 }
2828 2832
2829 static void 2833 static void
2830 doLOGICALArabicDeShapingTest(void) { 2834 doLOGICALArabicDeShapingTest(void) {
2831 static const UChar 2835 static const UChar
2832 source[]={ 2836 source[]={
2833 0x0020,0x0020,0x0020,0xFE8D,0xFEF5,0x0020,0xFEE5,0x0020,0xFE8D,0xFEF7,0x 0020, 2837 0x0020,0x0020,0x0020,0xFE8D,0xFEF5,0x0020,0xFEE5,0x0020,0xFE8D,0xFEF7,0x 0020,
2834 0xFED7,0xFEFC,0x0020,0xFEE1,0x0020,0xFE8D,0xFEDF,0xFECC,0xFEAE,0xFE91,0x FEF4, 2838 0xFED7,0xFEFC,0x0020,0xFEE1,0x0020,0xFE8D,0xFEDF,0xFECC,0xFEAE,0xFE91,0x FEF4,
(...skipping 15 matching lines...) Expand all
2850 0x644,0x627,0x20,0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x 20,0x627, 2854 0x644,0x627,0x20,0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x 20,0x627,
2851 0x644,0x62d,0x631,0x629,0x20,0x20,0x20,0x20 2855 0x644,0x62d,0x631,0x629,0x20,0x20,0x20,0x20
2852 }; 2856 };
2853 2857
2854 UChar dest[36]; 2858 UChar dest[36];
2855 UErrorCode errorCode; 2859 UErrorCode errorCode;
2856 int32_t length; 2860 int32_t length;
2857 2861
2858 errorCode=U_ZERO_ERROR; 2862 errorCode=U_ZERO_ERROR;
2859 2863
2860 length=u_shapeArabic(source, LENGTHOF(source), 2864 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2861 dest, LENGTHOF(dest), 2865 dest, UPRV_LENGTHOF(dest),
2862 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEA R| 2866 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEA R|
2863 U_SHAPE_TEXT_DIRECTION_LOGICAL, 2867 U_SHAPE_TEXT_DIRECTION_LOGICAL,
2864 &errorCode); 2868 &errorCode);
2865 2869
2866 if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_near) || memcmp(dest, un shape_near, length*U_SIZEOF_UCHAR)!=0) { 2870 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_near) || memcmp(des t, unshape_near, length*U_SIZEOF_UCHAR)!=0) {
2867 log_err("failure in u_shapeArabic(unshape_near)\n"); 2871 log_err("failure in u_shapeArabic(unshape_near)\n");
2868 } 2872 }
2869 2873
2870 errorCode=U_ZERO_ERROR; 2874 errorCode=U_ZERO_ERROR;
2871 2875
2872 length=u_shapeArabic(source, LENGTHOF(source), 2876 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2873 dest, LENGTHOF(dest), 2877 dest, UPRV_LENGTHOF(dest),
2874 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_ END| 2878 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_ END|
2875 U_SHAPE_TEXT_DIRECTION_LOGICAL, 2879 U_SHAPE_TEXT_DIRECTION_LOGICAL,
2876 &errorCode); 2880 &errorCode);
2877 2881
2878 if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_end) || memcmp(dest, unshape_at_end, length*U_SIZEOF_UCHAR)!=0) { 2882 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_at_end) || memcmp(d est, unshape_at_end, length*U_SIZEOF_UCHAR)!=0) {
2879 log_err("failure in u_shapeArabic(unshape_at_end)\n"); 2883 log_err("failure in u_shapeArabic(unshape_at_end)\n");
2880 } 2884 }
2881 2885
2882 errorCode=U_ZERO_ERROR; 2886 errorCode=U_ZERO_ERROR;
2883 2887
2884 length=u_shapeArabic(source, LENGTHOF(source), 2888 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2885 dest, LENGTHOF(dest), 2889 dest, UPRV_LENGTHOF(dest),
2886 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_ BEGINNING| 2890 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_ BEGINNING|
2887 U_SHAPE_TEXT_DIRECTION_LOGICAL, 2891 U_SHAPE_TEXT_DIRECTION_LOGICAL,
2888 &errorCode); 2892 &errorCode);
2889 2893
2890 if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_begin) || memcmp(dest , unshape_at_begin, length*U_SIZEOF_UCHAR)!=0) { 2894 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_at_begin) || memcmp (dest, unshape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2891 log_err("failure in u_shapeArabic(unshape_at_begin)\n"); 2895 log_err("failure in u_shapeArabic(unshape_at_begin)\n");
2892 } 2896 }
2893 2897
2894 errorCode=U_ZERO_ERROR; 2898 errorCode=U_ZERO_ERROR;
2895 2899
2896 length=u_shapeArabic(source, LENGTHOF(source), 2900 length=u_shapeArabic(source, UPRV_LENGTHOF(source),
2897 dest, LENGTHOF(dest), 2901 dest, UPRV_LENGTHOF(dest),
2898 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_GROW_SHRINK| 2902 U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
2899 U_SHAPE_TEXT_DIRECTION_LOGICAL, 2903 U_SHAPE_TEXT_DIRECTION_LOGICAL,
2900 &errorCode); 2904 &errorCode);
2901 2905
2902 if(U_FAILURE(errorCode) || memcmp(dest, unshape_grow_shrink, length*U_SIZEOF _UCHAR)!=0) { 2906 if(U_FAILURE(errorCode) || memcmp(dest, unshape_grow_shrink, length*U_SIZEOF _UCHAR)!=0) {
2903 log_err("failure in u_shapeArabic(unshape_grow_shrink)\n"); 2907 log_err("failure in u_shapeArabic(unshape_grow_shrink)\n");
2904 } 2908 }
2905 2909
2906 } 2910 }
2907 2911
2908 static void 2912 static void
2909 doTailTest(void) { 2913 doTailTest(void) {
2910 static const UChar src[] = { 0x0020, 0x0633, 0 }; 2914 static const UChar src[] = { 0x0020, 0x0633, 0 };
2911 static const UChar dst_old[] = { 0xFEB1, 0x200B,0 }; 2915 static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
2912 static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 }; 2916 static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
2913 UChar dst[3] = { 0x0000, 0x0000,0 }; 2917 UChar dst[3] = { 0x0000, 0x0000,0 };
2914 int32_t length; 2918 int32_t length;
2915 UErrorCode status; 2919 UErrorCode status;
2916 2920
2917 log_verbose("SRC: U+%04X U+%04X\n", src[0],src[1]); 2921 log_verbose("SRC: U+%04X U+%04X\n", src[0],src[1]);
2918 2922
2919 log_verbose("Trying old tail\n"); 2923 log_verbose("Trying old tail\n");
2920 status = U_ZERO_ERROR; 2924 status = U_ZERO_ERROR;
2921 length = u_shapeArabic(src, -1, dst, LENGTHOF(dst), 2925 length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
2922 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &statu s); 2926 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &statu s);
2923 if(U_FAILURE(status)) { 2927 if(U_FAILURE(status)) {
2924 log_err("Fail: status %s\n", u_errorName(status)); 2928 log_err("Fail: status %s\n", u_errorName(status));
2925 } else if(length!=2) { 2929 } else if(length!=2) {
2926 log_err("Fail: len %d expected 3\n", length); 2930 log_err("Fail: len %d expected 3\n", length);
2927 } else if(u_strncmp(dst,dst_old,LENGTHOF(dst))) { 2931 } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
2928 log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n", 2932 log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
2929 dst[0],dst[1],dst_old[0],dst_old[1]); 2933 dst[0],dst[1],dst_old[0],dst_old[1]);
2930 } else { 2934 } else {
2931 log_verbose("OK: U+%04X U+%04X len %d err %s\n", 2935 log_verbose("OK: U+%04X U+%04X len %d err %s\n",
2932 dst[0],dst[1],length,u_errorName(status)); 2936 dst[0],dst[1],length,u_errorName(status));
2933 } 2937 }
2934 2938
2935 2939
2936 log_verbose("Trying new tail\n"); 2940 log_verbose("Trying new tail\n");
2937 status = U_ZERO_ERROR; 2941 status = U_ZERO_ERROR;
2938 length = u_shapeArabic(src, -1, dst, LENGTHOF(dst), 2942 length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
2939 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE _TAIL_NEW_UNICODE, &status); 2943 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE _TAIL_NEW_UNICODE, &status);
2940 if(U_FAILURE(status)) { 2944 if(U_FAILURE(status)) {
2941 log_err("Fail: status %s\n", u_errorName(status)); 2945 log_err("Fail: status %s\n", u_errorName(status));
2942 } else if(length!=2) { 2946 } else if(length!=2) {
2943 log_err("Fail: len %d expected 3\n", length); 2947 log_err("Fail: len %d expected 3\n", length);
2944 } else if(u_strncmp(dst,dst_new,LENGTHOF(dst))) { 2948 } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
2945 log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n", 2949 log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
2946 dst[0],dst[1],dst_new[0],dst_new[1]); 2950 dst[0],dst[1],dst_new[0],dst_new[1]);
2947 } else { 2951 } else {
2948 log_verbose("OK: U+%04X U+%04X len %d err %s\n", 2952 log_verbose("OK: U+%04X U+%04X len %d err %s\n",
2949 dst[0],dst[1],length,u_errorName(status)); 2953 dst[0],dst[1],length,u_errorName(status));
2950 } 2954 }
2951 } 2955 }
2952 2956
2953 static void 2957 static void
2954 doArabicShapingTestForBug5421(void) { 2958 doArabicShapingTestForBug5421(void) {
(...skipping 17 matching lines...) Expand all
2972 }, untouched_presentation_r[]={ 2976 }, untouched_presentation_r[]={
2973 0x0020, 0xfe90,0xfe8D,0x0020 2977 0x0020, 0xfe90,0xfe8D,0x0020
2974 }; 2978 };
2975 2979
2976 UChar dest[38]; 2980 UChar dest[38];
2977 UErrorCode errorCode; 2981 UErrorCode errorCode;
2978 int32_t length; 2982 int32_t length;
2979 2983
2980 errorCode=U_ZERO_ERROR; 2984 errorCode=U_ZERO_ERROR;
2981 2985
2982 length=u_shapeArabic(persian_letters_source, LENGTHOF(persian_letters_source ), 2986 length=u_shapeArabic(persian_letters_source, UPRV_LENGTHOF(persian_letters_s ource),
2983 dest, LENGTHOF(dest), 2987 dest, UPRV_LENGTHOF(dest),
2984 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR , 2988 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR ,
2985 &errorCode); 2989 &errorCode);
2986 2990
2987 if(U_FAILURE(errorCode) || length!=LENGTHOF(persian_letters) || memcmp(dest, persian_letters, length*U_SIZEOF_UCHAR)!=0) { 2991 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(persian_letters) || memcmp( dest, persian_letters, length*U_SIZEOF_UCHAR)!=0) {
2988 log_err("failure in u_shapeArabic(persian_letters)\n"); 2992 log_err("failure in u_shapeArabic(persian_letters)\n");
2989 } 2993 }
2990 2994
2991 errorCode=U_ZERO_ERROR; 2995 errorCode=U_ZERO_ERROR;
2992 2996
2993 length=u_shapeArabic(tashkeel_aggregation_source, LENGTHOF(tashkeel_aggregat ion_source), 2997 length=u_shapeArabic(tashkeel_aggregation_source, UPRV_LENGTHOF(tashkeel_agg regation_source),
2994 dest, LENGTHOF(dest), 2998 dest, UPRV_LENGTHOF(dest),
2995 U_SHAPE_AGGREGATE_TASHKEEL|U_SHAPE_PRESERVE_PRESENTATIO N| 2999 U_SHAPE_AGGREGATE_TASHKEEL|U_SHAPE_PRESERVE_PRESENTATIO N|
2996 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_TEXT_DI RECTION_VISUAL_LTR, 3000 U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_TEXT_DI RECTION_VISUAL_LTR,
2997 &errorCode); 3001 &errorCode);
2998 3002
2999 if(U_FAILURE(errorCode) || length!=LENGTHOF(tashkeel_aggregation) || memcmp( dest, tashkeel_aggregation, length*U_SIZEOF_UCHAR)!=0) { 3003 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(tashkeel_aggregation) || me mcmp(dest, tashkeel_aggregation, length*U_SIZEOF_UCHAR)!=0) {
3000 log_err("failure in u_shapeArabic(tashkeel_aggregation)\n"); 3004 log_err("failure in u_shapeArabic(tashkeel_aggregation)\n");
3001 } 3005 }
3002 3006
3003 errorCode=U_ZERO_ERROR; 3007 errorCode=U_ZERO_ERROR;
3004 3008
3005 length=u_shapeArabic(untouched_presentation_source, LENGTHOF(untouched_prese ntation_source), 3009 length=u_shapeArabic(untouched_presentation_source, UPRV_LENGTHOF(untouched_ presentation_source),
3006 dest, LENGTHOF(dest), 3010 dest, UPRV_LENGTHOF(dest),
3007 U_SHAPE_PRESERVE_PRESENTATION| 3011 U_SHAPE_PRESERVE_PRESENTATION|
3008 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR , 3012 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR ,
3009 &errorCode); 3013 &errorCode);
3010 3014
3011 if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation) || memcm p(dest, untouched_presentation, length*U_SIZEOF_UCHAR)!=0) { 3015 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(untouched_presentation) || memcmp(dest, untouched_presentation, length*U_SIZEOF_UCHAR)!=0) {
3012 log_err("failure in u_shapeArabic(untouched_presentation)\n"); 3016 log_err("failure in u_shapeArabic(untouched_presentation)\n");
3013 } 3017 }
3014 3018
3015 errorCode=U_ZERO_ERROR; 3019 errorCode=U_ZERO_ERROR;
3016 3020
3017 length=u_shapeArabic(untouched_presentation_r_source, LENGTHOF(untouched_pre sentation_r_source), 3021 length=u_shapeArabic(untouched_presentation_r_source, UPRV_LENGTHOF(untouche d_presentation_r_source),
3018 dest, LENGTHOF(dest), 3022 dest, UPRV_LENGTHOF(dest),
3019 U_SHAPE_PRESERVE_PRESENTATION| 3023 U_SHAPE_PRESERVE_PRESENTATION|
3020 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_LOGICAL, 3024 U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_LOGICAL,
3021 &errorCode); 3025 &errorCode);
3022 3026
3023 if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation_r) || mem cmp(dest, untouched_presentation_r, length*U_SIZEOF_UCHAR)!=0) { 3027 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(untouched_presentation_r) | | memcmp(dest, untouched_presentation_r, length*U_SIZEOF_UCHAR)!=0) {
3024 log_err("failure in u_shapeArabic(untouched_presentation_r)\n"); 3028 log_err("failure in u_shapeArabic(untouched_presentation_r)\n");
3025 } 3029 }
3026 } 3030 }
3027 3031
3028 static void 3032 static void
3029 doArabicShapingTestForBug8703(void) { 3033 doArabicShapingTestForBug8703(void) {
3030 static const UChar 3034 static const UChar
3031 letters_source1[]={ 3035 letters_source1[]={
3032 0x0634,0x0651,0x0645,0x0652,0x0633 3036 0x0634,0x0651,0x0645,0x0652,0x0633
3033 }, letters_source2[]={ 3037 }, letters_source2[]={
(...skipping 27 matching lines...) Expand all
3061 }, letters_dest8[]={ 3065 }, letters_dest8[]={
3062 0xFEB2,0x0640,0xFEE4,0xFE7D,0xFEB7 3066 0xFEB2,0x0640,0xFEE4,0xFE7D,0xFEB7
3063 }; 3067 };
3064 3068
3065 UChar dest[20]; 3069 UChar dest[20];
3066 UErrorCode errorCode; 3070 UErrorCode errorCode;
3067 int32_t length; 3071 int32_t length;
3068 3072
3069 errorCode=U_ZERO_ERROR; 3073 errorCode=U_ZERO_ERROR;
3070 3074
3071 length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1), 3075 length=u_shapeArabic(letters_source1, UPRV_LENGTHOF(letters_source1),
3072 dest, LENGTHOF(dest), 3076 dest, UPRV_LENGTHOF(dest),
3073 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE, 3077 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE,
3074 &errorCode); 3078 &errorCode);
3075 3079
3076 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, l etters_dest1, length*U_SIZEOF_UCHAR)!=0) { 3080 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest1) || memcmp(de st, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
3077 log_err("failure in u_shapeArabic(letters_source1)\n"); 3081 log_err("failure in u_shapeArabic(letters_source1)\n");
3078 } 3082 }
3079 3083
3080 errorCode=U_ZERO_ERROR; 3084 errorCode=U_ZERO_ERROR;
3081 3085
3082 length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2), 3086 length=u_shapeArabic(letters_source2, UPRV_LENGTHOF(letters_source2),
3083 dest, LENGTHOF(dest), 3087 dest, UPRV_LENGTHOF(dest),
3084 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE, 3088 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE,
3085 &errorCode); 3089 &errorCode);
3086 3090
3087 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, l etters_dest2, length*U_SIZEOF_UCHAR)!=0) { 3091 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest2) || memcmp(de st, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
3088 log_err("failure in u_shapeArabic(letters_source2)\n"); 3092 log_err("failure in u_shapeArabic(letters_source2)\n");
3089 } 3093 }
3090 3094
3091 errorCode=U_ZERO_ERROR; 3095 errorCode=U_ZERO_ERROR;
3092 3096
3093 length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3), 3097 length=u_shapeArabic(letters_source3, UPRV_LENGTHOF(letters_source3),
3094 dest, LENGTHOF(dest), 3098 dest, UPRV_LENGTHOF(dest),
3095 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE, 3099 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE,
3096 &errorCode); 3100 &errorCode);
3097 3101
3098 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, l etters_dest3, length*U_SIZEOF_UCHAR)!=0) { 3102 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest3) || memcmp(de st, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
3099 log_err("failure in u_shapeArabic(letters_source3)\n"); 3103 log_err("failure in u_shapeArabic(letters_source3)\n");
3100 } 3104 }
3101 3105
3102 errorCode=U_ZERO_ERROR; 3106 errorCode=U_ZERO_ERROR;
3103 3107
3104 length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4), 3108 length=u_shapeArabic(letters_source4, UPRV_LENGTHOF(letters_source4),
3105 dest, LENGTHOF(dest), 3109 dest, UPRV_LENGTHOF(dest),
3106 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE, 3110 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3107 &errorCode); 3111 &errorCode);
3108 3112
3109 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, l etters_dest4, length*U_SIZEOF_UCHAR)!=0) { 3113 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest4) || memcmp(de st, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
3110 log_err("failure in u_shapeArabic(letters_source4)\n"); 3114 log_err("failure in u_shapeArabic(letters_source4)\n");
3111 } 3115 }
3112 3116
3113 errorCode=U_ZERO_ERROR; 3117 errorCode=U_ZERO_ERROR;
3114 3118
3115 length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5), 3119 length=u_shapeArabic(letters_source5, UPRV_LENGTHOF(letters_source5),
3116 dest, LENGTHOF(dest), 3120 dest, UPRV_LENGTHOF(dest),
3117 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE, 3121 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE,
3118 &errorCode); 3122 &errorCode);
3119 3123
3120 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, l etters_dest5, length*U_SIZEOF_UCHAR)!=0) { 3124 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest5) || memcmp(de st, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
3121 log_err("failure in u_shapeArabic(letters_source5)\n"); 3125 log_err("failure in u_shapeArabic(letters_source5)\n");
3122 } 3126 }
3123 3127
3124 errorCode=U_ZERO_ERROR; 3128 errorCode=U_ZERO_ERROR;
3125 3129
3126 length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6), 3130 length=u_shapeArabic(letters_source6, UPRV_LENGTHOF(letters_source6),
3127 dest, LENGTHOF(dest), 3131 dest, UPRV_LENGTHOF(dest),
3128 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE, 3132 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE,
3129 &errorCode); 3133 &errorCode);
3130 3134
3131 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, l etters_dest6, length*U_SIZEOF_UCHAR)!=0) { 3135 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest6) || memcmp(de st, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
3132 log_err("failure in u_shapeArabic(letters_source6)\n"); 3136 log_err("failure in u_shapeArabic(letters_source6)\n");
3133 } 3137 }
3134 3138
3135 errorCode=U_ZERO_ERROR; 3139 errorCode=U_ZERO_ERROR;
3136 3140
3137 length=u_shapeArabic(letters_source7, LENGTHOF(letters_source7), 3141 length=u_shapeArabic(letters_source7, UPRV_LENGTHOF(letters_source7),
3138 dest, LENGTHOF(dest), 3142 dest, UPRV_LENGTHOF(dest),
3139 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE, 3143 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE,
3140 &errorCode); 3144 &errorCode);
3141 3145
3142 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest7) || memcmp(dest, l etters_dest7, length*U_SIZEOF_UCHAR)!=0) { 3146 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest7) || memcmp(de st, letters_dest7, length*U_SIZEOF_UCHAR)!=0) {
3143 log_err("failure in u_shapeArabic(letters_source7)\n"); 3147 log_err("failure in u_shapeArabic(letters_source7)\n");
3144 } 3148 }
3145 3149
3146 errorCode=U_ZERO_ERROR; 3150 errorCode=U_ZERO_ERROR;
3147 3151
3148 length=u_shapeArabic(letters_source8, LENGTHOF(letters_source8), 3152 length=u_shapeArabic(letters_source8, UPRV_LENGTHOF(letters_source8),
3149 dest, LENGTHOF(dest), 3153 dest, UPRV_LENGTHOF(dest),
3150 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE, 3154 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3151 &errorCode); 3155 &errorCode);
3152 3156
3153 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest8) || memcmp(dest, l etters_dest8, length*U_SIZEOF_UCHAR)!=0) { 3157 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest8) || memcmp(de st, letters_dest8, length*U_SIZEOF_UCHAR)!=0) {
3154 log_err("failure in u_shapeArabic(letters_source8)\n"); 3158 log_err("failure in u_shapeArabic(letters_source8)\n");
3155 } 3159 }
3156 } 3160 }
3157 3161
3158 static void 3162 static void
3159 doArabicShapingTestForBug9024(void) { 3163 doArabicShapingTestForBug9024(void) {
3160 static const UChar 3164 static const UChar
3161 letters_source1[]={ /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */ 3165 letters_source1[]={ /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */
3162 0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20, 3166 0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20,
3163 0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20, 3167 0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20,
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after
3243 }, letters_dest6[]={ 3247 }, letters_dest6[]={
3244 0xD83B, 0xDE21, 0xFEB1, 0xD83B, 0xDE62, 0xFEE9 3248 0xD83B, 0xDE21, 0xFEB1, 0xD83B, 0xDE62, 0xFEE9
3245 }; 3249 };
3246 3250
3247 UChar dest[MAXLEN]; 3251 UChar dest[MAXLEN];
3248 UErrorCode errorCode; 3252 UErrorCode errorCode;
3249 int32_t length; 3253 int32_t length;
3250 3254
3251 errorCode=U_ZERO_ERROR; 3255 errorCode=U_ZERO_ERROR;
3252 3256
3253 length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1), 3257 length=u_shapeArabic(letters_source1, UPRV_LENGTHOF(letters_source1),
3254 dest, LENGTHOF(dest), 3258 dest, UPRV_LENGTHOF(dest),
3255 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE, 3259 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE,
3256 &errorCode); 3260 &errorCode);
3257 3261
3258 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, l etters_dest1, length*U_SIZEOF_UCHAR)!=0) { 3262 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest1) || memcmp(de st, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
3259 log_err("failure in u_shapeArabic(letters_source1)\n"); 3263 log_err("failure in u_shapeArabic(letters_source1)\n");
3260 } 3264 }
3261 3265
3262 errorCode=U_ZERO_ERROR; 3266 errorCode=U_ZERO_ERROR;
3263 3267
3264 length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2), 3268 length=u_shapeArabic(letters_source2, UPRV_LENGTHOF(letters_source2),
3265 dest, LENGTHOF(dest), 3269 dest, UPRV_LENGTHOF(dest),
3266 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE, 3270 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE,
3267 &errorCode); 3271 &errorCode);
3268 3272
3269 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, l etters_dest2, length*U_SIZEOF_UCHAR)!=0) { 3273 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest2) || memcmp(de st, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
3270 log_err("failure in u_shapeArabic(letters_source2)\n"); 3274 log_err("failure in u_shapeArabic(letters_source2)\n");
3271 } 3275 }
3272 3276
3273 errorCode=U_ZERO_ERROR; 3277 errorCode=U_ZERO_ERROR;
3274 3278
3275 length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3), 3279 length=u_shapeArabic(letters_source3, UPRV_LENGTHOF(letters_source3),
3276 dest, LENGTHOF(dest), 3280 dest, UPRV_LENGTHOF(dest),
3277 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE, 3281 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE SIZE | U_SHAPE_LETTERS_SHAPE,
3278 &errorCode); 3282 &errorCode);
3279 3283
3280 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, l etters_dest3, length*U_SIZEOF_UCHAR)!=0) { 3284 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest3) || memcmp(de st, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
3281 log_err("failure in u_shapeArabic(letters_source3)\n"); 3285 log_err("failure in u_shapeArabic(letters_source3)\n");
3282 } 3286 }
3283 3287
3284 errorCode=U_ZERO_ERROR; 3288 errorCode=U_ZERO_ERROR;
3285 3289
3286 length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4), 3290 length=u_shapeArabic(letters_source4, UPRV_LENGTHOF(letters_source4),
3287 dest, LENGTHOF(dest), 3291 dest, UPRV_LENGTHOF(dest),
3288 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE, 3292 U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RE PLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3289 &errorCode); 3293 &errorCode);
3290 3294
3291 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, l etters_dest4, length*U_SIZEOF_UCHAR)!=0) { 3295 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest4) || memcmp(de st, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
3292 log_err("failure in u_shapeArabic(letters_source4)\n"); 3296 log_err("failure in u_shapeArabic(letters_source4)\n");
3293 } 3297 }
3294 3298
3295 errorCode=U_ZERO_ERROR; 3299 errorCode=U_ZERO_ERROR;
3296 3300
3297 length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5), 3301 length=u_shapeArabic(letters_source5, UPRV_LENGTHOF(letters_source5),
3298 dest, LENGTHOF(dest), 3302 dest, UPRV_LENGTHOF(dest),
3299 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE, 3303 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BE GIN | U_SHAPE_LETTERS_SHAPE,
3300 &errorCode); 3304 &errorCode);
3301 3305
3302 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, l etters_dest5, length*U_SIZEOF_UCHAR)!=0) { 3306 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest5) || memcmp(de st, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
3303 log_err("failure in u_shapeArabic(letters_source5)\n"); 3307 log_err("failure in u_shapeArabic(letters_source5)\n");
3304 } 3308 }
3305 3309
3306 errorCode=U_ZERO_ERROR; 3310 errorCode=U_ZERO_ERROR;
3307 3311
3308 length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6), 3312 length=u_shapeArabic(letters_source6, UPRV_LENGTHOF(letters_source6),
3309 dest, LENGTHOF(dest), 3313 dest, UPRV_LENGTHOF(dest),
3310 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE, 3314 U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_EN D | U_SHAPE_LETTERS_SHAPE,
3311 &errorCode); 3315 &errorCode);
3312 3316
3313 if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, l etters_dest6, length*U_SIZEOF_UCHAR)!=0) { 3317 if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest6) || memcmp(de st, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
3314 log_err("failure in u_shapeArabic(letters_source6)\n"); 3318 log_err("failure in u_shapeArabic(letters_source6)\n");
3315 } 3319 }
3316 3320
3317 } 3321 }
3318 3322
3323 static void _testPresentationForms(const UChar* in) {
3324 enum Forms { GENERIC, ISOLATED, FINAL, INITIAL, MEDIAL };
3325 /* This character is used to check whether the in-character is rewritten corre ctly
3326 and whether the surrounding characters are shaped correctly as well. */
3327 UChar otherChar[] = {0x0628, 0xfe8f, 0xfe90, 0xfe91, 0xfe92};
3328 UChar src[3];
3329 UChar dst[3];
3330 UErrorCode errorCode;
3331 int32_t length;
3332
3333 /* Testing isolated shaping */
3334 src[0] = in[GENERIC];
3335 errorCode=U_ZERO_ERROR;
3336 length=u_shapeArabic(src, 1,
3337 dst, 1,
3338 U_SHAPE_LETTERS_SHAPE,
3339 &errorCode);
3340 if(U_FAILURE(errorCode) || length!=1 || dst[0] != in[ISOLATED]) {
3341 log_err("failure in u_shapeArabic(_testAllForms: shaping isolated): %x\n", in[GENERIC]);
3342 }
3343 errorCode=U_ZERO_ERROR;
3344 length=u_shapeArabic(dst, 1,
3345 src, 1,
3346 U_SHAPE_LETTERS_UNSHAPE,
3347 &errorCode);
3348 if(U_FAILURE(errorCode) || length!=1 || src[0] != in[GENERIC]) {
3349 log_err("failure in u_shapeArabic(_testAllForms: unshaping isolated): %x\n ", in[GENERIC]);
3350 }
3351
3352 /* Testing final shaping */
3353 src[0] = otherChar[GENERIC];
3354 src[1] = in[GENERIC];
3355 if (in[FINAL] != 0) {
3356 errorCode=U_ZERO_ERROR;
3357 length=u_shapeArabic(src, 2,
3358 dst, 2,
3359 U_SHAPE_LETTERS_SHAPE,
3360 &errorCode);
3361 if(U_FAILURE(errorCode) || length!=2 || dst[0] != otherChar[INITIAL] || dst[ 1] != in[FINAL]) {
3362 log_err("failure in u_shapeArabic(_testAllForms: shaping final): %x\n", in [GENERIC]);
3363 }
3364 errorCode=U_ZERO_ERROR;
3365 length=u_shapeArabic(dst, 2,
3366 src, 2,
3367 U_SHAPE_LETTERS_UNSHAPE,
3368 &errorCode);
3369 if(U_FAILURE(errorCode) || length!=2 || src[0] != otherChar[GENERIC] || src[ 1] != in[GENERIC]) {
3370 log_err("failure in u_shapeArabic(_testAllForms: unshaping final): %x\n", in[GENERIC]);
3371 }
3372 } else {
3373 errorCode=U_ZERO_ERROR;
3374 length=u_shapeArabic(src, 2,
3375 dst, 2,
3376 U_SHAPE_LETTERS_SHAPE,
3377 &errorCode);
3378 if(U_FAILURE(errorCode) || length!=2 || dst[0] != otherChar[ISOLATED] || dst [1] != in[ISOLATED]) {
3379 log_err("failure in u_shapeArabic(_testAllForms: shaping final): %x\n", in [GENERIC]);
3380 }
3381 errorCode=U_ZERO_ERROR;
3382 length=u_shapeArabic(dst, 2,
3383 src, 2,
3384 U_SHAPE_LETTERS_UNSHAPE,
3385 &errorCode);
3386 if(U_FAILURE(errorCode) || length!=2 || src[0] != otherChar[GENERIC] || src[ 1] != in[GENERIC]) {
3387 log_err("failure in u_shapeArabic(_testAllForms: unshaping final): %x\n", in[GENERIC]);
3388 }
3389 }
3390
3391 /* Testing initial shaping */
3392 src[0] = in[GENERIC];
3393 src[1] = otherChar[GENERIC];
3394 if (in[INITIAL] != 0) {
3395 /* Testing characters that have an initial form */
3396 errorCode=U_ZERO_ERROR;
3397 length=u_shapeArabic(src, 2,
3398 dst, 2,
3399 U_SHAPE_LETTERS_SHAPE,
3400 &errorCode);
3401 if(U_FAILURE(errorCode) || length!=2 || dst[0] != in[INITIAL] || dst[1] != o therChar[FINAL]) {
3402 log_err("failure in u_shapeArabic(_testAllForms: shaping initial): %x\n", in[GENERIC]);
3403 }
3404 errorCode=U_ZERO_ERROR;
3405 length=u_shapeArabic(dst, 2,
3406 src, 2,
3407 U_SHAPE_LETTERS_UNSHAPE,
3408 &errorCode);
3409 if(U_FAILURE(errorCode) || length!=2 || src[0] != in[GENERIC] || src[1] != o therChar[GENERIC]) {
3410 log_err("failure in u_shapeArabic(_testAllForms: unshaping initial): %x\n" , in[GENERIC]);
3411 }
3412 } else {
3413 /* Testing characters that do not have an initial form */
3414 errorCode=U_ZERO_ERROR;
3415 length=u_shapeArabic(src, 2,
3416 dst, 2,
3417 U_SHAPE_LETTERS_SHAPE,
3418 &errorCode);
3419 if(U_FAILURE(errorCode) || length!=2 || dst[0] != in[ISOLATED] || dst[1] != otherChar[ISOLATED]) {
3420 log_err("failure in u_shapeArabic(_testTwoForms: shaping initial): %x\n", in[GENERIC]);
3421 }
3422 errorCode=U_ZERO_ERROR;
3423 length=u_shapeArabic(dst, 2,
3424 src, 2,
3425 U_SHAPE_LETTERS_UNSHAPE,
3426 &errorCode);
3427 if(U_FAILURE(errorCode) || length!=2 || src[0] != in[GENERIC] || src[1] != o therChar[GENERIC]) {
3428 log_err("failure in u_shapeArabic(_testTwoForms: unshaping initial): %x\n" , in[GENERIC]);
3429 }
3430 }
3431
3432 /* Testing medial shaping */
3433 src[0] = otherChar[0];
3434 src[1] = in[GENERIC];
3435 src[2] = otherChar[0];
3436 errorCode=U_ZERO_ERROR;
3437 if (in[MEDIAL] != 0) {
3438 /* Testing characters that have an medial form */
3439 length=u_shapeArabic(src, 3,
3440 dst, 3,
3441 U_SHAPE_LETTERS_SHAPE,
3442 &errorCode);
3443 if(U_FAILURE(errorCode) || length!=3 || dst[0] != otherChar[INITIAL] || dst[ 1] != in[MEDIAL] || dst[2] != otherChar[FINAL]) {
3444 log_err("failure in u_shapeArabic(_testAllForms: shaping medial): %x\n", i n[GENERIC]);
3445 }
3446 errorCode=U_ZERO_ERROR;
3447 length=u_shapeArabic(dst, 3,
3448 src, 3,
3449 U_SHAPE_LETTERS_UNSHAPE,
3450 &errorCode);
3451 if(U_FAILURE(errorCode) || length!=3 || src[0] != otherChar[GENERIC] || src[ 1] != in[GENERIC] || src[2] != otherChar[GENERIC]) {
3452 log_err("failure in u_shapeArabic(_testAllForms: unshaping medial): %x\n", in[GENERIC]);
3453 }
3454 } else {
3455 /* Testing characters that do not have an medial form */
3456 errorCode=U_ZERO_ERROR;
3457 length=u_shapeArabic(src, 3,
3458 dst, 3,
3459 U_SHAPE_LETTERS_SHAPE,
3460 &errorCode);
3461 if(U_FAILURE(errorCode) || length!=3 || dst[0] != otherChar[INITIAL] || dst[ 1] != in[FINAL] || dst[2] != otherChar[ISOLATED]) {
3462 log_err("failure in u_shapeArabic(_testTwoForms: shaping medial): %x\n", i n[GENERIC]);
3463 }
3464 errorCode=U_ZERO_ERROR;
3465 length=u_shapeArabic(dst, 3,
3466 src, 3,
3467 U_SHAPE_LETTERS_UNSHAPE,
3468 &errorCode);
3469 if(U_FAILURE(errorCode) || length!=3 || src[0] != otherChar[GENERIC] || src[ 1] != in[GENERIC] || src[2] != otherChar[GENERIC]) {
3470 log_err("failure in u_shapeArabic(_testTwoForms: unshaping medial): %x\n", in[GENERIC]);
3471 }
3472 }
3473 }
3474
3475 static void
3476 doArabicShapingTestForNewCharacters(void) {
3477 static const UChar letterForms[][5]={
3478 { 0x0679, 0xFB66, 0xFB67, 0xFB68, 0xFB69 }, /* TTEH */
3479 { 0x067A, 0xFB5E, 0xFB5F, 0xFB60, 0xFB61 }, /* TTEHEH */
3480 { 0x067B, 0xFB52, 0xFB53, 0xFB54, 0xFB55 }, /* BEEH */
3481 { 0x0688, 0xFB88, 0xFB89, 0, 0 }, /* DDAL */
3482 { 0x068C, 0xFB84, 0xFB85, 0, 0 }, /* DAHAL */
3483 { 0x068D, 0xFB82, 0xFB83, 0, 0 }, /* DDAHAL */
3484 { 0x068E, 0xFB86, 0xFB87, 0, 0 }, /* DUL */
3485 { 0x0691, 0xFB8C, 0xFB8D, 0, 0 }, /* RREH */
3486 { 0x06BA, 0xFB9E, 0xFB9F, 0, 0 }, /* NOON GHUNNA */
3487 { 0x06BB, 0xFBA0, 0xFBA1, 0xFBA2, 0xFBA3 }, /* RNOON */
3488 { 0x06BE, 0xFBAA, 0xFBAB, 0xFBAC, 0xFBAD }, /* HEH DOACHASHMEE */
3489 { 0x06C0, 0xFBA4, 0xFBA5, 0, 0 }, /* HEH WITH YEH ABOVE */
3490 { 0x06C1, 0xFBA6, 0xFBA7, 0xFBA8, 0xFBA9 }, /* HEH GOAL */
3491 { 0x06C5, 0xFBE0, 0xFBE1, 0, 0 }, /* KIRGIHIZ OE */
3492 { 0x06C6, 0xFBD9, 0xFBDA, 0, 0 }, /* OE */
3493 { 0x06C7, 0xFBD7, 0xFBD8, 0, 0 }, /* U */
3494 { 0x06C8, 0xFBDB, 0xFBDC, 0, 0 }, /* YU */
3495 { 0x06C9, 0xFBE2, 0xFBE3, 0, 0 }, /* KIRGIZ YU */
3496 { 0x06CB, 0xFBDE, 0xFBDF, 0, 0}, /* VE */
3497 { 0x06D0, 0xFBE4, 0xFBE5, 0xFBE6, 0xFBE7 }, /* E */
3498 { 0x06D2, 0xFBAE, 0xFBAF, 0, 0 }, /* YEH BARREE */
3499 { 0x06D3, 0xFBB0, 0xFBB1, 0, 0 }, /* YEH BARREE WITH HAMZA ABOVE */
3500 { 0x0622, 0xFE81, 0xFE82, 0, 0, }, /* ALEF WITH MADDA ABOVE */
3501 { 0x0623, 0xFE83, 0xFE84, 0, 0, }, /* ALEF WITH HAMZA ABOVE */
3502 { 0x0624, 0xFE85, 0xFE86, 0, 0, }, /* WAW WITH HAMZA ABOVE */
3503 { 0x0625, 0xFE87, 0xFE88, 0, 0, }, /* ALEF WITH HAMZA BELOW */
3504 { 0x0626, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, }, /* YEH WITH HAMZA ABOVE */
3505 { 0x0627, 0xFE8D, 0xFE8E, 0, 0, }, /* ALEF */
3506 { 0x0628, 0xFE8F, 0xFE90, 0xFE91, 0xFE92, }, /* BEH */
3507 { 0x0629, 0xFE93, 0xFE94, 0, 0, }, /* TEH MARBUTA */
3508 { 0x062A, 0xFE95, 0xFE96, 0xFE97, 0xFE98, }, /* TEH */
3509 { 0x062B, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, }, /* THEH */
3510 { 0x062C, 0xFE9D, 0xFE9E, 0xFE9F, 0xFEA0, }, /* JEEM */
3511 { 0x062D, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, }, /* HAH */
3512 { 0x062E, 0xFEA5, 0xFEA6, 0xFEA7, 0xFEA8, }, /* KHAH */
3513 { 0x062F, 0xFEA9, 0xFEAA, 0, 0, }, /* DAL */
3514 { 0x0630, 0xFEAB, 0xFEAC, 0, 0, }, /* THAL */
3515 { 0x0631, 0xFEAD, 0xFEAE, 0, 0, }, /* REH */
3516 { 0x0632, 0xFEAF, 0xFEB0, 0, 0, }, /* ZAIN */
3517 { 0x0633, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, }, /* SEEN */
3518 { 0x0634, 0xFEB5, 0xFEB6, 0xFEB7, 0xFEB8, }, /* SHEEN */
3519 { 0x0635, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, }, /* SAD */
3520 { 0x0636, 0xFEBD, 0xFEBE, 0xFEBF, 0xFEC0, }, /* DAD */
3521 { 0x0637, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, }, /* TAH */
3522 { 0x0638, 0xFEC5, 0xFEC6, 0xFEC7, 0xFEC8, }, /* ZAH */
3523 { 0x0639, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, }, /* AIN */
3524 { 0x063A, 0xFECD, 0xFECE, 0xFECF, 0xFED0, }, /* GHAIN */
3525 { 0x0641, 0xFED1, 0xFED2, 0xFED3, 0xFED4, }, /* FEH */
3526 { 0x0642, 0xFED5, 0xFED6, 0xFED7, 0xFED8, }, /* QAF */
3527 { 0x0643, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, }, /* KAF */
3528 { 0x0644, 0xFEDD, 0xFEDE, 0xFEDF, 0xFEE0, }, /* LAM */
3529 { 0x0645, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, }, /* MEEM */
3530 { 0x0646, 0xFEE5, 0xFEE6, 0xFEE7, 0xFEE8, }, /* NOON */
3531 { 0x0647, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, }, /* HEH */
3532 { 0x0648, 0xFEED, 0xFEEE, 0, 0, }, /* WAW */
3533 { 0x0649, 0xFEEF, 0xFEF0, 0, 0, }, /* ALEF MAKSURA */
3534 { 0x064A, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, }, /* YEH */
3535 { 0x064E, 0xFE76, 0, 0, 0xFE77, }, /* FATHA */
3536 { 0x064F, 0xFE78, 0, 0, 0xFE79, }, /* DAMMA */
3537 { 0x0650, 0xFE7A, 0, 0, 0xFE7B, }, /* KASRA */
3538 { 0x0651, 0xFE7C, 0, 0, 0xFE7D, }, /* SHADDA */
3539 { 0x0652, 0xFE7E, 0, 0, 0xFE7F, }, /* SUKUN */
3540 { 0x0679, 0xFB66, 0xFB67, 0xFB68, 0xFB69, }, /* TTEH */
3541 { 0x067E, 0xFB56, 0xFB57, 0xFB58, 0xFB59, }, /* PEH */
3542 { 0x0686, 0xFB7A, 0xFB7B, 0xFB7C, 0xFB7D, }, /* TCHEH */
3543 { 0x0688, 0xFB88, 0xFB89, 0, 0, }, /* DDAL */
3544 { 0x0691, 0xFB8C, 0xFB8D, 0, 0, }, /* RREH */
3545 { 0x0698, 0xFB8A, 0xFB8B, 0, 0, }, /* JEH */
3546 { 0x06A9, 0xFB8E, 0xFB8F, 0xFB90, 0xFB91, }, /* KEHEH */
3547 { 0x06AF, 0xFB92, 0xFB93, 0xFB94, 0xFB95, }, /* GAF */
3548 { 0x06BA, 0xFB9E, 0xFB9F, 0, 0, }, /* NOON GHUNNA */
3549 { 0x06BE, 0xFBAA, 0xFBAB, 0xFBAC, 0xFBAD, }, /* HEH DOACHASHMEE */
3550 { 0x06C0, 0xFBA4, 0xFBA5, 0, 0, }, /* HEH WITH YEH ABOVE */
3551 { 0x06C1, 0xFBA6, 0xFBA7, 0xFBA8, 0xFBA9, }, /* HEH GOAL */
3552 { 0x06CC, 0xFBFC, 0xFBFD, 0xFBFE, 0xFBFF, }, /* FARSI YEH */
3553 { 0x06D2, 0xFBAE, 0xFBAF, 0, 0, }, /* YEH BARREE */
3554 { 0x06D3, 0xFBB0, 0xFBB1, 0, 0, }}; /* YEH BARREE WITH HAMZA ABOVE */
3555 int32_t i;
3556 for (i = 0; i < UPRV_LENGTHOF(letterForms); ++i) {
3557 _testPresentationForms(letterForms[i]);
3558 }
3559 }
3560
3319 /* helpers ------------------------------------------------------------------ */ 3561 /* helpers ------------------------------------------------------------------ */
3320 3562
3321 static void initCharFromDirProps(void) { 3563 static void initCharFromDirProps(void) {
3322 static const UVersionInfo ucd401={ 4, 0, 1, 0 }; 3564 static const UVersionInfo ucd401={ 4, 0, 1, 0 };
3323 static UVersionInfo ucdVersion={ 0, 0, 0, 0 }; 3565 static UVersionInfo ucdVersion={ 0, 0, 0, 0 };
3324 3566
3325 /* lazy initialization */ 3567 /* lazy initialization */
3326 if(ucdVersion[0]>0) { 3568 if(ucdVersion[0]>0) {
3327 return; 3569 return;
3328 } 3570 }
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after
3421 }; 3663 };
3422 static const struct { 3664 static const struct {
3423 uint32_t value; 3665 uint32_t value;
3424 const char* description; 3666 const char* description;
3425 } 3667 }
3426 options[] = { 3668 options[] = {
3427 { MAKE_ITEMS(UBIDI_OPTION_INSERT_MARKS) }, 3669 { MAKE_ITEMS(UBIDI_OPTION_INSERT_MARKS) },
3428 { MAKE_ITEMS(0) } 3670 { MAKE_ITEMS(0) }
3429 }; 3671 };
3430 3672
3431 #define TC_COUNT LENGTHOF(textIn) 3673 #define TC_COUNT UPRV_LENGTHOF(textIn)
3432 #define MODES_COUNT LENGTHOF(modes) 3674 #define MODES_COUNT UPRV_LENGTHOF(modes)
3433 #define OPTIONS_COUNT LENGTHOF(options) 3675 #define OPTIONS_COUNT UPRV_LENGTHOF(options)
3434 #define LEVELS_COUNT LENGTHOF(paraLevels) 3676 #define LEVELS_COUNT UPRV_LENGTHOF(paraLevels)
3435 3677
3436 static const char* const textIn[] = { 3678 static const char* const textIn[] = {
3437 /* (0) 123 */ 3679 /* (0) 123 */
3438 "123", 3680 "123",
3439 /* (1) .123->4.5 */ 3681 /* (1) .123->4.5 */
3440 ".123->4.5", 3682 ".123->4.5",
3441 /* (2) 678 */ 3683 /* (2) 678 */
3442 "678", 3684 "678",
3443 /* (3) .678->8.9 */ 3685 /* (3) .678->8.9 */
3444 ".678->8.9", 3686 ".678->8.9",
(...skipping 504 matching lines...) Expand 10 before | Expand all | Expand 10 after
3949 if(!pL2VBiDi) { 4191 if(!pL2VBiDi) {
3950 ubidi_close(pBiDi); /* in case this one was allocated */ 4192 ubidi_close(pBiDi); /* in case this one was allocated */
3951 return; 4193 return;
3952 } 4194 }
3953 ubidi_setReorderingMode(pBiDi, UBIDI_REORDER_RUNS_ONLY); 4195 ubidi_setReorderingMode(pBiDi, UBIDI_REORDER_RUNS_ONLY);
3954 ubidi_setReorderingOptions(pL2VBiDi, UBIDI_OPTION_REMOVE_CONTROLS); 4196 ubidi_setReorderingOptions(pL2VBiDi, UBIDI_OPTION_REMOVE_CONTROLS);
3955 4197
3956 for (option = 0; option < 2; option++) { 4198 for (option = 0; option < 2; option++) {
3957 ubidi_setReorderingOptions(pBiDi, option==0 ? UBIDI_OPTION_REMOVE_CONTRO LS 4199 ubidi_setReorderingOptions(pBiDi, option==0 ? UBIDI_OPTION_REMOVE_CONTRO LS
3958 : UBIDI_OPTION_INSERT_MARKS) ; 4200 : UBIDI_OPTION_INSERT_MARKS) ;
3959 for (i = 0, nCases = LENGTHOF(testCases); i < nCases; i++) { 4201 for (i = 0, nCases = UPRV_LENGTHOF(testCases); i < nCases; i++) {
3960 srcLen = strlen(testCases[i].textIn); 4202 srcLen = strlen(testCases[i].textIn);
3961 pseudoToU16(srcLen, testCases[i].textIn, src); 4203 pseudoToU16(srcLen, testCases[i].textIn, src);
3962 for(j = 0; j < 2; j++) { 4204 for(j = 0; j < 2; j++) {
3963 log_verbose("Now doing test for option %d, case %d, level %d\n", 4205 log_verbose("Now doing test for option %d, case %d, level %d\n",
3964 i, option, j); 4206 i, option, j);
3965 level = paraLevels[j]; 4207 level = paraLevels[j];
3966 ubidi_setPara(pBiDi, src, srcLen, level, NULL, &rc); 4208 ubidi_setPara(pBiDi, src, srcLen, level, NULL, &rc);
3967 assertSuccessful("ubidi_setPara", &rc); 4209 assertSuccessful("ubidi_setPara", &rc);
3968 *dest = 0; 4210 *dest = 0;
3969 destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN, UBIDI_DO_MIR RORING, &rc); 4211 destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN, UBIDI_DO_MIR RORING, &rc);
(...skipping 218 matching lines...) Expand 10 before | Expand all | Expand 10 after
4188 {"6, 4", "6, 4"} 4430 {"6, 4", "6, 4"}
4189 } 4431 }
4190 }; 4432 };
4191 UChar src[MAXLEN]; 4433 UChar src[MAXLEN];
4192 UBiDi *pBiDi = NULL; 4434 UBiDi *pBiDi = NULL;
4193 UChar *pSrc; 4435 UChar *pSrc;
4194 UErrorCode rc = U_ZERO_ERROR; 4436 UErrorCode rc = U_ZERO_ERROR;
4195 int32_t srcLen, processedLen, chunk, len, nPortions; 4437 int32_t srcLen, processedLen, chunk, len, nPortions;
4196 int i, j, levelIndex; 4438 int i, j, levelIndex;
4197 UBiDiLevel level; 4439 UBiDiLevel level;
4198 int nTests = LENGTHOF(testData), nLevels = LENGTHOF(paraLevels); 4440 int nTests = UPRV_LENGTHOF(testData), nLevels = UPRV_LENGTHOF(paraLevels);
4199 UBool mismatch, testOK = TRUE; 4441 UBool mismatch, testOK = TRUE;
4200 char processedLenStr[MAXPORTIONS * 5]; 4442 char processedLenStr[MAXPORTIONS * 5];
4201 4443
4202 log_verbose("\nEntering TestStreaming\n\n"); 4444 log_verbose("\nEntering TestStreaming\n\n");
4203 4445
4204 pBiDi = getBiDiObject(); 4446 pBiDi = getBiDiObject();
4205 4447
4206 ubidi_orderParagraphsLTR(pBiDi, TRUE); 4448 ubidi_orderParagraphsLTR(pBiDi, TRUE);
4207 4449
4208 for (levelIndex = 0; levelIndex < nLevels; levelIndex++) { 4450 for (levelIndex = 0; levelIndex < nLevels; levelIndex++) {
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
4278 AN, AN, DEF, DEF, DEF, DEF, DEF, DEF, /* 38-3F */ 4520 AN, AN, DEF, DEF, DEF, DEF, DEF, DEF, /* 38-3F */
4279 L, AL, AL, AL, AL, AL, AL, R, /* 40-47 */ 4521 L, AL, AL, AL, AL, AL, AL, R, /* 40-47 */
4280 R, R, R, R, R, R, R, R, /* 48-4F */ 4522 R, R, R, R, R, R, R, R, /* 48-4F */
4281 R, R, R, R, R, R, R, R, /* 50-57 */ 4523 R, R, R, R, R, R, R, R, /* 50-57 */
4282 R, R, R, LRE, DEF, RLE, PDF, S, /* 58-5F */ 4524 R, R, R, LRE, DEF, RLE, PDF, S, /* 58-5F */
4283 NSM, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 60-67 */ 4525 NSM, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 60-67 */
4284 DEF, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 68-6F */ 4526 DEF, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 68-6F */
4285 DEF, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 70-77 */ 4527 DEF, DEF, DEF, DEF, DEF, DEF, DEF, DEF, /* 70-77 */
4286 DEF, DEF, DEF, LRO, B, RLO, BN, DEF /* 78-7F */ 4528 DEF, DEF, DEF, LRO, B, RLO, BN, DEF /* 78-7F */
4287 }; 4529 };
4288 static const int nEntries = LENGTHOF(customClasses); 4530 static const int nEntries = UPRV_LENGTHOF(customClasses);
4289 const char *dummy = context; /* just to avoid a compiler warning */ 4531 const char *dummy = context; /* just to avoid a compiler warning */
4290 dummy++; 4532 dummy++;
4291 4533
4292 return c >= nEntries ? U_BIDI_CLASS_DEFAULT : customClasses[c]; 4534 return c >= nEntries ? U_BIDI_CLASS_DEFAULT : customClasses[c];
4293 } 4535 }
4294 4536
4295 U_CDECL_END 4537 U_CDECL_END
4296 4538
4297 static void verifyCallbackParams(UBiDiClassCallback* fn, const void* context, 4539 static void verifyCallbackParams(UBiDiClassCallback* fn, const void* context,
4298 UBiDiClassCallback* expectedFn, 4540 UBiDiClassCallback* expectedFn,
(...skipping 267 matching lines...) Expand 10 before | Expand all | Expand 10 after
4566 /*17*/ {" x 7", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL}, 4808 /*17*/ {" x 7", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
4567 /*18*/ {"x|", ".-=abc-+*", " 8", "*+-abc=-.", UBIDI_RTL}, 4809 /*18*/ {"x|", ".-=abc-+*", " 8", "*+-abc=-.", UBIDI_RTL},
4568 /*19*/ {"G|y", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL}, 4810 /*19*/ {"G|y", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
4569 /*20*/ {"", ".-=", "", ".-=", UBIDI_DEFAULT_LTR}, 4811 /*20*/ {"", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
4570 /*21*/ {"D", ".-=", "", "=-.", UBIDI_DEFAULT_LTR}, 4812 /*21*/ {"D", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4571 /*22*/ {"G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR}, 4813 /*22*/ {"G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4572 /*23*/ {"xG", ".-=", "", ".-=", UBIDI_DEFAULT_LTR}, 4814 /*23*/ {"xG", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
4573 /*24*/ {"x|G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR}, 4815 /*24*/ {"x|G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4574 /*25*/ {"x|G", ".-=|-+*", "", "=-.|-+*", UBIDI_DEFAULT_LTR}, 4816 /*25*/ {"x|G", ".-=|-+*", "", "=-.|-+*", UBIDI_DEFAULT_LTR},
4575 }; 4817 };
4576 #define CONTEXT_COUNT LENGTHOF(contextData) 4818 #define CONTEXT_COUNT UPRV_LENGTHOF(contextData)
4577 4819
4578 static void 4820 static void
4579 testContext(void) { 4821 testContext(void) {
4580 4822
4581 UChar prologue[MAXLEN], epilogue[MAXLEN], src[MAXLEN], dest[MAXLEN]; 4823 UChar prologue[MAXLEN], epilogue[MAXLEN], src[MAXLEN], dest[MAXLEN];
4582 char destChars[MAXLEN]; 4824 char destChars[MAXLEN];
4583 UBiDi *pBiDi = NULL; 4825 UBiDi *pBiDi = NULL;
4584 UErrorCode rc; 4826 UErrorCode rc;
4585 int32_t proLength, epiLength, srcLen, destLen, tc; 4827 int32_t proLength, epiLength, srcLen, destLen, tc;
4586 contextCase cc; 4828 contextCase cc;
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
4658 log_verbose("\nExiting TestContext \n\n"); 4900 log_verbose("\nExiting TestContext \n\n");
4659 } 4901 }
4660 4902
4661 /* Ticket#11054 ubidi_setPara crash with heavily nested brackets */ 4903 /* Ticket#11054 ubidi_setPara crash with heavily nested brackets */
4662 static void 4904 static void
4663 testBracketOverflow(void) { 4905 testBracketOverflow(void) {
4664 static const char* TEXT = "(((((((((((((((((((((((((((((((((((((((((a)(A)))) )))))))))))))))))))))))))))))))))))))"; 4906 static const char* TEXT = "(((((((((((((((((((((((((((((((((((((((((a)(A)))) )))))))))))))))))))))))))))))))))))))";
4665 UErrorCode status = U_ZERO_ERROR; 4907 UErrorCode status = U_ZERO_ERROR;
4666 UBiDi* bidi; 4908 UBiDi* bidi;
4667 UChar src[100]; 4909 UChar src[100];
4668 UChar dest[100];
4669 int32_t len; 4910 int32_t len;
4670 4911
4671 bidi = ubidi_open(); 4912 bidi = ubidi_open();
4672 len = uprv_strlen(TEXT); 4913 len = uprv_strlen(TEXT);
4673 pseudoToU16(len, TEXT, src); 4914 pseudoToU16(len, TEXT, src);
4674 ubidi_setPara(bidi, src, len, UBIDI_DEFAULT_LTR , NULL, &status); 4915 ubidi_setPara(bidi, src, len, UBIDI_DEFAULT_LTR , NULL, &status);
4675 if (U_FAILURE(status)) { 4916 if (U_FAILURE(status)) {
4676 log_err("setPara failed with heavily nested brackets - %s", u_errorName( status)); 4917 log_err("setPara failed with heavily nested brackets - %s", u_errorName( status));
4677 } 4918 }
4678 4919
4679 ubidi_close(bidi); 4920 ubidi_close(bidi);
4680 } 4921 }
4681 4922
OLDNEW
« no previous file with comments | « source/test/cintltst/capitst.c ('k') | source/test/cintltst/ccaltst.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698