react-native-update 10.34.3 → 10.34.4

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

@@ -3,7 +3,7 @@
 //
 /*
  The MIT License (MIT)
- Copyright (c) 2012-2022 HouSisong
+ Copyright (c) 2012-2017 HouSisong
 
  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
@@ -37,24 +37,16 @@
 #include <stdlib.h>
 #include "math.h"
 #include "../libHDiffPatch/HDiff/diff.h"
-#include "../libHDiffPatch/HDiff/diff_for_hpatch_lite.h"
 #include "../libHDiffPatch/HPatch/patch.h"
-#include "../libHDiffPatch/HPatchLite/hpatch_lite.h"
-#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h"
-#include "../libhsync/sync_make/sync_make.h"
-#include "../libhsync/sync_client/sync_client.h"
-using namespace hdiff_private;
 typedef unsigned char   TByte;
 typedef ptrdiff_t       TInt;
 typedef size_t          TUInt;
-const long kRandTestCount=5000;
-const size_t patch_single_stream_threadNum=1; // 1..5;  1 single-thread, >1 multi-threads
+const long kRandTestCount=20000;
 //#define _AttackPacth_ON
 
 //===== select compress plugin =====
 #define _CompressPlugin_no
 //#define _CompressPlugin_zlib
-//#define _CompressPlugin_ldef
 //#define _CompressPlugin_bz2
 //#define _CompressPlugin_lzma
 //#define _CompressPlugin_lzma2
@@ -63,123 +55,54 @@ const size_t patch_single_stream_threadNum=1; // 1..5;  1 single-thread, >1 mult
 //#define _CompressPlugin_zstd
 //#define _CompressPlugin_brotli
 //#define _CompressPlugin_lzham
-//#define _CompressPlugin_tuz
 
 #define IS_NOTICE_compress_canceled 0 //for test, close compress fail notice
 #define IS_REUSE_compress_handle    1 //for test, must in single thread
-#include "../compress_plugin_demo.h"   
+#include "../compress_plugin_demo.h"
 #include "../decompress_plugin_demo.h"
 
-#ifndef _CompressPlugin_no
-#include "../../hsynz/dict_compress_plugin_demo.h"   // https://github.com/sisong/hsynz
-#include "../../hsynz/dict_decompress_plugin_demo.h" // https://github.com/sisong/hsynz
-#endif
-
-#define _ChecksumPlugin_fadler32
-#include "../checksum_plugin_demo.h"
 
 #ifdef  _CompressPlugin_no
     const hdiff_TCompress* compressPlugin=0;
     hpatch_TDecompress* decompressPlugin=0;
-    hpi_compressType compressHpiType=hpi_compressType_no;
 #endif
 #ifdef  _CompressPlugin_zlib
     const hdiff_TCompress* compressPlugin=&zlibCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&zlibDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_zlib;
 #endif
 #ifdef  _CompressPlugin_bz2
     const hdiff_TCompress* compressPlugin=&bz2CompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&bz2DecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_bz2;
 #endif
 #ifdef  _CompressPlugin_lzma
     const hdiff_TCompress* compressPlugin=&lzmaCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&lzmaDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_lzma;
 #endif
 #ifdef  _CompressPlugin_lzma2
     const hdiff_TCompress* compressPlugin=&lzma2CompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&lzma2DecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_lzma2;
 #endif
 #ifdef  _CompressPlugin_lz4
     const hdiff_TCompress* compressPlugin=&lz4CompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&lz4DecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_lz4;
 #endif
 #ifdef  _CompressPlugin_lz4hc
     const hdiff_TCompress* compressPlugin=&lz4hcCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&lz4DecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_lz4;
 #endif
 #ifdef  _CompressPlugin_zstd
     const hdiff_TCompress* compressPlugin=&zstdCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&zstdDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_zstd;
 #endif
 #ifdef  _CompressPlugin_brotli
     const hdiff_TCompress* compressPlugin=&brotliCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&brotliDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_brotli;
 #endif
 #ifdef  _CompressPlugin_lzham
     const hdiff_TCompress* compressPlugin=&lzhamCompressPlugin.base;
     hpatch_TDecompress* decompressPlugin=&lzhamDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_lzham;
-#endif
-#ifdef  _CompressPlugin_tuz
-    const hdiff_TCompress* compressPlugin=&tuzCompressPlugin.base;
-    hpatch_TDecompress* decompressPlugin=&tuzDecompressPlugin;
-    hpi_compressType compressHpiType=hpi_compressType_tuz;
-#endif
-
-static hsync_TDictCompress* _getDictCompressPlugin(){
-#if defined(_CompressPlugin_ldef)
-    static TDictCompressPlugin_ldef _ldefDictCompressPlugin=ldefDictCompressPlugin;
-    _ldefDictCompressPlugin.compress_level=6;
-    return &_ldefDictCompressPlugin.base;
-#elif defined(_CompressPlugin_zlib)
-    static TDictCompressPlugin_zlib _zlibDictCompressPlugin=zlibDictCompressPlugin;
-    _zlibDictCompressPlugin.compress_level=6;
-    return &_zlibDictCompressPlugin.base;
-#elif defined(_CompressPlugin_zstd)
-    static TDictCompressPlugin_zstd _zstdDictCompressPlugin=zstdDictCompressPlugin;
-    _zstdDictCompressPlugin.compress_level=18;
-    return &_zstdDictCompressPlugin.base;
-#else
-    return 0;
-#endif
-}
-
-#ifndef _IS_USES_MY_RAND
-#  define _IS_USES_MY_RAND 1
-#endif
-#if (_IS_USES_MY_RAND)
-    #ifdef RAND_MAX
-    #   undef RAND_MAX
-    #endif
-    #define RAND_MAX 0x7fff
-    class  CMyRand{
-    public:
-        unsigned int _my_holdrand;
-    public:
-        inline CMyRand():_my_holdrand(1){}
-        inline int _my_rand(){
-            unsigned int result=_my_holdrand * 214013 + 2531011 ;
-            _my_holdrand = result;
-            return (result>>16) & RAND_MAX;
-        }
-    };
-    static CMyRand _MyRand;
-    inline int  _rand(){ return  _MyRand._my_rand(); }
-    inline void _srand(unsigned int seed){ _MyRand._my_holdrand=seed; }
-#else
-     #define  _rand  rand
-     #define  _srand srand
 #endif
 
-
 int testCompress(const char* str,const char* error_tag){
     assert(  ((compressPlugin==0)&&(decompressPlugin==0))
            ||((compressPlugin!=0)&&(decompressPlugin!=0)));
@@ -234,326 +157,31 @@ static bool check_diff_stream(const TByte* newData,const TByte* newData_end,
     return true;
 }
 
-static hpatch_TChecksum* hsynzDefaultChecksum=&fadler32ChecksumPlugin;
-
-struct TSyncInfoListener:public ISyncInfoListener{
-    inline TSyncInfoListener(){
-        infoImport=this;
-        findDecompressPlugin=_findDecompressPlugin;
-        onLoadedNewSyncInfo=0;
-        onNeedSyncInfo=0;
-        findChecksumPlugin=_findChecksumPlugin;
-    }
-    static hpatch_TChecksum* _findChecksumPlugin(ISyncInfoListener* listener,const char* strongChecksumType){
-        return hsynzDefaultChecksum;
-    }
-    static hsync_TDictDecompress* _findDecompressPlugin(ISyncInfoListener* listener,const char* compressType,size_t dictSize){
-#if defined(_CompressPlugin_ldef)
-        static TDictDecompressPlugin_ldef _ldefDictDecompressPlugin=ldefDictDecompressPlugin;
-        _ldefDictDecompressPlugin.dict_bits=(hpatch_byte)_dictSizeToDictBits(dictSize);
-        return &_ldefDictDecompressPlugin.base;
-#elif defined(_CompressPlugin_zlib)
-        static TDictDecompressPlugin_zlib _zlibDictDecompressPlugin=zlibDictDecompressPlugin;
-        _zlibDictDecompressPlugin.dict_bits=(hpatch_byte)_dictSizeToDictBits(dictSize);
-        return &_zlibDictDecompressPlugin.base;
-#elif defined(_CompressPlugin_zstd)
-        static TDictDecompressPlugin_zstd _zstdDictDecompressPlugin=zstdDictDecompressPlugin;
-        _zstdDictDecompressPlugin.dictSize=dictSize;
-        return &_zstdDictDecompressPlugin.base;
-#else
-        return 0;
-#endif
-    }
-};
-
-struct TReadSyncDataListener:public IReadSyncDataListener{
-    const std::vector<TByte>& _hzData;
-    inline explicit TReadSyncDataListener(const std::vector<TByte>& hsynzData):_hzData(hsynzData){
-        readSyncDataImport=this;
-        onNeedSyncInfo=0;
-        readSyncDataBegin=0;
-        readSyncData=_readSyncData;
-        readSyncDataEnd=0;
-    }
-    static hpatch_BOOL _readSyncData(struct IReadSyncDataListener* listener,uint32_t blockIndex,
-                                     hpatch_StreamPos_t posInNewSyncData,uint32_t isReLoadNewHalf,
-                                     hpatch_StreamPos_t posInNeedSyncData,uint32_t isReLoadDiffHalf,
-                                     unsigned char* out_syncDataBuf,uint32_t syncDataSize){
-        const TReadSyncDataListener* self=(const TReadSyncDataListener*)listener->readSyncDataImport;
-        const std::vector<TByte>& src=self->_hzData;
-        posInNewSyncData-=isReLoadNewHalf;
-        if (posInNewSyncData+syncDataSize>src.size()) return hpatch_FALSE;
-        memcpy(out_syncDataBuf,src.data()+(size_t)posInNewSyncData,syncDataSize);
-        return hpatch_TRUE;
-    }
-};
-
-static std::vector<TByte> _hsyniData;
-static std::vector<TByte> _hsynzData;
-static std::vector<TByte> _new_hsyniData;
-static std::vector<TByte> _new_hsynzData;
-static void _create_hsynz_diff(const TByte* newData,const TByte* newData_end,
-                               const TByte* oldData,const TByte* oldData_end,
-                               std::vector<TByte>& out_diff){
-    TSyncClient_resultType ret=kSyncClient_ok;
-    struct hpatch_TStreamInput  newStream;
-    mem_as_hStreamInput(&newStream,newData,newData_end);
-    _hsyniData.clear();
-    _hsynzData.clear();
-    _new_hsyniData.clear();
-    _new_hsynzData.clear();
-    TVectorAsStreamOutput hiStream(_hsyniData);
-    TVectorAsStreamOutput hzStream(_hsynzData);
-    create_sync_data(&newStream,&hiStream,&hzStream,
-                     hsynzDefaultChecksum,_getDictCompressPlugin(),0,kSyncBlockSize_min);
-
-    //local diff
-    struct hpatch_TStreamInput  oldStream;
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    out_diff.clear();
-    TVectorAsStreamOutput diffStream(out_diff);
-    TSyncInfoListener syncInfoListener;
-    TReadSyncDataListener readSyncDataListener(_hsynzData);
-    TNewDataSyncInfo newSyncInfo={0};
-    hiStream.streamSize=hiStream.dst.size();
-    ret=TNewDataSyncInfo_open(&newSyncInfo,(const hpatch_TStreamInput*)&hiStream,hpatch_FALSE,&syncInfoListener);
-    if (ret!=0) throw std::runtime_error("TNewDataSyncInfo_open() error!");
-    ret=sync_local_diff(&syncInfoListener,&readSyncDataListener,&oldStream,
-                        &newSyncInfo,&diffStream,kSyncDiff_default,0,1);
-    TNewDataSyncInfo_close(&newSyncInfo);
-    if (ret!=0) throw std::runtime_error("sync_local_diff() error!");
-}
-
-static hpatch_BOOL _hsynz_local_patch(unsigned char* out_newData,unsigned char* out_newData_end,
-                                      const unsigned char* oldData,const unsigned char* oldData_end,
-                                      const unsigned char* diff,const unsigned char* diff_end){
-    TSyncClient_resultType ret=kSyncClient_ok;
-    struct hpatch_TStreamOutput out_newStream;
-    struct hpatch_TStreamInput  oldStream;
-    struct hpatch_TStreamInput  diffStream;
-    struct hpatch_TStreamInput  hiStream;
-    mem_as_hStreamOutput(&out_newStream,out_newData,out_newData_end);
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    mem_as_hStreamInput(&diffStream,diff,diff_end);
-    const std::vector<TByte>& hsyniData=_new_hsyniData.empty()?_hsyniData:_new_hsyniData;
-    mem_as_hStreamInput(&hiStream,hsyniData.data(),hsyniData.data()+hsyniData.size());
-    TSyncInfoListener syncInfoListener;
-    TNewDataSyncInfo newSyncInfo={0};
-    ret=TNewDataSyncInfo_open(&newSyncInfo,&hiStream,hpatch_FALSE,&syncInfoListener);
-    if (ret!=0){
-#ifdef _AttackPacth_ON
-        return hpatch_FALSE;
-#else
-        throw std::runtime_error("TNewDataSyncInfo_open() error!");
-#endif
-    }
-    ret=sync_local_patch(&syncInfoListener,&diffStream,&oldStream,&newSyncInfo,&out_newStream,0,1);
-    TNewDataSyncInfo_close(&newSyncInfo);
-    if (ret!=0){
-#ifdef _AttackPacth_ON
-        return hpatch_FALSE;
-#else
-        throw std::runtime_error("sync_local_patch() error!");
-#endif
-    }
-    return hpatch_TRUE;
-}
-
-static hpatch_BOOL _hsynz_sync_patch(unsigned char* out_newData,unsigned char* out_newData_end,
-                                     const unsigned char* oldData,const unsigned char* oldData_end){
-    TSyncClient_resultType ret=kSyncClient_ok;
-    struct hpatch_TStreamOutput out_newStream;
-    struct hpatch_TStreamInput  oldStream;
-    struct hpatch_TStreamInput  hiStream;
-    mem_as_hStreamOutput(&out_newStream,out_newData,out_newData_end);
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    const std::vector<TByte>& hsyniData=_new_hsyniData.empty()?_hsyniData:_new_hsyniData;
-    const std::vector<TByte>& hsynzData=_new_hsynzData.empty()?_hsynzData:_new_hsynzData;
-    mem_as_hStreamInput(&hiStream,hsyniData.data(),hsyniData.data()+hsyniData.size());
-    TSyncInfoListener syncInfoListener;
-    TNewDataSyncInfo newSyncInfo={0};
-    TReadSyncDataListener readSyncDataListener(hsynzData);
-    ret=TNewDataSyncInfo_open(&newSyncInfo,&hiStream,hpatch_FALSE,&syncInfoListener);
-    if (ret!=0){
-#ifdef _AttackPacth_ON
-        return hpatch_FALSE;
-#else
-        throw std::runtime_error("TNewDataSyncInfo_open() error!");
-#endif
-    }
-    ret=sync_patch(&syncInfoListener,&readSyncDataListener,&oldStream,&newSyncInfo,&out_newStream,0,0,0,1);
-    TNewDataSyncInfo_close(&newSyncInfo);
-    if (ret!=0){
-#ifdef _AttackPacth_ON
-        return hpatch_FALSE;
-#else
-        throw std::runtime_error("sync_patch() error!");
-#endif
-    }
-    return hpatch_TRUE;
-}
-
-static std::vector<TByte> _newTempData;
-bool _check_hsynz_local_patch(const TByte* newData,const TByte* newData_end,
-                              const TByte* oldData,const TByte* oldData_end,
-                              const TByte* diff,const TByte* diff_end){
-    _newTempData.resize(newData_end-newData);
-    memset(_newTempData.data(),0,_newTempData.size());
-    if (!_hsynz_local_patch(_newTempData.data(),_newTempData.data()+_newTempData.size(),
-                            oldData,oldData_end,diff,diff_end))  return false;
-    if (0!=memcmp(_newTempData.data(),newData,_newTempData.size()))
-#ifdef _AttackPacth_ON
-        return false;
-#else
-        throw std::runtime_error("_check_hsynz_local_patch() error!");
-#endif
-    return true;
-}
-
-bool _check_hsynz_sync_patch(const TByte* newData,const TByte* newData_end,
-                             const TByte* oldData,const TByte* oldData_end){
-    _newTempData.resize(newData_end-newData);
-    memset(_newTempData.data(),0,_newTempData.size());
-    if (!_hsynz_sync_patch(_newTempData.data(),_newTempData.data()+_newTempData.size(),
-                           oldData,oldData_end))  return false;
-    if (0!=memcmp(_newTempData.data(),newData,_newTempData.size()))
-#ifdef _AttackPacth_ON
-        return false;
-#else
-        throw std::runtime_error("_check_hsynz_sync_patch() error!");
-#endif
-    return true;
-}
-
-enum TDiffType{
-    kDiffO,
-    kDiffZ,
-    kDiffZs,
-    kDiffS,
-    kDiffSs,
-    kDiffi,
-    kDiffiI, //inplace-patch
-    kHSynz,
-};
-static const size_t kDiffTypeCount=kHSynz+1;
 
 #ifdef _AttackPacth_ON
-
-hpatch_BOOL _sspatch_onDiffInfo(struct sspatch_listener_t* listener,
-                                const hpatch_singleCompressedDiffInfo* info,
-                                hpatch_TDecompress** out_decompressPlugin,
-                                unsigned char** out_temp_cache,
-                                unsigned char** out_temp_cacheEnd){
-    size_t temp_cache_size=info->stepMemSize+hpatch_kFileIOBufBetterSize*3;
-    static TAutoMem _buf;
-    if (_buf.size()<temp_cache_size)
-        _buf.realloc(temp_cache_size);
-    unsigned char* temp_cache=_buf.data();
-    *out_temp_cache=temp_cache;
-    *out_temp_cacheEnd=temp_cache+temp_cache_size;
-    *out_decompressPlugin=decompressPlugin;
-    return hpatch_TRUE;
-}
-
-struct TPatchiListener:public hpatchi_listener_t{
-    hpatch_decompressHandle decompresser;
-    hpatch_TDecompress*     decompressPlugin;
-    inline TPatchiListener():decompresser(0){}
-    inline ~TPatchiListener(){ if (decompresser) decompressPlugin->close(decompressPlugin,decompresser); }
-    const hpi_byte* diffData_cur;
-    const hpi_byte* diffData_end;
-    hpatch_TStreamInput diffStream;
-    hpi_pos_t           uncompressSize;
-    const hpi_byte* newData_cur;
-    const hpi_byte* newData_end;
-    const hpi_byte* oldData;
-    const hpi_byte* oldData_end;
-
-    static hpi_BOOL _read_diff(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
-        TPatchiListener& self=*(TPatchiListener*)inputStream;
-        const hpi_byte* cur=self.diffData_cur;
-        size_t d_size=self.diffData_end-cur;
-        size_t r_size=*data_size;
-        if (r_size>d_size){
-            r_size=d_size;
-            *data_size=(hpi_size_t)r_size;
-        }
-        memcpy(out_data,cur,r_size);
-        self.diffData_cur=cur+r_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _read_diff_dec(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
-        TPatchiListener& self=*(TPatchiListener*)inputStream;
-        hpi_size_t r_size=*data_size;
-        if (r_size>self.uncompressSize){
-            r_size=(hpi_size_t)self.uncompressSize;
-            *data_size=(hpi_size_t)self.uncompressSize;
-        }
-        if (!self.decompressPlugin->decompress_part(self.decompresser,out_data,out_data+r_size))
-            return hpi_FALSE;
-        self.uncompressSize-=r_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _write_new(struct hpatchi_listener_t* listener,const hpi_byte* data,hpi_size_t data_size){
-        TPatchiListener& self=*(TPatchiListener*)listener;
-        if (data_size>(size_t)(self.newData_end-self.newData_cur)) 
-            return hpi_FALSE;
-        if (0!=memcmp(self.newData_cur,data,data_size))
-            return hpi_FALSE;
-        self.newData_cur+=data_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _read_old(struct hpatchi_listener_t* listener,hpi_pos_t read_from_pos,hpi_byte* out_data,hpi_size_t data_size){
-        TPatchiListener& self=*(TPatchiListener*)listener;
-        size_t dsize=self.oldData_end-self.oldData;
-        if ((read_from_pos>dsize)|(data_size>(size_t)(dsize-read_from_pos))) return hpi_FALSE;
-        memcpy(out_data,self.oldData+(size_t)read_from_pos,data_size);
-        return hpi_TRUE;
-    }
-};
-
-
 long attackPacth(TByte* out_newData,TByte* out_newData_end,
                         const TByte* oldData,const TByte* oldData_end,
                         const TByte* diffData,const TByte* diffData_end,
-                        const char* error_tag,TDiffType diffType){
-    switch (diffType){
-        case kDiffO: {
-            hpatch_BOOL rt0=patch(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
-            hpatch_BOOL rt1=_patch_mem_stream(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
-            if (rt0!=rt1){
-                printf("\n attackPacth error!!! tag:%s\n",error_tag);
-                return 1;
-            }
-        } break;
-        case kDiffZ: {
-            patch_decompress_mem(out_newData,out_newData_end,oldData,oldData_end,
-                                 diffData,diffData_end,decompressPlugin);
-        } break;
-        case kDiffS: {
-            sspatch_listener_t listener={0,_sspatch_onDiffInfo,0};
-            patch_single_stream_mem(&listener,out_newData,out_newData_end,oldData,oldData_end,
-                                    diffData,diffData_end,0,patch_single_stream_threadNum);
-        } break;
-        case kDiffi: case kDiffiI: {
-            hpi_compressType    compressType;
-            check_lite_diff_open(diffData,diffData_end,&compressType);
-            check_lite_diff(out_newData,out_newData_end,oldData,oldData_end,
-                            diffData,diffData_end,decompressPlugin);
-        } break;
-        case kHSynz: {
-            _hsynz_local_patch(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
-            _hsynz_sync_patch(out_newData,out_newData_end,oldData,oldData_end);
-        } break;
+                        const char* error_tag,bool isDiffz){
+    if (isDiffz){
+        patch_decompress_mem(out_newData,out_newData_end,oldData,oldData_end,
+                             diffData,diffData_end,decompressPlugin);
+    }else{
+        hpatch_BOOL rt0=patch(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
+        hpatch_BOOL rt1=_patch_mem_stream(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
+        if (rt0!=rt1){
+            printf("\n attackPacth error!!! tag:%s\n",error_tag);
+            return 1;
+        }
     }
     return 0;
 }
 
 long attackPacth(TInt newSize,const TByte* oldData,const TByte* oldData_end,
-                 const TByte* _diffData,const TByte* _diffData_end,int seed,TDiffType diffType){
+                 const TByte* _diffData,const TByte* _diffData_end,int seed,bool isDiffz){
     char tag[250]="\0";
-    _srand(seed);
-    const int kLoopCount=1000;
+    srand(seed);
+    const long kLoopCount=1000;
     long exceptionCount=0;
     std::vector<TByte> _newData(newSize);
     TByte* newData=_newData.data();
@@ -562,38 +190,15 @@ long attackPacth(TInt newSize,const TByte* oldData,const TByte* oldData_end,
     std::vector<TByte> new_diffData(diffSize);
     TByte* diffData=new_diffData.data();
     TByte* diffData_end=diffData+diffSize;
-    if (diffType==kHSynz){
-        _new_hsyniData.resize(_hsyniData.size());
-        _new_hsynzData.resize(_hsynzData.size());
-    }
-
     try {
-        for (int i=0; i<kLoopCount; ++i) {
+        for (long i=0; i<kLoopCount; ++i) {
             sprintf(tag, "attackPacth exceptionCount=%ld testSeed=%d i=%ld",exceptionCount,seed,i);
-            if (diffType==kHSynz){
-                const int hisize=(int)_hsyniData.size();
-                memcpy(_new_hsyniData.data(),_hsyniData.data(),hisize);
-                int randCount=(int)(1+_rand()*(1.0/RAND_MAX)*_rand()*(1.0/RAND_MAX)*hisize/2);
-                TByte* hiData=_new_hsyniData.data();
-                for (int r=0; r<randCount; ++r)
-                    hiData[_rand()%hisize]=_rand();
-
-                const int hzsize=(int)_hsynzData.size();
-                if (hzsize>0){
-                    memcpy(_new_hsynzData.data(),_hsynzData.data(),hzsize);
-                    randCount=(int)(1+_rand()*(1.0/RAND_MAX)*_rand()*(1.0/RAND_MAX)*hzsize/8);
-                    TByte* hzData=_new_hsynzData.data();
-                    for (int r=0; r<randCount; ++r)
-                        hzData[_rand()%hzsize]=_rand();
-                }
+            memcpy(diffData,_diffData,_diffData_end-_diffData);
+            const long randCount=(long)(1+rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX)*diffSize/3);
+            for (long r=0; r<randCount; ++r){
+                diffData[rand()%diffSize]=rand();
             }
-
-            memcpy(diffData,_diffData,diffSize);
-            const int randCount=(int)(1+_rand()*(1.0/RAND_MAX)*_rand()*(1.0/RAND_MAX)*diffSize/4);
-            for (int r=0; r<randCount; ++r)
-                diffData[_rand()%diffSize]=_rand();
-
-            exceptionCount+=attackPacth(newData,newData_end,oldData,oldData_end,diffData,diffData_end,tag,diffType);
+            exceptionCount+=attackPacth(newData,newData_end,oldData,oldData_end,diffData,diffData_end,tag,isDiffz);
         }
         return exceptionCount;
     } catch (...) {
@@ -603,47 +208,58 @@ long attackPacth(TInt newSize,const TByte* oldData,const TByte* oldData_end,
 }
 #endif
 
-long test(const TByte* newData,const TByte* newData_end,
-          const TByte* oldData,const TByte* oldData_end,const char* tag,hpatch_StreamPos_t* out_diffSizes){
-    printf("%s newSize:%ld oldSize:%ld ",tag, (long)(newData_end-newData), (long)(oldData_end-oldData));
-    long result=0;
-    {//test diffs
-        std::vector<TByte> diffData;
-        create_single_compressed_diff(newData,newData_end,oldData,oldData_end,diffData,compressPlugin);
-        if (out_diffSizes) out_diffSizes[kDiffS]+=diffData.size();
-        if (!check_single_compressed_diff(newData,newData_end,oldData,oldData_end,
-                                          diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
-            printf("\n diffs error!!! tag:%s\n",tag);
-            ++result;
+struct TVectorStreamOutput:public hpatch_TStreamOutput{
+    explicit TVectorStreamOutput(std::vector<TByte>& _dst):dst(_dst){
+        this->streamImport=this;
+        this->streamSize=~(hpatch_StreamPos_t)0;
+        this->read_writed=0;
+        this->write=_write;
+    }
+    static hpatch_BOOL _write(const hpatch_TStreamOutput* stream,
+                              const hpatch_StreamPos_t writeToPos,
+                              const unsigned char* data,const unsigned char* data_end){
+        TVectorStreamOutput* self=(TVectorStreamOutput*)stream->streamImport;
+        std::vector<TByte>& dst=self->dst;
+        size_t writeLen=(size_t)(data_end-data);
+        if (writeToPos>dst.size()) return false;
+        if  (dst.size()==writeToPos){
+            dst.insert(dst.end(),data,data_end);
         }else{
-            printf(" diffs:%ld", (long)(diffData.size()));
-#ifdef _AttackPacth_ON
-            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffS);
-            if (exceptionCount>0) return exceptionCount;
-#endif
+            if (writeToPos+writeLen!=(size_t)(writeToPos+writeLen)) return false;
+            if (dst.size()<writeToPos+writeLen)
+                dst.resize((size_t)(writeToPos+writeLen));
+            memcpy(&dst[(size_t)writeToPos],data,writeLen);
         }
+        return true;
     }
-    {//test diffs stream
+    std::vector<TByte>& dst;
+};
+
+long test(const TByte* newData,const TByte* newData_end,
+          const TByte* oldData,const TByte* oldData_end,const char* tag,size_t* out_diffSize=0){
+    printf("%s newSize:%ld oldSize:%ld ",tag, (long)(newData_end-newData), (long)(oldData_end-oldData));
+    long result=0;
+    {//test diffz stream
         std::vector<TByte> diffData;
         struct hpatch_TStreamInput  newStream;
         struct hpatch_TStreamInput  oldStream;
-        TVectorAsStreamOutput out_diffStream(diffData);
+        TVectorStreamOutput out_diffStream(diffData);
         mem_as_hStreamInput(&newStream,newData,newData_end);
         mem_as_hStreamInput(&oldStream,oldData,oldData_end);
 
-        create_single_compressed_diff_stream(&newStream,&oldStream,&out_diffStream,compressPlugin,1<<4);
-        if (out_diffSizes) out_diffSizes[kDiffSs]+=diffData.size();
+        create_compressed_diff_stream(&newStream,&oldStream,&out_diffStream,compressPlugin,1<<4);
+        
         struct hpatch_TStreamInput in_diffStream;
         mem_as_hStreamInput(&in_diffStream,diffData.data(),diffData.data()+diffData.size());
-        if (!check_single_compressed_diff(&newStream,&oldStream,&in_diffStream,decompressPlugin,patch_single_stream_threadNum)){
-            printf("\n diffs stream error!!! tag:%s\n",tag);
+        if (!check_compressed_diff(newData,newData_end,oldData,oldData_end,
+                                   diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
+            printf("\n diffz stream error!!! tag:%s\n",tag);
             ++result;
         }else{
-            printf(" diffs(stream):%ld", (long)(diffData.size()));
+            printf(" diffzStream:%ld", (long)(diffData.size()));
 #ifdef _AttackPacth_ON
             long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffS);
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),true);
             if (exceptionCount>0) return exceptionCount;
 #endif
         }
@@ -651,7 +267,6 @@ long test(const TByte* newData,const TByte* newData_end,
     {//test diffz
         std::vector<TByte> diffData;
         create_compressed_diff(newData,newData_end,oldData,oldData_end,diffData,compressPlugin);
-        if (out_diffSizes) out_diffSizes[kDiffZ]+=diffData.size();
         if (!check_compressed_diff(newData,newData_end,oldData,oldData_end,
                                    diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
             printf("\n diffz error!!! tag:%s\n",tag);
@@ -660,69 +275,7 @@ long test(const TByte* newData,const TByte* newData_end,
             printf(" diffz:%ld", (long)(diffData.size()));
 #ifdef _AttackPacth_ON
             long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffZ);
-            if (exceptionCount>0) return exceptionCount;
-#endif
-        }
-    }
-    {//test diffz stream
-        std::vector<TByte> diffData;
-        struct hpatch_TStreamInput  newStream;
-        struct hpatch_TStreamInput  oldStream;
-        TVectorAsStreamOutput out_diffStream(diffData);
-        mem_as_hStreamInput(&newStream,newData,newData_end);
-        mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-
-        create_compressed_diff_stream(&newStream,&oldStream,&out_diffStream,compressPlugin,1<<4);
-        if (out_diffSizes) out_diffSizes[kDiffZs]+=diffData.size();
-        struct hpatch_TStreamInput in_diffStream;
-        mem_as_hStreamInput(&in_diffStream,diffData.data(),diffData.data()+diffData.size());
-        if (!check_compressed_diff(&newStream,&oldStream,&in_diffStream,decompressPlugin)){
-            printf("\n diffz stream error!!! tag:%s\n",tag);
-            ++result;
-        }else{
-            printf(" diffz(stream):%ld", (long)(diffData.size()));
-#ifdef _AttackPacth_ON
-            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffZ);
-            if (exceptionCount>0) return exceptionCount;
-#endif
-        }
-    }
-    {//test diffi
-        std::vector<TByte> diffData;
-        hdiffi_TCompress compressPlugini={compressPlugin,compressHpiType};
-        create_lite_diff(newData,newData_end,oldData,oldData_end,diffData,&compressPlugini);
-        if (out_diffSizes) out_diffSizes[kDiffi]+=diffData.size();
-        if (!check_lite_diff(newData,newData_end,oldData,oldData_end,
-                             diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
-            printf("\n diffi error!!! tag:%s\n",tag);
-            ++result;
-        }else{
-            printf(" diffi:%ld", (long)(diffData.size()));
-#ifdef _AttackPacth_ON
-            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffi);
-            if (exceptionCount>0) return exceptionCount;
-#endif
-        }
-    }
-
-    {//test diffi inplace-patch
-        std::vector<TByte> diffData;
-        hdiffi_TCompress compressPlugini={compressPlugin,compressHpiType};
-        size_t extraSafeSize=(size_t)(_rand()*(1.0/RAND_MAX)*(size_t)(oldData_end-oldData));
-        create_inplaceB_lite_diff(newData,newData_end,oldData,oldData_end,diffData,extraSafeSize,&compressPlugini);
-        if (out_diffSizes) out_diffSizes[kDiffiI]+=diffData.size();
-        if (!check_lite_diff(newData,newData_end,oldData,oldData_end,
-                             diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
-            printf("\n diffiI error!!! tag:%s\n",tag);
-            ++result;
-        }else{
-            printf(" diffiI:%ld", (long)(diffData.size()));
-#ifdef _AttackPacth_ON
-            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffiI);
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),true);
             if (exceptionCount>0) return exceptionCount;
 #endif
         }
@@ -730,67 +283,49 @@ long test(const TByte* newData,const TByte* newData_end,
     {//test diff
         std::vector<TByte> diffData;
         create_diff(newData,newData_end,oldData,oldData_end, diffData);
-        if (out_diffSizes) out_diffSizes[kDiffO]+=diffData.size();
+        if (out_diffSize!=0)
+            *out_diffSize=diffData.size();
         if ((!check_diff(newData,newData_end,oldData,oldData_end,diffData.data(),diffData.data()+diffData.size()))
             ||(!check_diff_stream(newData,newData_end,oldData,oldData_end,
                                   diffData.data(),diffData.data()+diffData.size())) ){
-            printf("\n diffo error!!! tag:%s\n",tag);
+            printf("\n  error!!! tag:%s\n",tag);
             ++result;
         }else{
-            printf(" diffo:%ld", (long)(diffData.size()));
+            printf(" diff:%ld\n", (long)(diffData.size()));
 #ifdef _AttackPacth_ON
             long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kDiffO);
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),false);
             if (exceptionCount>0) return exceptionCount;
 #endif
         }
     }
-    {//test hsynz
-        std::vector<TByte> diffData;
-        _create_hsynz_diff(newData,newData_end,oldData,oldData_end,diffData);
-        if (out_diffSizes) out_diffSizes[kHSynz]+=diffData.size();
-        if ((!_check_hsynz_local_patch(newData,newData_end,oldData,oldData_end,diffData.data(),diffData.data()+diffData.size()))
-            ||(!_check_hsynz_sync_patch(newData,newData_end,oldData,oldData_end))){
-            printf("\n hsynz error!!! tag:%s\n",tag);
-            ++result;
-        }else{
-            printf(" hsynz:%ld", (long)(diffData.size()));
-#ifdef _AttackPacth_ON
-            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
-                                            diffData.data(),diffData.data()+diffData.size(),_rand(),kHSynz);
-            if (exceptionCount>0) return exceptionCount;
-#endif
-        }
-    }
-    printf("\n");
     return result;
 }
 
+
+
 static inline long test(const char* newStr,const char* oldStr,const char* error_tag){
     const TByte* newData=(const TByte*)newStr;
     const TByte* oldData=(const TByte*)oldStr;
-    return test(newData,newData+strlen(newStr),oldData,oldData+strlen(oldStr),error_tag,0);
+    return test(newData,newData+strlen(newStr),oldData,oldData+strlen(oldStr),error_tag);
 }
 
 
 void setRandDataSize(int kMaxDataSize,std::vector<TByte>& oldData,std::vector<TByte>& newData,
                             double sunSizeMin,double subSizeMax){
-    const TInt oldSize=(TInt)(_rand()*(1.0/RAND_MAX)*_rand()*(1.0/RAND_MAX)*kMaxDataSize);
-    const TInt newSize=(TInt)(oldSize*(sunSizeMin+_rand()*(1.0/RAND_MAX)*(subSizeMax-sunSizeMin)));
+    const TInt oldSize=(TInt)(rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX)*kMaxDataSize);
+    const TInt newSize=(TInt)(oldSize*(sunSizeMin+rand()*(1.0/RAND_MAX)*(subSizeMax-sunSizeMin)));
     newData.resize(newSize);
     oldData.resize(oldSize);
 }
 
 void setRandData(std::vector<TByte>& data){
     for (TInt i=0; i<(TInt)data.size(); ++i)
-        data[i]=_rand();
+        data[i]=rand();
 }
 
 
 int main(int argc, const char * argv[]){
-#if (_IS_OUT_DIFF_INFO)
-    _hdiff_is_out_diff_info=0;
-#endif
     clock_t time1=clock();
     long errorCount=0;
     errorCount+=testCompress("","c1");
@@ -814,30 +349,27 @@ int main(int argc, const char * argv[]){
     errorCount+=test("a123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr1", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "13");
 
     {
-        const char* _strData14="a1234567898765432123456776djng5;wsvdoivnkdnvdfnvnkljdfdfkjfnvdlfknvvdfnvknfnk54321234567765432asaddjbvdjvbdfbvb"
-                                "dfve.kskj3bt3jht38985iojtjn76i7khjmfgyrdjrj5jsdasfefw45fg4gacasc234fervsvdfdghn6767kk7887oklo990gr232eqwdscdsfef4g4gr1";
+        const char* _strData14="a123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr1";
         const TByte* data14=(const TByte*)_strData14;
         const size_t dataSize=strlen(_strData14);
-        hpatch_StreamPos_t diffSize14[kDiffTypeCount]={0};
-        errorCount+=test(data14, data14+dataSize,data14, data14+dataSize, "14",diffSize14);
-        for (int i=0;i<kDiffTypeCount;++i){
-            if (diffSize14[i]>=dataSize){
-                ++errorCount;
-                printf("error!!! tag:%s\n","14 test diff size");
-            }
+        size_t diffSize14=0;
+        errorCount+=test(data14, data14+dataSize,data14, data14+dataSize, "14",&diffSize14);
+        if (diffSize14>=dataSize){
+            ++errorCount;
+            printf("error!!! tag:%s\n","14 test diff size");
         }
     }
 
-    const int kMaxDataSize=1024*32;
+    const int kMaxDataSize=1024*16;
     
     std::vector<int> seeds(kRandTestCount);
-    _srand(0);
+    srand(0);
     for (int i=0; i<kRandTestCount; ++i)
-        seeds[i]=((unsigned int)_rand())*(unsigned int)(RAND_MAX+1)+(unsigned int)_rand();
+        seeds[i]=rand();
 
-    hpatch_StreamPos_t sumNewSize=0;
-    hpatch_StreamPos_t sumOldSize=0;
-    hpatch_StreamPos_t sumDiffSizes[kDiffTypeCount]={0};
+    double sumNewSize=0;
+    double sumOldSize=0;
+    double sumDiffSize=0;
     std::vector<TByte> _newData;
     std::vector<TByte> _oldData;
     for (TInt i=0; i<kRandTestCount; ++i) {
@@ -848,7 +380,7 @@ int main(int argc, const char * argv[]){
         sprintf(tag, "error==%ld testSeed=%d",errorCount,seeds[i]);
     #endif
 
-        _srand(seeds[i]);
+        srand(seeds[i]);
 
         setRandDataSize(kMaxDataSize,_oldData,_newData,0.7,1.5);
         setRandData(_oldData);
@@ -858,30 +390,26 @@ int main(int argc, const char * argv[]){
         const TInt kMaxCopyCount=(TInt)sqrt((double)oldSize);
         TByte* newData=_newData.data();
         TByte* oldData=_oldData.data();
-        const TInt copyCount=0+(TInt)((1-_rand()*(1.0/RAND_MAX)*_rand()*(1.0/RAND_MAX))*kMaxCopyCount*1);
-        const TInt kMaxCopyLength=(TInt)(1+_rand()*(1.0/RAND_MAX)*kMaxCopyCount*16);
+        const TInt copyCount=0+(TInt)((1-rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX))*kMaxCopyCount*4);
+        const TInt kMaxCopyLength=(TInt)(1+rand()*(1.0/RAND_MAX)*kMaxCopyCount*4);
         for (TInt ci=0; ci<copyCount; ++ci) {
-            const TInt length=1+(TInt)(_rand()*(1.0/RAND_MAX)*kMaxCopyLength);
+            const TInt length=1+(TInt)(rand()*(1.0/RAND_MAX)*kMaxCopyLength);
             if ((length>oldSize*4/5)||(length>newSize*4/5)) {
                 continue;
             }
-            const TInt oldPos=(oldSize-length==0)?0:(TInt)(_rand()*(1.0/RAND_MAX)*(oldSize-length));
-            const TInt newPos=(newSize-length==0)?0:(TInt)(_rand()*(1.0/RAND_MAX)*(newSize-length));
+            const TInt oldPos=(oldSize-length==0)?0:(TInt)(rand()*(1.0/RAND_MAX)*(oldSize-length));
+            const TInt newPos=(newSize-length==0)?0:(TInt)(rand()*(1.0/RAND_MAX)*(newSize-length));
             memcpy(&newData[0]+newPos, &oldData[0]+oldPos, length);
         }
-        errorCount+=test(&newData[0],&newData[0]+newSize,&oldData[0],&oldData[0]+oldSize,tag,sumDiffSizes);
+        size_t diffSize=0;
+        errorCount+=test(&newData[0],&newData[0]+newSize,&oldData[0],&oldData[0]+oldSize,tag,&diffSize);
         sumNewSize+=newSize;
         sumOldSize+=oldSize;
+        sumDiffSize+=diffSize;
     }
 
     printf("\nchecked:%ld  errorCount:%ld\n",kRandTestCount,errorCount);
-    printf("newSize:100%% oldSize:%2.2f%% diffO:%2.2f%% diffZ:%2.2f%%(s:%2.2f%%)"
-           " diffS:%2.2f%%(s:%2.2f%%) diffi:%2.2f%% diffiI:%2.2f%% hsynz:%2.2f%%\n",
-            sumOldSize*100.0/sumNewSize,sumDiffSizes[kDiffO]*100.0/sumNewSize,
-            sumDiffSizes[kDiffZ]*100.0/sumNewSize,sumDiffSizes[kDiffZs]*100.0/sumNewSize,
-            sumDiffSizes[kDiffS]*100.0/sumNewSize,sumDiffSizes[kDiffSs]*100.0/sumNewSize,
-            sumDiffSizes[kDiffi]*100.0/sumNewSize,sumDiffSizes[kDiffiI]*100.0/sumNewSize,
-            sumDiffSizes[kHSynz]*100.0/sumNewSize);
+    printf("newSize:100%% oldSize:%2.2f%% diffSize:%2.2f%%\n",sumOldSize*100.0/sumNewSize,sumDiffSize*100.0/sumNewSize);
     clock_t time2=clock();
     printf("\nrun time:%.1f s\n",(time2-time1)*(1.0/CLOCKS_PER_SEC));