react-native-update 10.34.6 → 10.34.8

package/harmony/pushy/src/main/cpp/HDiffPatch/test/_private_searchBestParams.cpp

@@ -1,301 +0,0 @@
-//_private_searchBestParams.cpp
-// tool for HDiff
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2012-2017 HouSisong
- 
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following
- conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.
-*/
-#include <iostream>
-#include <fstream>
-#include <string>
-#include <vector>
-#include <sstream>
-#include "assert.h"
-#include <vector>
-#include <math.h> //pow
-#include <string.h>
-#include <stdlib.h>
-#include "../libHDiffPatch/HDiff/diff.h"
-#include "../libHDiffPatch/HPatch/patch.h"
-#include "../libHDiffPatch/HDiff/private_diff/suffix_string.h"
-
-typedef unsigned char   TByte;
-typedef unsigned int    TUInt32;
-typedef ptrdiff_t       TInt;
-
-void readFile(std::vector<TByte>& data,const char* fileName){
-    std::ifstream file(fileName, std::ios::in | std::ios::binary | std::ios::ate);
-    std::streampos file_length=file.tellg();
-    file.seekg(0,std::ios::beg);
-    size_t needRead=(size_t)file_length;
-    if ((file_length<0)||((std::streamsize)needRead!=(std::streamsize)file_length)) {
-        file.close();
-        std::cout<<"open read file \""<<fileName<<"\" ERROR!\n";
-        exit(1);
-    }
-    data.resize(needRead);
-    file.read((char*)data.data(), needRead);
-    std::streamsize readed=file.gcount();
-    file.close();
-    if ((std::streamsize)needRead!=readed){
-        std::cout<<"read file \""<<fileName<<"\" ERROR!\n";
-        exit(1);
-    }
-}
-
-void writeFile(const std::vector<TByte>& data,const char* fileName){
-    std::ofstream file(fileName, std::ios::out | std::ios::binary | std::ios::trunc);
-    file.write((const char*)data.data(), data.size());
-    file.close();
-}
-
-#define IS_NOTICE_compress_canceled 0 //for test, close compress fail notice
-#define IS_REUSE_compress_handle    1 //for test, must in single thread
-
-//===== select compress plugin =====
-#define _CompressPlugin_no
-#define _CompressPlugin_zlib
-#define _CompressPlugin_bz2
-#define _CompressPlugin_lzma
-
-#include "../compress_plugin_demo.h"
-#include "../decompress_plugin_demo.h"
-
-struct THDiffPrivateParams{
-    int out0;
-    int out1;
-    std::string asString()const{
-        std::stringstream str;
-        str<<out0;str<<',';
-        str<<out1;
-        return str.str();
-    }
-};
-
-struct TDiffInfo{
-    hdiff_private::TSuffixString sstring;
-    std::vector<TByte>  oldData;
-    std::vector<TByte>  newData;
-    std::string         oldFileName;
-    size_t              oldFileSize;
-    std::string         newFileName;
-    size_t              newFileSize;
-    THDiffPrivateParams kP;
-    size_t              diffSize;
-    size_t              zipSize;
-    size_t              bz2Size;
-    size_t              lzmaSize;
-    std::string asString()const{
-        std::stringstream str;
-        
-        //str<<getFileName(oldFileName); str<<'\t';
-        //str<<getFileName(newFileName); str<<'\t';
-        //str<<oldFileSize; str<<'\t';
-        //str<<newFileSize; str<<'\t';
-        str<<kP.asString(); str<<'\t';
-        str<<diffSize; str<<'\t';
-        str<<zipSize; str<<'\t';
-        str<<bz2Size; str<<'\t';
-        str<<lzmaSize;
-        
-        return str.str();
-    }
-    std::string getFileName(const std::string& fullFileName)const{
-        size_t pos=fullFileName.find_last_of('/');
-        if (pos==std::string::npos)
-            return fullFileName;
-        else
-            return fullFileName.c_str()+pos+1;
-    }
-};
-
-static size_t _compress_diff(const TDiffInfo& di,const hdiff_TCompress* compressPlugin,
-                             hpatch_TDecompress* decompressPlugin){
-    extern void __hdiff_private__create_compressed_diff(const TByte* newData,const TByte* newData_end,
-                                                        const TByte* oldData,const TByte* oldData_end,
-                                                        std::vector<TByte>& out_diff,
-                                                        const hdiff_TCompress* compressPlugin,
-                                                        int kMinSingleMatchScore,
-                                                        const hdiff_private::TSuffixString* sstring);
-    std::vector<TByte> diffData;
-    const TByte* newData0=di.newData.data();
-    const TByte* oldData0=di.oldData.data();
-    __hdiff_private__create_compressed_diff(newData0,newData0+di.newData.size(),
-                                             oldData0,oldData0+di.oldData.size(),diffData,
-                                             compressPlugin,di.kP.out0,&di.sstring);
-    /*
-    if (!check_compressed_diff(newData0,newData0+di.newData.size(),
-                               oldData0,oldData0+di.oldData.size(),
-                               diffData.data(),diffData.data()+diffData.size(),
-                               decompressPlugin)){
-        std::cout<<"\ncheck hdiffz data error!!!\n";
-        exit(1);
-    }//*/
-    return diffData.size();
-}
-
-void doDiff(TDiffInfo& di){
-    if (di.sstring.SASize()==0){
-        readFile(di.oldData,di.oldFileName.c_str());
-        readFile(di.newData,di.newFileName.c_str());
-        di.oldFileSize=di.oldData.size();
-        di.newFileSize=di.newData.size();
-        const TByte* oldData0=di.oldData.data();
-        di.sstring.resetSuffixString(oldData0,oldData0+di.oldData.size());
-    }
-    
-    di.diffSize=_compress_diff(di,0,0);
-    di.zipSize=_compress_diff(di,&zlibCompressPlugin.base,&zlibDecompressPlugin);
-    di.bz2Size=_compress_diff(di,&bz2CompressPlugin.base,&bz2DecompressPlugin);
-    di.lzmaSize=_compress_diff(di,&lzmaCompressPlugin.base,&lzmaDecompressPlugin);
-}
-
-static std::string rToStr(double R){
-    char buf[256];
-    sprintf(buf,"%0.6f",R);
-    return buf;
-}
-
-static std::string rToTag(double cur,double& best){
-    if (cur<best){
-        best=cur;
-        return "*";
-    }else if (cur==best){
-        return "-";
-    }else{
-        return " ";
-    }
-}
-
-void getBestHDiffPrivateParams(const std::vector<std::string>& fileNames){
-    const int kDoCount=(int)fileNames.size()/2;
-    std::vector<TDiffInfo> DiList(kDoCount);
-    for (int doi=0; doi<kDoCount; ++doi) {
-        TDiffInfo& curDi=DiList[doi];
-        curDi.oldFileName=fileNames[doi*2+0];
-        curDi.newFileName=fileNames[doi*2+1];
-    }
-    
-    double bestDiffR=1e308;
-    double bestZipDiffR=1e308;
-    double bestBz2DiffR=1e308;
-    double bestLzmaDiffR=1e308;
-    double bestCompressDiffR=1e308;
-    bool isOutSrcSize=false;
-    
-    int kMinSingleMatchScore;
-    for (kMinSingleMatchScore=8; kMinSingleMatchScore>=0; kMinSingleMatchScore--){{
-        THDiffPrivateParams kP={kMinSingleMatchScore,0};
-        
-        double sumDiffR=1;
-        double sumZipDiffR=1;
-        double sumBz2DiffR=1;
-        double sumLzmaDiffR=1;
-        size_t sumOldSize=0;
-        size_t sumNewSize=0;
-        size_t sumDiffSize=0;
-        size_t sumZipDiffSize=0;
-        size_t sumBz2DiffSize=0;
-        size_t sumLzmaDiffSize=0;
-        for (size_t doi=0; doi<DiList.size(); ++doi) {
-            TDiffInfo& curDi=DiList[doi];
-            curDi.kP=kP;
-            
-            doDiff(curDi);
-            double curDiffRi=curDi.diffSize*1.0/curDi.newFileSize;
-            double curZipDiffRi=curDi.zipSize*1.0/curDi.newFileSize;
-            double curBz2DiffRi=curDi.bz2Size*1.0/curDi.newFileSize;
-            double curLzmaDiffRi=curDi.lzmaSize*1.0/curDi.newFileSize;
-            sumDiffR*=curDiffRi;
-            sumZipDiffR*=curZipDiffRi;
-            sumBz2DiffR*=curBz2DiffRi;
-            sumLzmaDiffR*=curLzmaDiffRi;
-            sumNewSize+=curDi.newFileSize;
-            sumOldSize+=curDi.oldFileSize;
-            sumDiffSize+=curDi.diffSize;
-            sumZipDiffSize+=curDi.zipSize;
-            sumBz2DiffSize+=curDi.bz2Size;
-            sumLzmaDiffSize+=curDi.lzmaSize;
-            //std::cout<<curDi.asString()<<"\t"<<curDiffRi<<"\n";
-        }
-        
-        const double curDiffR=pow(sumDiffR,1.0/kDoCount);
-        const double curZipDiffR=pow(sumZipDiffR,1.0/kDoCount);
-        const double curBz2DiffR=pow(sumBz2DiffR,1.0/kDoCount);
-        const double curLzmaDiffR=pow(sumLzmaDiffR,1.0/kDoCount);
-        const double curCompressDiffR=(curZipDiffR*1+curBz2DiffR*1+curLzmaDiffR*1)/(1+1+1);
-        {
-            TDiffInfo curDi;
-            curDi.oldFileName="";
-            curDi.newFileName="";
-            curDi.kP=kP;
-            curDi.oldFileSize=sumOldSize;
-            curDi.newFileSize=sumNewSize;
-            curDi.diffSize=sumDiffSize;
-            curDi.zipSize=sumZipDiffSize;
-            curDi.bz2Size=sumBz2DiffSize;
-            curDi.lzmaSize=sumLzmaDiffSize;
-            
-            std:: string tag="";
-            tag+=rToTag(curDiffR,bestDiffR);
-            tag+=rToTag(curZipDiffR,bestZipDiffR);
-            tag+=rToTag(curBz2DiffR,bestBz2DiffR);
-            tag+=rToTag(curLzmaDiffR,bestLzmaDiffR);
-            tag+="| "+rToTag(curCompressDiffR,bestCompressDiffR);
-            if (!isOutSrcSize){
-                isOutSrcSize=true;
-                std::cout<<"null zlab bz2 lzma "<<"\t";
-                std::cout<<"diff( "<<curDi.oldFileSize<<", ";
-                std::cout<<curDi.newFileSize<<")\n";
-            }
-            std::cout<<tag<<"\t";
-            std::cout<<curDi.asString()<<"\t"
-                     <<rToStr(curDiffR)<<"\t"
-                     <<rToStr(curZipDiffR)<<"\t"
-                     <<rToStr(curBz2DiffR)<<"\t"
-                     <<rToStr(curLzmaDiffR);
-            
-            std::cout<<"\n";
-        }
-    }}
-}
-
-
-int main(int argc, const char * argv[]){
-    if ((argc<3)||((argc-1)%2!=0)) {
-        throw argc;
-    }
-    std::vector<std::string> fileNames;
-    for (int i=1; i<argc; ++i) {
-        std::cout<<argv[i]<<"\n";
-        fileNames.push_back(argv[i]);
-    }
-
-    getBestHDiffPrivateParams(fileNames);
-    
-    std::cout<<"\nok!\n";
-    return 0;
-}
-
-

package/harmony/pushy/src/main/cpp/HDiffPatch/test/hpatchz_test.cpp

@@ -1,292 +0,0 @@
-//  hpatchz_test.cpp
-//  Created by housisong on 2021/02/04.
-/*
- The MIT License (MIT)
- Copyright (c) 2012-2021 HouSisong
- 
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following
- conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.
-*/
-#include <stdio.h>
-#include <iostream>
-#include <string.h>
-#include <string>
-#include <fstream>
-#include <math.h>
-#include <vector>
-#include <algorithm>
-#include <stdio.h>
-#include <assert.h>
-#include <sstream>
-#define  _IS_NEED_MAIN 0
-#define  _IS_NEED_PRINT_LOG 0
-#define  _IS_NEED_ORIGINAL 0
-#include "../hpatchz.c"
-
-bool        is_attack =true;
-size_t      kLoopCount = 1000;
-const bool  is_log_attack_tag=true;
-size_t      cache_size_memory=0;
-int     error_count=0;
-size_t  test_i=0;
-size_t  caseNum=0;
-
-
-const size_t kMaxSize=400*1024*1024;
-
-template<class T> inline static
-std::string _to_string(const T& v){
-    std::ostringstream os;
-    os<<v;
-    return os.str();
-}
-
-#define tcheck(v) { if (!(v)) { assert(false); throw "error!"; } }
-
-void readFile(std::vector<TByte>& data,const char* fileName){
-    bool _isInClear=false;
-    int result=0;
-    const size_t kStepSize =1024*256;
-    size_t  readPos=0;
-    size_t  fileSize;
-    hpatch_TFileStreamInput    fStream;
-    hpatch_TFileStreamInput_init(&fStream);
-
-    check(hpatch_TFileStreamInput_open(&fStream,fileName),-1,"open file");
-    fileSize=(size_t)fStream.base.streamSize;
-    check(fileSize==fStream.base.streamSize,-1,"file size");
-    try{
-        data.resize(fileSize);
-    }catch(...){
-        check(false,-1,"memory alloc");
-    }
-    while (readPos<fileSize){
-        size_t readLen=kStepSize;
-        if (readPos+readLen>fileSize)
-            readLen=fileSize-readPos;
-        check(fStream.base.read(&fStream.base,readPos,data.data()+readPos,
-                                data.data()+readPos+readLen),-1,"read file data");
-        readPos+=readLen;
-    }
-clear:
-    _isInClear=true;
-    check(hpatch_TFileStreamInput_close(&fStream),-1,"close file");
-    if (0!=result)
-        throw result;
-}
-
-
-hpatch_BOOL _hpatchz(const hpatch_TStreamOutput* _out_newData,
-                     const hpatch_TStreamInput*  oldData,
-                     const hpatch_TStreamInput*  compressedDiff,
-                    TByte* temp_cache,TByte* temp_cache_end){
-    hpatch_TStreamOutput out_newData=*_out_newData;
-    hpatch_TDecompress* decompressPlugin=0;
-    hpatch_compressedDiffInfo diffInfo;
-    if (!getCompressedDiffInfo(&diffInfo,compressedDiff))
-        return hpatch_FALSE;
-    if (oldData->streamSize!=diffInfo.oldDataSize)
-        return hpatch_FALSE;
-    out_newData.streamSize=diffInfo.newDataSize;
-    {
-        if (strlen(diffInfo.compressType)>0){
-#ifdef  _CompressPlugin_zlib
-            if ((!decompressPlugin)&&zlibDecompressPlugin.is_can_open(diffInfo.compressType))
-                decompressPlugin=&zlibDecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_bz2
-            if ((!decompressPlugin)&&bz2DecompressPlugin.is_can_open(diffInfo.compressType))
-                decompressPlugin=&bz2DecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_lzma
-            if ((!decompressPlugin)&&lzmaDecompressPlugin.is_can_open(diffInfo.compressType))
-                decompressPlugin=&lzmaDecompressPlugin;
-#endif
-#if (defined(_CompressPlugin_lz4) || (defined(_CompressPlugin_lz4hc)))
-            if ((!decompressPlugin)&&lz4DecompressPlugin.is_can_open(diffInfo.compressType))
-                decompressPlugin=&lz4DecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_zstd
-            if ((!decompressPlugin)&&zstdDecompressPlugin.is_can_open(diffInfo.compressType))
-                decompressPlugin=&zstdDecompressPlugin;
-#endif
-        }
-        if (decompressPlugin==0)
-            return hpatch_FALSE;
-    }
-    return patch_decompress_with_cache(&out_newData,oldData,compressedDiff,decompressPlugin,
-                                       temp_cache,temp_cache_end);
-}
-
-int     _attack_seed=1111;
-void testCaseByData(const std::string& tag,const std::vector<TByte>& oldData,const std::vector<TByte>& patData,
-                    const std::vector<TByte>& newData,int& error_count){
-    double  time0=clock_s();
-    static std::vector<TByte> out_newData;
-    static std::vector<TByte> temp_cache;
-    temp_cache.resize(cache_size_memory);
-    if (out_newData.empty()) out_newData.reserve(kMaxSize);
-    out_newData.resize(newData.size());
-    hpatch_TStreamOutput out_newStream;
-    mem_as_hStreamOutput(&out_newStream,out_newData.data(),out_newData.data()+out_newData.size());
-    std::cout << tag;
-    if (is_attack){
-        static std::vector<TByte> _oldData;
-        static std::vector<TByte> _patData;
-        if (_oldData.empty()) _oldData.reserve(kMaxSize);
-        if (_patData.empty()) _patData.reserve(kMaxSize);
-        _oldData.resize(oldData.size());
-        _patData.resize(patData.size());
-        hpatch_TStreamInput oldStream;
-        hpatch_TStreamInput patStream;
-
-        for (size_t i=0;i<kLoopCount;++i,++test_i){
-            srand(_attack_seed);
-            _attack_seed+=1;
-            //if (test_i<?) continue;
-
-            long in_codeSize=(long)patData.size();
-            memcpy(_oldData.data(),oldData.data(),_oldData.size());
-            memcpy(_patData.data(),patData.data(),in_codeSize);
-            mem_as_hStreamInput(&oldStream,_oldData.data(),_oldData.data()+_oldData.size());
-            mem_as_hStreamInput(&patStream,_patData.data(),_patData.data()+in_codeSize);
-
-            if (in_codeSize){
-                const long randCount=(long)(1+pow(rand()*(1.0/RAND_MAX),4)*1000);
-                for (long r=0; r<randCount; ++r){
-                    _patData[rand()%in_codeSize]=rand();
-                }
-            }
-            try{
-                if (is_log_attack_tag) std::cout <<tag;
-                _hpatchz(&out_newStream,&oldStream,&patStream,
-                         temp_cache.data(),temp_cache.data()+temp_cache.size());
-                if (is_log_attack_tag) std::cout <<" | test_i=="<<test_i<<" , error_count=="<<error_count<<"\n";
-            }catch (...){
-                ++error_count;
-                std::cout <<" | test_i=="<<test_i<<" , error_count=="<<error_count<<", throw error\n";
-            }
-        }
-    }else{
-        hpatch_TStreamInput oldStream;
-        hpatch_TStreamInput patStream;
-        mem_as_hStreamInput(&oldStream,oldData.data(),oldData.data()+oldData.size());
-        mem_as_hStreamInput(&patStream,patData.data(),patData.data()+patData.size());
-        for (size_t i=0;i<kLoopCount;++i,++test_i){
-            memset(out_newData.data(),0,out_newData.size());
-            
-            hpatch_BOOL result=_hpatchz(&out_newStream,&oldStream,&patStream,
-                                        temp_cache.data(),temp_cache.data()+temp_cache.size());
-            if (!result){
-                ++error_count;
-                std::cout <<" | test_i=="<<test_i<<" , error_count=="<<error_count<<", return error_code=="<<result<<" \n";
-            }else if (0!=memcmp(out_newData.data(),newData.data(),out_newData.size())){
-                ++error_count;
-                std::cout <<" | test_i=="<<test_i<<" , error_count=="<<error_count<<", out error data\n";
-            }else if (is_log_attack_tag){
-                std::cout <<" | test_i=="<<test_i<<" , error_count=="<<error_count<<"\n";
-            }
-        }
-    }
-    std::cout <<" | error_count=="<<error_count<<" , tescaseNum=="<<caseNum<<" , time: "<<(clock_s()-time0)<<" s\n";
-}
-
-void testCaseByFile(const std::string& tag,const std::string& oldPath,const std::string& patPath,const std::string& newPath,int& error_count){
-    static std::vector<TByte> oldData;
-    static std::vector<TByte> patData;
-    static std::vector<TByte> newData;
-    if (oldData.empty()) oldData.reserve(kMaxSize);
-    if (patData.empty()) patData.reserve(kMaxSize);
-    if (newData.empty()) newData.reserve(kMaxSize);
-    if (oldPath.empty())
-        oldData.resize(0);
-    else
-        readFile(oldData,oldPath.c_str());
-    readFile(patData,patPath.c_str());
-    readFile(newData,newPath.c_str());
-
-    testCaseByData(tag,oldData,patData,newData,error_count);
-}
-
-void testCaseByLine(const std::string& dirPath,const std::string& line,int& error_count){
-    //1|12306_5.2.11.apk--12306_5.1.2.apk.hdiffz_-s-16.pat
-    size_t pos0=line.find_first_of('|');
-    if (pos0==std::string::npos) return;
-    pos0+=1;
-    const std::string patFile=line.substr(pos0);
-    size_t pos1=line.find(".apk--")+4;
-    const std::string newFile=line.substr(pos0,pos1-pos0);
-    pos0=pos1+2;
-    pos1=line.find(".hdiffz_");
-    const std::string oldFile=line.substr(pos0,pos1-pos0);
-    pos0=pos1+8;
-    pos1=line.size()-4;
-    const std::string diffOp=line.substr(pos0,pos1-pos0);
-
-    std::string tag=newFile + " <- " + oldFile + " " + diffOp;
-    testCaseByFile(tag,oldFile.empty()?oldFile:(dirPath+oldFile),dirPath+patFile,dirPath+newFile,error_count);
-}
-
-size_t aToSize(const char* str) {
-    size_t result;
-    if (!kmg_to_size(str, strlen(str), &result))
-        throw str;
-    return result;
-}
-
-int main(int argc, const char*  argv[]){
-    double  time0=clock_s();
-    std::cout <<"hpatchz(attack code)\n";
-    std::cout <<"input \"patch_test.txt\" file path for test\n";
-    tcheck(argc==5);
-    std::string txt=argv[1];
-    is_attack = (1==aToSize(argv[2]));
-    kLoopCount= aToSize(argv[3]);
-    cache_size_memory=aToSize(argv[4]);
-
-    size_t pos=txt.find_last_of('\\');
-    if (pos==std::string::npos)
-        pos=txt.find_last_of('/');
-    std::string dirPath=txt.substr(0,(pos==std::string::npos)?0:pos+1);
-
-    std::vector<std::string> lines;
-    {
-        std::fstream fs(txt);
-        std::string  line;
-        while(std::getline(fs,line)){
-            size_t strLen=line.size();
-            if ((strLen>0)&&(line[strLen-1]=='\r')) line.resize(strLen-1);
-            lines.push_back(line);
-        }
-    }
-
-    for (size_t i=0;i<lines.size();++i){
-        const std::string& line=lines[i];
-        ++caseNum;
-        testCaseByLine(dirPath,line,error_count);
-    }
-
-    std::cout << "\n  error_count=="<<error_count<<"\n";
-    std::cout <<"\ndone!\n";
-    std::cout <<"\n time: "<<(clock_s()-time0)<<" s\n";
-    return error_count;
-}
-