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

Side by Side Diff: source/test/intltest/regiontst.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:

3 * Copyright (c) 2013-2015, International Business Machines Corporation

4 * and others. All Rights Reserved.

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

6

7 /***********************************************************************

8 * This testcase ported from ICU4J ( RegionTest.java ) to ICU4C *

9 * Try to keep them in sync if at all possible...! *

10 ***********************************************************************/

11

12 #include "unicode/utypes.h"

13 #include "cstring.h"

14

15 #if !UCONFIG_NO_FORMATTING

16

17 #include "unicode/region.h"

18 #include "regiontst.h"

19

20 typedef struct KnownRegion {

21 const char *code;

22 int32_t numeric;

23 const char *parent;

24 URegionType type;

25 const char *containingContinent;

26 } KnownRegion;

27

28 static KnownRegion knownRegions[] = {

29 // Code, Num, Parent, Type, Containing Continent

30 { "TP" , 626, "035", URGN_TERRITORY, "142" },

31 { "001", 1, NULL , URGN_WORLD, NULL },

32 { "002", 2, "001", URGN_CONTINENT, NULL },

33 { "003", 3, NULL, URGN_GROUPING, NULL },

34 { "005", 5, "019", URGN_SUBCONTINENT, "019" },

35 { "009", 9, "001", URGN_CONTINENT, NULL},

36 { "011", 11, "002", URGN_SUBCONTINENT, "002" },

37 { "013", 13, "019", URGN_SUBCONTINENT, "019" },

38 { "014", 14, "002", URGN_SUBCONTINENT, "002" },

39 { "015", 15, "002", URGN_SUBCONTINENT, "002" },

40 { "017", 17, "002", URGN_SUBCONTINENT, "002" },

41 { "018", 18, "002", URGN_SUBCONTINENT, "002" },

42 { "019", 19, "001", URGN_CONTINENT, NULL },

43 { "021", 21, "019", URGN_SUBCONTINENT, "019" },

44 { "029", 29, "019", URGN_SUBCONTINENT, "019" },

45 { "030", 30, "142", URGN_SUBCONTINENT, "142" },

46 { "034", 34, "142", URGN_SUBCONTINENT, "142" },

47 { "035", 35, "142", URGN_SUBCONTINENT, "142" },

48 { "039", 39, "150", URGN_SUBCONTINENT, "150"},

49 { "053", 53, "009", URGN_SUBCONTINENT, "009" },

50 { "054", 54, "009", URGN_SUBCONTINENT, "009" },

51 { "057", 57, "009", URGN_SUBCONTINENT, "009" },

52 { "061", 61, "009", URGN_SUBCONTINENT, "009" },

53 { "142", 142, "001", URGN_CONTINENT, NULL },

54 { "143", 143, "142", URGN_SUBCONTINENT, "142" },

55 { "145", 145, "142", URGN_SUBCONTINENT, "142" },

56 { "150", 150, "001", URGN_CONTINENT, NULL },

57 { "151", 151, "150", URGN_SUBCONTINENT, "150" },

58 { "154", 154, "150", URGN_SUBCONTINENT, "150" },

59 { "155", 155, "150", URGN_SUBCONTINENT, "150" },

60 { "419", 419, NULL, URGN_GROUPING , NULL},

61 { "AC" , -1, "QO" , URGN_TERRITORY, "009" },

62 { "AD" , 20, "039", URGN_TERRITORY, "150" },

63 { "AE" , 784, "145", URGN_TERRITORY, "142" },

64 { "AF" , 4, "034", URGN_TERRITORY, "142" },

65 { "AG" , 28, "029", URGN_TERRITORY, "019" },

66 { "AI" , 660, "029", URGN_TERRITORY, "019" },

67 { "AL" , 8, "039", URGN_TERRITORY, "150" },

68 { "AM" , 51, "145", URGN_TERRITORY, "142" },

69 { "AN" , 530, NULL, URGN_DEPRECATED, NULL },

70 { "AO" , 24, "017", URGN_TERRITORY, "002" },

71 { "AQ" , 10, "QO" , URGN_TERRITORY, "009" },

72 { "AR" , 32, "005", URGN_TERRITORY, "019" },

73 { "AS" , 16, "061", URGN_TERRITORY, "009" },

74 { "AT" , 40, "155", URGN_TERRITORY, "150" },

75 { "AU" , 36, "053", URGN_TERRITORY, "009" },

76 { "AW" , 533, "029", URGN_TERRITORY, "019" },

77 { "AX" , 248, "154", URGN_TERRITORY, "150" },

78 { "AZ" , 31, "145", URGN_TERRITORY, "142" },

79 { "BA" , 70, "039", URGN_TERRITORY, "150" },

80 { "BB" , 52, "029", URGN_TERRITORY, "019" },

81 { "BD" , 50, "034", URGN_TERRITORY, "142" },

82 { "BE" , 56, "155", URGN_TERRITORY, "150" },

83 { "BF" , 854, "011", URGN_TERRITORY, "002" },

84 { "BG" , 100, "151", URGN_TERRITORY, "150" },

85 { "BH" , 48, "145", URGN_TERRITORY, "142" },

86 { "BI" , 108, "014", URGN_TERRITORY, "002" },

87 { "BJ" , 204, "011", URGN_TERRITORY, "002" },

88 { "BL" , 652, "029", URGN_TERRITORY, "019" },

89 { "BM" , 60, "021", URGN_TERRITORY, "019" },

90 { "BN" , 96, "035", URGN_TERRITORY, "142" },

91 { "BO" , 68, "005", URGN_TERRITORY, "019" },

92 { "BQ" , 535, "029", URGN_TERRITORY, "019" },

93 { "BR" , 76, "005", URGN_TERRITORY, "019" },

94 { "BS" , 44, "029", URGN_TERRITORY, "019" },

95 { "BT" , 64, "034", URGN_TERRITORY, "142" },

96 { "BU" , 104, "035", URGN_TERRITORY, "142" },

97 { "BV" , 74, "QO" , URGN_TERRITORY, "009" },

98 { "BW" , 72, "018", URGN_TERRITORY, "002" },

99 { "BY" , 112, "151", URGN_TERRITORY, "150" },

100 { "BZ" , 84, "013", URGN_TERRITORY, "019" },

101 { "CA" , 124, "021", URGN_TERRITORY, "019" },

102 { "CC" , 166, "QO" , URGN_TERRITORY, "009" },

103 { "CD" , 180, "017", URGN_TERRITORY, "002" },

104 { "CF" , 140, "017", URGN_TERRITORY, "002" },

105 { "CG" , 178, "017", URGN_TERRITORY, "002" },

106 { "CH" , 756, "155", URGN_TERRITORY, "150" },

107 { "CI" , 384, "011", URGN_TERRITORY, "002" },

108 { "CK" , 184, "061", URGN_TERRITORY, "009" },

109 { "CL" , 152, "005", URGN_TERRITORY, "019" },

110 { "CM" , 120, "017", URGN_TERRITORY, "002" },

111 { "CN" , 156, "030", URGN_TERRITORY, "142" },

112 { "CO" , 170, "005", URGN_TERRITORY, "019" },

113 { "CP" , -1 , "QO" , URGN_TERRITORY, "009" },

114 { "CR" , 188, "013", URGN_TERRITORY, "019" },

115 { "CU" , 192, "029", URGN_TERRITORY, "019" },

116 { "CV" , 132, "011", URGN_TERRITORY, "002" },

117 { "CW" , 531, "029", URGN_TERRITORY, "019" },

118 { "CX" , 162, "QO" , URGN_TERRITORY, "009" },

119 { "CY" , 196, "145", URGN_TERRITORY, "142" },

120 { "CZ" , 203, "151", URGN_TERRITORY, "150" },

121 { "DD" , 276, "155", URGN_TERRITORY, "150" },

122 { "DE" , 276, "155", URGN_TERRITORY, "150" },

123 { "DG" , -1 , "QO" , URGN_TERRITORY, "009" },

124 { "DJ" , 262, "014", URGN_TERRITORY, "002" },

125 { "DK" , 208, "154", URGN_TERRITORY, "150" },

126 { "DM" , 212, "029", URGN_TERRITORY, "019" },

127 { "DO" , 214, "029", URGN_TERRITORY, "019" },

128 { "DZ" , 12, "015", URGN_TERRITORY, "002" },

129 { "EA" , -1, "015", URGN_TERRITORY, "002" },

130 { "EC" , 218, "005", URGN_TERRITORY, "019" },

131 { "EE" , 233, "154", URGN_TERRITORY, "150" },

132 { "EG" , 818, "015", URGN_TERRITORY, "002" },

133 { "EH" , 732, "015", URGN_TERRITORY, "002" },

134 { "ER" , 232, "014", URGN_TERRITORY, "002" },

135 { "ES" , 724, "039", URGN_TERRITORY, "150" },

136 { "ET" , 231, "014", URGN_TERRITORY, "002" },

137 { "EU" , 967, NULL, URGN_GROUPING, NULL },

138 { "FI" , 246, "154", URGN_TERRITORY, "150" },

139 { "FJ" , 242, "054", URGN_TERRITORY, "009" },

140 { "FK" , 238, "005", URGN_TERRITORY, "019" },

141 { "FM" , 583, "057", URGN_TERRITORY, "009" },

142 { "FO" , 234, "154", URGN_TERRITORY, "150" },

143 { "FR" , 250, "155", URGN_TERRITORY, "150" },

144 { "FX" , 250, "155", URGN_TERRITORY, "150" },

145 { "GA" , 266, "017", URGN_TERRITORY, "002" },

146 { "GB" , 826, "154", URGN_TERRITORY, "150" },

147 { "GD" , 308, "029", URGN_TERRITORY, "019" },

148 { "GE" , 268, "145", URGN_TERRITORY, "142" },

149 { "GF" , 254, "005", URGN_TERRITORY, "019" },

150 { "GG" , 831, "154", URGN_TERRITORY, "150" },

151 { "GH" , 288, "011", URGN_TERRITORY, "002" },

152 { "GI" , 292, "039", URGN_TERRITORY, "150" },

153 { "GL" , 304, "021", URGN_TERRITORY, "019" },

154 { "GM" , 270, "011", URGN_TERRITORY, "002" },

155 { "GN" , 324, "011", URGN_TERRITORY, "002" },

156 { "GP" , 312, "029", URGN_TERRITORY, "019" },

157 { "GQ" , 226, "017", URGN_TERRITORY, "002" },

158 { "GR" , 300, "039", URGN_TERRITORY, "150" },

159 { "GS" , 239, "QO" , URGN_TERRITORY, "009" },

160 { "GT" , 320, "013", URGN_TERRITORY, "019" },

161 { "GU" , 316, "057", URGN_TERRITORY, "009" },

162 { "GW" , 624, "011", URGN_TERRITORY, "002" },

163 { "GY" , 328, "005", URGN_TERRITORY, "019" },

164 { "HK" , 344, "030", URGN_TERRITORY, "142" },

165 { "HM" , 334, "QO" , URGN_TERRITORY, "009" },

166 { "HN" , 340, "013", URGN_TERRITORY, "019" },

167 { "HR" , 191, "039", URGN_TERRITORY, "150" },

168 { "HT" , 332, "029", URGN_TERRITORY, "019" },

169 { "HU" , 348, "151", URGN_TERRITORY, "150" },

170 { "IC" , -1, "015", URGN_TERRITORY, "002" },

171 { "ID" , 360, "035", URGN_TERRITORY, "142" },

172 { "IE" , 372, "154", URGN_TERRITORY, "150" },

173 { "IL" , 376, "145", URGN_TERRITORY, "142" },

174 { "IM" , 833, "154", URGN_TERRITORY, "150" },

175 { "IN" , 356, "034", URGN_TERRITORY, "142" },

176 { "IO" , 86, "QO" , URGN_TERRITORY, "009" },

177 { "IQ" , 368, "145", URGN_TERRITORY, "142" },

178 { "IR" , 364, "034", URGN_TERRITORY, "142" },

179 { "IS" , 352, "154", URGN_TERRITORY, "150" },

180 { "IT" , 380, "039", URGN_TERRITORY, "150" },

181 { "JE" , 832, "154", URGN_TERRITORY, "150" },

182 { "JM" , 388, "029", URGN_TERRITORY, "019" },

183 { "JO" , 400, "145", URGN_TERRITORY, "142" },

184 { "JP" , 392, "030", URGN_TERRITORY, "142" },

185 { "KE" , 404, "014", URGN_TERRITORY, "002" },

186 { "KG" , 417, "143", URGN_TERRITORY, "142" },

187 { "KH" , 116, "035", URGN_TERRITORY, "142" },

188 { "KI" , 296, "057", URGN_TERRITORY, "009" },

189 { "KM" , 174, "014", URGN_TERRITORY, "002" },

190 { "KN" , 659, "029", URGN_TERRITORY, "019" },

191 { "KP" , 408, "030", URGN_TERRITORY, "142" },

192 { "KR" , 410, "030", URGN_TERRITORY, "142" },

193 { "KW" , 414, "145", URGN_TERRITORY, "142" },

194 { "KY" , 136, "029", URGN_TERRITORY, "019" },

195 { "KZ" , 398, "143", URGN_TERRITORY, "142" },

196 { "LA" , 418, "035", URGN_TERRITORY, "142" },

197 { "LB" , 422, "145", URGN_TERRITORY, "142" },

198 { "LC" , 662, "029", URGN_TERRITORY, "019" },

199 { "LI" , 438, "155", URGN_TERRITORY, "150" },

200 { "LK" , 144, "034", URGN_TERRITORY, "142" },

201 { "LR" , 430, "011", URGN_TERRITORY, "002" },

202 { "LS" , 426, "018", URGN_TERRITORY, "002" },

203 { "LT" , 440, "154", URGN_TERRITORY, "150" },

204 { "LU" , 442, "155", URGN_TERRITORY, "150" },

205 { "LV" , 428, "154", URGN_TERRITORY, "150" },

206 { "LY" , 434, "015", URGN_TERRITORY, "002" },

207 { "MA" , 504, "015", URGN_TERRITORY, "002" },

208 { "MC" , 492, "155", URGN_TERRITORY, "150" },

209 { "MD" , 498, "151", URGN_TERRITORY, "150" },

210 { "ME" , 499, "039", URGN_TERRITORY, "150" },

211 { "MF" , 663, "029", URGN_TERRITORY, "019" },

212 { "MG" , 450, "014", URGN_TERRITORY, "002" },

213 { "MH" , 584, "057", URGN_TERRITORY, "009" },

214 { "MK" , 807, "039", URGN_TERRITORY, "150" },

215 { "ML" , 466, "011", URGN_TERRITORY, "002" },

216 { "MM" , 104, "035", URGN_TERRITORY, "142" },

217 { "MN" , 496, "030", URGN_TERRITORY, "142" },

218 { "MO" , 446, "030", URGN_TERRITORY, "142" },

219 { "MP" , 580, "057", URGN_TERRITORY, "009" },

220 { "MQ" , 474, "029", URGN_TERRITORY, "019" },

221 { "MR" , 478, "011", URGN_TERRITORY, "002" },

222 { "MS" , 500, "029", URGN_TERRITORY, "019" },

223 { "MT" , 470, "039", URGN_TERRITORY, "150" },

224 { "MU" , 480, "014", URGN_TERRITORY, "002" },

225 { "MV" , 462, "034", URGN_TERRITORY, "142" },

226 { "MW" , 454, "014", URGN_TERRITORY, "002" },

227 { "MX" , 484, "013", URGN_TERRITORY, "019"},

228 { "MY" , 458, "035", URGN_TERRITORY, "142" },

229 { "MZ" , 508, "014", URGN_TERRITORY, "002" },

230 { "NA" , 516, "018", URGN_TERRITORY, "002" },

231 { "NC" , 540, "054", URGN_TERRITORY, "009" },

232 { "NE" , 562, "011", URGN_TERRITORY, "002" },

233 { "NF" , 574, "053", URGN_TERRITORY, "009" },

234 { "NG" , 566, "011", URGN_TERRITORY, "002" },

235 { "NI" , 558, "013", URGN_TERRITORY, "019" },

236 { "NL" , 528, "155", URGN_TERRITORY, "150" },

237 { "NO" , 578, "154", URGN_TERRITORY, "150" },

238 { "NP" , 524, "034", URGN_TERRITORY, "142" },

239 { "NR" , 520, "057", URGN_TERRITORY, "009" },

240 { "NT" , 536, NULL , URGN_DEPRECATED, NULL },

241 { "NU" , 570, "061", URGN_TERRITORY, "009" },

242 { "NZ" , 554, "053", URGN_TERRITORY, "009" },

243 { "OM" , 512, "145", URGN_TERRITORY, "142" },

244 { "PA" , 591, "013", URGN_TERRITORY, "019" },

245 { "PE" , 604, "005", URGN_TERRITORY, "019" },

246 { "PF" , 258, "061", URGN_TERRITORY, "009" },

247 { "PG" , 598, "054", URGN_TERRITORY, "009" },

248 { "PH" , 608, "035", URGN_TERRITORY, "142" },

249 { "PK" , 586, "034", URGN_TERRITORY, "142" },

250 { "PL" , 616, "151", URGN_TERRITORY, "150" },

251 { "PM" , 666, "021", URGN_TERRITORY, "019" },

252 { "PN" , 612, "061", URGN_TERRITORY, "009" },

253 { "PR" , 630, "029", URGN_TERRITORY, "019" },

254 { "PS" , 275, "145", URGN_TERRITORY, "142" },

255 { "PT" , 620, "039", URGN_TERRITORY, "150" },

256 { "PW" , 585, "057", URGN_TERRITORY, "009" },

257 { "PY" , 600, "005", URGN_TERRITORY, "019" },

258 { "QA" , 634, "145", URGN_TERRITORY, "142" },

259 { "QO" , 961, "009", URGN_SUBCONTINENT, "009" },

260 { "QU" , 967, NULL, URGN_GROUPING, NULL },

261 { "RE" , 638, "014", URGN_TERRITORY, "002" },

262 { "RO" , 642, "151", URGN_TERRITORY, "150" },

263 { "RS" , 688, "039", URGN_TERRITORY, "150" },

264 { "RU" , 643, "151", URGN_TERRITORY, "150" },

265 { "RW" , 646, "014", URGN_TERRITORY, "002" },

266 { "SA" , 682, "145", URGN_TERRITORY, "142" },

267 { "SB" , 90, "054", URGN_TERRITORY, "009" },

268 { "SC" , 690, "014", URGN_TERRITORY, "002" },

269 { "SD" , 729, "015", URGN_TERRITORY, "002" },

270 { "SE" , 752, "154", URGN_TERRITORY, "150" },

271 { "SG" , 702, "035", URGN_TERRITORY, "142" },

272 { "SH" , 654, "011", URGN_TERRITORY, "002" },

273 { "SI" , 705, "039", URGN_TERRITORY, "150" },

274 { "SJ" , 744, "154", URGN_TERRITORY, "150" },

275 { "SK" , 703, "151", URGN_TERRITORY, "150" },

276 { "SL" , 694, "011", URGN_TERRITORY, "002" },

277 { "SM" , 674, "039", URGN_TERRITORY, "150" },

278 { "SN" , 686, "011", URGN_TERRITORY, "002" },

279 { "SO" , 706, "014", URGN_TERRITORY, "002" },

280 { "SR" , 740, "005", URGN_TERRITORY, "019" },

281 { "SS" , 728, "015", URGN_TERRITORY, "002" },

282 { "ST" , 678, "017", URGN_TERRITORY, "002" },

283 { "SU" , 810, NULL , URGN_DEPRECATED , NULL},

284 { "SV" , 222, "013", URGN_TERRITORY, "019" },

285 { "SX" , 534, "029", URGN_TERRITORY, "019" },

286 { "SY" , 760, "145", URGN_TERRITORY, "142" },

287 { "SZ" , 748, "018", URGN_TERRITORY, "002" },

288 { "TA" , -1, "QO", URGN_TERRITORY, "009" },

289 { "TC" , 796, "029", URGN_TERRITORY, "019" },

290 { "TD" , 148, "017", URGN_TERRITORY, "002" },

291 { "TF" , 260, "QO" , URGN_TERRITORY, "009" },

292 { "TG" , 768, "011", URGN_TERRITORY, "002" },

293 { "TH" , 764, "035", URGN_TERRITORY, "142" },

294 { "TJ" , 762, "143", URGN_TERRITORY, "142" },

295 { "TK" , 772, "061", URGN_TERRITORY, "009" },

296 { "TL" , 626, "035", URGN_TERRITORY, "142" },

297 { "TM" , 795, "143", URGN_TERRITORY, "142" },

298 { "TN" , 788, "015", URGN_TERRITORY, "002" },

299 { "TO" , 776, "061", URGN_TERRITORY, "009" },

300 { "TP" , 626, "035", URGN_TERRITORY, "142" },

301 { "TR" , 792, "145", URGN_TERRITORY, "142" },

302 { "TT" , 780, "029", URGN_TERRITORY, "019" },

303 { "TV" , 798, "061", URGN_TERRITORY, "009" },

304 { "TW" , 158, "030", URGN_TERRITORY, "142" },

305 { "TZ" , 834, "014", URGN_TERRITORY, "002" },

306 { "UA" , 804, "151", URGN_TERRITORY, "150" },

307 { "UG" , 800, "014", URGN_TERRITORY, "002" },

308 { "UM" , 581, "QO" , URGN_TERRITORY, "009" },

309 { "US" , 840, "021", URGN_TERRITORY, "019" },

310 { "UY" , 858, "005", URGN_TERRITORY, "019" },

311 { "UZ" , 860, "143", URGN_TERRITORY, "142" },

312 { "VA" , 336, "039", URGN_TERRITORY, "150" },

313 { "VC" , 670, "029", URGN_TERRITORY, "019" },

314 { "VE" , 862, "005", URGN_TERRITORY, "019" },

315 { "VG" , 92, "029", URGN_TERRITORY, "019" },

316 { "VI" , 850, "029", URGN_TERRITORY, "019" },

317 { "VN" , 704, "035", URGN_TERRITORY, "142" },

318 { "VU" , 548, "054", URGN_TERRITORY, "009" },

319 { "WF" , 876, "061", URGN_TERRITORY, "009" },

320 { "WS" , 882, "061", URGN_TERRITORY, "009" },

321 { "YD" , 887, "145", URGN_TERRITORY, "142" },

322 { "YE" , 887, "145", URGN_TERRITORY, "142" },

323 { "YT" , 175, "014", URGN_TERRITORY, "002" },

324 { "ZA" , 710, "018", URGN_TERRITORY, "002" },

325 { "ZM" , 894, "014", URGN_TERRITORY, "002" },

326 { "ZR" , 180, "017", URGN_TERRITORY, "002" },

327 { "ZW" , 716, "014", URGN_TERRITORY, "002" },

328 { "ZZ" , 999, NULL , URGN_UNKNOWN, NULL }

329 };

330

331 // *****************************************************************************

332 // class RegionTest

333 // *****************************************************************************

334

335

336 RegionTest::RegionTest() {

337 }

338

339 RegionTest::~RegionTest() {

340 }

341

342 void

343 RegionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )

344 {

345 optionv = (par && *par=='v');

346

347 TESTCASE_AUTO_BEGIN;

348 TESTCASE_AUTO(TestKnownRegions);

349 TESTCASE_AUTO(TestGetInstanceString);

350 TESTCASE_AUTO(TestGetInstanceInt);

351 TESTCASE_AUTO(TestGetContainedRegions);

352 TESTCASE_AUTO(TestGetContainedRegionsWithType);

353 TESTCASE_AUTO(TestGetContainingRegion);

354 TESTCASE_AUTO(TestGetContainingRegionWithType);

355 TESTCASE_AUTO(TestGetPreferredValues);

356 TESTCASE_AUTO(TestContains);

357 TESTCASE_AUTO(TestAvailableTerritories);

358 TESTCASE_AUTO(TestNoContainedRegions);

359 TESTCASE_AUTO_END;

360 }

361

362

363 void RegionTest::TestKnownRegions() {

364

365 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

366 KnownRegion rd = knownRegions[i];

367 UErrorCode status = U_ZERO_ERROR;

368 const Region *r = Region::getInstance(rd.code,status);

369 if ( r ) {

370 int32_t n = r->getNumericCode();

371 int32_t e = rd.numeric;

372 if ( n != e ) {

373 errln("Numeric code mismatch for region %s. Expected:%d Got:%d" ,r->getRegionCode(),e,n);

374 }

375

376 if (r->getType() != rd.type) {

377 errln("Expected region %s to be of type %d. Got: %d",r->getRegio nCode(),rd.type,r->getType());

378 }

379

380 int32_t nc = rd.numeric;

381 if ( nc > 0 ) {

382 const Region *ncRegion = Region::getInstance(nc,status);

383 if ( ncRegion != r && nc != 891 ) { // 891 is special case - C S and YU both deprecated codes for region 891

384 errln("Creating region %s by its numeric code returned a dif ferent region. Got: %s instead.",r->getRegionCode(),ncRegion->getRegionCode());

385 }

386 }

387 } else {

388 dataerrln("Known region %s was not recognized.",rd.code);

389 }

390 }

391 }

392

393 void RegionTest::TestGetInstanceString() {

394 typedef struct TestData {

395 const char *inputID;

396 const char *expectedID;

397 URegionType expectedType;

398 } TestData;

399

400 static TestData testData[] = {

401 // Input ID, Expected ID, Expected Type

402 { "DE", "DE", URGN_TERRITORY }, // Normal region

403 { "QU", "EU", URGN_GROUPING }, // Alias to a grouping

404 { "DD", "DE", URGN_TERRITORY }, // Alias to a deprecated region (East G ermany) with single preferred value

405 { "276", "DE", URGN_TERRITORY }, // Numeric code for Germany

406 { "278", "DE", URGN_TERRITORY }, // Numeric code for East Germany (Depre cated)

407 { "SU", "SU", URGN_DEPRECATED }, // Alias to a deprecated region with mu ltiple preferred values

408 { "AN", "AN", URGN_DEPRECATED }, // Deprecated region with multiple pref erred values

409 { "SVK", "SK", URGN_TERRITORY } // 3-letter code - Slovakia

410 };

411

412

413 UErrorCode status = U_ZERO_ERROR;

414 const Region r = Region::getInstance((const char )NULL,status);

415 if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {

416 errcheckln(status, "Calling Region::getInstance(NULL) should have trigge red an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));

417 }

418

419 status = U_ZERO_ERROR;

420 r = Region::getInstance("BOGUS",status);

421 if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {

422 errcheckln(status, "Calling Region::getInstance(\"BOGUS\") should have t riggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));

423 }

424

425

426 for (int32_t i = 0 ; i < UPRV_LENGTHOF(testData) ; i++ ) {

427 TestData data = testData[i];

428 status = U_ZERO_ERROR;

429 r = Region::getInstance(data.inputID,status);

430 const char *id;

431 URegionType type;

432 if ( r ) {

433 id = r->getRegionCode();

434 type = r->getType();

435 } else {

436 id = "NULL";

437 type = URGN_UNKNOWN;

438 }

439 if ( uprv_strcmp(id,data.expectedID)) {

440 dataerrln("Unexpected region ID for Region::getInstance(\"%s\"); Exp ected: %s Got: %s",data.inputID,data.expectedID,id);

441 }

442 if ( type != data.expectedType) {

443 dataerrln("Unexpected region type for Region::getInstance(\"%s\"); E xpected: %d Got: %d",data.inputID,data.expectedType,type);

444 }

445 }

446 }

447

448 void RegionTest::TestGetInstanceInt() {

449 typedef struct TestData {

450 int32_t inputID;

451 const char *expectedID;

452 URegionType expectedType;

453 } TestData;

454

455 static TestData testData[] = {

456 // Input ID, Expected ID, Expected Type

457 { 276, "DE", URGN_TERRITORY }, // Numeric code for Germany

458 { 278, "DE", URGN_TERRITORY }, // Numeric code for East Germany (Deprec ated)

459 { 419, "419", URGN_GROUPING }, // Latin America

460 { 736, "SD", URGN_TERRITORY }, // Sudan (pre-2011) - changed numeric co de after South Sudan split off

461 { 729, "SD", URGN_TERRITORY }, // Sudan (post-2011) - changed numeric c ode after South Sudan split off

462 };

463

464 UErrorCode status = U_ZERO_ERROR;

465 Region::getInstance(-123,status);

466 if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {

467 errcheckln(status, "Calling Region::getInstance(-123) should have trigge red an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));

468 }

469

470 for (int32_t i = 0 ; i < UPRV_LENGTHOF(testData) ; i++ ) {

471 TestData data = testData[i];

472 status = U_ZERO_ERROR;

473 const Region *r = Region::getInstance(data.inputID,status);

474 const char *id;

475 URegionType type;

476 if ( r ) {

477 id = r->getRegionCode();

478 type = r->getType();

479 } else {

480 id = "NULL";

481 type = URGN_UNKNOWN;

482 }

483 if ( uprv_strcmp(data.expectedID,id)) {

484 dataerrln("Unexpected region ID for Region.getInstance(%d)); Expecte d: %s Got: %s",data.inputID,data.expectedID,id);

485 }

486 if ( data.expectedType != type) {

487 dataerrln("Unexpected region type for Region.getInstance(%d)); Expec ted: %d Got: %d",data.inputID,data.expectedType,type);

488 }

489 }

490 }

491

492 void RegionTest::TestGetContainedRegions() {

493 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

494 KnownRegion rd = knownRegions[i];

495 UErrorCode status = U_ZERO_ERROR;

496

497 const Region *r = Region::getInstance(rd.code,status);

498 if (r) {

499 if (r->getType() == URGN_GROUPING) {

500 continue;

501 }

502 StringEnumeration *containedRegions = r->getContainedRegions(status) ;

503 if (U_FAILURE(status)) {

504 errln("%s->getContainedRegions(status) failed: %s", r->getRegionCo de(), u_errorName(status));

505 continue;

506 }

507 for ( int32_t i = 0 ; i < containedRegions->count(status); i++ ) {

508 const char *crID = containedRegions->next(NULL,status);

509 const Region *cr = Region::getInstance(crID,status);

510 const Region *containingRegion = cr ? cr->getContainingRegion() : NULL;

511 if ( !containingRegion \|\| containingRegion != r ) {

512 errln("Region: %s contains region %s. Expected containing re gion of this region to be the original region, but got %s",

513 r->getRegionCode(),cr->getRegionCode(),containingRegion? containingRegion->getRegionCode():"NULL");

514 }

515 }

516 delete containedRegions;

517 } else {

518 dataerrln("Known region %s was not recognized.",rd.code);

519 }

520 }

521 }

522

523 void RegionTest::TestGetContainedRegionsWithType() {

524 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

525 KnownRegion rd = knownRegions[i];

526 UErrorCode status = U_ZERO_ERROR;

527

528 const Region *r = Region::getInstance(rd.code,status);

529 if (r) {

530 if (r->getType() != URGN_CONTINENT) {

531 continue;

532 }

533 StringEnumeration *containedRegions = r->getContainedRegions(URGN_TE RRITORY, status);

534 if (U_FAILURE(status)) {

535 errln("%s->getContainedRegions(URGN_TERRITORY, status) failed: %s" , r->getRegionCode(), u_errorName(status));

536 continue;

537 }

538 for ( int32_t j = 0 ; j < containedRegions->count(status); j++ ) {

539 const char *crID = containedRegions->next(NULL,status);

540 const Region *cr = Region::getInstance(crID,status);

541 const Region *containingRegion = cr ? cr->getContainingRegion(UR GN_CONTINENT) : NULL;

542 if ( !containingRegion \|\| containingRegion != r ) {

543 errln("Continent: %s contains territory %s. Expected contain ing continent of this region to be the original region, but got %s",

544 r->getRegionCode(),cr->getRegionCode(),containingRegion? containingRegion->getRegionCode():"NULL");

545 }

546 }

547 delete containedRegions;

548 } else {

549 dataerrln("Known region %s was not recognized.",rd.code);

550 }

551 }

552 }

553

554 void RegionTest::TestGetContainingRegion() {

555 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

556 KnownRegion rd = knownRegions[i];

557 UErrorCode status = U_ZERO_ERROR;

558 const Region *r = Region::getInstance(rd.code,status);

559 if (r) {

560 const Region *c = r->getContainingRegion();

561 if (rd.parent == NULL) {

562 if ( c ) {

563 errln("Containing region for %s should have been NULL. Got: %s",r->getRegionCode(),c->getRegionCode());

564 }

565 } else {

566 const Region *p = Region::getInstance(rd.parent,status);

567 if ( !c \|\| p != c ) {

568 errln("Expected containing continent of region %s to be %s. Got: %s",

569 r->getRegionCode(),p?p->getRegionCode():"NULL",c?c->getR egionCode():"NULL" );

570 }

571 }

572 } else {

573 dataerrln("Known region %s was not recognized.",rd.code);

574 }

575 }

576 }

577

578 void RegionTest::TestGetContainingRegionWithType() {

579 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

580 KnownRegion rd = knownRegions[i];

581 UErrorCode status = U_ZERO_ERROR;

582

583 const Region *r = Region::getInstance(rd.code,status);

584 if (r) {

585 const Region *c = r->getContainingRegion(URGN_CONTINENT);

586 if (rd.containingContinent == NULL) {

587 if ( c != NULL) {

588 errln("Containing continent for %s should have been NULL. Got: %s",r->getRegionCode(), c->getRegionCode());

589 }

590 } else {

591 const Region *p = Region::getInstance(rd.containingContinent,sta tus);

592 if ( p != c ) {

593 errln("Expected containing continent of region %s to be %s. Got: %s",

594 r->getRegionCode(),p?p->getRegionCode():"NULL",c?c->getR egionCode():"NULL" );

595 }

596 }

597 } else {

598 dataerrln("Known region %s was not recognized.",rd.code);

599 }

600 }

601 }

602

603 void RegionTest::TestGetPreferredValues() {

604 static const char *testData[6][17] = {

605 // Input ID, Expected Preferred Values...

606 { "AN", "CW", "SX", "BQ", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL, NULL }, // Netherlands Antilles

607 { "CS", "RS", "ME", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL, NULL }, // Serbia & Montenegro

608 { "FQ", "AQ", "TF", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL, NULL }, // French Southern and Antarctic Territori es

609 { "NT", "IQ", "SA", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL, NULL }, // Neutral Zone

610 { "PC", "FM", "MH", "MP", "PW", NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL, NULL, }, // Pacific Islands Trust Territory

611 { "SU", "RU", "AM", "AZ", "BY", "EE", "GE", "KZ", "KG", "LV", "LT", "MD" , "TJ", "TM", "UA", "UZ" , NULL}, // Soviet Union

612 };

613

614 for ( int32_t i = 0 ; i < 6 ; i++ ) {

615 const char **data = testData[i];

616 UErrorCode status = U_ZERO_ERROR;

617 const Region *r = Region::getInstance(data[0],status);

618 if (r) {

619 StringEnumeration *preferredValues = r->getPreferredValues(status);

620 if (U_FAILURE(status)) {

621 errln("%s->getPreferredValues(status) failed: %s", r->getRegionCod e(), u_errorName(status));

622 continue;

623 }

624 for ( int i = 1 ; data[i] ; i++ ) {

625 UBool found = FALSE;

626 preferredValues->reset(status);

627 while ( const char *check = preferredValues->next(NULL,status) ) {

628 if ( !uprv_strcmp(check,data[i]) ) {

629 found = TRUE;

630 break;

631 }

632 }

633 if ( !found ) {

634 errln("Region::getPreferredValues() for region \"%s\" should have contained \"%s\" but it didn't.",r->getRegionCode(),data[i]);

635 }

636 }

637 delete preferredValues;

638 } else {

639 dataerrln("Known region %s was not recognized.",data[0]);

640 }

641 }

642 }

643

644 void RegionTest::TestContains() {

645 for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {

646 KnownRegion rd = knownRegions[i];

647 UErrorCode status = U_ZERO_ERROR;

648

649 const Region *r = Region::getInstance(rd.code,status);

650 if (r) {

651 const Region *c = r->getContainingRegion();

652 while ( c ) {

653 if ( !c->contains(*r)) {

654 errln("Region \"%s\" should have contained \"%s\" but it did n't.",c->getRegionCode(),r->getRegionCode());

655 }

656 c = c->getContainingRegion();

657 }

658 } else {

659 dataerrln("Known region %s was not recognized.",rd.code);

660 }

661 }

662 }

663

664 void RegionTest::TestAvailableTerritories() {

665 // Test to make sure that the set of territories contained in World and the set of all available

666 // territories are one and the same.

667 UErrorCode status = U_ZERO_ERROR;

668 StringEnumeration *availableTerritories = Region::getAvailable(URGN_TERRITOR Y, status);

669 if (U_FAILURE(status)) {

670 dataerrln("Region::getAvailable(URGN_TERRITORY,status) failed: %s", u_er rorName(status));

671 return;

672 }

673 const Region *world = Region::getInstance("001",status);

674 if (U_FAILURE(status)) {

675 dataerrln("Region::getInstance(\"001\",status) failed: %s", u_errorName( status));

676 return;

677 }

678 StringEnumeration *containedInWorld = world->getContainedRegions(URGN_TERRIT ORY, status);

679 if (U_FAILURE(status)) {

680 errln("world->getContainedRegions(URGN_TERRITORY, status) failed: %s", u _errorName(status));

681 return;

682 }

683 if ( !availableTerritories \|\| !containedInWorld \|\| availableTerritories != containedInWorld ) {

684 char availableTerritoriesString[1024] = "";

685 char containedInWorldString[1024] = "";

686 if ( availableTerritories ) {

687 for (int32_t i = 0 ; i < availableTerritories->count(status) ; i++ ) {

688 if ( i > 0 ) {

689 uprv_strcat(availableTerritoriesString," ");

690 }

691 uprv_strcat(availableTerritoriesString,availableTerritories->nex t(NULL,status));

692 }

693 } else {

694 uprv_strcpy(availableTerritoriesString,"NULL");

695 }

696 if ( containedInWorld ) {

697 for (int32_t i = 0 ; i < containedInWorld->count(status) ; i++ ) {

698 if ( i > 0 ) {

699 uprv_strcat(containedInWorldString," ");

700 }

701 uprv_strcat(containedInWorldString,containedInWorld->next(NULL,s tatus));

702 }

703 } else {

704 uprv_strcpy(containedInWorldString,"NULL");

705 }

706 errln("Available territories and all territories contained in world shou ld be the same set.\nAvailable = %s\nContained in World = %s",

707 availableTerritoriesString,containedInWorldString);

708 }

709 delete availableTerritories;

710 delete containedInWorld;

711 }

712

713 void RegionTest::TestNoContainedRegions(void) {

714 UErrorCode status = U_ZERO_ERROR;

715 const Region *region = Region::getInstance("BM",status);

716 if (U_FAILURE(status) \|\| region == NULL) {

717 dataerrln("Fail called to Region::getInstance(\"BM\", status) - %s", u_err orName(status));

718 return;

719 }

720 StringEnumeration *containedRegions = region->getContainedRegions(status);

721 if (U_FAILURE(status)) {

722 errln("%s->getContainedRegions(status) failed: %s", region->getRegionCode( ), u_errorName(status));

723 return;

724 }

725 const char *emptyStr = containedRegions->next(NULL, status);

726 if (U_FAILURE(status)\|\|(emptyStr!=NULL)) {

727 errln("Error, 'BM' should have no subregions, but returned str=%p, err=%s\n" , emptyStr, u_errorName(status));

728 } else {

729 logln("Success - BM has no subregions\n");

730 }

731 delete containedRegions;

732 }

733

734 #endif /* #if !UCONFIG_NO_FORMATTING */

735

736 //eof

OLD	NEW

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