source/test/intltest/restsnew.cpp - Issue 2435373002: Delete source/test

Side by Side Diff: source/test/intltest/restsnew.cpp

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 (c) 1997-2014, International Business Machines

3 * Corporation and others. All Rights Reserved.

4 ********************************************************************/

5

6 #include "unicode/utypes.h"

7

8 #include "cstring.h"

9 #include "unicode/unistr.h"

10 #include "unicode/resbund.h"

11 #include "restsnew.h"

12

13 #include <stdlib.h>

14 #include <time.h>

15 #include <string.h>

16 #include <limits.h>

17

18 //**************************************************************************** *******

19

20 static const UChar kErrorUChars[] = { 0x45, 0x52, 0x52, 0x4f, 0x52, 0 };

21 static const int32_t kErrorLength = 5;

22 static const int32_t kERROR_COUNT = -1234567;

23

24 //**************************************************************************** *******

25

26 enum E_Where

27 {

28 e_Root,

29 e_te,

30 e_te_IN,

31 e_Where_count

32 };

33

34 //**************************************************************************** *******

35

36 #define CONFIRM_EQ(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + ( UnicodeString)" instead of " + (expected)); }

37 #define CONFIRM_GE(actual,expected) if ((actual)>=(expected)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + ( UnicodeString)" instead of x >= " + (expected)); }

38 #define CONFIRM_NE(actual,expected) if ((expected)!=(actual)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + ( UnicodeString)" instead of x != " + (expected)); }

39

40 #define CONFIRM_UErrorCode(actual,expected) if ((expected)==(actual)) { record_p ass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (Uni codeString)u_errorName(actual) + (UnicodeString)" instead of " + (UnicodeString) u_errorName(expected)); }

41

42 //**************************************************************************** *******

43

44 /**

45 * Convert an integer, positive or negative, to a character string radix 10.

46 */

47 static char*

48 itoa(int32_t i, char* buf)

49 {

50 char* result = buf;

51

52 // Handle negative

53 if (i < 0)

54 {

55 *buf++ = '-';

56 i = -i;

57 }

58

59 // Output digits in reverse order

60 char* p = buf;

61 do

62 {

63 *p++ = (char)('0' + (i % 10));

64 i /= 10;

65 }

66 while (i);

67 *p-- = 0;

68

69 // Reverse the string

70 while (buf < p)

71 {

72 char c = *buf;

73 buf++ = p;

74 *p-- = c;

75 }

76

77 return result;

78 }

79

80

81

82 //**************************************************************************** *******

83

84 // Array of our test objects

85

86 static struct

87 {

88 const char* name;

89 Locale *locale;

90 UErrorCode expected_constructor_status;

91 E_Where where;

92 UBool like[e_Where_count];

93 UBool inherits[e_Where_count];

94 }

95 param[] =

96 {

97 // "te" means test

98 // "IN" means inherits

99 // "NE" or "ne" means "does not exist"

100

101 { "root", 0, U_ZERO_ERROR, e_Root, { TRUE, FALSE, F ALSE }, { TRUE, FALSE, FALSE } },

102 { "te", 0, U_ZERO_ERROR, e_te, { FALSE, TRUE, F ALSE }, { TRUE, TRUE, FALSE } },

103 { "te_IN", 0, U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },

104 { "te_NE", 0, U_USING_FALLBACK_WARNING, e_te, { FALSE, TRUE, F ALSE }, { TRUE, TRUE, FALSE } },

105 { "te_IN_NE", 0, U_USING_FALLBACK_WARNING, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },

106 { "ne", 0, U_USING_DEFAULT_WARNING, e_Root, { TRUE, FALSE, F ALSE }, { TRUE, FALSE, FALSE } }

107 };

108

109 static int32_t bundles_count = sizeof(param) / sizeof(param[0]);

110

111 //**************************************************************************** *******

112

113 /**

114 * Return a random unsigned long l where 0N <= l <= ULONG_MAX.

115 */

116

117 static uint32_t

118 randul()

119 {

120 static UBool initialized = FALSE;

121 if (!initialized)

122 {

123 srand((unsigned)time(NULL));

124 initialized = TRUE;

125 }

126 // Assume rand has at least 12 bits of precision

127 uint32_t l = 0;

128 for (uint32_t i=0; i<sizeof(l); ++i)

129 ((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4);

130 return l;

131 }

132

133 /**

134 * Return a random double x where 0.0 <= x < 1.0.

135 */

136 static double

137 randd()

138 {

139 return (double)(randul() / ULONG_MAX);

140 }

141

142 /**

143 * Return a random integer i where 0 <= i < n.

144 */

145 static int32_t randi(int32_t n)

146 {

147 return (int32_t)(randd() * n);

148 }

149

150 //**************************************************************************** *******

151

152 /*

153 Don't use more than one of these at a time because of the Locale names

154 */

155 NewResourceBundleTest::NewResourceBundleTest()

156 : pass(0),

157 fail(0)

158 {

159 if (param[5].locale == NULL) {

160 param[0].locale = new Locale("root");

161 param[1].locale = new Locale("te");

162 param[2].locale = new Locale("te", "IN");

163 param[3].locale = new Locale("te", "NE");

164 param[4].locale = new Locale("te", "IN", "NE");

165 param[5].locale = new Locale("ne");

166 }

167 }

168

169 NewResourceBundleTest::~NewResourceBundleTest()

170 {

171 if (param[5].locale) {

172 int idx;

173 for (idx = 0; idx < (int)(sizeof(param)/sizeof(param[0])); idx++) {

174 delete param[idx].locale;

175 param[idx].locale = NULL;

176 }

177 }

178 }

179

180 void NewResourceBundleTest::runIndexedTest( int32_t index, UBool exec, const cha r* &name, char* /par/ )

181 {

182 if (exec) logln("TestSuite ResourceBundleTest: ");

183 switch (index) {

184 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION

185 case 0: name = "TestResourceBundles"; if (exec) TestResourceBundles(); break ;

186 case 1: name = "TestConstruction"; if (exec) TestConstruction(); break;

187 case 2: name = "TestIteration"; if (exec) TestIteration(); break;

188 case 3: name = "TestOtherAPI"; if(exec) TestOtherAPI(); break;

189 case 4: name = "TestNewTypes"; if(exec) TestNewTypes(); break;

190 #else

191 case 0: case 1: case 2: case 3: case 4: name = "skip"; break;

192 #endif

193

194 case 5: name = "TestGetByFallback"; if(exec) TestGetByFallback(); break;

195 default: name = ""; break; //needed to end loop

196 }

197 }

198

199 //**************************************************************************** *******

200

201 void

202 NewResourceBundleTest::TestResourceBundles()

203 {

204 UErrorCode status = U_ZERO_ERROR;

205 loadTestData(status);

206 if(U_FAILURE(status))

207 {

208 dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName( status)));

209 return;

210 }

211

212 /* Make sure that users using te_IN for the default locale don't get test fa ilures. */

213 Locale originalDefault;

214 if (Locale::getDefault() == Locale("te_IN")) {

215 Locale::setDefault(Locale("en_US"), status);

216 }

217

218 testTag("only_in_Root", TRUE, FALSE, FALSE);

219 testTag("only_in_te", FALSE, TRUE, FALSE);

220 testTag("only_in_te_IN", FALSE, FALSE, TRUE);

221 testTag("in_Root_te", TRUE, TRUE, FALSE);

222 testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);

223 testTag("in_Root_te_IN", TRUE, FALSE, TRUE);

224 testTag("in_te_te_IN", FALSE, TRUE, TRUE);

225 testTag("nonexistent", FALSE, FALSE, FALSE);

226 logln("Passed: %d\nFailed: %d", pass, fail);

227

228 /* Restore the default locale for the other tests. */

229 Locale::setDefault(originalDefault, status);

230 }

231

232 void

233 NewResourceBundleTest::TestConstruction()

234 {

235 UErrorCode err = U_ZERO_ERROR;

236 Locale locale("te", "IN");

237

238 const char* testdatapath;

239 testdatapath=loadTestData(err);

240 if(U_FAILURE(err))

241 {

242 dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName( err)));

243 return;

244 }

245

246 /* Make sure that users using te_IN for the default locale don't get test fa ilures. */

247 Locale originalDefault;

248 if (Locale::getDefault() == Locale("te_IN")) {

249 Locale::setDefault(Locale("en_US"), err);

250 }

251

252 ResourceBundle test1((UnicodeString)testdatapath, err);

253 ResourceBundle test2(testdatapath, locale, err);

254

255 UnicodeString result1;

256 UnicodeString result2;

257

258 result1 = test1.getStringEx("string_in_Root_te_te_IN", err);

259 result2 = test2.getStringEx("string_in_Root_te_te_IN", err);

260 if (U_FAILURE(err)) {

261 errln("Something threw an error in TestConstruction()");

262 return;

263 }

264

265 logln("for string_in_Root_te_te_IN, root.txt had " + result1);

266 logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);

267

268 if (result1 != "ROOT" \|\| result2 != "TE_IN") {

269 errln("Construction test failed; run verbose for more information");

270 }

271

272 const char* version1;

273 const char* version2;

274

275 version1 = test1.getVersionNumber();

276 version2 = test2.getVersionNumber();

277

278 char *versionID1 = new char[1 + strlen(U_ICU_VERSION) + strlen(version1)]; / / + 1 for zero byte

279 char *versionID2 = new char[1 + strlen(U_ICU_VERSION) + strlen(version2)]; / / + 1 for zero byte

280

281 strcpy(versionID1, "44.0"); // hardcoded, please change if the default.txt file or ResourceBundle::kVersionSeparater is changed.

282

283 strcpy(versionID2, "55.0"); // hardcoded, please change if the te_IN.txt fi le or ResourceBundle::kVersionSeparater is changed.

284

285 logln(UnicodeString("getVersionNumber on default.txt returned ") + version1 + UnicodeString(" Expect: " ) + versionID1);

286 logln(UnicodeString("getVersionNumber on te_IN.txt returned ") + version2 + UnicodeString(" Expect: " ) + versionID2);

287

288 if (strcmp(version1, versionID1) != 0) {

289 errln("getVersionNumber(version1) failed. %s != %s", version1, versionID 1);

290 }

291 if (strcmp(version2, versionID2) != 0) {

292 errln("getVersionNumber(version2) failed. %s != %s", version2, versionID 2);

293 }

294 delete[] versionID1;

295 delete[] versionID2;

296

297 /* Restore the default locale for the other tests. */

298 Locale::setDefault(originalDefault, err);

299 }

300

301 void

302 NewResourceBundleTest::TestIteration()

303 {

304 UErrorCode err = U_ZERO_ERROR;

305 const char* testdatapath;

306 const char* data[]={

307 "string_in_Root_te_te_IN", "1",

308 "array_in_Root_te_te_IN", "5",

309 "array_2d_in_Root_te_te_IN", "4",

310 };

311

312 Locale *locale=new Locale("te_IN");

313

314 testdatapath=loadTestData(err);

315 if(U_FAILURE(err))

316 {

317 dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName( err)));

318 return;

319 }

320

321 ResourceBundle test1(testdatapath, *locale, err);

322 if(U_FAILURE(err)){

323 errln("Construction failed");

324 }

325 uint32_t i;

326 int32_t count, row=0, col=0;

327 char buf[5];

328 UnicodeString expected;

329 UnicodeString element("TE_IN");

330 UnicodeString action;

331

332

333 for(i=0; i<sizeof(data)/sizeof(data[0]); i=i+2){

334 action = "te_IN";

335 action +=".get(";

336 action += data[i];

337 action +=", err)";

338 err=U_ZERO_ERROR;

339 ResourceBundle bundle = test1.get(data[i], err);

340 if(!U_FAILURE(err)){

341 action = "te_IN";

342 action +=".getKey()";

343

344 CONFIRM_EQ((UnicodeString)bundle.getKey(), (UnicodeString)data[i]);

345

346 count=0;

347 row=0;

348 while(bundle.hasNext()){

349 action = data[i];

350 action +=".getNextString(err)";

351 row=count;

352 UnicodeString got=bundle.getNextString(err);

353 if(U_SUCCESS(err)){

354 expected=element;

355 if(bundle.getSize() > 1){

356 CONFIRM_EQ(bundle.getType(), URES_ARRAY);

357 expected+=itoa(row, buf);

358 ResourceBundle rowbundle=bundle.get(row, err);

359 if(!U_FAILURE(err) && rowbundle.getSize()>1){

360 col=0;

361 while(rowbundle.hasNext()){

362 expected=element;

363 got=rowbundle.getNextString(err);

364 if(!U_FAILURE(err)){

365 expected+=itoa(row, buf);

366 expected+=itoa(col, buf);

367 col++;

368 CONFIRM_EQ(got, expected);

369 }

370 }

371 CONFIRM_EQ(col, rowbundle.getSize());

372 }

373 }

374 else{

375 CONFIRM_EQ(bundle.getType(), (int32_t)URES_STRING);

376 }

377 }

378 CONFIRM_EQ(got, expected);

379 count++;

380 }

381 action = data[i];

382 action +=".getSize()";

383 CONFIRM_EQ(bundle.getSize(), count);

384 CONFIRM_EQ(count, atoi(data[i+1]));

385 //after reaching the end

386 err=U_ZERO_ERROR;

387 ResourceBundle errbundle=bundle.getNext(err);

388 action = "After reaching the end of the Iterator:- ";

389 action +=data[i];

390 action +=".getNext()";

391 CONFIRM_NE(err, (int32_t)U_ZERO_ERROR);

392 CONFIRM_EQ(u_errorName(err), u_errorName(U_INDEX_OUTOFBOUNDS_ERROR)) ;

393 //reset the iterator

394 err = U_ZERO_ERROR;

395 bundle.resetIterator();

396 /* The following code is causing a crash

397 **CRASH****

398 */

399

400 bundle.getNext(err);

401 if(U_FAILURE(err)){

402 errln("ERROR: getNext() throw an error");

403 }

404 }

405 }

406 delete locale;

407 }

408

409 // TODO: add operator== and != to ResourceBundle

410 static UBool

411 equalRB(ResourceBundle &a, ResourceBundle &b) {

412 UResType type;

413 UErrorCode status;

414

415 type=a.getType();

416 status=U_ZERO_ERROR;

417 return

418 type==b.getType() &&

419 a.getLocale()==b.getLocale() &&

420 0==strcmp(a.getName(), b.getName()) &&

421 type==URES_STRING ?

422 a.getString(status)==b.getString(status) :

423 type==URES_INT ?

424 a.getInt(status)==b.getInt(status) :

425 TRUE;

426 }

427

428 void

429 NewResourceBundleTest::TestOtherAPI(){

430 UErrorCode err = U_ZERO_ERROR;

431 const char* testdatapath=loadTestData(err);

432 UnicodeString tDataPathUS = UnicodeString(testdatapath, "");

433

434 if(U_FAILURE(err))

435 {

436 dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName( err)));

437 return;

438 }

439

440 /* Make sure that users using te_IN for the default locale don't get test fa ilures. */

441 Locale originalDefault;

442 if (Locale::getDefault() == Locale("te_IN")) {

443 Locale::setDefault(Locale("en_US"), err);

444 }

445

446 Locale *locale=new Locale("te_IN");

447

448 ResourceBundle test0(tDataPathUS, *locale, err);

449 if(U_FAILURE(err)){

450 errln("Construction failed");

451 return;

452 }

453

454 ResourceBundle test1(testdatapath, *locale, err);

455 if(U_FAILURE(err)){

456 errln("Construction failed");

457 return;

458 }

459

460 logln("Testing getLocale()\n");

461 if(strcmp(test1.getLocale().getName(), locale->getName()) !=0 ){

462 errln("FAIL: ResourceBundle::getLocale() failed\n");

463 }

464

465 delete locale;

466

467 logln("Testing ResourceBundle(UErrorCode)\n");

468 ResourceBundle defaultresource(err);

469 ResourceBundle explicitdefaultresource(NULL, Locale::getDefault(), err);

470 if(U_FAILURE(err)){

471 errcheckln(err, "Construction of default resourcebundle failed - %s", u_ errorName(err));

472 return;

473 }

474 // You can't compare the default locale to the resolved locale in the

475 // resource bundle due to aliasing, keywords in the default locale

476 // or the chance that the machine running these tests is using a locale

477 // that isn't available in ICU.

478 if(strcmp(defaultresource.getLocale().getName(), explicitdefaultresource.get Locale().getName()) != 0){

479 errln("Construction of default resourcebundle didn't take the defaultloc ale. Expected %s Got %s err=%s\n",

480 explicitdefaultresource.getLocale().getName(), defaultresource.getLo cale().getName(), u_errorName(err));

481 }

482

483

484 ResourceBundle copyRes(defaultresource);

485 if(strcmp(copyRes.getName(), defaultresource.getName() ) !=0 \|\|

486 strcmp(test1.getName(), defaultresource.getName() ) ==0 \|\|

487 strcmp(copyRes.getLocale().getName(), defaultresource.getLocale().getNam e() ) !=0 \|\|

488 strcmp(test1.getLocale().getName(), defaultresource.getLocale().getName( ) ) ==0 )

489 {

490 errln("copy construction failed\n");

491 }

492

493 ResourceBundle defaultSub = defaultresource.get((int32_t)0, err);

494 ResourceBundle defSubCopy(defaultSub);

495 if(strcmp(defSubCopy.getName(), defaultSub.getName() ) !=0 \|\|

496 strcmp(defSubCopy.getLocale().getName(), defaultSub.getLocale().getName( ) ) !=0 ){

497 errln("copy construction for subresource failed\n");

498 }

499

500 ResourceBundle *p;

501

502 p = defaultresource.clone();

503 if(p == &defaultresource \|\| !equalRB(*p, defaultresource)) {

504 errln("ResourceBundle.clone() failed");

505 }

506 delete p;

507

508 p = defaultSub.clone();

509 if(p == &defaultSub \|\| !equalRB(*p, defaultSub)) {

510 errln("2nd ResourceBundle.clone() failed");

511 }

512 delete p;

513

514 UVersionInfo ver;

515 copyRes.getVersion(ver);

516

517 logln("Version returned: [%d.%d.%d.%d]\n", ver[0], ver[1], ver[2], ver[3]);

518

519 logln("Testing C like UnicodeString APIs\n");

520

521 UResourceBundle testCAPI = NULL, bundle = NULL, rowbundle = NULL, temp = NULL;

522 err = U_ZERO_ERROR;

523 const char* data[]={

524 "string_in_Root_te_te_IN", "1",

525 "array_in_Root_te_te_IN", "5",

526 "array_2d_in_Root_te_te_IN", "4",

527 };

528

529

530 testCAPI = ures_open(testdatapath, "te_IN", &err);

531

532 if(U_SUCCESS(err)) {

533 // Do the testing

534 // first iteration

535

536 uint32_t i;

537 int32_t count, row=0, col=0;

538 char buf[5];

539 UnicodeString expected;

540 UnicodeString element("TE_IN");

541 UnicodeString action;

542

543

544 for(i=0; i<sizeof(data)/sizeof(data[0]); i=i+2){

545 action = "te_IN";

546 action +=".get(";

547 action += data[i];

548 action +=", err)";

549 err=U_ZERO_ERROR;

550 bundle = ures_getByKey(testCAPI, data[i], bundle, &err);

551 if(!U_FAILURE(err)){

552 const char* key = NULL;

553 action = "te_IN";

554 action +=".getKey()";

555

556 CONFIRM_EQ((UnicodeString)ures_getKey(bundle), (UnicodeString)da ta[i]);

557

558 count=0;

559 row=0;

560 while(ures_hasNext(bundle)){

561 action = data[i];

562 action +=".getNextString(err)";

563 row=count;

564 UnicodeString got=ures_getNextUnicodeString(bundle, &key, &e rr);

565 if(U_SUCCESS(err)){

566 expected=element;

567 if(ures_getSize(bundle) > 1){

568 CONFIRM_EQ(ures_getType(bundle), URES_ARRAY);

569 expected+=itoa(row, buf);

570 rowbundle=ures_getByIndex(bundle, row, rowbundle, &e rr);

571 if(!U_FAILURE(err) && ures_getSize(rowbundle)>1){

572 col=0;

573 while(ures_hasNext(rowbundle)){

574 expected=element;

575 got=ures_getNextUnicodeString(rowbundle, &ke y, &err);

576 temp = ures_getByIndex(rowbundle, col, temp, &err);

577 UnicodeString bla = ures_getUnicodeString(te mp, &err);

578 UnicodeString bla2 = ures_getUnicodeStringBy Index(rowbundle, col, &err);

579 if(!U_FAILURE(err)){

580 expected+=itoa(row, buf);

581 expected+=itoa(col, buf);

582 col++;

583 CONFIRM_EQ(got, expected);

584 CONFIRM_EQ(bla, expected);

585 CONFIRM_EQ(bla2, expected);

586 }

587 }

588 CONFIRM_EQ(col, ures_getSize(rowbundle));

589 }

590 }

591 else{

592 CONFIRM_EQ(ures_getType(bundle), (int32_t)URES_STRIN G);

593 }

594 }

595 CONFIRM_EQ(got, expected);

596 count++;

597 }

598 }

599 }

600 ures_close(temp);

601 ures_close(rowbundle);

602 ures_close(bundle);

603 ures_close(testCAPI);

604 } else {

605 errln("failed to open a resource bundle\n");

606 }

607

608 /* Restore the default locale for the other tests. */

609 Locale::setDefault(originalDefault, err);

610 }

611

612

613

614

615 //**************************************************************************** *******

616

617 UBool

618 NewResourceBundleTest::testTag(const char* frag,

619 UBool in_Root,

620 UBool in_te,

621 UBool in_te_IN)

622 {

623 int32_t failOrig = fail;

624

625 // Make array from input params

626

627 UBool is_in[] = { in_Root, in_te, in_te_IN };

628

629 const char* NAME[] = { "ROOT", "TE", "TE_IN" };

630

631 // Now try to load the desired items

632

633 char tag[100];

634 UnicodeString action;

635

636 int32_t i,j,row,col, actual_bundle;

637 int32_t index;

638 const char* testdatapath;

639

640 UErrorCode status = U_ZERO_ERROR;

641 testdatapath=loadTestData(status);

642 if(U_FAILURE(status))

643 {

644 dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName( status)));

645 return FALSE;

646 }

647

648 for (i=0; i<bundles_count; ++i)

649 {

650 action = "Constructor for ";

651 action += param[i].name;

652

653 status = U_ZERO_ERROR;

654 ResourceBundle theBundle( testdatapath, *param[i].locale, status);

655 //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testd ata", *param[i].locale, status);

656 CONFIRM_UErrorCode(status,param[i].expected_constructor_status);

657

658 if(i == 5)

659 actual_bundle = 0; /* ne -> default */

660 else if(i == 3)

661 actual_bundle = 1; /* te_NE -> te */

662 else if(i == 4)

663 actual_bundle = 2; /* te_IN_NE -> te_IN */

664 else

665 actual_bundle = i;

666

667

668 UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR;

669 for (j=e_te_IN; j>=e_Root; --j)

670 {

671 if (is_in[j] && param[i].inherits[j])

672 {

673 if(j == actual_bundle) /* it's in the same bundle OR it's a none xistent=default bundle (5) */

674 expected_resource_status = U_ZERO_ERROR;

675 else if(j == 0)

676 expected_resource_status = U_USING_DEFAULT_WARNING;

677 else

678 expected_resource_status = U_USING_FALLBACK_WARNING;

679

680 break;

681 }

682 }

683

684 UErrorCode expected_status;

685

686 UnicodeString base;

687 for (j=param[i].where; j>=0; --j)

688 {

689 if (is_in[j])

690 {

691 base = NAME[j];

692 break;

693 }

694 }

695

696 //---------------------------------------------------------------------- ----

697 // string

698

699 uprv_strcpy(tag, "string_");

700 uprv_strcat(tag, frag);

701

702 action = param[i].name;

703 action += ".getStringEx(";

704 action += tag;

705 action += ")";

706

707

708 status = U_ZERO_ERROR;

709 UnicodeString string = theBundle.getStringEx(tag, status);

710 if(U_FAILURE(status)) {

711 string.setTo(TRUE, kErrorUChars, kErrorLength);

712 }

713

714 CONFIRM_UErrorCode(status, expected_resource_status);

715

716 UnicodeString expected_string(kErrorUChars);

717 if (U_SUCCESS(status)) {

718 expected_string = base;

719 }

720

721 CONFIRM_EQ(string, expected_string);

722

723 //---------------------------------------------------------------------- ----

724 // array ResourceBundle using the key

725

726 uprv_strcpy(tag, "array_");

727 uprv_strcat(tag, frag);

728

729 action = param[i].name;

730 action += ".get(";

731 action += tag;

732 action += ")";

733

734 int32_t count = kERROR_COUNT;

735 status = U_ZERO_ERROR;

736 ResourceBundle array = theBundle.get(tag, status);

737 CONFIRM_UErrorCode(status,expected_resource_status);

738

739

740 if (U_SUCCESS(status))

741 {

742 //confirm the resource type is an array

743 UResType bundleType=array.getType();

744 CONFIRM_EQ(bundleType, URES_ARRAY);

745

746 count=array.getSize();

747 CONFIRM_GE(count,1);

748

749 for (j=0; j<count; ++j)

750 {

751 char buf[32];

752 expected_string = base;

753 expected_string += itoa(j,buf);

754 CONFIRM_EQ(array.getNextString(status),expected_string);

755 }

756

757 }

758 else

759 {

760 CONFIRM_EQ(count,kERROR_COUNT);

761 // CONFIRM_EQ((int32_t)(unsigned long)array,(int32_t)0);

762 count = 0;

763 }

764

765 //---------------------------------------------------------------------- ----

766 // arrayItem ResourceBundle using the index

767

768

769 for (j=0; j<100; ++j)

770 {

771 index = count ? (randi(count * 3) - count) : (randi(200) - 100);

772 status = U_ZERO_ERROR;

773 string = kErrorUChars;

774 ResourceBundle array = theBundle.get(tag, status);

775 if(!U_FAILURE(status)){

776 UnicodeString t = array.getStringEx(index, status);

777 if(!U_FAILURE(status)) {

778 string=t;

779 }

780 }

781

782 expected_status = (index >= 0 && index < count) ? expected_resource_ status : U_MISSING_RESOURCE_ERROR;

783 CONFIRM_UErrorCode(status,expected_status);

784

785 if (U_SUCCESS(status)){

786 char buf[32];

787 expected_string = base;

788 expected_string += itoa(index,buf);

789 } else {

790 expected_string = kErrorUChars;

791 }

792 CONFIRM_EQ(string,expected_string);

793

794 }

795

796 //---------------------------------------------------------------------- ----

797 // 2dArray

798

799 uprv_strcpy(tag, "array_2d_");

800 uprv_strcat(tag, frag);

801

802 action = param[i].name;

803 action += ".get(";

804 action += tag;

805 action += ")";

806

807

808 int32_t row_count = kERROR_COUNT, column_count = kERROR_COUNT;

809 status = U_ZERO_ERROR;

810 ResourceBundle array2d=theBundle.get(tag, status);

811

812 //const UnicodeString** array2d = theBundle.get2dArray(tag, row_count, c olumn_count, status);

813 CONFIRM_UErrorCode(status,expected_resource_status);

814

815 if (U_SUCCESS(status))

816 {

817 //confirm the resource type is an 2darray

818 UResType bundleType=array2d.getType();

819 CONFIRM_EQ(bundleType, URES_ARRAY);

820

821 row_count=array2d.getSize();

822 CONFIRM_GE(row_count,1);

823

824 for(row=0; row<row_count; ++row){

825 ResourceBundle tablerow=array2d.get(row, status);

826 CONFIRM_UErrorCode(status, expected_resource_status);

827 if(U_SUCCESS(status)){

828 //confirm the resourcetype of each table row is an array

829 UResType rowType=tablerow.getType();

830 CONFIRM_EQ(rowType, URES_ARRAY);

831

832 column_count=tablerow.getSize();

833 CONFIRM_GE(column_count,1);

834

835 for (col=0; j<column_count; ++j) {

836 char buf[32];

837 expected_string = base;

838 expected_string += itoa(row,buf);

839 expected_string += itoa(col,buf);

840 CONFIRM_EQ(tablerow.getNextString(status),expected_st ring);

841 }

842 }

843 }

844 }else{

845 CONFIRM_EQ(row_count,kERROR_COUNT);

846 CONFIRM_EQ(column_count,kERROR_COUNT);

847 row_count=column_count=0;

848 }

849

850

851

852

853 //----------------------------------------------------------------------- ---

854 // 2dArrayItem

855 for (j=0; j<200; ++j)

856 {

857 row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100);

858 col = column_count ? (randi(column_count * 3) - column_count) : (rand i(200) - 100);

859 status = U_ZERO_ERROR;

860 string = kErrorUChars;

861 ResourceBundle array2d=theBundle.get(tag, status);

862 if(U_SUCCESS(status)){

863 ResourceBundle tablerow=array2d.get(row, status);

864 if(U_SUCCESS(status)) {

865 UnicodeString t=tablerow.getStringEx(col, status);

866 if(U_SUCCESS(status)){

867 string=t;

868 }

869 }

870 }

871 expected_status = (row >= 0 && row < row_count && col >= 0 && col < c olumn_count) ?

872 expected_resource_status: U_MISSING_RESOURCE_E RROR;

873 CONFIRM_UErrorCode(status,expected_status);

874

875 if (U_SUCCESS(status)){

876 char buf[32];

877 expected_string = base;

878 expected_string += itoa(row,buf);

879 expected_string += itoa(col,buf);

880 } else {

881 expected_string = kErrorUChars;

882 }

883 CONFIRM_EQ(string,expected_string);

884

885 }

886

887 //---------------------------------------------------------------------- ----

888 // taggedArray

889

890 uprv_strcpy(tag, "tagged_array_");

891 uprv_strcat(tag, frag);

892

893 action = param[i].name;

894 action += ".get(";

895 action += tag;

896 action += ")";

897

898 int32_t tag_count;

899 status = U_ZERO_ERROR;

900

901 ResourceBundle tags=theBundle.get(tag, status);

902 CONFIRM_UErrorCode(status, expected_resource_status);

903

904 if (U_SUCCESS(status)) {

905 UResType bundleType=tags.getType();

906 CONFIRM_EQ(bundleType, URES_TABLE);

907

908 tag_count=tags.getSize();

909 CONFIRM_GE((int32_t)tag_count, (int32_t)0);

910

911 for(index=0; index <tag_count; index++){

912 ResourceBundle tagelement=tags.get(index, status);

913 UnicodeString key=tagelement.getKey();

914 UnicodeString value=tagelement.getNextString(status);

915 logln("tag = " + key + ", value = " + value );

916 if(key.startsWith("tag") && value.startsWith(base)){

917 record_pass();

918 }else{

919 record_fail();

920 }

921

922 }

923

924 for(index=0; index <tag_count; index++){

925 ResourceBundle tagelement=tags.get(index, status);

926 const char *tkey=NULL;

927 UnicodeString value=tagelement.getNextString(&tkey, status);

928 UnicodeString key(tkey);

929 logln("tag = " + key + ", value = " + value );

930 if(value.startsWith(base)){

931 record_pass();

932 }else{

933 record_fail();

934 }

935 }

936

937 }else{

938 tag_count=0;

939 }

940

941

942

943

944 //---------------------------------------------------------------------- ----

945 // taggedArrayItem

946

947 action = param[i].name;

948 action += ".get(";

949 action += tag;

950 action += ")";

951

952 count = 0;

953 for (index=-20; index<20; ++index)

954 {

955 char buf[32];

956 status = U_ZERO_ERROR;

957 string = kErrorUChars;

958 char item_tag[8];

959 uprv_strcpy(item_tag, "tag");

960 uprv_strcat(item_tag, itoa(index,buf));

961 ResourceBundle tags=theBundle.get(tag, status);

962 if(U_SUCCESS(status)){

963 ResourceBundle tagelement=tags.get(item_tag, status);

964 if(!U_FAILURE(status)){

965 UResType elementType=tagelement.getType();

966 CONFIRM_EQ(elementType, (int32_t)URES_STRING);

967 const char* key=tagelement.getKey();

968 CONFIRM_EQ((UnicodeString)key, (UnicodeString)item_tag);

969 UnicodeString t=tagelement.getString(status);

970 if(!U_FAILURE(status)){

971 string=t;

972 }

973 }

974 if (index < 0) {

975 CONFIRM_UErrorCode(status,U_MISSING_RESOURCE_ERROR);

976 }

977 else{

978 if (status != U_MISSING_RESOURCE_ERROR) {

979 count++;

980 expected_string = base;

981 expected_string += buf;

982 CONFIRM_EQ(string,expected_string);

983 }

984 }

985 }

986

987 }

988 CONFIRM_EQ(count, tag_count);

989

990 }

991 return (UBool)(failOrig == fail);

992 }

993

994 void

995 NewResourceBundleTest::record_pass()

996 {

997 ++pass;

998 }

999 void

1000 NewResourceBundleTest::record_fail()

1001 {

1002 err();

1003 ++fail;

1004 }

1005

1006

1007 void

1008 NewResourceBundleTest::TestNewTypes() {

1009 char action[256];

1010 const char* testdatapath;

1011 UErrorCode status = U_ZERO_ERROR;

1012 uint8_t *binResult = NULL;

1013 int32_t len = 0;

1014 int32_t i = 0;

1015 int32_t intResult = 0;

1016 uint32_t uintResult = 0;

1017 UChar expected[] = { 'a','b','c','\0','d','e','f' };

1018 const char* expect ="tab:\t cr:\r ff:\f newline:\n backslash:\\\\ quote=\\\' doubleQuote=\\\" singlequoutes=''";

1019 UChar uExpect[200];

1020

1021 testdatapath=loadTestData(status);

1022

1023 if(U_FAILURE(status))

1024 {

1025 dataerrln("Could not load testdata.dat %s \n",u_errorName(status));

1026 return;

1027 }

1028

1029 ResourceBundle theBundle(testdatapath, "testtypes", status);

1030 ResourceBundle bundle(testdatapath, Locale("te_IN"),status);

1031

1032 UnicodeString emptyStr = theBundle.getStringEx("emptystring", status);

1033 if(emptyStr.length() != 0) {

1034 logln("Empty string returned invalid value\n");

1035 }

1036

1037 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1038

1039 /* This test reads the string "abc\u0000def" from the bundle */

1040 /* if everything is working correctly, the size of this string */

1041 /* should be 7. Everything else is a wrong answer, esp. 3 and 6*/

1042

1043 strcpy(action, "getting and testing of string with embeded zero");

1044 ResourceBundle res = theBundle.get("zerotest", status);

1045 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1046 CONFIRM_EQ(res.getType(), URES_STRING);

1047 UnicodeString zeroString=res.getString(status);

1048 len = zeroString.length();

1049 if(U_SUCCESS(status)){

1050 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1051 CONFIRM_EQ(len, 7);

1052 CONFIRM_NE(len, 3);

1053 }

1054 for(i=0;i<len;i++){

1055 if(zeroString[i]!= expected[i]){

1056 logln("Output didnot match Expected: \\u%4X Got: \\u%4X", expected[i ], zeroString[i]);

1057 }

1058 }

1059

1060 strcpy(action, "getting and testing of binary type");

1061 res = theBundle.get("binarytest", status);

1062 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1063 CONFIRM_EQ(res.getType(), URES_BINARY);

1064 binResult=(uint8_t*)res.getBinary(len, status);

1065 if(U_SUCCESS(status)){

1066 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1067 CONFIRM_EQ(len, 15);

1068 for(i = 0; i<15; i++) {

1069 CONFIRM_EQ(binResult[i], i);

1070 }

1071 }

1072

1073 strcpy(action, "getting and testing of imported binary type");

1074 res = theBundle.get("importtest",status);

1075 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1076 CONFIRM_EQ(res.getType(), URES_BINARY);

1077 binResult=(uint8_t*)res.getBinary(len, status);

1078 if(U_SUCCESS(status)){

1079 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1080 CONFIRM_EQ(len, 15);

1081 for(i = 0; i<15; i++) {

1082 CONFIRM_EQ(binResult[i], i);

1083 }

1084 }

1085

1086 strcpy(action, "getting and testing of integer types");

1087 res = theBundle.get("one", status);

1088 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1089 CONFIRM_EQ(res.getType(), URES_INT);

1090 intResult=res.getInt(status);

1091 uintResult = res.getUInt(status);

1092 if(U_SUCCESS(status)){

1093 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1094 CONFIRM_EQ(uintResult, (uint32_t)intResult);

1095 CONFIRM_EQ(intResult, 1);

1096 }

1097

1098 strcpy(action, "getting minusone");

1099 res = theBundle.get((const char*)"minusone", status);

1100 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1101 CONFIRM_EQ(res.getType(), URES_INT);

1102 intResult=res.getInt(status);

1103 uintResult = res.getUInt(status);

1104 if(U_SUCCESS(status)){

1105 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1106 CONFIRM_EQ(uintResult, 0x0FFFFFFF); /* a 28 bit integer */

1107 CONFIRM_EQ(intResult, -1);

1108 CONFIRM_NE(uintResult, (uint32_t)intResult);

1109 }

1110

1111 strcpy(action, "getting plusone");

1112 res = theBundle.get("plusone",status);

1113 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1114 CONFIRM_EQ(res.getType(), URES_INT);

1115 intResult=res.getInt(status);

1116 uintResult = res.getUInt(status);

1117 if(U_SUCCESS(status)){

1118 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1119 CONFIRM_EQ(uintResult, (uint32_t)intResult);

1120 CONFIRM_EQ(intResult, 1);

1121 }

1122

1123 res = theBundle.get("onehundredtwentythree",status);

1124 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1125 CONFIRM_EQ(res.getType(), URES_INT);

1126 intResult=res.getInt(status);

1127 if(U_SUCCESS(status)){

1128 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1129 CONFIRM_EQ(intResult, 123);

1130 }

1131

1132 /* this tests if escapes are preserved or not */

1133 {

1134 UnicodeString str = theBundle.getStringEx("testescape",status);

1135 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1136 if(U_SUCCESS(status)){

1137 u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1);

1138 if(str.compare(uExpect)!=0){

1139 errln("Did not get the expected string for testescape expected. Expected : "

1140 +UnicodeString(uExpect )+ " Got: " + str);

1141 }

1142 }

1143 }

1144 /* test for jitterbug#1435 */

1145 {

1146 UnicodeString str = theBundle.getStringEx("test_underscores",status);

1147 expect ="test message ....";

1148 CONFIRM_UErrorCode(status, U_ZERO_ERROR);

1149 u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1);

1150 if(str.compare(uExpect)!=0){

1151 errln("Did not get the expected string for test_underscores.\n");

1152 }

1153 }

1154

1155

1156 }

1157

1158 void

1159 NewResourceBundleTest::TestGetByFallback() {

1160 UErrorCode status = U_ZERO_ERROR;

1161

1162 ResourceBundle heRes(NULL, "he", status);

1163

1164 heRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", s tatus).getWithFallback("DateTime", status);

1165 if(U_SUCCESS(status)) {

1166 errln("he locale's Islamic-civil DateTime resource exists. How did it ge t here?\n");

1167 }

1168 status = U_ZERO_ERROR;

1169

1170 heRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", s tatus).getWithFallback("eras", status);

1171 if(U_FAILURE(status)) {

1172 dataerrln("Didn't get Islamic Eras. I know they are there! - %s", u_erro rName(status));

1173 }

1174 status = U_ZERO_ERROR;

1175

1176 ResourceBundle rootRes(NULL, "root", status);

1177 rootRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", status).getWithFallback("DateTime", status);

1178 if(U_SUCCESS(status)) {

1179 errln("Root's Islamic-civil's DateTime resource exists. How did it get h ere?\n");

1180 }

1181 status = U_ZERO_ERROR;

1182

1183 }

1184 //eof

1185

OLD	NEW

« no previous file with comments | « source/test/intltest/restsnew.h ('k') | source/test/intltest/scientificnumberformattertest.cpp » ('j') | no next file with comments »