ck_chrfile.cpp

一个不错

  }
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);
  CHK_SAME_SYSF(tmp1,NObj);

  if((r=tmp0._swap(tmp1))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp1);
  CHK_NOT_DEFAULT(tmp0);
  CHK_SAME_SYSF(tmp0,NObj);

  WyByteFlow bf1;
  if((r=tmp1._swap(bf1))!=Wym_EBADTYPE) {
    WY_THROW( WyRet() );
  }
 }

 // read,write ...(const char*)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   char buf[2]={6,7};
   size_t n_rd(99);
   if((r=tmp.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((buf[0]!=6)||(buf[1]!=7)) {
     WY_THROW( WyRet() );
   }
   n_rd=5;
   if((r=tmp.read(buf,0,n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_rd=5;
   if((r=NObj.read(buf,0,n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   size_t n_wr(7);
   if((r=tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if((buf[0]!=6)||(buf[1]!=7)) {
     WY_THROW( WyRet() );
   }
   n_wr=100;
   if((r=tmp.write(WyStr(),n_wr))!=Wym_EBADF) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=100;
   if((r=tmp.write(WyCSeg("",size_t(0)),n_wr))!=Wym_EBADF) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp._tcdrain())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((buf[0]!=6)||(buf[1]!=7)) {
     WY_THROW( WyRet() );
   }
 }

 // read(WyStr)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   WyStr buf;
   size_t n_rd=5;
   if((r=tmp.read(buf,size_t(1),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(buf.is_default()==false) {
     WY_THROW( WyRet() );
   }
 }

 // reset(WyFileHandle)
 //
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyFileHandle()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   if((r=tmp.reset(NObj.fh()))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);

   if(tmp.fh()==NObj.fh()) {
     WY_THROW( WyRet() );
   }

   if((r=tmp.reset(WyFileHandle()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // reset(WyChrFile)
 //
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyChrFile()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);

   if(tmp.fh()==NObj.fh()) {
     WY_THROW( WyRet() );
   }

   if((r=tmp.reset(WyChrFile()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

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

  new(p1) WyChrFile(RefFileName,O_RDONLY);
  if(p1->_isatty()==false) {
    p1->~WyChrFile();
    WY_THROW( WyRet() );
  }

  // move *p1 to p2
  WyFileHandle ofh( p1->fh() );
  try {
    new(p2) WyChrFile(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~WyChrFile();
    throw;
  };
  WyFileHandle nfh( p2->fh() );
  p2->~WyChrFile();

  if(nfh!=ofh) {
    WY_THROW( WyRet() );
  }
 }

};

// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 // stat NObj
 WyChrFile NObj;     // non-default object for the test
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefFileName,O_RDWR))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(NObj);
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
 }

 // constructor
 {
   WyChrFile tmp(NObj);
   CHK_NOT_DEFAULT(tmp);
   if(tmp.fh()==NObj.fh()) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

 // reset()
 {
   WyChrFile tmp(NObj);
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // reset(const WyByteFlow&)
 {
   WyChrFile tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(static_cast<WyByteFlow&>(NObj)))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

 // chk t.reset(t)
 {
   WyChrFile tmp(NObj);
   WyFileHandle TmpFh( tmp.fh() );
   if((r=tmp.reset(tmp))!=Ok) {
     WY_THROW(r);
   }
   if(TmpFh!=tmp.fh()) {
     // Ok either way
   }
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // reset(const char*,int)
 {
   WyChrFile tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(RefFileName.c_str(),O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   //CHK_SAME_SYSF(tmp,NObj);
 }

 // reset(const WyStr&,int)
 {
   WyChrFile tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(RefFileName,O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   //CHK_SAME_SYSF(tmp,NObj);
 }

 // reset(WyFileHandle)
 {
   WyChrFile tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(WyFileHandle(STDERR_FILENO)))!=Ok) {
     WY_THROW(r);
   }
   //CHK_SAME_SYSF(tmp,NObj);
 }

 // (zero byte) read,write
 {
   WyChrFile tmp(NObj);
   char buf[2]={-1,-1};
   size_t n_rd=5;   // anything >1
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.read(buf,0,n_rd))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_rd=200;

   if((r=tmp.write(buf,0,n_rd))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.write(WyStr(),n_rd))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(tmp._isatty()==false) {
     WY_THROW( WyRet() );
   }
   if((r=tmp._tcdrain())!=Ok) {  // tmp is tty
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

};

static void t_throw(void)
{
 // WyChrFile(const WyChrFile&)
 //
 if(exaustfd_flag) {
   try {
     const WyChrFile tmp(RefFileName,O_RDONLY);
     exaust_cpy_ctor(tmp);
     WY_THROW( WyRet() );  // not expected
   }
   catch(const WyChrFile::Reply& e) {
     if((e!=Wym_EMFILE)&&(e!=Wym_ENOMEM)) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   }
   catch(...) {
     throw;
   };
 }

 // WyChrFile(const char*,int)
 //
 try {
   WyChrFile tt2("no.such.name",0);
   WY_THROW( WyRet() );  // not expected
 }
 catch(const WyChrFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 }
 catch(...) {
   throw;
 };

 // WyChrFile(const WyStr&,int)
 //
 try {

   // WyChrFile tt2(WyStr(NoSuchPathName),0);  // wont compile????
   //
   WyChrFile tt2(WyStr("no.such.name"),0);
   WY_THROW( WyRet() );  // not expected
 }
 catch(const WyChrFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 }
 catch(...) {
   throw;
 };

 // WyChrFile(WyFileHandle)
 //
 {
   int v= wyc_open(__FILE__,O_RDONLY);
   if(v==-1) {
     WY_THROW( WyRet(WyReply(errno)) );
   }
   Wy_AtDestroy<int,const Wy__TypeFD&> rrid(WySysFile::wy_close,v);
   try {
     WyChrFile tmp(( WyFileHandle(v) ));    /* See the following check */
     WY_THROW( WyRet() );
   }
   catch(const WyChrFile::Reply& e) {
     if(e!=Wym_EBADF) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };

   try {
     WyChrFile tmp( (WyFileHandle(v)) );
     WY_THROW( WyRet() );
   }
   catch(const WyChrFile::Reply& e) {
     if(e!=Wym_EBADF) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 try {
   //WyChrFile tmp( WyFileHandle(NoSuchFd) );  // wont compile????
   WyChrFile tmp( WyFileHandle(-2) );  // assert no fd(-2)
   WY_THROW( WyRet() );  // not expected
 }
 catch(const WyChrFile::Reply& e) {
   if(e!=Wym_EBADF) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 }
 catch(const WyRet& e) {
     WY_THROW( WyRet(e) );
 }
 catch(...) {
   throw;
 };

 // Test destructor throw
 //
 {
   WyChrFile tmp;
   //std::memset(&tmp,NoSuchFd,sizeof(tmp));  
   // destructor of tmp is now not to throw for this setting
 }
};

static void t_error_ret(void)
{
 WyRet r;

 // stat
 {
  WyChrFile tmp;
  WyFileStat stt;
  if((r=tmp.stat(stt))!=Wym_EBADF) {
    WY_THROW(r);
  }
 }

 // reset(const char*,int)
 {
  WyChrFile tmp;
  if((r=tmp.reset("no.such.name",0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);
 }

 // reset(const WyStr&,int)
 {
  WyChrFile tmp;
  if((r=tmp.reset(WyStr("no.such.name"),0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);
 }

 // reset(WyFileHanle)
 {
  WyChrFile tmp;
  if((r=tmp.reset( WyFileHandle(-1) ))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);
 }

 // reset() base
 {
  WyChrFile tmp;
  CHK_DEFAULT(tmp);
  WyByteFlow *bp=&tmp;
  if((r=bp->reset())!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);
 }

 // EFBIG
 {
  WyChrFile tmp(RefFileName,O_RDONLY);
  WyStr buf;
  size_t n_rd(8);
  CHK_NOT_DEFAULT(tmp);
  if((r=tmp.read(buf,WyStr::max_capacity()+1,n_rd))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

 // chk WyByteFlow::reset(void)
 {
  WyChrFile tmp(RefFileName,O_RDONLY);
  if((r=static_cast<WyByteFlow&>(tmp).reset())!=Ok) {
    WY_THROW(r);
  }
  if(tmp.fh()!=WyFileHandle()) {
    WY_THROW(r);
  }
 }

 // chk _alloc not override
 {
   class T : public WyChrFile {
   } tmp;
   WyChrFile* p=tmp._alloc(r);
   if(r!=Wym_ENOSYS) {
     if(r==Ok) {
       delete p;
     }
     WY_THROW(r);
   }
 }
};

static void t_read_line(void)
{
 //WyRet r;
 WyChrFile f0;
 WyChrFile f1(RefFileName,O_RDONLY);

 CHK_DEFAULT(f0);
 CHK_NOT_DEFAULT(f1);
};

void ck_chrfile(bool exaustfd)
try {
  exaustfd_flag=exaustfd;
#ifdef WY_DEBUG
 initial_fdcnt=wydbg_get_fdcnt();
#endif
   setup_test();
   t1();
   t2();
   t_throw();
   t_error_ret();
   t_read_line();
   close_test();
#ifdef WY_DEBUG
 // fd may be lost. report is only valid in single thread test
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );
 }
 Wy::cout << " fd allocated= " << wydbg_get_fdcnt_max() << '\n';
#endif
}
catch(...) {
 close_test();
#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
 throw;
};