chk_terminal.cpp

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2003

   Check WyTerminal public members

   Build: make chk_terminal

   Note: Test data files should exist in the working directory
         Files may be created in the working directory and unlinked
*/

#include "wyterminal.h"
#include "wy_atdestroy.h"
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <new>
#include <iostream>

#if WYTERMINAL_VERSION!=31
#error Test code is for WYTERMINAL_VERSION 31
#endif

#ifdef WY_DEBUG
static int initial_fdcnt=0;
#endif

const int NoSuchFd=-2;
static const WyStr RefFileName("/dev/tty");

static long baud_rate(speed_t sp)
{
 switch(sp) {
   case B0:  return(0);
   case B50:  return(50);
   case B75:  return(75);
   case B134: return(134); // 134.5
   case B150: return(150);
   case B200: return(200);
   case B300: return(300);
   case B600: return(600);
   case B1200: return(1200);
   case B1800: return(1800);
   case B2400: return(2400);
   case B4800: return(4800);
   case B9600: return(9600);
   case B19200: return(9200);
   case B38400: return(38400);
   case B57600: return(57600);
   case B115200: return(115200);
   case B230400: return(230400);
   default:
     return(-1);
 }
};

static void dump_termios(const WyStr& fname,const WyTermios& tio)
{
  std::cout << "WyTerminal file = " << fname.c_str() << std::endl;
  std::cout << "    ispeed= " << baud_rate(tio.getispeed()) << std::endl;
  std::cout << "    ospeed= " << baud_rate(tio.getospeed()) << std::endl;
};

//
// Assert ff is default
//
static void assert_default(const WyTerminal& ff)
{
 WyRet r;

 if(ff.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()==false) {
   WY_THROW( WyRet() );
 }

 // chk fh()
 if(ff.fh()!=WyFileHandle()) {
   WY_THROW( WyRet() );
 }

 // stat
 {
   WyFileStat stt;
   if((r=ff.stat(stt))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(stt.is_default()==false) {
     WY_THROW( WyRet() );
   }
 }
 if(static_cast<const WyByteFlow&>(ff).ftype()!=0) {
   WY_THROW( WyRet() );
 }
};

static void assert_not_default(const WyTerminal& ff)
{
 WyRet r;

 if(ff.is_default()) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()) {
   WY_THROW( WyRet() );
 }

 // stat
 {
   WyFileStat stt;
   if((r=ff.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
   if(::isatty(ff.fh().fd())==0) {
     WY_THROW( WyRet() );
   }
 }
 if(static_cast<const WyByteFlow&>(ff).ftype()!=S_IFCHR) {
   WY_THROW( WyRet() );
 }
};

//
// Assert f1,f2 the same device
//
static void assert_same_sysf(const WyChrFile& f1,const WyChrFile& f2)
{
 if(f1.is_default()) {
   assert_default(f1);
 } else {
   assert_not_default(f1);
 }

 if(f2.is_default()) {
   assert_default(f2);
 } else {
   assert_not_default(f2);
 }

 if(f1.is_default()&&f2.is_default()) {
   return;
 }
 WyRet r;
 WyFileStat stt1,stt2;
 if((r=f1.stat(stt1))!=Ok) {
   WY_THROW( WyRet() );
 }
 if((r=f2.stat(stt2))!=Ok) {
   WY_THROW( WyRet() );
 }
 if(stt1.sf_ino()!=stt2.sf_ino()) {
   WY_THROW( WyRet() );
 }
 if(stt1.sf_dev()!=stt2.sf_dev()) {
   WY_THROW( WyRet() );
 }
};

#define CHK_DEFAULT(p)\
    try { assert_default(p); } catch(...) { WY_THROW( WyRet()); }
#define CHK_NOT_DEFAULT(p)\
    try { assert_not_default(p); } catch(...) { WY_THROW( WyRet()); }
#define CHK_SAME_SYSF(p1,p2)\
    try { assert_same_sysf(p1,p2); } catch(...) { WY_THROW( WyRet()); }

static void exaust_cpy_ctor(const WySysFile& termf)
{
 WyTerminal tmp(termf);
 exaust_cpy_ctor(termf);   // recursive until failure
};

static void exaust_cpy_ctor(const WyTerminal& termf)
{
 WyTerminal tmp(termf);
 exaust_cpy_ctor(termf);   // recursive until failure
};

//
// Setup the test 
//
static void setup_test(void)
{
};

//
// Undo setup_test
//
static void close_test(void)
{
};

//
// Check basic operations on default object
//
static void t1(void)
{
 WyRet r;

 const WyTerminal NObj(RefFileName,O_RDONLY);  // for the test as argument
 CHK_NOT_DEFAULT(NObj);
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
 }

 // WyTerminal()/WyTerminal(const WyTerminal)
 {
   WyTerminal tmp0;
   WyTerminal tmp1(tmp0);
   CHK_DEFAULT(tmp0);
   CHK_DEFAULT(tmp1);

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

   WyTerminal tmp3(static_cast<const WyByteFlow&>(NObj));
   CHK_SAME_SYSF(tmp3,NObj);
   WyTerminal tmp4(static_cast<const WyChrFile&>(NObj));
   CHK_SAME_SYSF(tmp4,NObj);
 }

 // WyTerminal(const WySysFile&)
 {
   WyChrFile chrf(RefFileName,O_RDONLY);
   WyTerminal tmp(chrf);
   CHK_SAME_SYSF(tmp,chrf);
 }

 // WyTerminal(const char*,int)
 {
   WyTerminal tmp(RefFileName.c_str(),O_RDONLY);  // same as NObj
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,NObj);
 }

 // WyTerminal(const WyStr&,int)
 {
   WyTerminal tmp(RefFileName,O_RDONLY);  // same as NObj
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,NObj);
 }

 // WyTerminal(WyFileHandle)
 {
   WyTerminal tmp( WyFileHandle(STDERR_FILENO) );
   CHK_NOT_DEFAULT(tmp);
   WyFileStat stt;
   if((r=tmp.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
   if(tmp.fh().fd()==STDERR_FILENO) {
     WY_THROW( WyRet() );
   }

   WyFileHandle fh;
   WyTerminal tmp2(fh);
   CHK_DEFAULT(tmp2);
 }

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

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

 // reset(const WySysFile&)
 {
   WyTerminal tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(tmp))!=Ok) {   // self-op
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);

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

   WyChrFile chrf(RefFileName,O_RDONLY);
   if((r=tmp.reset(chrf))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,chrf);
 }

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

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

 // reset(WyFileHandle)
 {
   WyTerminal tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyFileHandle(STDERR_FILENO)))!=Ok) {  // same as NObj
     WY_THROW(r);
   }
   WyFileStat stt;
   if((r=tmp.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.reset(WyFileHandle()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // read,,write,drain
 {
   WyTerminal tmp;
   CHK_DEFAULT(tmp);
   size_t n_rd,n_wr;
   char buf[2];
   WyStr str;
   n_rd=4;
   if((r=tmp.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_rd=3;
   if((r=tmp.read(&buf[0],1,n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }

   n_wr=4;
   if((r=tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=4;
   if((r=tmp.write(WyStr(),n_wr))!=Wym_EBADF) {
     WY_THROW( WyRet() );
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.drain())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // reset(WyFileHandle)
 //
 {
   WyTerminal 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() );
   }
   CHK_SAME_SYSF(tmp,NObj);

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

 // _swap
 {
  WyTerminal tmp0(NObj),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(NObj);

  if((r=tmp1._swap(tmp2))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);

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

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

  WyByteFlow tmp3;
  if((r=tmp3._swap(tmp2))!=Wym_EBADTYPE) {
    WY_THROW(r);
  }

  WySysFile* sp=&tmp1;
  if((r=sp->_swap(tmp0))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);
 }

 // chk _alloc
 {
   WyTerminal tmp;
   WyTerminal* p=tmp._alloc(r);
   if(r!=Ok) {
     WY_THROW(r);
   }
   if(p==0) {
     WY_THROW( WyRet() );
   }
   Wy_AtDestroy<void,WyTerminal*> rrid(Wy::_delete_one,p);
   CHK_DEFAULT(*p);
   if((r=tmp._swap(*p))!=Ok) {
     WY_THROW(r);
   }
    CHK_DEFAULT(*p);
    CHK_DEFAULT(tmp);
 }

 //
 // reset(WyTerminal)
 //
 {
   WyTerminal tmp;
   CHK_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);

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

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

 //
 // sendbreak,flush,flow
 //
 {
   WyTerminal tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.sendbreak(0))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   if((r=tmp.flush(TCIFLUSH))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   if((r=tmp.flow(TCOOFF))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

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

   if((r=tmp.getattr(tio))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(tio.is_default()==false) {
     //WY_THROW( WyRet() );
     std::cerr << "::tcgetattr modified its argument in failure? (EBADF)\n";
     tio.reset();
   }

   if((r=tmp.setattr(tio,TCSANOW))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(tio.is_default()==false) {
     WY_THROW( WyRet() );
   }