| /* |
| ********************************************************************** |
| * Copyright (c) 2002-2003, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| ********************************************************************** |
| */ |
| /** |
| * This Program tests the performance of ICU's Normalization engine against Windows |
| * to run it use the command like |
| * |
| * c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8 -l |
| */ |
| #include "normperf.h" |
| |
| #define LENGTHOF(array) (sizeof(array)/sizeof((array)[0])) |
| |
| UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) { |
| switch (index) { |
| TESTCASE(0,TestICU_NFC_NFD_Text); |
| TESTCASE(1,TestICU_NFC_NFC_Text); |
| TESTCASE(2,TestICU_NFC_Orig_Text); |
| |
| TESTCASE(3,TestICU_NFD_NFD_Text); |
| TESTCASE(4,TestICU_NFD_NFC_Text); |
| TESTCASE(5,TestICU_NFD_Orig_Text); |
| |
| TESTCASE(6,TestICU_FCD_NFD_Text); |
| TESTCASE(7,TestICU_FCD_NFC_Text); |
| TESTCASE(8,TestICU_FCD_Orig_Text); |
| |
| TESTCASE(9,TestWin_NFC_NFD_Text); |
| TESTCASE(10,TestWin_NFC_NFC_Text); |
| TESTCASE(11,TestWin_NFC_Orig_Text); |
| |
| TESTCASE(12,TestWin_NFD_NFD_Text); |
| TESTCASE(13,TestWin_NFD_NFC_Text); |
| TESTCASE(14,TestWin_NFD_Orig_Text); |
| |
| TESTCASE(15,TestQC_NFC_NFD_Text); |
| TESTCASE(16,TestQC_NFC_NFC_Text); |
| TESTCASE(17,TestQC_NFC_Orig_Text); |
| |
| TESTCASE(18,TestQC_NFD_NFD_Text); |
| TESTCASE(19,TestQC_NFD_NFC_Text); |
| TESTCASE(20,TestQC_NFD_Orig_Text); |
| |
| TESTCASE(21,TestQC_FCD_NFD_Text); |
| TESTCASE(22,TestQC_FCD_NFC_Text); |
| TESTCASE(23,TestQC_FCD_Orig_Text); |
| |
| TESTCASE(24,TestIsNormalized_NFC_NFD_Text); |
| TESTCASE(25,TestIsNormalized_NFC_NFC_Text); |
| TESTCASE(26,TestIsNormalized_NFC_Orig_Text); |
| |
| TESTCASE(27,TestIsNormalized_NFD_NFD_Text); |
| TESTCASE(28,TestIsNormalized_NFD_NFC_Text); |
| TESTCASE(29,TestIsNormalized_NFD_Orig_Text); |
| |
| TESTCASE(30,TestIsNormalized_FCD_NFD_Text); |
| TESTCASE(31,TestIsNormalized_FCD_NFC_Text); |
| TESTCASE(32,TestIsNormalized_FCD_Orig_Text); |
| |
| default: |
| name = ""; |
| return NULL; |
| } |
| return NULL; |
| |
| } |
| |
| void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ |
| int32_t reqLen = 0; |
| UErrorCode status = U_ZERO_ERROR; |
| for(;;){ |
| /* pure pre-flight */ |
| reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); |
| if(status==U_BUFFER_OVERFLOW_ERROR){ |
| status=U_ZERO_ERROR; |
| dest->name = new UChar[reqLen+1]; |
| reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status); |
| dest->len=reqLen; |
| break; |
| }else if(U_FAILURE(status)){ |
| printf("Could not normalize input. Error: %s", u_errorName(status)); |
| } |
| } |
| } |
| UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ |
| int32_t reqLen = 0; |
| UErrorCode status = U_ZERO_ERROR; |
| UChar* dest = NULL; |
| for(;;){ |
| /* pure pre-flight */ |
| reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); |
| if(status==U_BUFFER_OVERFLOW_ERROR){ |
| status=U_ZERO_ERROR; |
| dest = new UChar[reqLen+1]; |
| reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status); |
| len=reqLen; |
| break; |
| }else if(U_FAILURE(status)){ |
| printf("Could not normalize input. Error: %s", u_errorName(status)); |
| return NULL; |
| } |
| } |
| return dest; |
| } |
| |
| static UOption cmdLineOptions[]={ |
| UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG) |
| }; |
| |
| NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status) |
| : UPerfTest(argc,argv,status), options(0) { |
| NFDBuffer = NULL; |
| NFCBuffer = NULL; |
| NFDBufferLen = 0; |
| NFCBufferLen = 0; |
| NFDFileLines = NULL; |
| NFCFileLines = NULL; |
| |
| if(status== U_ILLEGAL_ARGUMENT_ERROR){ |
| fprintf(stderr,gUsageString, "normperf"); |
| return; |
| } |
| |
| if(U_FAILURE(status)){ |
| fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status)); |
| return; |
| } |
| |
| _remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, (int32_t)(LENGTHOF(cmdLineOptions)), cmdLineOptions); |
| if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) { |
| options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16); |
| } |
| |
| if(line_mode){ |
| ULine* filelines = getLines(status); |
| if(U_FAILURE(status)){ |
| fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status)); |
| return; |
| } |
| NFDFileLines = new ULine[numLines]; |
| NFCFileLines = new ULine[numLines]; |
| |
| for(int32_t i=0;i<numLines;i++){ |
| normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options); |
| normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options); |
| |
| } |
| }else if(bulk_mode){ |
| int32_t srcLen = 0; |
| const UChar* src = getBuffer(srcLen,status); |
| NFDBufferLen = 0; |
| NFCBufferLen = 0; |
| |
| if(U_FAILURE(status)){ |
| fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status)); |
| return; |
| } |
| |
| NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options); |
| NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options); |
| } |
| |
| } |
| |
| NormalizerPerformanceTest::~NormalizerPerformanceTest(){ |
| delete[] NFDFileLines; |
| delete[] NFCFileLines; |
| delete[] NFDBuffer; |
| delete[] NFCBuffer; |
| } |
| |
| // Test NFC Performance |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen); |
| return func; |
| } |
| } |
| |
| // Test NFD Performance |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen); |
| return func; |
| } |
| } |
| |
| // Test FCD Performance |
| UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen); |
| return func; |
| } |
| |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen); |
| return func; |
| } |
| } |
| |
| // Test Win NFC Performance |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen); |
| return func; |
| } |
| } |
| |
| // Test Win NFD Performance |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){ |
| if(line_mode){ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen); |
| return func; |
| }else{ |
| NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen); |
| return func; |
| } |
| } |
| |
| // Test Quick Check Performance |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| |
| UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| |
| // Test isNormalized Performance |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen); |
| return func; |
| } |
| } |
| |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen); |
| return func; |
| } |
| } |
| |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){ |
| if(line_mode){ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen); |
| return func; |
| }else{ |
| QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen); |
| return func; |
| } |
| } |
| |
| int main(int argc, const char* argv[]){ |
| UErrorCode status = U_ZERO_ERROR; |
| NormalizerPerformanceTest test(argc, argv, status); |
| if(U_FAILURE(status)){ |
| return status; |
| } |
| if(test.run()==FALSE){ |
| fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n"); |
| return -1; |
| } |
| return 0; |
| } |
