chk_terminal.cpp

一个不错

   CHK_DEFAULT(tmp);
 }

 // ttyname
 {
   WyTerminal tmp;
   WyStr pn;
   if((r=tmp.devname(pn))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(pn.is_default()==false) {
     WY_THROW( WyRet() );  // pn modified
   }

   //WyTerminal t2(Wy::cout);
   //if((r=t2.devname(pn))!=Ok) {
   //  WY_THROW(r);
   //}
   //std::cerr << "Wy::cout= " << pn.c_str() << '\n';
 }
 
 //
 // virtual function
 //
 {
   WyTerminal t0;
   WyChrFile c0,*p=&t0;
   if((r=c0.reset(t0))!=Ok) {
     WY_THROW(r);
   }

   // modified to return Ok since c0 is default
   if((r=p->reset(c0))!=Ok) {
     WY_THROW(r);
   }
   if((r=p->_swap(c0))!=Wym_EBADTYPE) {
     WY_THROW(r);
   }
   if((r=c0._swap(*p))!=Wym_EBADTYPE) {
     std::cout << p->class_name << std::endl;
     WY_THROW(r);
   }
   if((r=p->reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(t0,NObj);
 }
};

//
// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 // stat NObj
 WyTerminal 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() );
   }
   std::cout << "Terminal, m_blksize= " << stt.sf_blksize() << '\n';
 }

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

   WyTerminal tmp2(static_cast<const WyByteFlow&>(NObj));
   CHK_SAME_SYSF(tmp2,NObj);
 }

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

 // reset(const WyChrFile&)
 {
   WyTerminal tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   WyFileHandle TmpFh( tmp.fh() );
   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
   if(tmp.fh()!=TmpFh) {
     // ok, same device, not the same fd
     //WY_THROW( WyRet() );
   }

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

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

 // reset(const WyStr&,int)
 {
   WyTerminal 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)
 {
   WyTerminal tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(WyFileHandle(STDERR_FILENO)))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.reset(WyFileHandle()))!=Ok) {
     WY_THROW(r);
   }
 }

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

   n_wr=1;
   if((r=tmp.write(buf,0,n_wr))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=1;
   if((r=tmp.write(WyStr(),n_wr))!=Ok) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.drain())!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // reset()
 {
   WyTerminal tmp(NObj);
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(RefFileName,O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(tmp.fh()==NObj.fh()) {
     WY_THROW( WyRet() );
   }
 }

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

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

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

 //
 // sendbreak,flush,flow
 //
 {
   WyTerminal tmp(NObj);
   CHK_NOT_DEFAULT(tmp);
   
   if((r=tmp.sendbreak(0))!=Ok) {
     WY_THROW(r);
   }

   if((r=tmp.flush(TCOFLUSH))!=Ok) {
     WY_THROW(r);
   }

   if((r=tmp.flow(TCOON))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // 
 // getattr,setattr
 //
 {
   WyTerminal tmp(NObj);
   WyTermios tio;
   CHK_NOT_DEFAULT(tmp);
   if(tio.is_default()==false) {
     WY_THROW( WyRet() );
   }

   if((r=tmp.getattr(tio))!=Ok) {
     WY_THROW(r);
   }
   if(tio.is_default()) {
     WY_THROW( WyRet() );
   }

   WyTermios tio_org(tio);
   dump_termios(RefFileName,tio);

   if((r=tmp.setattr(tio_org,TCSANOW))!=Ok) { // write the same back
     WY_THROW(r);
   }
   if((r=tmp.getattr(tio))!=Ok) {
     WY_THROW(r);
   }
   if(tio!=tio_org) {
     WY_THROW( WyRet() );
   }
 }

 // ttyname
 {
   WyTerminal tmp(NObj);
   WyStr pn;
   if((r=tmp.devname(pn))!=Ok) {
     WY_THROW(r);
   }
   if(pn!=RefFileName) {
     std::cerr << "devname()=" << pn.c_str() << std::endl;
     WY_THROW( WyRet() );
   }
 }

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

  new(p1) WyTerminal(RefFileName,O_RDONLY);
  try {
   WyStr pn;
   if((r=p1->devname(pn))!=Ok) {
     WY_THROW(r);
   }
   if(pn!=RefFileName) {
     std::cerr << "devname()=" << pn.c_str() << std::endl;
     WY_THROW( WyRet() );
   }
  }
  catch(...) {
    p1->~WyTerminal();
    throw;
  };

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

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

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

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

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

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

 //
 // Test destructor exception
 //
 {
   WyTerminal tmp;
   //std::memset(&tmp,-2,sizeof(tmp));
   // destructor of tmp is now not to cause exception for this setting
 }
};

static void t_error_ret(void)
{
 WyRet r;

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

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

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

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

 // reset() base
 {
  WyTerminal tmp(RefFileName,O_RDONLY);
  CHK_NOT_DEFAULT(tmp);
  WyChrFile *bp=&tmp;
  if((r=bp->reset())!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);
 }

 // EFBIG
 {
  WyTerminal tmp(RefFileName,O_RDONLY);
  WyStr buf;
  size_t n_rd(3);
  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() );
  }
  n_rd=9;
  if((r=tmp.read(buf,std::numeric_limits<size_t>::max(),n_rd))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

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

static const WyStr chdr(
                  "+------------------+\n"
                  "| main(..) caught: |\n"
                  "+------------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wyterminal.h ...\n";
 if(std::strcmp(WyTerminal::class_name,"WyTerminal")!=0) {
   WY_THROW( WyRet() );
 }
#ifdef WY_DEBUG
 initial_fdcnt=wydbg_get_fdcnt();
#endif
 try {
   setup_test();
   t1();
   t2();
   t_throw();
   t_error_ret();
   close_test();
 }
 catch(...) {
   close_test();
#ifdef WY_DEBUG
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );           // fd lost
 }
#endif
   throw;
 }
#ifdef WY_DEBUG
 if(wydbg_get_fdcnt()!=initial_fdcnt) {
   WY_THROW( WyRet() );           // fd lost
 }
#endif
 std::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 std::cerr << chdr.c_str() << Wy::wrd(e).c_str() << std::endl;
 return(-1);
}
catch(const std::exception& e) {
 std::cerr << chdr.c_str() << "std::exception" << std::endl;
 return(-1);
}
catch(...) {
 std::cerr << chdr.c_str() << "unknown unwind" << std::endl;
 return(-1);
};