react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_import.h

@@ -27,41 +27,66 @@
 
 #ifndef parallel_import_h
 #define parallel_import_h
-#include "parallel_import_c.h"
-#include "../libHDiffPatch/HPatch/patch_types.h" //for *inline
+
+//select define one for support parallel
+//#define _IS_USED_PTHREAD       1
+//#define _IS_USED_CPP11THREAD   1
+//#define _IS_USED_WIN32THREAD   1
+
+#ifndef _IS_USED_MULTITHREAD
+#   define _IS_USED_MULTITHREAD 1
+#endif
+
+#if ((_IS_USED_PTHREAD>0) || (_IS_USED_CPP11THREAD>0) || (_IS_USED_WIN32THREAD>0))
+#   //ok have one
+#   define _IS_USED_MULTITHREAD 1
+#else
+#   if (_IS_USED_MULTITHREAD>0)
+#       if ( (!(defined _IS_USED_WIN32THREAD)) && (defined _WIN32) )
+#           define  _IS_USED_WIN32THREAD        1
+#       else
+#           if ( (!(defined _IS_USED_CPP11THREAD)) && (__cplusplus >= 201103L) )
+#               define  _IS_USED_CPP11THREAD    1
+#           else
+#               if (!(defined _IS_USED_PTHREAD))
+#                   define _IS_USED_PTHREAD     1
+#               endif
+#           endif
+#       endif
+#   endif
+#endif
+
 #if (_IS_USED_MULTITHREAD)
-#include <stdexcept>
 
-//cpp version of MT API
-//  if have error, throw std::runtime_error
+    //并行临界区锁;
+    typedef void*   HLocker;
+    HLocker     locker_new(void);
+    void        locker_delete(HLocker locker);
+    void        locker_enter(HLocker locker);
+    void        locker_leave(HLocker locker);
+    
+    //同步变量;
+    typedef void*   HCondvar;
+#if (_IS_USED_CPP11THREAD)
+#   define TLockerBox           void  /*  used std::unique_lock<std::mutex>  */
+#   define _TLockerBox_name     std::unique_lock<std::mutex>
+#else
+    typedef struct{
+        HLocker locker;
+    } TLockerBox;
+#endif
+    HCondvar    condvar_new(void);
+    void        condvar_delete(HCondvar cond);
+    void        condvar_wait(HCondvar cond,TLockerBox* lockerBox);
+    void        condvar_signal(HCondvar cond);
+    void        condvar_broadcast(HCondvar cond);
 
-#define _check_fn_throw(value) { \
-    if (!(value)) throw std::runtime_error(#value " run error!"); }
-#define _check_fn_ret_throw(T,value) { T _v=value; if (!_v) throw std::runtime_error(#value " run error!"); return _v; }
+    void this_thread_yield(void);
 
-hpatch_force_inline static
-HLocker     locker_new(void)                { _check_fn_ret_throw(HLocker,c_locker_new()); }
-hpatch_force_inline static 
-void        locker_delete(HLocker locker)   { _check_fn_throw(c_locker_delete(locker)); }
-hpatch_force_inline static
-void        locker_enter(HLocker locker)    { _check_fn_throw(c_locker_enter(locker)); }
-hpatch_force_inline static
-void        locker_leave(HLocker locker)    { _check_fn_throw(c_locker_leave(locker)); }
-hpatch_force_inline static
-HCondvar    condvar_new(void)               { _check_fn_ret_throw(HCondvar,c_condvar_new()); }
-hpatch_force_inline static
-void        condvar_delete(HCondvar cond)   { _check_fn_throw(c_condvar_delete(cond)); }
-hpatch_force_inline static
-void        condvar_wait_at(HCondvar cond,HLocker locker) { _check_fn_throw(c_condvar_wait(cond,locker)); }
-hpatch_force_inline static
-void        condvar_signal(HCondvar cond)   { _check_fn_throw(c_condvar_signal(cond)); }
-hpatch_force_inline static
-void        condvar_broadcast(HCondvar cond){ _check_fn_throw(c_condvar_broadcast(cond)); }
-#define     this_thread_yield               c_this_thread_yield
-hpatch_force_inline static
-void        thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
-                            int isUseThisThread,int threadIndexOffset){
-                _check_fn_throw(c_thread_parallel(threadCount,threadProc,workData,isUseThisThread,threadIndexOffset)); }
+    //parallel run
+    typedef void (*TThreadRunCallBackProc)(int threadIndex,void* workData);
+    void  thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                          int isUseThisThread,int threadIndexStart);
 
 #endif //_IS_USED_MULTITHREAD
 #endif //parallel_import_h

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

@@ -162,7 +162,7 @@ void doDiff(TDiffInfo& di){
         di.oldFileSize=di.oldData.size();
         di.newFileSize=di.newData.size();
         const TByte* oldData0=di.oldData.data();
-        di.sstring.resetSuffixString(oldData0,oldData0+di.oldData.size(),8);
+        di.sstring.resetSuffixString(oldData0,oldData0+di.oldData.size());
     }
     
     di.diffSize=_compress_diff(di,0,0);

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

@@ -38,6 +38,7 @@
 #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;

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

@@ -30,45 +30,16 @@
 #include <iostream>
 #include <stdlib.h>
 #include <vector>
-#include <assert.h>
 #include <unordered_map>
-#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
-#include "../_clock_for_demo.h"
-#define _IS_NEED_ZLIB   1
-#define _IS_NEED_MD5    0
-#if (_IS_NEED_ZLIB)
 #include "zlib.h"
-#endif
-#if (_IS_NEED_MD5)
 #include "md5.h" // https://sourceforge.net/projects/libmd5-rfc
-#endif
-
+#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+#include "../_clock_for_demo.h"
 typedef unsigned char   TByte;
 typedef ptrdiff_t       TInt;
 typedef size_t          TUInt;
 
-#define _IS_USES_MY_RAND
-#ifdef _IS_USES_MY_RAND
-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
-
-/* //interface
+/*
 struct THash{
     typename TValue;
     static const char* name() const;
@@ -77,7 +48,6 @@ struct THash{
     void hash_finish(TValue* hv);
 };*/
 
-#if (_IS_NEED_MD5)
 struct THash_md5_128{
     typedef std::pair<uint64_t,uint64_t> TValue;
     inline static const char* name() { return "md5_128"; }
@@ -87,6 +57,7 @@ struct THash_md5_128{
         { md5_append(&_hv,pdata,(int)(pdata_end-pdata)); }
     inline void hash_end(TValue* hv) { md5_finish(&_hv,(TByte*)hv); }
 };
+
 namespace std{
     template<> struct hash<THash_md5_128::TValue>{
         inline size_t operator()(const THash_md5_128::TValue& v) const{
@@ -97,9 +68,7 @@ namespace std{
             return (x.first^x.second) < (y.first^y.second); }
     };
 }
-#endif
 
-#if (_IS_NEED_ZLIB)
 struct THash_crc32{
     typedef uint32_t TValue;
     inline static const char* name() { return "crc32"; }
@@ -116,13 +85,9 @@ struct THash_adler32{
     TValue _hv;
     inline void hash_begin() { _hv=(TValue)adler32(0,0,0); }
     inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { //TValue _tv=(TValue)adler32_append(_hv,pdata,(pdata_end-pdata));
-                          _hv=(TValue)adler32(_hv,pdata,(uInt)(pdata_end-pdata));
-                          //assert(_hv==_tv);
-                        }
+                        { _hv=(TValue)adler32(_hv,pdata,(uInt)(pdata_end-pdata)); }
     inline void hash_end(TValue* hv) { *hv=_hv; }
 };
-#endif
 
 
 struct THash_adler32h{
@@ -131,22 +96,12 @@ struct THash_adler32h{
     TValue _hv;
     inline void hash_begin() { _hv=adler32_start(0,0); }
     inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { _hv=adler32_append(_hv,pdata,(pdata_end-pdata));}
+                        { _hv=adler32_append(_hv,pdata,(pdata_end-pdata));
+                            //assert(_hv==(TValue)adler32(1,pdata,(pdata_end-pdata)));
+                        }
     inline void hash_end(TValue* hv) { *hv=_hv; }
 };
 
-template<size_t kTestBit>
-struct THash_adler32h_bit{
-    typedef uint32_t TValue;
-    inline static const char* name() { return "adler32h_bit"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=adler32_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { _hv=adler32_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv&((1<<kTestBit)-1); }
-};
-
-
 struct THash_fadler32{
     typedef uint32_t TValue;
     inline static const char* name() { return "fadler32"; }
@@ -177,27 +132,6 @@ struct THash_fadler64{
     inline void hash_end(TValue* hv) { *hv=_hv; }
 };
 
-template<int xshl_bits>
-struct THash_fadler64_xshl{
-    typedef uint64_t TValue;
-    inline static const char* name() { return "fadler64_x"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=fast_adler64_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                    { _hv=fast_adler64_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=toSavedPartRollHash(_hv,xshl_bits); }
-    
-    static inline
-    uint64_t toSavedPartRollHash(uint64_t rollHash,size_t savedRollHashBits){
-        if (savedRollHashBits<64)
-            return ((rollHash>>savedRollHashBits)^rollHash) & ((((uint64_t)1)<<savedRollHashBits)-1);
-            //return ((rollHash>>savedRollHashBits)) & ((((uint64_t)1)<<savedRollHashBits)-1);
-        else
-            return rollHash;
-    }
-};
-
-#if (_IS_NEED_FAST_ADLER128)
 struct THash_fadler128{
     typedef adler128_t TValue;
     inline static const char* name() { return "fadler128"; }
@@ -217,48 +151,11 @@ struct _adler128_t_cmp{
         return (x.adler==y.adler) & (x.sum==y.sum);
     }
 };
-#endif
-
-template <class THash>
-void test_speed(const TByte* data,const TByte* data_end){
-    const size_t kMinHashDataSize=0;
-    const size_t kMaxHashDataSize=1024*1024;
-    const size_t kTestCount = 1000000;
-    
-    printf("%s%s ",THash::name(),std::string(12-strlen(THash::name()),' ').c_str());
-    
-    THash th;
-    static typename THash::TValue hv;
-    unsigned int rand_seed=1;
-    _srand(rand_seed);
-    
-    double time0=clock_s();
-    size_t total_size = 0;
-    
-    for(size_t i = 0; i < kTestCount; i++) {
-        size_t dlen =kMinHashDataSize+(_rand() % (kMaxHashDataSize+1-kMinHashDataSize));
-        size_t dstrat=((uint64_t)_rand()+((uint64_t)_rand()*(RAND_MAX+1))) % ((data_end-data)-dlen);
-        assert(dstrat+dlen<=(size_t)(data_end-data));
-        const TByte* pv=data+dstrat;
-        th.hash_begin();
-        
-        th.hash(pv,pv+dlen);
-        total_size+=dlen;
-        
-        th.hash_end(&hv);
-    }
-    
-    double time_used = clock_s() - time0;
-    double speed = total_size / (time_used * 1024.0 * 1024.0); // MB/s
-    
-    printf("speed: %.1f MB/s\n", speed);
-}
 
 const uint64_t kMaxMapNodeSize=80000000ull; //run test memory ctrl
 const size_t   kRandTestMaxSize=1024*1024*1024;//test rand data size
-    size_t   kMinHashDataSize=0;
-    size_t   kMaxHashDataSize=256;
-    size_t   kMinClash=0; //run test max time ctrl
+const size_t   kMaxHashDataSize=256;
+      size_t   kMinClash=0; //run test max time ctrl
 
 template <class THash,class TUInt,int kTestBit=sizeof(TUInt)*8,TUInt kTestMask=(TUInt)~(TUInt)0>
 void test(const TByte* data,const TByte* data_end){
@@ -272,24 +169,23 @@ void test(const TByte* data,const TByte* data_end){
     for (size_t m=0;m<clip_count;++m)
         maps[m].reserve(kMaxMapNodeSize*3/clip_count);
     unsigned int rand_seed=7;
-    _srand(rand_seed);
-    if (kTestMask!=(TUInt)~(TUInt)0) printf("mask[%08X %08X] ",(int)(((uint64_t)kTestMask)>>32),(int)kTestMask);
-    printf("%s%s ",THash::name(),std::string(12-strlen(THash::name()),' ').c_str());
+    if (kTestMask!=(TUInt)~(TUInt)0) printf("mask[%08X %08X] ",(int)(kTestMask>>32),(int)kTestMask);
+    printf("%s%s ",THash::name(),std::string(10-strlen(THash::name()),' ').c_str());
     
     uint64_t    curClashMin=0;
     uint64_t    clashs[clip_count]={0};
     double clashBases[clip_count]={0};
     size_t i=0;
     while (curClashMin<kMinClash) {
-        uint64_t    clashMin=~(uint64_t)0;
+        uint64_t    clashMin=-(uint64_t)1;
         for (size_t m=0;m<clip_count;++m){
             if (clashs[m]<clashMin) clashMin=clashs[m];
         }
         curClashMin=clashMin;
         
-        size_t dlen =kMinHashDataSize+(_rand() % (kMaxHashDataSize+1-kMinHashDataSize));
-        size_t dstrat=((uint64_t)_rand()+((uint64_t)_rand()*(RAND_MAX+1))) % ((data_end-data)-dlen);
-        assert(dstrat+dlen<=(size_t)(data_end-data));
+        size_t dlen=rand_r(&rand_seed) % kMaxHashDataSize;
+        size_t dstrat=rand_r(&rand_seed) % ((data_end-data) - dlen);
+        assert(dstrat+dlen<=(data_end-data));
         const TByte* pv    =data+dstrat;
         const TByte* pv_end=pv+dlen;
         
@@ -359,7 +255,6 @@ void test(const TByte* data,const TByte* data_end){
     printf(" \ttime:%.1fs\n",(clock_s()-time0));
 }
 
-#if (_IS_NEED_FAST_ADLER128)
 template <uint64_t kTestMask0,uint64_t kTestMask1>
 void test_fadler128(const TByte* data,const TByte* data_end){
     typedef THash_fadler128 THash;
@@ -373,7 +268,6 @@ void test_fadler128(const TByte* data,const TByte* data_end){
     for (size_t m=0;m<clip_count;++m)
         maps[m].reserve(kMaxMapNodeSize*3/clip_count);
     unsigned int rand_seed=7;
-    _srand(rand_seed);
     printf("mask[%08X %08X ",(int)(kTestMask1>>32),(int)kTestMask1);
     printf("%08X %08X] ",(int)(kTestMask0>>32),(int)kTestMask0);
     printf("%s%s ",THash::name(),std::string(10-strlen(THash::name()),' ').c_str());
@@ -383,14 +277,14 @@ void test_fadler128(const TByte* data,const TByte* data_end){
     double clashBases[clip_count]={0};
     size_t i=0;
     while (curClashMin<kMinClash) {
-        uint64_t    clashMin=~(uint64_t)0;
+        uint64_t    clashMin=-(uint64_t)1;
         for (size_t m=0;m<clip_count;++m){
             if (clashs[m]<clashMin) clashMin=clashs[m];
         }
         curClashMin=clashMin;
         
-        size_t dlen =kMinHashDataSize+(_rand() % (kMaxHashDataSize+1-kMinHashDataSize));
-        size_t dstrat=_rand() % ((data_end-data) - dlen);
+        size_t dlen=rand_r(&rand_seed) % kMaxHashDataSize;
+        size_t dstrat=rand_r(&rand_seed) % ((data_end-data) - dlen);
         assert(dstrat+dlen<=(data_end-data));
         const TByte* pv    =data+dstrat;
         const TByte* pv_end=pv+dlen;
@@ -461,40 +355,8 @@ void test_fadler128(const TByte* data,const TByte* data_end){
     if (clip_count>0) printf("]");
     printf(" \ttime:%.1fs\n",(clock_s()-time0));
 }
-#endif
 
 int main() {
-    
-    printf("init test data ...\n");
-    std::vector<TByte> data(kRandTestMaxSize);
-    unsigned int rand_seed=0;
-    _srand(rand_seed);
-    for (size_t i=0; i<data.size(); ++i) {
-        data[i]=(TByte)_rand();
-    }
-    printf("\n");
-
-    //test speed
-    printf("test hash speed ...\n");
-#if (_IS_NEED_ZLIB)
-    test_speed<THash_adler32>(data.data(),data.data()+data.size());
-    test_speed<THash_crc32>(data.data(),data.data()+data.size());
-#endif
-#if (_IS_NEED_MD5)
-    test_speed<THash_md5_128>(data.data(),data.data()+data.size());
-#endif
-    test_speed<THash_adler32h>(data.data(),data.data()+data.size());
-    test_speed<THash_adler64h>(data.data(),data.data()+data.size());
-    test_speed<THash_fadler32>(data.data(),data.data()+data.size());
-    test_speed<THash_fadler64>(data.data(),data.data()+data.size());
-#if (_IS_NEED_FAST_ADLER128)
-    test_speed<THash_fadler128>(data.data(),data.data()+data.size());
-#endif
-    printf("\n");
-
-    //test clash
-    printf("test hash clash ...\n");
-
     double bestCR_32bit =1.0/(((uint64_t)1)<<32);
     double bestCR_64bit =bestCR_32bit*bestCR_32bit;
     double bestCR_128bit=bestCR_64bit*bestCR_64bit;
@@ -503,78 +365,28 @@ int main() {
     printf("48bit  hash  best clash rate: %.3e (1/%llu) \n",
            1.0/(((uint64_t)1)<<48),(((uint64_t)1)<<48));
     printf("64bit  hash  best clash rate: %.3e (1/%llu%llu) \n",
-           bestCR_64bit,(((uint64_t)(~(uint64_t)0)))/10,(((uint64_t)(~(uint64_t)0)))%10+1);
+           bestCR_64bit,(((uint64_t)(-(uint64_t)1)))/10,(((uint64_t)(-(uint64_t)1)))%10+1);
     printf("128bit hash  best clash rate: %.3e (1/%.3e) \n\n",
            bestCR_128bit,1/bestCR_128bit);
+    
+    std::vector<TByte> data(kRandTestMaxSize);
+    unsigned int rand_seed=0;
+    for (size_t i=0; i<data.size(); ++i) {
+        data[i]=(TByte)rand_r(&rand_seed);
+    }
     const uint64_t kTestMask8=((((uint64_t)1)<<8)-1);
     const uint64_t kTestMask16=((((uint64_t)1)<<16)-1);
     const uint64_t kTestMask32=((((uint64_t)1)<<32)-1);
     const uint64_t kTestMask64=~(uint64_t)0;
-
-    /* //only test adler32h by bit
-    kMinHashDataSize=1024;
-    kMaxHashDataSize=1024;
-    kMinClash=10000;
-    test<THash_adler32h_bit<1>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<2>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<3>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<4>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<5>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<6>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<7>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<8>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<9>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<10>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<11>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<12>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<13>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<14>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<15>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<16>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<17>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<18>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<19>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<20>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<21>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<22>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<23>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<24>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<25>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<26>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<27>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<28>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<29>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<30>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<31>,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h_bit<32>,uint32_t>(data.data(),data.data()+data.size());
-    return 0;
-    //*/
-
-    /* //test defect in fadler64 & toSavedPartRollHash
-    kMinClash=10000;
-    {
-        typedef THash_fadler64_xshl<32> THash_fadler64_x;
-        test<THash_fadler64_x, uint8_t>(data.data(), data.data() + data.size());
-        test<THash_fadler64_x, uint16_t>(data.data(), data.data() + data.size());
-        test<THash_fadler64_x, uint32_t>(data.data(), data.data() + data.size());
-        printf("\n");
-    }
-    return 0;
-    //*/
-
+    
     //*
     kMinClash=100000;
-    test<THash_adler32h,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h,uint32_t>(data.data(),data.data()+data.size());
-#if (_IS_NEED_ZLIB)
+    test<THash_adler32,uint8_t>(data.data(),data.data()+data.size());
+    test<THash_adler32,uint16_t>(data.data(),data.data()+data.size());
     test<THash_adler32,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_crc32,uint16_t>(data.data(),data.data()+data.size());
+    test<THash_adler32h,uint32_t>(data.data(),data.data()+data.size());
     test<THash_crc32,uint32_t>(data.data(),data.data()+data.size());
-#endif
-#if (_IS_NEED_MD5)
     test<THash_md5_128,uint32_t>(data.data(),data.data()+data.size());
-#endif
     test<THash_adler64h,uint8_t>(data.data(),data.data()+data.size());
     test<THash_adler64h,uint16_t>(data.data(),data.data()+data.size());
     test<THash_adler64h,uint32_t>(data.data(),data.data()+data.size());
@@ -586,17 +398,15 @@ int main() {
     test<THash_fadler64,uint16_t>(data.data(),data.data()+data.size());
     test<THash_fadler64,uint32_t>(data.data(),data.data()+data.size());
     //test<THash_fadler64,uint64_t>(data.data(),data.data()+data.size());
-#if (_IS_NEED_FAST_ADLER128)
     test<THash_fadler128,uint8_t>(data.data(),data.data()+data.size());
     test<THash_fadler128,uint16_t>(data.data(),data.data()+data.size());
     test<THash_fadler128,uint32_t>(data.data(),data.data()+data.size());
     kMinClash=50;
     test<THash_fadler128,uint64_t>(data.data(),data.data()+data.size());
-#endif
     printf("\n");
     //*/
     //*
-    printf("NOTE: test fadler64 32bit ...\n");
+     printf("NOTE: test fadler64 32bit ...\n");
     kMinClash=100000;
     test<THash_fadler64,uint64_t,32,kTestMask32>(data.data(),data.data()+data.size());
     test<THash_fadler64,uint64_t,32,kTestMask32<<32>(data.data(),data.data()+data.size());
@@ -607,7 +417,6 @@ int main() {
     printf("\n");
     //*/
     /*
-#if (_IS_NEED_FAST_ADLER128)
     printf("NOTE: not enough time to get next test results ...\n");
     kMinClash=1;
     test_fadler128<kTestMask32,kTestMask32>(data.data(),data.data()+data.size());
@@ -615,15 +424,12 @@ int main() {
     test_fadler128<kTestMask32<<32,kTestMask32>(data.data(),data.data()+data.size());
     test_fadler128<kTestMask32<<32,kTestMask32<<32>(data.data(),data.data()+data.size());
     printf("\n");
-#endif
     //*/
     //*
     printf("NOTE: not enough time to get next test results ...\n");
     kMinClash=1; // for timesaving but increase deviation
     test<THash_fadler64,uint64_t>(data.data(),data.data()+data.size());
-#if (_IS_NEED_MD5)
     test<THash_md5_128,uint64_t>(data.data(),data.data()+data.size());
-#endif
     //*/
     return 0;
 }