1 /* 2 ********************************************************************** 3 * Copyright (c) 2002-2014, International Business Machines 4 * Corporation and others. All Rights Reserved. 5 ********************************************************************** 6 ********************************************************************** 7 */ 8 /** 9 * This Program tests the performance of ICU's Normalization engine against Windows 10 * to run it use the command like 11 * 12 * c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8 -l 13 */ 14 #include "normperf.h" 15 #include "uoptions.h" 16 #include "cmemory.h" // for UPRV_LENGTHOF 17 #include <stdio.h> 18 19 UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) { 20 switch (index) { 21 TESTCASE(0,TestICU_NFC_NFD_Text); 22 TESTCASE(1,TestICU_NFC_NFC_Text); 23 TESTCASE(2,TestICU_NFC_Orig_Text); 24 25 TESTCASE(3,TestICU_NFD_NFD_Text); 26 TESTCASE(4,TestICU_NFD_NFC_Text); 27 TESTCASE(5,TestICU_NFD_Orig_Text); 28 29 TESTCASE(6,TestICU_FCD_NFD_Text); 30 TESTCASE(7,TestICU_FCD_NFC_Text); 31 TESTCASE(8,TestICU_FCD_Orig_Text); 32 33 TESTCASE(9,TestWin_NFC_NFD_Text); 34 TESTCASE(10,TestWin_NFC_NFC_Text); 35 TESTCASE(11,TestWin_NFC_Orig_Text); 36 37 TESTCASE(12,TestWin_NFD_NFD_Text); 38 TESTCASE(13,TestWin_NFD_NFC_Text); 39 TESTCASE(14,TestWin_NFD_Orig_Text); 40 41 TESTCASE(15,TestQC_NFC_NFD_Text); 42 TESTCASE(16,TestQC_NFC_NFC_Text); 43 TESTCASE(17,TestQC_NFC_Orig_Text); 44 45 TESTCASE(18,TestQC_NFD_NFD_Text); 46 TESTCASE(19,TestQC_NFD_NFC_Text); 47 TESTCASE(20,TestQC_NFD_Orig_Text); 48 49 TESTCASE(21,TestQC_FCD_NFD_Text); 50 TESTCASE(22,TestQC_FCD_NFC_Text); 51 TESTCASE(23,TestQC_FCD_Orig_Text); 52 53 TESTCASE(24,TestIsNormalized_NFC_NFD_Text); 54 TESTCASE(25,TestIsNormalized_NFC_NFC_Text); 55 TESTCASE(26,TestIsNormalized_NFC_Orig_Text); 56 57 TESTCASE(27,TestIsNormalized_NFD_NFD_Text); 58 TESTCASE(28,TestIsNormalized_NFD_NFC_Text); 59 TESTCASE(29,TestIsNormalized_NFD_Orig_Text); 60 61 TESTCASE(30,TestIsNormalized_FCD_NFD_Text); 62 TESTCASE(31,TestIsNormalized_FCD_NFC_Text); 63 TESTCASE(32,TestIsNormalized_FCD_Orig_Text); 64 65 default: 66 name = ""; 67 return NULL; 68 } 69 return NULL; 70 71 } 72 73 void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ 74 int32_t reqLen = 0; 75 UErrorCode status = U_ZERO_ERROR; 76 for(;;){ 77 /* pure pre-flight */ 78 reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); 79 if(status==U_BUFFER_OVERFLOW_ERROR){ 80 status=U_ZERO_ERROR; 81 dest->name = new UChar[reqLen+1]; 82 reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status); 83 dest->len=reqLen; 84 break; 85 }else if(U_FAILURE(status)){ 86 printf("Could not normalize input. Error: %s", u_errorName(status)); 87 } 88 } 89 } 90 UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ 91 int32_t reqLen = 0; 92 UErrorCode status = U_ZERO_ERROR; 93 UChar* dest = NULL; 94 for(;;){ 95 /* pure pre-flight */ 96 reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); 97 if(status==U_BUFFER_OVERFLOW_ERROR){ 98 status=U_ZERO_ERROR; 99 dest = new UChar[reqLen+1]; 100 reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status); 101 len=reqLen; 102 break; 103 }else if(U_FAILURE(status)){ 104 printf("Could not normalize input. Error: %s", u_errorName(status)); 105 return NULL; 106 } 107 } 108 return dest; 109 } 110 111 static UOption cmdLineOptions[]={ 112 UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG) 113 }; 114 115 NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status) 116 : UPerfTest(argc,argv,status), options(0) { 117 NFDBuffer = NULL; 118 NFCBuffer = NULL; 119 NFDBufferLen = 0; 120 NFCBufferLen = 0; 121 NFDFileLines = NULL; 122 NFCFileLines = NULL; 123 124 if(status== U_ILLEGAL_ARGUMENT_ERROR){ 125 fprintf(stderr,gUsageString, "normperf"); 126 return; 127 } 128 129 if(U_FAILURE(status)){ 130 fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status)); 131 return; 132 } 133 134 _remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, (int32_t)(UPRV_LENGTHOF(cmdLineOptions)), cmdLineOptions); 135 if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) { 136 options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16); 137 } 138 139 if(line_mode){ 140 ULine* filelines = getLines(status); 141 if(U_FAILURE(status)){ 142 fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status)); 143 return; 144 } 145 NFDFileLines = new ULine[numLines]; 146 NFCFileLines = new ULine[numLines]; 147 148 for(int32_t i=0;i<numLines;i++){ 149 normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options); 150 normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options); 151 152 } 153 }else if(bulk_mode){ 154 int32_t srcLen = 0; 155 const UChar* src = getBuffer(srcLen,status); 156 NFDBufferLen = 0; 157 NFCBufferLen = 0; 158 159 if(U_FAILURE(status)){ 160 fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status)); 161 return; 162 } 163 164 NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options); 165 NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options); 166 } 167 168 } 169 170 NormalizerPerformanceTest::~NormalizerPerformanceTest(){ 171 delete[] NFDFileLines; 172 delete[] NFCFileLines; 173 delete[] NFDBuffer; 174 delete[] NFCBuffer; 175 } 176 177 // Test NFC Performance 178 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){ 179 if(line_mode){ 180 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen); 181 return func; 182 }else{ 183 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen); 184 return func; 185 } 186 } 187 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){ 188 if(line_mode){ 189 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen); 190 return func; 191 }else{ 192 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen); 193 return func; 194 } 195 } 196 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){ 197 if(line_mode){ 198 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen); 199 return func; 200 }else{ 201 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen); 202 return func; 203 } 204 } 205 206 // Test NFD Performance 207 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){ 208 if(line_mode){ 209 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen); 210 return func; 211 }else{ 212 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen); 213 return func; 214 } 215 } 216 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){ 217 if(line_mode){ 218 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen); 219 return func; 220 }else{ 221 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen); 222 return func; 223 } 224 } 225 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){ 226 if(line_mode){ 227 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen); 228 return func; 229 }else{ 230 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen); 231 return func; 232 } 233 } 234 235 // Test FCD Performance 236 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){ 237 if(line_mode){ 238 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen); 239 return func; 240 }else{ 241 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen); 242 return func; 243 } 244 245 } 246 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){ 247 if(line_mode){ 248 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen); 249 return func; 250 }else{ 251 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen); 252 return func; 253 } 254 } 255 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){ 256 if(line_mode){ 257 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen); 258 return func; 259 }else{ 260 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen); 261 return func; 262 } 263 } 264 265 // Test Win NFC Performance 266 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){ 267 if(line_mode){ 268 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen); 269 return func; 270 }else{ 271 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen); 272 return func; 273 } 274 } 275 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){ 276 if(line_mode){ 277 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen); 278 return func; 279 }else{ 280 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen); 281 return func; 282 } 283 } 284 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){ 285 if(line_mode){ 286 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen); 287 return func; 288 }else{ 289 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen); 290 return func; 291 } 292 } 293 294 // Test Win NFD Performance 295 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){ 296 if(line_mode){ 297 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen); 298 return func; 299 }else{ 300 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen); 301 return func; 302 } 303 } 304 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){ 305 if(line_mode){ 306 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen); 307 return func; 308 }else{ 309 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen); 310 return func; 311 } 312 } 313 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){ 314 if(line_mode){ 315 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen); 316 return func; 317 }else{ 318 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen); 319 return func; 320 } 321 } 322 323 // Test Quick Check Performance 324 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){ 325 if(line_mode){ 326 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen); 327 return func; 328 }else{ 329 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); 330 return func; 331 } 332 } 333 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){ 334 if(line_mode){ 335 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen); 336 return func; 337 }else{ 338 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); 339 return func; 340 } 341 } 342 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){ 343 if(line_mode){ 344 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen); 345 return func; 346 }else{ 347 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen); 348 return func; 349 } 350 } 351 352 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){ 353 if(line_mode){ 354 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen); 355 return func; 356 }else{ 357 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); 358 return func; 359 } 360 } 361 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){ 362 if(line_mode){ 363 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen); 364 return func; 365 }else{ 366 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); 367 return func; 368 } 369 } 370 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){ 371 if(line_mode){ 372 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen); 373 return func; 374 }else{ 375 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen); 376 return func; 377 } 378 } 379 380 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){ 381 if(line_mode){ 382 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen); 383 return func; 384 }else{ 385 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); 386 return func; 387 } 388 } 389 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){ 390 if(line_mode){ 391 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen); 392 return func; 393 }else{ 394 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); 395 return func; 396 } 397 } 398 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){ 399 if(line_mode){ 400 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen); 401 return func; 402 }else{ 403 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen); 404 return func; 405 } 406 } 407 408 // Test isNormalized Performance 409 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){ 410 if(line_mode){ 411 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen); 412 return func; 413 }else{ 414 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); 415 return func; 416 } 417 } 418 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){ 419 if(line_mode){ 420 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen); 421 return func; 422 }else{ 423 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); 424 return func; 425 } 426 } 427 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){ 428 if(line_mode){ 429 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen); 430 return func; 431 }else{ 432 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen); 433 return func; 434 } 435 } 436 437 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){ 438 if(line_mode){ 439 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen); 440 return func; 441 }else{ 442 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); 443 return func; 444 } 445 } 446 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){ 447 if(line_mode){ 448 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen); 449 return func; 450 }else{ 451 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); 452 return func; 453 } 454 } 455 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){ 456 if(line_mode){ 457 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen); 458 return func; 459 }else{ 460 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen); 461 return func; 462 } 463 } 464 465 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){ 466 if(line_mode){ 467 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen); 468 return func; 469 }else{ 470 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); 471 return func; 472 } 473 } 474 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){ 475 if(line_mode){ 476 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen); 477 return func; 478 }else{ 479 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); 480 return func; 481 } 482 } 483 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){ 484 if(line_mode){ 485 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen); 486 return func; 487 }else{ 488 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen); 489 return func; 490 } 491 } 492 493 int main(int argc, const char* argv[]){ 494 UErrorCode status = U_ZERO_ERROR; 495 NormalizerPerformanceTest test(argc, argv, status); 496 if(U_FAILURE(status)){ 497 return status; 498 } 499 if(test.run()==FALSE){ 500 fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n"); 501 return -1; 502 } 503 return 0; 504 } 505
