chk_hstr.cpp

一个不错

   }

   // resize
   {
     tmp->set_string("ggff");
     chk_invariant(tmp);
     if((r=tmp->resize(2,'t'))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"gg")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->resize(4,'s'))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"ggss")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->resize(3))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"ggs")!=0) {
       WY_THROW( WyRet() );
     }
     {
       const char RES[]={'g','g','s',0,0,0};
       if((r=tmp->resize(6))!=Ok) {
         WY_THROW(r);
       }
       chk_invariant(tmp);
       if(Wy::_strcmp(tmp->cseg(),WyCSeg(RES,6))!=0) {
         WY_THROW( WyRet() );
       }
     }
   }

   // replace
   {
     chk_invariant(tmp);
     tmp->set_string();
     chk_invariant(tmp);
     if((r=tmp->replace(0,0,WyCSeg("kio")))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"kio")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->replace(1,0,WyCSeg("kio")))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"kkioio")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->replace(2,3,WyCSeg("x")))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"kkxo")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->replace(2,3,WyCSeg("x")))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"kkx")!=0) {
       WY_THROW( WyRet() );
     }

     if((r=tmp->replace(2,3,2,'8'))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"kk88")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tmp->replace(1,2,*tp3))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if(Wy::_strcmp(tmp->cseg(),"k1238")!=0) {
       WY_THROW( WyRet() );
     }
   }

   // _strcmp
   {
     chk_invariant(tmp);
     tmp->set_string();
     chk_invariant(tmp);
     if(tmp->_strcmp(*tp0)!=0) {
       WY_THROW( WyRet() );
     }
     if(tp3->_strcmp(*tp3)!=0) {
       WY_THROW( WyRet() );
     }
     if(tp3->_strcmp(*tp4)==0) {
       WY_THROW( WyRet() );
     }
     if(tp3->_strcmp(tp3->cseg())!=0) {
       WY_THROW( WyRet() );
     }
     if(tp3->_strcmp(tp4->cseg())==0) {
       WY_THROW( WyRet() );
     }
   }

   // copyto
   {
     char buf[16];
     size_t rlen=100;
     chk_invariant(tp3);
     if((r=tp3->copyto(&rlen,buf,sizeof(buf),1))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tp3);
     if(rlen!=2) {
       WY_THROW( WyRet() );
     }
     if(Wy::_strcmp(WyCSeg(buf,rlen),"23")!=0) {
       WY_THROW( WyRet() );
     }
     if((r=tp3->copyto(&rlen,buf,0,1))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tp3);
     if(rlen!=0) {
       WY_THROW( WyRet() );
     }
     if(Wy::_strcmp(WyCSeg(buf,rlen),"23")==0) {
       WY_THROW( WyRet() );
     }
     if((r=tp3->copyto(&rlen,buf+1,sizeof(buf)-1,0))!=Ok) {
       WY_THROW(r);
     }
     if(Wy::_strcmp(WyCSeg(buf,4),"2123")!=0) {
       WY_THROW( WyRet() );
     }
     if(rlen!=3) {
       WY_THROW( WyRet() );
     }
   }

    // _setsize(size_t)
    {
     if((r=tmp->set_string("helo-world"))!=Ok) {
       WY_THROW(r);
     }
     chk_invariant(tmp);
     if((r=tmp->_setsize(3))!=Ok) {
       WY_THROW(r);
     }
     if(tmp->_strcmp("hel")!=0) {
       WY_THROW(r);
     }
     if((r=tmp->_setsize(tmp->_capacity()))!=Ok) {
       WY_THROW(r);
     }
     if((r=tmp->_setsize(tmp->_capacity()+1))!=Wym_EFBIG) {
       WY_THROW(r);
     }
    }
   }
   catch(...) {
     Wy__HStr::free(tp0);
     Wy__HStr::free(tp1);
     Wy__HStr::free(tp2);
     Wy__HStr::free(tp3);
     Wy__HStr::free(tp4);
     Wy__HStr::free(tp5);
     Wy__HStr::free(tmp);
     throw;
   };
  
   Wy__HStr::free(tp0);
   Wy__HStr::free(tp1);
   Wy__HStr::free(tp2);
   Wy__HStr::free(tp3);
   Wy__HStr::free(tp4);
   Wy__HStr::free(tp5);
   Wy__HStr::free(tmp);
};
  
static void ck_error(void)
{
 Wy__HStr* GPtr0=Wy__HStr::alloc();     // GPtr0 is common for the check
 Wy__HStr* GPtr1=Wy__HStr::alloc("1");  // GPtr1 is common for the check
 WyRet r;

 try {
  
   // alloc(size_t)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(Wy__HStr::max_capacity()+1);
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // alloc(size_t,char)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(size_t(-1),'x');
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // alloc(const WyCSeg&)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(WyCSeg("",size_t(-1)));
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // alloc(const WyCSeg&,const WyCSeg&)
   {
     try {
       WyCSeg bseg("",size_t(-1));
       Wy__HStr* hptr=Wy__HStr::alloc(bseg,bseg);
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // alloc(const WyCSeg&,const WyCSeg&,const WyCSeg&)
   {
     try {
       WyCSeg bseg("",size_t(-1));
       Wy__HStr* hptr=Wy__HStr::alloc(bseg,bseg,bseg);
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   // alloc(const Wy__HStr&)
   {
   }

   // alloc(const WCSeg&,char)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(WyCSeg("",Wy__HStr::max_capacity()),'z');
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // alloc(const WCSeg&,size_t,char)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(WyCSeg("",Wy__HStr::max_capacity()),1,'z');
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   // alloc(const WCSeg&,size_t,char,const WyCSeg&)
   {
     try {
       Wy__HStr* hptr=Wy__HStr::alloc(WyCSeg(""),Wy__HStr::max_capacity(),'z',
                                      WyCSeg("a"));
       Wy__HStr::free(hptr);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EFBIG) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   // cseg(size_t)
   {
     try {
       GPtr0->cseg(GPtr0->size()+1);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EINVAL) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // cseg(size_t,size_t)
   {
     try {
       GPtr0->cseg(GPtr0->size()+1,2);
       WY_THROW( WyRet() );
     }
     catch(const Wy__HStr::Reply& e) {
       if(e!=Wym_EINVAL) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   // set_string(..)
   if((r=GPtr0->set_string(*GPtr0))!=Ok) {  // note GPtr.size()==0, so Ok
     WY_THROW(r);
   }
   if((r=GPtr1->set_string(*GPtr1))!=Wym_ELOOP) {
     WY_THROW(r);
   }
   if((r=GPtr1->set_string(GPtr1->cseg()))!=Wym_ELOOP) {
     WY_THROW(r);
   }
   if((r=GPtr1->set_string(WyCSeg("",size_t(-1))))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   if((r=GPtr1->set_string(size_t(-1),'a'))!=Wym_EFBIG) {
     WY_THROW(r);
   }

   // append
   if((r=GPtr1->append(*GPtr1))!=Ok) {
     // imp. feature
     WY_THROW(r);
   }
   if((r=GPtr1->append(GPtr1->cseg()))!=Ok) {
     // imp. feature
     WY_THROW(r);
   }
   if((r=GPtr1->append(WyCSeg("",size_t(-1))))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   if((r=GPtr1->append(size_t(-1),'a'))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   if((r=GPtr1->set_string(GPtr1->_capacity(),'F'))!=Ok) {
     WY_THROW(r);
   }
   if((r=GPtr1->append('x'))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   
   // insert
   if((r=GPtr1->set_string(3,'F'))!=Ok) {
     WY_THROW(r);
   }
   if((r=GPtr1->insert(GPtr1->size()+1,WyCSeg("x")))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->insert(1,GPtr1->cseg()))!=Wym_ELOOP) {
     WY_THROW(r);
   }
   if((r=GPtr1->insert(1,WyCSeg("",GPtr1->_capacity())))!=Wym_EFBIG) {
     WY_THROW(r);
   }

   if((r=GPtr1->insert(GPtr1->size()+1,1,'a'))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->insert(1,GPtr1->_capacity(),'a'))!=Wym_EFBIG) {
     WY_THROW(r);
   }

   if((r=GPtr1->insert(GPtr1->size()+1,*GPtr0))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->insert(0,*GPtr1))!=Wym_ELOOP) {
     WY_THROW(r);
   }

   // erase
   if((r=GPtr1->erase(GPtr1->size()+1))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->erase(GPtr1->size()+1,1))!=Wym_EINVAL) {
     WY_THROW(r);
   }

   // resize
   if((r=GPtr1->resize(GPtr1->_capacity()+1))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   if((r=GPtr1->resize(GPtr1->_capacity()))!=Ok) {
     WY_THROW(r);
   }
   if((r=GPtr1->resize(GPtr1->_capacity()+1,'a'))!=Wym_EFBIG) {
     WY_THROW(r);
   }

   // replace
   if((r=GPtr1->set_string(3,'F'))!=Ok) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(GPtr1->size()+1,1,*GPtr1))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(1,1,*GPtr1))!=Wym_ELOOP) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(GPtr1->size()+1,1,WyCSeg("",1)))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(1,1,WyCSeg("",GPtr1->_capacity())))!=Wym_EFBIG) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(1,1,GPtr1->cseg()))!=Wym_ELOOP) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(GPtr1->size()+1,1,1,'a'))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=GPtr1->replace(1,1,GPtr1->_capacity(),'a'))!=Wym_EFBIG) {
     WY_THROW(r);
   }

   // copyto
   {
    char buf[16];
    size_t rlen=99;
    if((r=GPtr1->set_string(3,'F'))!=Ok) {
      WY_THROW(r);
    }
    if((r=GPtr1->copyto(&rlen,(char*)0,1,0))!=Wym_EFAULT) {
      WY_THROW(r);
    }
    if((r=GPtr1->copyto(&rlen,buf,sizeof(buf),GPtr1->size()+1))!=Wym_EINVAL) {
      WY_THROW(r);
    }
   }
  }
  catch(...) {
    Wy__HStr::free(GPtr0);
    Wy__HStr::free(GPtr1);
    throw;
  };
};

static void print_ret(const WyRet& r)
{
#ifndef WYLIB_CONFIG_NORSLI
 if(r.sli_ptr()==0) {
   std::cerr << r->c_repstr();
 } else {
   std::cerr << r.sli_ptr()->src_file()<< '(' << r.sli_ptr()->src_line()
             << "): " << r->c_repstr();
 }
#else
   std::cerr << r->c_repstr();
#endif
};

static const std::string chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wy__hstr.h ...\n";
 if(std::string(Wy__HStr::class_name)!="Wy__HStr") {
   WY_THROW(WyRet() );
 }
 std::cout << "sizeof(Wy__HStr)=" << sizeof(Wy__HStr) << std::endl;
 if((sizeof(Wy__HStr)%sizeof(double))!=0) {
   std::cout << "  Warning: sizeof(Wy__HStr) is not double aligned\n";
 }

 std::cout << std::dec
           << "  Wy__HStr::min_capacity()= " << Wy__HStr::min_capacity()
           << std::endl;
 std::cout << std::hex
           << "  Wy__HStr::max_capacity()= 0x" << Wy__HStr::max_capacity()
           << std::endl;

 if(std::string().max_size()!=Wy__HStr::max_capacity()) {
   std::cout << std::hex
           << "  std::string().max_size()= 0x" << std::string().max_size()
           << std::endl;
 }

 ck_str();
 ck_error();
 std::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 std::cerr << chdr;
 print_ret(e);
 std::cerr << std::endl;
 return(-1);
}
catch(const std::exception& e) {
 std::cerr << chdr;
 std::cerr << chdr << "std::exception( \n" << e.what()
           << "\" )" << std::endl;
 std::cerr << std::endl;
 return(-1);
}
catch(...) {
 std::cerr << chdr << "unknow exception" << std::endl;
 throw;
};