OLD | NEW |
1 /* | 1 /* |
2 ****************************************************************************** | 2 ****************************************************************************** |
3 * | 3 * |
4 * Copyright (C) 2001-2008, International Business Machines | 4 * Copyright (C) 2001-2014, International Business Machines |
5 * Corporation and others. All Rights Reserved. | 5 * Corporation and others. All Rights Reserved. |
6 * | 6 * |
7 ****************************************************************************** | 7 ****************************************************************************** |
8 * file name: trietest.c | 8 * file name: trietest.c |
9 * encoding: US-ASCII | 9 * encoding: US-ASCII |
10 * tab size: 8 (not used) | 10 * tab size: 8 (not used) |
11 * indentation:4 | 11 * indentation:4 |
12 * | 12 * |
13 * created on: 2008sep01 (starting from a copy of trietest.c) | 13 * created on: 2008sep01 (starting from a copy of trietest.c) |
14 * created by: Markus W. Scherer | 14 * created by: Markus W. Scherer |
15 */ | 15 */ |
16 | 16 |
17 #include <stdio.h> | 17 #include <stdio.h> |
18 #include "unicode/utypes.h" | 18 #include "unicode/utypes.h" |
19 #include "utrie2.h" | 19 #include "utrie2.h" |
20 #include "utrie.h" | 20 #include "utrie.h" |
21 #include "cstring.h" | 21 #include "cstring.h" |
22 #include "cmemory.h" | 22 #include "cmemory.h" |
23 #include "udataswp.h" | 23 #include "udataswp.h" |
24 #include "cintltst.h" | 24 #include "cintltst.h" |
25 | 25 |
26 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) | |
27 | |
28 void addTrie2Test(TestNode** root); | 26 void addTrie2Test(TestNode** root); |
29 | 27 |
30 /* Values for setting possibly overlapping, out-of-order ranges of values */ | 28 /* Values for setting possibly overlapping, out-of-order ranges of values */ |
31 typedef struct SetRange { | 29 typedef struct SetRange { |
32 UChar32 start, limit; | 30 UChar32 start, limit; |
33 uint32_t value; | 31 uint32_t value; |
34 UBool overwrite; | 32 UBool overwrite; |
35 } SetRange; | 33 } SetRange; |
36 | 34 |
37 /* | 35 /* |
(...skipping 989 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1027 | 1025 |
1028 static const CheckRange | 1026 static const CheckRange |
1029 checkRangesSingleValue[]={ | 1027 checkRangesSingleValue[]={ |
1030 { 0, 3 }, | 1028 { 0, 3 }, |
1031 { 0x110000, 5 } | 1029 { 0x110000, 5 } |
1032 }; | 1030 }; |
1033 | 1031 |
1034 static void | 1032 static void |
1035 TrieTest(void) { | 1033 TrieTest(void) { |
1036 testTrieRanges("set1", FALSE, | 1034 testTrieRanges("set1", FALSE, |
1037 setRanges1, LENGTHOF(setRanges1), | 1035 setRanges1, UPRV_LENGTHOF(setRanges1), |
1038 checkRanges1, LENGTHOF(checkRanges1)); | 1036 checkRanges1, UPRV_LENGTHOF(checkRanges1)); |
1039 testTrieRanges("set2-overlap", FALSE, | 1037 testTrieRanges("set2-overlap", FALSE, |
1040 setRanges2, LENGTHOF(setRanges2), | 1038 setRanges2, UPRV_LENGTHOF(setRanges2), |
1041 checkRanges2, LENGTHOF(checkRanges2)); | 1039 checkRanges2, UPRV_LENGTHOF(checkRanges2)); |
1042 testTrieRanges("set3-initial-9", FALSE, | 1040 testTrieRanges("set3-initial-9", FALSE, |
1043 setRanges3, LENGTHOF(setRanges3), | 1041 setRanges3, UPRV_LENGTHOF(setRanges3), |
1044 checkRanges3, LENGTHOF(checkRanges3)); | 1042 checkRanges3, UPRV_LENGTHOF(checkRanges3)); |
1045 testTrieRanges("set-empty", FALSE, | 1043 testTrieRanges("set-empty", FALSE, |
1046 setRangesEmpty, 0, | 1044 setRangesEmpty, 0, |
1047 checkRangesEmpty, LENGTHOF(checkRangesEmpty)); | 1045 checkRangesEmpty, UPRV_LENGTHOF(checkRangesEmpty)); |
1048 testTrieRanges("set-single-value", FALSE, | 1046 testTrieRanges("set-single-value", FALSE, |
1049 setRangesSingleValue, LENGTHOF(setRangesSingleValue), | 1047 setRangesSingleValue, UPRV_LENGTHOF(setRangesSingleValue), |
1050 checkRangesSingleValue, LENGTHOF(checkRangesSingleValue)); | 1048 checkRangesSingleValue, UPRV_LENGTHOF(checkRangesSingleValue)); |
1051 | 1049 |
1052 testTrieRanges("set2-overlap.withClone", TRUE, | 1050 testTrieRanges("set2-overlap.withClone", TRUE, |
1053 setRanges2, LENGTHOF(setRanges2), | 1051 setRanges2, UPRV_LENGTHOF(setRanges2), |
1054 checkRanges2, LENGTHOF(checkRanges2)); | 1052 checkRanges2, UPRV_LENGTHOF(checkRanges2)); |
1055 } | 1053 } |
1056 | 1054 |
1057 static void | 1055 static void |
1058 EnumNewTrieForLeadSurrogateTest(void) { | 1056 EnumNewTrieForLeadSurrogateTest(void) { |
1059 static const char *const testName="enum-for-lead"; | 1057 static const char *const testName="enum-for-lead"; |
1060 UTrie2 *trie=makeTrieWithRanges(testName, FALSE, | 1058 UTrie2 *trie=makeTrieWithRanges(testName, FALSE, |
1061 setRanges2, LENGTHOF(setRanges2), | 1059 setRanges2, UPRV_LENGTHOF(setRanges2), |
1062 checkRanges2, LENGTHOF(checkRanges2)); | 1060 checkRanges2, UPRV_LENGTHOF(checkRanges2)); |
1063 while(trie!=NULL) { | 1061 while(trie!=NULL) { |
1064 const CheckRange *checkRanges; | 1062 const CheckRange *checkRanges; |
1065 | 1063 |
1066 checkRanges=checkRanges2_d800+1; | 1064 checkRanges=checkRanges2_d800+1; |
1067 utrie2_enumForLeadSurrogate(trie, 0xd800, | 1065 utrie2_enumForLeadSurrogate(trie, 0xd800, |
1068 testEnumValue, testEnumRange, | 1066 testEnumValue, testEnumRange, |
1069 &checkRanges); | 1067 &checkRanges); |
1070 checkRanges=checkRanges2_d87e+1; | 1068 checkRanges=checkRanges2_d87e+1; |
1071 utrie2_enumForLeadSurrogate(trie, 0xd87e, | 1069 utrie2_enumForLeadSurrogate(trie, 0xd87e, |
1072 testEnumValue, testEnumRange, | 1070 testEnumValue, testEnumRange, |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1123 checkRanges[0].value=errorValue; | 1121 checkRanges[0].value=errorValue; |
1124 checkRanges[1].value=checkRanges[2].value=initialValue; | 1122 checkRanges[1].value=checkRanges[2].value=initialValue; |
1125 | 1123 |
1126 errorCode=U_ZERO_ERROR; | 1124 errorCode=U_ZERO_ERROR; |
1127 trie=utrie2_openDummy(valueBits, initialValue, errorValue, &errorCode); | 1125 trie=utrie2_openDummy(valueBits, initialValue, errorValue, &errorCode); |
1128 if(U_FAILURE(errorCode)) { | 1126 if(U_FAILURE(errorCode)) { |
1129 log_err("utrie2_openDummy(valueBits=%d) failed - %s\n", valueBits, u_err
orName(errorCode)); | 1127 log_err("utrie2_openDummy(valueBits=%d) failed - %s\n", valueBits, u_err
orName(errorCode)); |
1130 return; | 1128 return; |
1131 } | 1129 } |
1132 | 1130 |
1133 testFrozenTrie(testName, trie, valueBits, checkRanges, LENGTHOF(checkRanges)
); | 1131 testFrozenTrie(testName, trie, valueBits, checkRanges, UPRV_LENGTHOF(checkRa
nges)); |
1134 utrie2_close(trie); | 1132 utrie2_close(trie); |
1135 } | 1133 } |
1136 | 1134 |
1137 static void | 1135 static void |
1138 DummyTrieTest(void) { | 1136 DummyTrieTest(void) { |
1139 dummyTest(UTRIE2_16_VALUE_BITS); | 1137 dummyTest(UTRIE2_16_VALUE_BITS); |
1140 dummyTest(UTRIE2_32_VALUE_BITS); | 1138 dummyTest(UTRIE2_32_VALUE_BITS); |
1141 } | 1139 } |
1142 | 1140 |
1143 /* test builder memory management ------------------------------------------- */ | 1141 /* test builder memory management ------------------------------------------- */ |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1184 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode); | 1182 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode); |
1185 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode); | 1183 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode); |
1186 if(U_FAILURE(errorCode)) { | 1184 if(U_FAILURE(errorCode)) { |
1187 log_err("error: setting lots of ranges into a trie (%s) failed - %s\n", | 1185 log_err("error: setting lots of ranges into a trie (%s) failed - %s\n", |
1188 testName, u_errorName(errorCode)); | 1186 testName, u_errorName(errorCode)); |
1189 utrie2_close(trie); | 1187 utrie2_close(trie); |
1190 return; | 1188 return; |
1191 } | 1189 } |
1192 | 1190 |
1193 trie=testTrieSerializeAllValueBits(testName, trie, FALSE, | 1191 trie=testTrieSerializeAllValueBits(testName, trie, FALSE, |
1194 checkRanges, LENGTHOF(checkRanges)); | 1192 checkRanges, UPRV_LENGTHOF(checkRanges)); |
1195 utrie2_close(trie); | 1193 utrie2_close(trie); |
1196 } | 1194 } |
1197 | 1195 |
1198 static void | 1196 static void |
1199 GrowDataArrayTest(void) { | 1197 GrowDataArrayTest(void) { |
1200 static const CheckRange | 1198 static const CheckRange |
1201 checkRanges[]={ | 1199 checkRanges[]={ |
1202 { 0, 1 }, | 1200 { 0, 1 }, |
1203 { 0x720, 2 }, | 1201 { 0x720, 2 }, |
1204 { 0x7a0, 3 }, | 1202 { 0x7a0, 3 }, |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1242 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode); | 1240 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode); |
1243 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode); | 1241 utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode); |
1244 if(U_FAILURE(errorCode)) { | 1242 if(U_FAILURE(errorCode)) { |
1245 log_err("error: setting lots of values into a trie (%s) failed - %s\n", | 1243 log_err("error: setting lots of values into a trie (%s) failed - %s\n", |
1246 testName, u_errorName(errorCode)); | 1244 testName, u_errorName(errorCode)); |
1247 utrie2_close(trie); | 1245 utrie2_close(trie); |
1248 return; | 1246 return; |
1249 } | 1247 } |
1250 | 1248 |
1251 trie=testTrieSerializeAllValueBits(testName, trie, FALSE, | 1249 trie=testTrieSerializeAllValueBits(testName, trie, FALSE, |
1252 checkRanges, LENGTHOF(checkRanges)); | 1250 checkRanges, UPRV_LENGTHOF(checkRanges
)); |
1253 utrie2_close(trie); | 1251 utrie2_close(trie); |
1254 } | 1252 } |
1255 | 1253 |
1256 /* versions 1 and 2 --------------------------------------------------------- */ | 1254 /* versions 1 and 2 --------------------------------------------------------- */ |
1257 | 1255 |
1258 static void | 1256 static void |
1259 GetVersionTest(void) { | 1257 GetVersionTest(void) { |
1260 uint32_t data[4]; | 1258 uint32_t data[4]; |
1261 if( /* version 1 */ | 1259 if( /* version 1 */ |
1262 (data[0]=0x54726965, 1!=utrie2_getVersion(data, sizeof(data), FALSE)) || | 1260 (data[0]=0x54726965, 1!=utrie2_getVersion(data, sizeof(data), FALSE)) || |
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1404 break; | 1402 break; |
1405 } | 1403 } |
1406 } | 1404 } |
1407 } | 1405 } |
1408 utrie2_close(trie2); | 1406 utrie2_close(trie2); |
1409 } | 1407 } |
1410 | 1408 |
1411 static void | 1409 static void |
1412 Trie12ConversionTest(void) { | 1410 Trie12ConversionTest(void) { |
1413 testTrie2FromTrie1("trie1->trie2", | 1411 testTrie2FromTrie1("trie1->trie2", |
1414 setRanges2, LENGTHOF(setRanges2), | 1412 setRanges2, UPRV_LENGTHOF(setRanges2), |
1415 checkRanges2, LENGTHOF(checkRanges2)); | 1413 checkRanges2, UPRV_LENGTHOF(checkRanges2)); |
1416 } | 1414 } |
1417 | 1415 |
1418 void | 1416 void |
1419 addTrie2Test(TestNode** root) { | 1417 addTrie2Test(TestNode** root) { |
1420 addTest(root, &TrieTest, "tsutil/trie2test/TrieTest"); | 1418 addTest(root, &TrieTest, "tsutil/trie2test/TrieTest"); |
1421 addTest(root, &EnumNewTrieForLeadSurrogateTest, | 1419 addTest(root, &EnumNewTrieForLeadSurrogateTest, |
1422 "tsutil/trie2test/EnumNewTrieForLeadSurrogateTest"); | 1420 "tsutil/trie2test/EnumNewTrieForLeadSurrogateTest"); |
1423 addTest(root, &DummyTrieTest, "tsutil/trie2test/DummyTrieTest"); | 1421 addTest(root, &DummyTrieTest, "tsutil/trie2test/DummyTrieTest"); |
1424 addTest(root, &FreeBlocksTest, "tsutil/trie2test/FreeBlocksTest"); | 1422 addTest(root, &FreeBlocksTest, "tsutil/trie2test/FreeBlocksTest"); |
1425 addTest(root, &GrowDataArrayTest, "tsutil/trie2test/GrowDataArrayTest"); | 1423 addTest(root, &GrowDataArrayTest, "tsutil/trie2test/GrowDataArrayTest"); |
1426 addTest(root, &GetVersionTest, "tsutil/trie2test/GetVersionTest"); | 1424 addTest(root, &GetVersionTest, "tsutil/trie2test/GetVersionTest"); |
1427 addTest(root, &Trie12ConversionTest, "tsutil/trie2test/Trie12ConversionTest"
); | 1425 addTest(root, &Trie12ConversionTest, "tsutil/trie2test/Trie12ConversionTest"
); |
1428 } | 1426 } |
OLD | NEW |