source/test/cintltst/citertst.c - Issue 2435373002: Delete source/test

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

Issue 2435373002: Delete source/test (Closed)

Patch Set: Created 4 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /********************************************************************

2 * COPYRIGHT:

3 * Copyright (c) 1997-2014, International Business Machines Corporation and

4 * others. All Rights Reserved.

5 ********************************************************************/

6 /******************************************************************************* *

7 *

8 * File CITERTST.C

9 *

10 * Modification History:

11 * Date Name Description

12 * Madhu Katragadda Ported for C API

13 * 02/19/01 synwee Modified test case for new collation iterator

14 ******************************************************************************** */

15 /*

16 * Collation Iterator tests.

17 * (Let me reiterate my position...)

18 */

19

20 #include "unicode/utypes.h"

21

22 #if !UCONFIG_NO_COLLATION

23

24 #include "unicode/ucol.h"

25 #include "unicode/ucoleitr.h"

26 #include "unicode/uloc.h"

27 #include "unicode/uchar.h"

28 #include "unicode/ustring.h"

29 #include "unicode/putil.h"

30 #include "callcoll.h"

31 #include "cmemory.h"

32 #include "cintltst.h"

33 #include "citertst.h"

34 #include "ccolltst.h"

35 #include "filestrm.h"

36 #include "cstring.h"

37 #include "ucol_imp.h"

38 #include "uparse.h"

39 #include <stdio.h>

40

41 extern uint8_t ucol_uprv_getCaseBits(const UChar , uint32_t, UErrorCode );

42

43 void addCollIterTest(TestNode** root)

44 {

45 addTest(root, &TestPrevious, "tscoll/citertst/TestPrevious");

46 addTest(root, &TestOffset, "tscoll/citertst/TestOffset");

47 addTest(root, &TestSetText, "tscoll/citertst/TestSetText");

48 addTest(root, &TestMaxExpansion, "tscoll/citertst/TestMaxExpansion");

49 addTest(root, &TestUnicodeChar, "tscoll/citertst/TestUnicodeChar");

50 addTest(root, &TestNormalizedUnicodeChar,

51 "tscoll/citertst/TestNormalizedUnicodeChar");

52 addTest(root, &TestNormalization, "tscoll/citertst/TestNormalization");

53 addTest(root, &TestBug672, "tscoll/citertst/TestBug672");

54 addTest(root, &TestBug672Normalize, "tscoll/citertst/TestBug672Normalize");

55 addTest(root, &TestSmallBuffer, "tscoll/citertst/TestSmallBuffer");

56 addTest(root, &TestDiscontiguos, "tscoll/citertst/TestDiscontiguos");

57 addTest(root, &TestSearchCollatorElements, "tscoll/citertst/TestSearchCollat orElements");

58 }

59

60 /* The locales we support */

61

62 static const char * LOCALES[] = {"en_AU", "en_BE", "en_CA"};

63

64 static void TestBug672() {

65 UErrorCode status = U_ZERO_ERROR;

66 UChar pattern[20];

67 UChar text[50];

68 int i;

69 int result[3][3];

70

71 u_uastrcpy(pattern, "resume");

72 u_uastrcpy(text, "Time to resume updating my resume.");

73

74 for (i = 0; i < 3; ++ i) {

75 UCollator *coll = ucol_open(LOCALES[i], &status);

76 UCollationElements *pitr = ucol_openElements(coll, pattern, -1,

77 &status);

78 UCollationElements *titer = ucol_openElements(coll, text, -1,

79 &status);

80 if (U_FAILURE(status)) {

81 log_err_status(status, "ERROR: in creation of either the collator or the collation iterator :%s\n",

82 myErrorName(status));

83 return;

84 }

85

86 log_verbose("locale tested %s\n", LOCALES[i]);

87

88 while (ucol_next(pitr, &status) != UCOL_NULLORDER &&

89 U_SUCCESS(status)) {

90 }

91 if (U_FAILURE(status)) {

92 log_err("ERROR: reversing collation iterator :%s\n",

93 myErrorName(status));

94 return;

95 }

96 ucol_reset(pitr);

97

98 ucol_setOffset(titer, u_strlen(pattern), &status);

99 if (U_FAILURE(status)) {

100 log_err("ERROR: setting offset in collator :%s\n",

101 myErrorName(status));

102 return;

103 }

104 result[i][0] = ucol_getOffset(titer);

105 log_verbose("Text iterator set to offset %d\n", result[i][0]);

106

107 /* Use previous() */

108 ucol_previous(titer, &status);

109 result[i][1] = ucol_getOffset(titer);

110 log_verbose("Current offset %d after previous\n", result[i][1]);

111

112 /* Add one to index */

113 log_verbose("Adding one to current offset...\n");

114 ucol_setOffset(titer, ucol_getOffset(titer) + 1, &status);

115 if (U_FAILURE(status)) {

116 log_err("ERROR: setting offset in collator :%s\n",

117 myErrorName(status));

118 return;

119 }

120 result[i][2] = ucol_getOffset(titer);

121 log_verbose("Current offset in text = %d\n", result[i][2]);

122 ucol_closeElements(pitr);

123 ucol_closeElements(titer);

124 ucol_close(coll);

125 }

126

127 if (uprv_memcmp(result[0], result[1], 3) != 0 \|\|

128 uprv_memcmp(result[1], result[2], 3) != 0) {

129 log_err("ERROR: Different locales have different offsets at the same cha racter\n");

130 }

131 }

132

133

134

135 /* Running this test with normalization enabled showed up a bug in the incremen tal

136 normalization code. */

137 static void TestBug672Normalize() {

138 UErrorCode status = U_ZERO_ERROR;

139 UChar pattern[20];

140 UChar text[50];

141 int i;

142 int result[3][3];

143

144 u_uastrcpy(pattern, "resume");

145 u_uastrcpy(text, "Time to resume updating my resume.");

146

147 for (i = 0; i < 3; ++ i) {

148 UCollator *coll = ucol_open(LOCALES[i], &status);

149 UCollationElements *pitr = NULL;

150 UCollationElements *titer = NULL;

151

152 ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);

153

154 pitr = ucol_openElements(coll, pattern, -1, &status);

155 titer = ucol_openElements(coll, text, -1, &status);

156 if (U_FAILURE(status)) {

157 log_err_status(status, "ERROR: in creation of either the collator or the collation iterator :%s\n",

158 myErrorName(status));

159 return;

160 }

161

162 log_verbose("locale tested %s\n", LOCALES[i]);

163

164 while (ucol_next(pitr, &status) != UCOL_NULLORDER &&

165 U_SUCCESS(status)) {

166 }

167 if (U_FAILURE(status)) {

168 log_err("ERROR: reversing collation iterator :%s\n",

169 myErrorName(status));

170 return;

171 }

172 ucol_reset(pitr);

173

174 ucol_setOffset(titer, u_strlen(pattern), &status);

175 if (U_FAILURE(status)) {

176 log_err("ERROR: setting offset in collator :%s\n",

177 myErrorName(status));

178 return;

179 }

180 result[i][0] = ucol_getOffset(titer);

181 log_verbose("Text iterator set to offset %d\n", result[i][0]);

182

183 /* Use previous() */

184 ucol_previous(titer, &status);

185 result[i][1] = ucol_getOffset(titer);

186 log_verbose("Current offset %d after previous\n", result[i][1]);

187

188 /* Add one to index */

189 log_verbose("Adding one to current offset...\n");

190 ucol_setOffset(titer, ucol_getOffset(titer) + 1, &status);

191 if (U_FAILURE(status)) {

192 log_err("ERROR: setting offset in collator :%s\n",

193 myErrorName(status));

194 return;

195 }

196 result[i][2] = ucol_getOffset(titer);

197 log_verbose("Current offset in text = %d\n", result[i][2]);

198 ucol_closeElements(pitr);

199 ucol_closeElements(titer);

200 ucol_close(coll);

201 }

202

203 if (uprv_memcmp(result[0], result[1], 3) != 0 \|\|

204 uprv_memcmp(result[1], result[2], 3) != 0) {

205 log_err("ERROR: Different locales have different offsets at the same cha racter\n");

206 }

207 }

208

209

210

211

212 /**

213 * Test for CollationElementIterator previous and next for the whole set of

214 * unicode characters.

215 */

216 static void TestUnicodeChar()

217 {

218 UChar source[0x100];

219 UCollator *en_us;

220 UCollationElements *iter;

221 UErrorCode status = U_ZERO_ERROR;

222 UChar codepoint;

223

224 UChar *test;

225 en_us = ucol_open("en_US", &status);

226 if (U_FAILURE(status)){

227 log_err_status(status, "ERROR: in creation of collation data using ucol_o pen()\n %s\n",

228 myErrorName(status));

229 return;

230 }

231

232 for (codepoint = 1; codepoint < 0xFFFE;)

233 {

234 test = source;

235

236 while (codepoint % 0xFF != 0)

237 {

238 if (u_isdefined(codepoint))

239 *(test ++) = codepoint;

240 codepoint ++;

241 }

242

243 if (u_isdefined(codepoint))

244 *(test ++) = codepoint;

245

246 if (codepoint != 0xFFFF)

247 codepoint ++;

248

249 *test = 0;

250 iter=ucol_openElements(en_us, source, u_strlen(source), &status);

251 if(U_FAILURE(status)){

252 log_err("ERROR: in creation of collation element iterator using ucol_o penElements()\n %s\n",

253 myErrorName(status));

254 ucol_close(en_us);

255 return;

256 }

257 /* A basic test to see if it's working at all */

258 log_verbose("codepoint testing %x\n", codepoint);

259 backAndForth(iter);

260 ucol_closeElements(iter);

261

262 /* null termination test */

263 iter=ucol_openElements(en_us, source, -1, &status);

264 if(U_FAILURE(status)){

265 log_err("ERROR: in creation of collation element iterator using ucol_o penElements()\n %s\n",

266 myErrorName(status));

267 ucol_close(en_us);

268 return;

269 }

270 /* A basic test to see if it's working at all */

271 backAndForth(iter);

272 ucol_closeElements(iter);

273 }

274

275 ucol_close(en_us);

276 }

277

278 /**

279 * Test for CollationElementIterator previous and next for the whole set of

280 * unicode characters with normalization on.

281 */

282 static void TestNormalizedUnicodeChar()

283 {

284 UChar source[0x100];

285 UCollator *th_th;

286 UCollationElements *iter;

287 UErrorCode status = U_ZERO_ERROR;

288 UChar codepoint;

289

290 UChar *test;

291 /* thai should have normalization on */

292 th_th = ucol_open("th_TH", &status);

293 if (U_FAILURE(status)){

294 log_err_status(status, "ERROR: in creation of thai collation using ucol_ open()\n %s\n",

295 myErrorName(status));

296 return;

297 }

298

299 for (codepoint = 1; codepoint < 0xFFFE;)

300 {

301 test = source;

302

303 while (codepoint % 0xFF != 0)

304 {

305 if (u_isdefined(codepoint))

306 *(test ++) = codepoint;

307 codepoint ++;

308 }

309

310 if (u_isdefined(codepoint))

311 *(test ++) = codepoint;

312

313 if (codepoint != 0xFFFF)

314 codepoint ++;

315

316 *test = 0;

317 iter=ucol_openElements(th_th, source, u_strlen(source), &status);

318 if(U_FAILURE(status)){

319 log_err("ERROR: in creation of collation element iterator using ucol_o penElements()\n %s\n",

320 myErrorName(status));

321 ucol_close(th_th);

322 return;

323 }

324

325 backAndForth(iter);

326 ucol_closeElements(iter);

327

328 iter=ucol_openElements(th_th, source, -1, &status);

329 if(U_FAILURE(status)){

330 log_err("ERROR: in creation of collation element iterator using ucol_o penElements()\n %s\n",

331 myErrorName(status));

332 ucol_close(th_th);

333 return;

334 }

335

336 backAndForth(iter);

337 ucol_closeElements(iter);

338 }

339

340 ucol_close(th_th);

341 }

342

343 /**

344 * Test the incremental normalization

345 */

346 static void TestNormalization()

347 {

348 UErrorCode status = U_ZERO_ERROR;

349 const char *str =

350 "&a < \\u0300\\u0315 < A\\u0300\\u0315 < \\u0316\\u0 315B < \\u0316\\u0300\\u0315";

351 UCollator *coll;

352 UChar rule[50];

353 int rulelen = u_unescape(str, rule, 50);

354 int count = 0;

355 const char *testdata[] =

356 {"\\u1ED9", "o\\u0323\\u0302",

357 "\\u0300\\u0315", "\\u0315\\u0300",

358 "A\\u0300\\u0315B", "A\\u0315\\u0300B",

359 "A\\u0316\\u0315B", "A\\u0315\\u0316B",

360 "\\u0316\\u0300\\u0315", "\\u0315\\u0300\\u0316",

361 "A\\u0316\\u0300\\u0315B", "A\\u0315\\u0300\\u0316B",

362 "\\u0316\\u0315\\u0300", "A\\u0316\\u0315\\u0300B"};

363 int32_t srclen;

364 UChar source[10];

365 UCollationElements *iter;

366

367 coll = ucol_openRules(rule, rulelen, UCOL_ON, UCOL_TERTIARY, NULL, &status);

368 ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);

369 if (U_FAILURE(status)){

370 log_err_status(status, "ERROR: in creation of collator using ucol_openRu les()\n %s\n",

371 myErrorName(status));

372 return;

373 }

374

375 srclen = u_unescape(testdata[0], source, 10);

376 iter = ucol_openElements(coll, source, srclen, &status);

377 backAndForth(iter);

378 ucol_closeElements(iter);

379

380 srclen = u_unescape(testdata[1], source, 10);

381 iter = ucol_openElements(coll, source, srclen, &status);

382 backAndForth(iter);

383 ucol_closeElements(iter);

384

385 while (count < 12) {

386 srclen = u_unescape(testdata[count], source, 10);

387 iter = ucol_openElements(coll, source, srclen, &status);

388

389 if (U_FAILURE(status)){

390 log_err("ERROR: in creation of collator element iterator\n %s\n",

391 myErrorName(status));

392 return;

393 }

394 backAndForth(iter);

395 ucol_closeElements(iter);

396

397 iter = ucol_openElements(coll, source, -1, &status);

398

399 if (U_FAILURE(status)){

400 log_err("ERROR: in creation of collator element iterator\n %s\n",

401 myErrorName(status));

402 return;

403 }

404 backAndForth(iter);

405 ucol_closeElements(iter);

406 count ++;

407 }

408 ucol_close(coll);

409 }

410

411 /**

412 * Test for CollationElementIterator.previous()

413 *

414 * @bug 4108758 - Make sure it works with contracting characters

415 *

416 */

417 static void TestPrevious()

418 {

419 UCollator *coll=NULL;

420 UChar rule[50];

421 UChar *source;

422 UCollator c1, c2, *c3;

423 UCollationElements *iter;

424 UErrorCode status = U_ZERO_ERROR;

425 UChar test1[50];

426 UChar test2[50];

427

428 u_uastrcpy(test1, "What subset of all possible test cases?");

429 u_uastrcpy(test2, "has the highest probability of detecting");

430 coll = ucol_open("en_US", &status);

431

432 iter=ucol_openElements(coll, test1, u_strlen(test1), &status);

433 log_verbose("English locale testing back and forth\n");

434 if(U_FAILURE(status)){

435 log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",

436 myErrorName(status));

437 ucol_close(coll);

438 return;

439 }

440 /* A basic test to see if it's working at all */

441 backAndForth(iter);

442 ucol_closeElements(iter);

443 ucol_close(coll);

444

445 /* Test with a contracting character sequence */

446 u_uastrcpy(rule, "&a,A < b,B < c,C, d,D < z,Z < ch,cH,Ch,CH");

447 c1 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGTH, N ULL, &status);

448

449 log_verbose("Contraction rule testing back and forth with no normalization\n ");

450

451 if (c1 == NULL \|\| U_FAILURE(status))

452 {

453 log_err("Couldn't create a RuleBasedCollator with a contracting sequence \n %s\n",

454 myErrorName(status));

455 return;

456 }

457 source=(UChar)malloc(sizeof(UChar) 20);

458 u_uastrcpy(source, "abchdcba");

459 iter=ucol_openElements(c1, source, u_strlen(source), &status);

460 if(U_FAILURE(status)){

461 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

462 myErrorName(status));

463 return;

464 }

465 backAndForth(iter);

466 ucol_closeElements(iter);

467 ucol_close(c1);

468

469 /* Test with an expanding character sequence */

470 u_uastrcpy(rule, "&a < b < c/abd < d");

471 c2 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGTH, N ULL, &status);

472 log_verbose("Expansion rule testing back and forth with no normalization\n") ;

473 if (c2 == NULL \|\| U_FAILURE(status))

474 {

475 log_err("Couldn't create a RuleBasedCollator with a contracting sequence .\n %s\n",

476 myErrorName(status));

477 return;

478 }

479 u_uastrcpy(source, "abcd");

480 iter=ucol_openElements(c2, source, u_strlen(source), &status);

481 if(U_FAILURE(status)){

482 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

483 myErrorName(status));

484 return;

485 }

486 backAndForth(iter);

487 ucol_closeElements(iter);

488 ucol_close(c2);

489 /* Now try both */

490 u_uastrcpy(rule, "&a < b < c/aba < d < z < ch");

491 c3 = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT, UCOL_DEFAULT_STRENG TH,NULL, &status);

492 log_verbose("Expansion/contraction rule testing back and forth with no norma lization\n");

493

494 if (c3 == NULL \|\| U_FAILURE(status))

495 {

496 log_err("Couldn't create a RuleBasedCollator with a contracting sequence .\n %s\n",

497 myErrorName(status));

498 return;

499 }

500 u_uastrcpy(source, "abcdbchdc");

501 iter=ucol_openElements(c3, source, u_strlen(source), &status);

502 if(U_FAILURE(status)){

503 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

504 myErrorName(status));

505 return;

506 }

507 backAndForth(iter);

508 ucol_closeElements(iter);

509 ucol_close(c3);

510 source[0] = 0x0e41;

511 source[1] = 0x0e02;

512 source[2] = 0x0e41;

513 source[3] = 0x0e02;

514 source[4] = 0x0e27;

515 source[5] = 0x61;

516 source[6] = 0x62;

517 source[7] = 0x63;

518 source[8] = 0;

519

520 coll = ucol_open("th_TH", &status);

521 log_verbose("Thai locale testing back and forth with normalization\n");

522 iter=ucol_openElements(coll, source, u_strlen(source), &status);

523 if(U_FAILURE(status)){

524 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

525 myErrorName(status));

526 return;

527 }

528 backAndForth(iter);

529 ucol_closeElements(iter);

530 ucol_close(coll);

531

532 /* prev test */

533 source[0] = 0x0061;

534 source[1] = 0x30CF;

535 source[2] = 0x3099;

536 source[3] = 0x30FC;

537 source[4] = 0;

538

539 coll = ucol_open("ja_JP", &status);

540 log_verbose("Japanese locale testing back and forth with normalization\n");

541 iter=ucol_openElements(coll, source, u_strlen(source), &status);

542 if(U_FAILURE(status)){

543 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

544 myErrorName(status));

545 return;

546 }

547 backAndForth(iter);

548 ucol_closeElements(iter);

549 ucol_close(coll);

550

551 free(source);

552 }

553

554 /**

555 * Test for getOffset() and setOffset()

556 */

557 static void TestOffset()

558 {

559 UErrorCode status= U_ZERO_ERROR;

560 UCollator *en_us=NULL;

561 UCollationElements iter, pristine;

562 int32_t offset;

563 OrderAndOffset *orders;

564 int32_t orderLength=0;

565 int count = 0;

566 UChar test1[50];

567 UChar test2[50];

568

569 u_uastrcpy(test1, "What subset of all possible test cases?");

570 u_uastrcpy(test2, "has the highest probability of detecting");

571 en_us = ucol_open("en_US", &status);

572 log_verbose("Testing getOffset and setOffset for collations\n");

573 iter = ucol_openElements(en_us, test1, u_strlen(test1), &status);

574 if(U_FAILURE(status)){

575 log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",

576 myErrorName(status));

577 ucol_close(en_us);

578 return;

579 }

580

581 /* testing boundaries */

582 ucol_setOffset(iter, 0, &status);

583 if (U_FAILURE(status) \|\| ucol_previous(iter, &status) != UCOL_NULLORDER) {

584 log_err("Error: After setting offset to 0, we should be at the end "

585 "of the backwards iteration");

586 }

587 ucol_setOffset(iter, u_strlen(test1), &status);

588 if (U_FAILURE(status) \|\| ucol_next(iter, &status) != UCOL_NULLORDER) {

589 log_err("Error: After setting offset to end of the string, we should "

590 "be at the end of the backwards iteration");

591 }

592

593 /* Run all the way through the iterator, then get the offset */

594

595 orders = getOrders(iter, &orderLength);

596

597 offset = ucol_getOffset(iter);

598

599 if (offset != u_strlen(test1))

600 {

601 log_err("offset at end != length %d vs %d\n", offset,

602 u_strlen(test1) );

603 }

604

605 /* Now set the offset back to the beginning and see if it works */

606 pristine=ucol_openElements(en_us, test1, u_strlen(test1), &status);

607 if(U_FAILURE(status)){

608 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

609 myErrorName(status));

610 ucol_close(en_us);

611 return;

612 }

613 status = U_ZERO_ERROR;

614

615 ucol_setOffset(iter, 0, &status);

616 if (U_FAILURE(status))

617 {

618 log_err("setOffset failed. %s\n", myErrorName(status));

619 }

620 else

621 {

622 assertEqual(iter, pristine);

623 }

624

625 ucol_closeElements(pristine);

626 ucol_closeElements(iter);

627 free(orders);

628

629 /* testing offsets in normalization buffer */

630 test1[0] = 0x61;

631 test1[1] = 0x300;

632 test1[2] = 0x316;

633 test1[3] = 0x62;

634 test1[4] = 0;

635 ucol_setAttribute(en_us, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);

636 iter = ucol_openElements(en_us, test1, 4, &status);

637 if(U_FAILURE(status)){

638 log_err("ERROR: in creation of collation element iterator using ucol_ope nElements()\n %s\n",

639 myErrorName(status));

640 ucol_close(en_us);

641 return;

642 }

643

644 count = 0;

645 while (ucol_next(iter, &status) != UCOL_NULLORDER &&

646 U_SUCCESS(status)) {

647 switch (count) {

648 case 0:

649 if (ucol_getOffset(iter) != 1) {

650 log_err("ERROR: Offset of iteration should be 1\n");

651 }

652 break;

653 case 3:

654 if (ucol_getOffset(iter) != 4) {

655 log_err("ERROR: Offset of iteration should be 4\n");

656 }

657 break;

658 default:

659 if (ucol_getOffset(iter) != 3) {

660 log_err("ERROR: Offset of iteration should be 3\n");

661 }

662 }

663 count ++;

664 }

665

666 ucol_reset(iter);

667 count = 0;

668 while (ucol_previous(iter, &status) != UCOL_NULLORDER &&

669 U_SUCCESS(status)) {

670 switch (count) {

671 case 0:

672 case 1:

673 if (ucol_getOffset(iter) != 3) {

674 log_err("ERROR: Offset of iteration should be 3\n");

675 }

676 break;

677 case 2:

678 if (ucol_getOffset(iter) != 1) {

679 log_err("ERROR: Offset of iteration should be 1\n");

680 }

681 break;

682 default:

683 if (ucol_getOffset(iter) != 0) {

684 log_err("ERROR: Offset of iteration should be 0\n");

685 }

686 }

687 count ++;

688 }

689

690 if(U_FAILURE(status)){

691 log_err("ERROR: in iterating collation elements %s\n",

692 myErrorName(status));

693 }

694

695 ucol_closeElements(iter);

696 ucol_close(en_us);

697 }

698

699 /**

700 * Test for setText()

701 */

702 static void TestSetText()

703 {

704 int32_t c,i;

705 UErrorCode status = U_ZERO_ERROR;

706 UCollator *en_us=NULL;

707 UCollationElements iter1, iter2;

708 UChar test1[50];

709 UChar test2[50];

710

711 u_uastrcpy(test1, "What subset of all possible test cases?");

712 u_uastrcpy(test2, "has the highest probability of detecting");

713 en_us = ucol_open("en_US", &status);

714 log_verbose("testing setText for Collation elements\n");

715 iter1=ucol_openElements(en_us, test1, u_strlen(test1), &status);

716 if(U_FAILURE(status)){

717 log_err_status(status, "ERROR: in creation of collation element iterator 1 using ucol_openElements()\n %s\n",

718 myErrorName(status));

719 ucol_close(en_us);

720 return;

721 }

722 iter2=ucol_openElements(en_us, test2, u_strlen(test2), &status);

723 if(U_FAILURE(status)){

724 log_err("ERROR: in creation of collation element iterator2 using ucol_op enElements()\n %s\n",

725 myErrorName(status));

726 ucol_close(en_us);

727 return;

728 }

729

730 /* Run through the second iterator just to exercise it */

731 c = ucol_next(iter2, &status);

732 i = 0;

733

734 while ( ++i < 10 && (c != UCOL_NULLORDER))

735 {

736 if (U_FAILURE(status))

737 {

738 log_err("iter2->next() returned an error. %s\n", myErrorName(status) );

739 ucol_closeElements(iter2);

740 ucol_closeElements(iter1);

741 ucol_close(en_us);

742 return;

743 }

744

745 c = ucol_next(iter2, &status);

746 }

747

748 /* Now set it to point to the same string as the first iterator */

749 ucol_setText(iter2, test1, u_strlen(test1), &status);

750 if (U_FAILURE(status))

751 {

752 log_err("call to iter2->setText(test1) failed. %s\n", myErrorName(status ));

753 }

754 else

755 {

756 assertEqual(iter1, iter2);

757 }

758

759 /* Now set it to point to a null string with fake length*/

760 ucol_setText(iter2, NULL, 2, &status);

761 if (status != U_ILLEGAL_ARGUMENT_ERROR)

762 {

763 log_err("call to iter2->setText(null, 2) should yield an illegal-argumen t-error - %s\n",

764 myErrorName(status));

765 }

766

767 ucol_closeElements(iter2);

768 ucol_closeElements(iter1);

769 ucol_close(en_us);

770 }

771

772 /** @bug 4108762

773 * Test for getMaxExpansion()

774 */

775 static void TestMaxExpansion()

776 {

777 UErrorCode status = U_ZERO_ERROR;

778 UCollator coll ;/= ucol_open("en_US", &status);*/

779 UChar ch = 0;

780 UChar32 unassigned = 0xEFFFD;

781 UChar supplementary[2];

782 uint32_t stringOffset = 0;

783 UBool isError = FALSE;

784 uint32_t sorder = 0;

785 UCollationElements iter ;/= ucol_openElements(coll, &ch, 1, &status);*/

786 uint32_t temporder = 0;

787

788 UChar rule[256];

789 u_uastrcpy(rule, "&a < ab < c/aba < d < z < ch");

790 coll = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT,

791 UCOL_DEFAULT_STRENGTH,NULL, &status);

792 if(U_SUCCESS(status) && coll) {

793 iter = ucol_openElements(coll, &ch, 1, &status);

794

795 while (ch < 0xFFFF && U_SUCCESS(status)) {

796 int count = 1;

797 uint32_t order;

798 int32_t size = 0;

799

800 ch ++;

801

802 ucol_setText(iter, &ch, 1, &status);

803 order = ucol_previous(iter, &status);

804

805 /* thai management */

806 if (order == 0)

807 order = ucol_previous(iter, &status);

808

809 while (U_SUCCESS(status) &&

810 ucol_previous(iter, &status) != UCOL_NULLORDER) {

811 count ++;

812 }

813

814 size = ucol_getMaxExpansion(iter, order);

815 if (U_FAILURE(status) \|\| size < count) {

816 log_err("Failure at codepoint %d, maximum expansion count < %d\n",

817 ch, count);

818 }

819 }

820

821 /* testing for exact max expansion */

822 ch = 0;

823 while (ch < 0x61) {

824 uint32_t order;

825 int32_t size;

826 ucol_setText(iter, &ch, 1, &status);

827 order = ucol_previous(iter, &status);

828 size = ucol_getMaxExpansion(iter, order);

829 if (U_FAILURE(status) \|\| size != 1) {

830 log_err("Failure at codepoint %d, maximum expansion count < %d\n",

831 ch, 1);

832 }

833 ch ++;

834 }

835

836 ch = 0x63;

837 ucol_setText(iter, &ch, 1, &status);

838 temporder = ucol_previous(iter, &status);

839

840 if (U_FAILURE(status) \|\| ucol_getMaxExpansion(iter, temporder) != 3) {

841 log_err("Failure at codepoint %d, maximum expansion count != %d\n",

842 ch, 3);

843 }

844

845 ch = 0x64;

846 ucol_setText(iter, &ch, 1, &status);

847 temporder = ucol_previous(iter, &status);

848

849 if (U_FAILURE(status) \|\| ucol_getMaxExpansion(iter, temporder) != 1) {

850 log_err("Failure at codepoint %d, maximum expansion count != %d\n",

851 ch, 3);

852 }

853

854 U16_APPEND(supplementary, stringOffset, 2, unassigned, isError);

855 (void)isError; /* Suppress set but not used warning. */

856 ucol_setText(iter, supplementary, 2, &status);

857 sorder = ucol_previous(iter, &status);

858

859 if (U_FAILURE(status) \|\| ucol_getMaxExpansion(iter, sorder) != 2) {

860 log_err("Failure at codepoint %d, maximum expansion count < %d\n",

861 ch, 2);

862 }

863

864 /* testing jamo */

865 ch = 0x1165;

866

867 ucol_setText(iter, &ch, 1, &status);

868 temporder = ucol_previous(iter, &status);

869 if (U_FAILURE(status) \|\| ucol_getMaxExpansion(iter, temporder) > 3) {

870 log_err("Failure at codepoint %d, maximum expansion count > %d\n",

871 ch, 3);

872 }

873

874 ucol_closeElements(iter);

875 ucol_close(coll);

876

877 /* testing special jamo &a<\u1160 */

878 rule[0] = 0x26;

879 rule[1] = 0x71;

880 rule[2] = 0x3c;

881 rule[3] = 0x1165;

882 rule[4] = 0x2f;

883 rule[5] = 0x71;

884 rule[6] = 0x71;

885 rule[7] = 0x71;

886 rule[8] = 0x71;

887 rule[9] = 0;

888

889 coll = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT,

890 UCOL_DEFAULT_STRENGTH,NULL, &status);

891 iter = ucol_openElements(coll, &ch, 1, &status);

892

893 temporder = ucol_previous(iter, &status);

894 if (U_FAILURE(status) \|\| ucol_getMaxExpansion(iter, temporder) != 6) {

895 log_err("Failure at codepoint %d, maximum expansion count > %d\n",

896 ch, 5);

897 }

898

899 ucol_closeElements(iter);

900 ucol_close(coll);

901 } else {

902 log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(statu s));

903 }

904

905 }

906

907

908 static void assertEqual(UCollationElements i1, UCollationElements i2)

909 {

910 int32_t c1, c2;

911 int32_t count = 0;

912 UErrorCode status = U_ZERO_ERROR;

913

914 do

915 {

916 c1 = ucol_next(i1, &status);

917 c2 = ucol_next(i2, &status);

918

919 if (c1 != c2)

920 {

921 log_err("Error in iteration %d assetEqual between\n %d and %d, t hey are not equal\n", count, c1, c2);

922 break;

923 }

924

925 count += 1;

926 }

927 while (c1 != UCOL_NULLORDER);

928 }

929

930 /**

931 * Testing iterators with extremely small buffers

932 */

933 static void TestSmallBuffer()

934 {

935 UErrorCode status = U_ZERO_ERROR;

936 UCollator *coll;

937 UCollationElements *testiter,

938 *iter;

939 int32_t count = 0;

940 OrderAndOffset *testorders,

941 *orders;

942

943 UChar teststr[500];

944 UChar str[] = {0x300, 0x31A, 0};

945 /*

946 creating a long string of decomposable characters,

947 since by default the writable buffer is of size 256

948 */

949 while (count < 500) {

950 if ((count & 1) == 0) {

951 teststr[count ++] = 0x300;

952 }

953 else {

954 teststr[count ++] = 0x31A;

955 }

956 }

957

958 coll = ucol_open("th_TH", &status);

959 if(U_SUCCESS(status) && coll) {

960 testiter = ucol_openElements(coll, teststr, 500, &status);

961 iter = ucol_openElements(coll, str, 2, &status);

962

963 orders = getOrders(iter, &count);

964 if (count != 2) {

965 log_err("Error collation elements size is not 2 for \\u0300\\u031A\n") ;

966 }

967

968 /*

969 this will rearrange the string data to 250 characters of 0x300 first then

970 250 characters of 0x031A

971 */

972 testorders = getOrders(testiter, &count);

973

974 if (count != 500) {

975 log_err("Error decomposition does not give the right sized collation e lements\n");

976 }

977

978 while (count != 0) {

979 /* UCA collation element for 0x0F76 */

980 if ((count > 250 && testorders[-- count].order != orders[1].order) \|\|

981 (count <= 250 && testorders[-- count].order != orders[0].order)) {

982 log_err("Error decomposition does not give the right collation ele ment at %d count\n", count);

983 break;

984 }

985 }

986

987 free(testorders);

988 free(orders);

989

990 ucol_reset(testiter);

991

992 /* ensures closing of elements done properly to clear writable buffer */

993 ucol_next(testiter, &status);

994 ucol_next(testiter, &status);

995 ucol_closeElements(testiter);

996 ucol_closeElements(iter);

997 ucol_close(coll);

998 } else {

999 log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(statu s));

1000 }

1001 }

1002

1003 /**

1004 * Testing the discontigous contractions

1005 */

1006 static void TestDiscontiguos() {

1007 const char *rulestr =

1008 "&z < AB < X\\u0300 < ABC < X\\u0300\\u0315";

1009 UChar rule[50];

1010 int rulelen = u_unescape(rulestr, rule, 50);

1011 const char *src[] = {

1012 "ADB", "ADBC", "A\\u0315B", "A\\u0315BC",

1013 /* base character blocked */

1014 "XD\\u0300", "XD\\u0300\\u0315",

1015 /* non blocking combining character */

1016 "X\\u0319\\u0300", "X\\u0319\\u0300\\u0315",

1017 /* blocking combining character */

1018 "X\\u0314\\u0300", "X\\u0314\\u0300\\u0315",

1019 /* contraction prefix */

1020 "ABDC", "AB\\u0315C","X\\u0300D\\u0315", "X\\u0300\\u0319\\u0315",

1021 "X\\u0300\\u031A\\u0315",

1022 /* ends not with a contraction character */

1023 "X\\u0319\\u0300D", "X\\u0319\\u0300\\u0315D", "X\\u0300D\\u0315D",

1024 "X\\u0300\\u0319\\u0315D", "X\\u0300\\u031A\\u0315D"

1025 };

1026 const char *tgt[] = {

1027 /* non blocking combining character */

1028 "A D B", "A D BC", "A \\u0315 B", "A \\u0315 BC",

1029 /* base character blocked */

1030 "X D \\u0300", "X D \\u0300\\u0315",

1031 /* non blocking combining character */

1032 "X\\u0300 \\u0319", "X\\u0300\\u0315 \\u0319",

1033 /* blocking combining character */

1034 "X \\u0314 \\u0300", "X \\u0314 \\u0300\\u0315",

1035 /* contraction prefix */

1036 "AB DC", "AB \\u0315 C","X\\u0300 D \\u0315", "X\\u0300\\u0315 \\u0319",

1037 "X\\u0300 \\u031A \\u0315",

1038 /* ends not with a contraction character */

1039 "X\\u0300 \\u0319D", "X\\u0300\\u0315 \\u0319D", "X\\u0300 D\\u0315D",

1040 "X\\u0300\\u0315 \\u0319D", "X\\u0300 \\u031A\\u0315D"

1041 };

1042 int size = 20;

1043 UCollator *coll;

1044 UErrorCode status = U_ZERO_ERROR;

1045 int count = 0;

1046 UCollationElements *iter;

1047 UCollationElements *resultiter;

1048

1049 coll = ucol_openRules(rule, rulelen, UCOL_OFF, UCOL_DEFAULT_STRENGTH,N ULL, &status);

1050 iter = ucol_openElements(coll, rule, 1, &status);

1051 resultiter = ucol_openElements(coll, rule, 1, &status);

1052

1053 if (U_FAILURE(status)) {

1054 log_err_status(status, "Error opening collation rules -> %s\n", u_errorN ame(status));

1055 return;

1056 }

1057

1058 while (count < size) {

1059 UChar str[20];

1060 UChar tstr[20];

1061 int strLen = u_unescape(src[count], str, 20);

1062 UChar *s;

1063

1064 ucol_setText(iter, str, strLen, &status);

1065 if (U_FAILURE(status)) {

1066 log_err("Error opening collation iterator\n");

1067 return;

1068 }

1069

1070 u_unescape(tgt[count], tstr, 20);

1071 s = tstr;

1072

1073 log_verbose("count %d\n", count);

1074

1075 for (;;) {

1076 uint32_t ce;

1077 UChar *e = u_strchr(s, 0x20);

1078 if (e == 0) {

1079 e = u_strchr(s, 0);

1080 }

1081 ucol_setText(resultiter, s, (int32_t)(e - s), &status);

1082 ce = ucol_next(resultiter, &status);

1083 if (U_FAILURE(status)) {

1084 log_err("Error manipulating collation iterator\n");

1085 return;

1086 }

1087 while (ce != UCOL_NULLORDER) {

1088 if (ce != (uint32_t)ucol_next(iter, &status) \|\|

1089 U_FAILURE(status)) {

1090 log_err("Discontiguos contraction test mismatch\n");

1091 return;

1092 }

1093 ce = ucol_next(resultiter, &status);

1094 if (U_FAILURE(status)) {

1095 log_err("Error getting next collation element\n");

1096 return;

1097 }

1098 }

1099 s = e + 1;

1100 if (*e == 0) {

1101 break;

1102 }

1103 }

1104 ucol_reset(iter);

1105 backAndForth(iter);

1106 count ++;

1107 }

1108 ucol_closeElements(resultiter);

1109 ucol_closeElements(iter);

1110 ucol_close(coll);

1111 }

1112

1113 /**

1114 * TestSearchCollatorElements tests iterator behavior (forwards and backwards) wi th

1115 * normalization on AND jamo tailoring, among other things.

1116 *

1117 * Note: This test is sensitive to changes of the root collator,

1118 * for example whether the ae-ligature maps to three CEs (as in the DUCET)

1119 * or to two CEs (as in the CLDR 24 FractionalUCA.txt).

1120 * It is also sensitive to how those CEs map to the iterator's 32-bit CE encoding .

1121 * For example, the DUCET's artificial secondary CE in the ae-ligature

1122 * may map to two 32-bit iterator CEs (as it did until ICU 52).

1123 */

1124 static const UChar tsceText[] = { /* Nothing in here should be ignorable */

1125 0x0020, 0xAC00, /* simple LV Hangul */

1126 0x0020, 0xAC01, /* simple LVT Hangul */

1127 0x0020, 0xAC0F, /* LVTT, last jamo expands for search */

1128 0x0020, 0xAFFF, /* LLVVVTT, every jamo expands for search */

1129 0x0020, 0x1100, 0x1161, 0x11A8, /* 0xAC01 as conjoining jamo */

1130 0x0020, 0x3131, 0x314F, 0x3131, /* 0xAC01 as compatibility jamo */

1131 0x0020, 0x1100, 0x1161, 0x11B6, /* 0xAC0F as conjoining jamo; last expands f or search */

1132 0x0020, 0x1101, 0x1170, 0x11B6, /* 0xAFFF as conjoining jamo; all expand for search */

1133 0x0020, 0x00E6, /* small letter ae, expands */

1134 0x0020, 0x1E4D, /* small letter o with tilde and acute, deco mposes */

1135 0x0020

1136 };

1137 enum { kLen_tsceText = sizeof(tsceText)/sizeof(tsceText[0]) };

1138

1139 static const int32_t rootStandardOffsets[] = {

1140 0, 1,2,

1141 2, 3,4,4,

1142 4, 5,6,6,

1143 6, 7,8,8,

1144 8, 9,10,11,

1145 12, 13,14,15,

1146 16, 17,18,19,

1147 20, 21,22,23,

1148 24, 25,26, /* plus another 1-2 offset=26 if ae-ligature maps to three CEs * /

1149 26, 27,28,28,

1150 28,

1151 29

1152 };

1153 enum { kLen_rootStandardOffsets = sizeof(rootStandardOffsets)/sizeof(rootStandar dOffsets[0]) };

1154

1155 static const int32_t rootSearchOffsets[] = {

1156 0, 1,2,

1157 2, 3,4,4,

1158 4, 5,6,6,6,

1159 6, 7,8,8,8,8,8,8,

1160 8, 9,10,11,

1161 12, 13,14,15,

1162 16, 17,18,19,20,

1163 20, 21,22,22,23,23,23,24,

1164 24, 25,26, /* plus another 1-2 offset=26 if ae-ligature maps to three CEs * /

1165 26, 27,28,28,

1166 28,

1167 29

1168 };

1169 enum { kLen_rootSearchOffsets = sizeof(rootSearchOffsets)/sizeof(rootSearchOffse ts[0]) };

1170

1171 typedef struct {

1172 const char * locale;

1173 const int32_t * offsets;

1174 int32_t offsetsLen;

1175 } TSCEItem;

1176

1177 static const TSCEItem tsceItems[] = {

1178 { "root", rootStandardOffsets, kLen_rootStandardOffsets },

1179 { "root@collation=search", rootSearchOffsets, kLen_rootSearchOffsets },

1180 { NULL, NULL, 0 }

1181 };

1182

1183 static void TestSearchCollatorElements(void)

1184 {

1185 const TSCEItem * tsceItemPtr;

1186 for (tsceItemPtr = tsceItems; tsceItemPtr->locale != NULL; tsceItemPtr++) {

1187 UErrorCode status = U_ZERO_ERROR;

1188 UCollator* ucol = ucol_open(tsceItemPtr->locale, &status);

1189 if ( U_SUCCESS(status) ) {

1190 UCollationElements * uce = ucol_openElements(ucol, tsceText, kLen_ts ceText, &status);

1191 if ( U_SUCCESS(status) ) {

1192 int32_t offset, element;

1193 const int32_t * nextOffsetPtr;

1194 const int32_t * limitOffsetPtr;

1195

1196 nextOffsetPtr = tsceItemPtr->offsets;

1197 limitOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen;

1198 do {

1199 offset = ucol_getOffset(uce);

1200 element = ucol_next(uce, &status);

1201 log_verbose("(%s) offset=%2d ce=%08x\n", tsceItemPtr->local e, offset, element);

1202 if ( element == 0 ) {

1203 log_err("error, locale %s, ucol_next returned element 0\ n", tsceItemPtr->locale );

1204 }

1205 if ( nextOffsetPtr < limitOffsetPtr ) {

1206 if (offset != *nextOffsetPtr) {

1207 log_err("error, locale %s, expected ucol_next -> uco l_getOffset %d, got %d\n",

1208 tsceItemPtr->locale, *nextOffsetPtr, offset );

1209 nextOffsetPtr = limitOffsetPtr;

1210 break;

1211 }

1212 nextOffsetPtr++;

1213 } else {

1214 log_err("error, locale %s, ucol_next returned more eleme nts than expected\n", tsceItemPtr->locale );

1215 }

1216 } while ( U_SUCCESS(status) && element != UCOL_NULLORDER );

1217 if ( nextOffsetPtr < limitOffsetPtr ) {

1218 log_err("error, locale %s, ucol_next returned fewer elements than expected\n", tsceItemPtr->locale );

1219 }

1220

1221 ucol_setOffset(uce, kLen_tsceText, &status);

1222 status = U_ZERO_ERROR;

1223 nextOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen;

1224 limitOffsetPtr = tsceItemPtr->offsets;

1225 do {

1226 offset = ucol_getOffset(uce);

1227 element = ucol_previous(uce, &status);

1228 if ( element == 0 ) {

1229 log_err("error, locale %s, ucol_previous returned elemen t 0\n", tsceItemPtr->locale );

1230 }

1231 if ( nextOffsetPtr > limitOffsetPtr ) {

1232 nextOffsetPtr--;

1233 if (offset != *nextOffsetPtr) {

1234 log_err("error, locale %s, expected ucol_previous -> ucol_getOffset %d, got %d\n",

1235 tsceItemPtr->loc ale, *nextOffsetPtr, offset );

1236 nextOffsetPtr = limitOffsetPtr;

1237 break;

1238 }

1239 } else {

1240 log_err("error, locale %s, ucol_previous returned more e lements than expected\n", tsceItemPtr->locale );

1241 }

1242 } while ( U_SUCCESS(status) && element != UCOL_NULLORDER );

1243 if ( nextOffsetPtr > limitOffsetPtr ) {

1244 log_err("error, locale %s, ucol_previous returned fewer elem ents than expected\n", tsceItemPtr->locale );

1245 }

1246

1247 ucol_closeElements(uce);

1248 } else {

1249 log_err("error, locale %s, ucol_openElements failed: %s\n", tsce ItemPtr->locale, u_errorName(status) );

1250 }

1251 ucol_close(ucol);

1252 } else {

1253 log_data_err("error, locale %s, ucol_open failed: %s\n", tsceItemPtr ->locale, u_errorName(status) );

1254 }

1255 }

1256 }

1257

1258 #endif /* #if !UCONFIG_NO_COLLATION */

OLD	NEW

« no previous file with comments | « source/test/cintltst/citertst.h ('k') | source/test/cintltst/cjaptst.h » ('j') | no next file with comments »