ck_byteflow.cpp

一个不错

     };
   }
  
   // chk copy ctor failure (const WySysFile&)
   {
     try {
       const WySysFile tmp(HSrc0);
       exaust_cpy_ctor(tmp);
       WY_THROW( WyRet() );
     }
     catch(const WyByteFlow::Reply& e) {
       if((e!=Wym_EMFILE)&&(e!=Wym_ENOMEM)) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // chk copy ctor failure (const WyByteFlow&)
   {
     try {
       const WyByteFlow tmp(HSrc0);
       exaust_cpy_ctor(tmp);
       WY_THROW( WyRet() );
     }
     catch(const WyByteFlow::Reply& e) {
       if((e!=Wym_EMFILE)&&(e!=Wym_ENOMEM)) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // chk copy ctor failure (const char*,int)
   {
     try {
       const WyByteFlow tmp("nosuchfile.delete.me",O_RDONLY);
       WY_THROW( WyRet() );
     }
     catch(const WyByteFlow::Reply& e) {
       if(e!=Wym_ENOENT) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // chk copy ctor failure (const WyStr&,int)
   {
     try {
       const WyByteFlow tmp( WyStr("nosuchfile.delete.me"),O_RDONLY);
       WY_THROW( WyRet() );
     }
     catch(const WyByteFlow::Reply& e) {
       if(e!=Wym_ENOENT) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   // chk err reset(WyFileHandle)
   {
    WyByteFlow tmp;
    if((r=tmp.reset(WyFileHandle(-2)))!=Wym_EBADF) {
      WY_THROW(r);
    }
   }

   // chk err reset(const WyByteFlow&)/reset(const WySysFile&)
   {
     WyByteFlow tmp1(HSrc0);
     r=exaust_reset(tmp1);
     if((r!=Wym_EMFILE)&&(r!=Wym_ENOMEM)) {
       WY_THROW( WyRet(r) );
     }

     WySysFile tmp2(HSrc0);
     r=exaust_reset(tmp2);
     if((r!=Wym_EMFILE)&&(r!=Wym_ENOMEM)) {
       WY_THROW( WyRet(r) );
     }
   }
  
   // chk _swap err
   {
     WyByteFlow tmp0;
     WySysFile tmp1;
     WyRet r( tmp0._swap(tmp1) );
     if(r!=Wym_EBADTYPE) {
       WY_THROW( WyRet(r) );
     }
     r=tmp1._swap(tmp0);
     if(r!=Wym_EBADTYPE) {
       WY_THROW( WyRet(r) );
     }
   }

   // chk move ctor
   {
    char raw_buf[2*sizeof(WyByteFlow)];
    ::memset(raw_buf,0,sizeof(raw_buf));
    WyByteFlow* const p1( reinterpret_cast<WyByteFlow*>(raw_buf) );
    WyByteFlow* const p2(p1+1);

    new(p1) WyByteFlow(__FILE__,O_RDONLY);

    // move *p1 to p2
    WyFileHandle ofh( p1->fh() );
    mode_t oft( p1->ftype() );
    if(oft!=S_IFREG) {
      WY_THROW( WyRet() );
    }
    try {
      new(p2) WyByteFlow(*p1,Wy::ByMove);
    }
    catch(...) {
      p1->~WyByteFlow();
      throw;
    };
    WyFileHandle nfh( p2->fh() );
    mode_t nft( p2->ftype() );
    p2->~WyByteFlow();

    if(nfh!=ofh) {
      WY_THROW( WyRet() );
    }
    if(nft!=oft) {
      WY_THROW( WyRet() );
    }
   }
 } catch(...) {
   throw;
 };

};

static void close_fds(int fd0, int fd1)
{
 ::close(fd0);
 ::close(fd1);
};

// chk WyByteFlow read/write
//
static void ck_byteflow_2(void)
{
 WyRet r;
 
 // default read/write
 {
   WyByteFlow tmp;
   CHK_DEFAULT(tmp);
   char buf[2];
   size_t n_rd=99;
   if((r=tmp.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);

   n_rd=99;
   const char cstr[]="xxx";
   WyStr str(cstr);
   if((r=tmp.read(str,5,n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(str!=cstr) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);

   size_t n_wr=99;
   if((r=tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);

   n_wr=99;
   if((r=tmp.write(str,n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if(str!=cstr) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);

   n_wr=99;
   if((r=tmp.write(WyCSeg(cstr),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if(str!=cstr) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);

   //if((r=tmp.drain())!=Wym_EBADF) {
   //  WY_THROW(r);
   //}
 }

 // use a pipe for the r/w test
 int fds[2];
 if(::pipe(fds)!=0) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 Wy_AtDestroy2<void,int,int> rrid(close_fds,fds[0],fds[1]);
 // Note:
 //    WyByteFlow prd( fd );  // conversion to non-scalar type (WyByteFlow)
 //                           // error
 //
 //    WyByteFlow prd( WyFileHandle(fd) ); // function declaration interpreted 
 //
 WyByteFlow prd= WyFileHandle(fds[0]);   // read end of the pipe
 WyByteFlow pwr= WyFileHandle(fds[1]);   // write end of the pipe

 // default read/write
 {
   // note: data size 0 not checked
   const char* tdata[]={"a","\ndata for read\nwrite test\n"};
   char rbuf[128];
   for(size_t idx=0; idx<sizeof(tdata)/sizeof(char*); ++idx) {
     const char* dptr=tdata[idx];
     size_t n_rd,n_wr;
 
     // rw cstr
     n_wr=99;
     if((r=pwr.write(dptr,::strlen(dptr),n_wr))!=Ok) {
       WY_THROW(r);
     }
     if(n_wr!=::strlen(dptr)) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }

     n_rd=99;
     if((r=prd.read(rbuf,sizeof(rbuf),n_rd))!=Ok) {
       WY_THROW(r);
     }
     if(n_rd!=n_wr) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }
     if(::memcmp(rbuf,dptr,n_rd)!=0) {
       WY_THROW( WyRet() );
     }

     // rw WyStr
     const WyStr wstr(dptr);
     n_wr=99;
     if((r=pwr.write(wstr,n_wr))!=Ok) {
       WY_THROW(r);
     }
     if(n_wr!=wstr.size()) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }
     WyStr rstr;
     n_rd=99;
     if((r=prd.read(rstr,100,n_rd))!=Ok) {
       WY_THROW(r);
     }
     if(n_rd!=n_wr) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }
     if(wstr!=rstr) {
       WY_THROW( WyRet() );
     }

     // w WyCSeg/append read
     n_wr=99;
     WyCSeg wseg(wstr.cseg());
     if((r=pwr.write(wseg,n_wr))!=Ok) {
       WY_THROW(r);
     }
     if(n_wr!=wseg.size()) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }
     const WyStr apd_res(rstr+rstr);   // expected result of the append read
     n_rd=99;
     if((r=prd.read(rstr,100,n_rd))!=Ok) {
       WY_THROW(r);
     }
     if(n_rd!=n_wr) {
       WY_THROW( WyRet() );      // may be Ok, but not experienced
     }
     if(apd_res!=rstr) {
       WY_THROW( WyRet() );
     }
   }
 }
};

// average function form for cleanup
static void set_sdev(WyByteFlow& sdev,const WyByteFlow& ndev)
{
 sdev.reset(ndev);
};

// chk the stand device object sdev and its associated STDxx_FILENO
//
static void ck_sdev(WyByteFlow& sdev, int sfd)
{
 WyRet r;
 if(sdev.is_default()) {
   WY_THROW( WyRet() );
 }
 if(sdev.fh()!=WyFileHandle(sfd)) {
   WY_THROW( WyRet() );
 }
 const WyByteFlow PreSdev(sdev);
 CHK_SAME_SYSF(sdev,PreSdev);

 try {
   const char* ftxt="/* Copyrig";   // first 10 characters of this file
   const size_t ftxt_len=::strlen(ftxt);
   const int nfd=wyc_open(__FILE__,O_RDONLY);
   if(nfd==-1) {
     WY_THROW( WyRet(WyReply(errno)) );
   }
   Wy_AtDestroy<int,const Wy__TypeFD&> rrid(WySysFile::wy_close,nfd);
 
   Wy_AtDestroy2<void,WyByteFlow&,const WyByteFlow&> 
                            rrad_dev(set_sdev,sdev,PreSdev);
   // reset(WyFileHandle)/read
   {
     if((r=sdev.reset( WyFileHandle(nfd) ))!=Ok) {
       WY_THROW(r);
     }
     if(sdev.fh()!= WyFileHandle(sfd)) {
       WY_THROW( WyRet() );  // fd should not change
     }
     WyStr str;
     size_t n_rd=99;
     if((r=sdev.read(str,ftxt_len,n_rd))!=Ok) {
       WY_THROW(r);
     }
     if(str!=WyCSeg(ftxt,ftxt_len)) {
       WY_THROW( WyRet() );
     }
     if(n_rd!=ftxt_len) {
       WY_THROW( WyRet() );
     }

     n_rd=99;
     if((r=sdev.read(&str[0],str._capacity(),n_rd))!=Ok) {
       WY_THROW(r);
     }
     if(n_rd==99) {
       WY_THROW( WyRet() );
     }
   }

   {
     size_t n_wr=99;
     if((r=sdev.write("",0,n_wr))!=Wym_EBADF) {  // sdev is rd-only
       WY_THROW(r);
     }
     if(n_wr!=0) {
       WY_THROW( WyRet() );
     }
     //if((r=sdev.drain())!=Ok) {
     //  WY_THROW(r);
     //}
   }
 }
 catch(...) {
   CHK_SAME_SYSF(sdev,PreSdev);
   throw;
 }
 CHK_SAME_SYSF(sdev,PreSdev);

 // chk reset()
 try {
   r=sdev.reset();
   WY_THROW(r);
 }
 catch(const WyRet& e) {
   if(e!=Wym_EBADF) {
     // using ::dup2 to recover system std fd
     const int rfd=wyc_dup2(PreSdev.fh().fd(),sfd);
     if(rfd==-1) {
       WY_THROW( WyRet(WyReply(errno)) );
     }
     if(rfd!=sfd) {
       WY_THROW( WyRet() );
     }
     CHK_SAME_SYSF(PreSdev,WyFileHandle(sfd));
     WY_THROW( WyRet(r) );
   }
   // FALLTHROUGH
 }
 catch(...) {
   // using ::dup2 to recover system std fd
   const int rfd=wyc_dup2(PreSdev.fh().fd(),sfd);
   if(rfd==-1) {
     WY_THROW( WyRet(WyReply(errno)) );
   }
   if(rfd!=sfd) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(PreSdev,WyFileHandle(sfd));
   throw;
 };

 // chk _alloc
 {
  WyByteFlow* p=sdev._alloc(r);
  if(r!=Wym_ENOSYS) {
    WY_THROW(r);
  }
  if(p!=0) {
    WY_THROW( WyRet() );
  }
  /*
  Wy_AtDestroy<void,WyByteFlow*> rrid(Wy::_delete_one,p);
  CHK_DEFAULT(*p);
  if(typeid(*p)!=typeid(WyByteFlow)) {
    WY_THROW(r);
  } */
 }

};

static void ck_ioe(void)
{
 ck_sdev(Wy::cin,STDIN_FILENO);
 ck_sdev(Wy::cout,STDOUT_FILENO);
 ck_sdev(Wy::cerr,STDERR_FILENO);
};

void ck_byteflow(void)
{
#ifdef WY_DEBUG
 initial_fdcnt=wydbg_get_fdcnt();
#endif

 ck_byteflow_1();
#ifdef WY_DEBUG
 // fd may be lost. report is only valid in single thread test
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );
 }
#endif

 ck_byteflow_2();
#ifdef WY_DEBUG
 // fd may be lost. report is only valid in single thread test
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );
 }
#endif

#ifdef WY_DEBUG
 // fd may be lost. report is only valid in single thread test
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );
 }
#endif

 ck_ioe();
#ifdef WY_DEBUG
 // fd may be lost. report is only valid in single thread test
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );
 }
#endif
};