chk_fifofile.cpp

一个不错

   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);
/*
   if((r=tmp._read_till(buf,0,&n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp._read_till(buf,0,&n_rd,char(9)))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   CHK_NOT_DEFA ULT(tmp);
*/
   n_wr=1;
   if((r=tmp.write(buf,0,n_wr))!=Ok) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   CHK_NOT_DEFAULT(tmp);
   n_wr=3;
   if((r=tmp.write(WyStr(),n_wr))!=Ok) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   CHK_NOT_DEFAULT(tmp);
   //if((r=tmp.drain())!=Wym_EINVAL) {
   //  WY_THROW(r); // ref fsync(2)
   //}
   CHK_NOT_DEFAULT(tmp);
/*
   WyFifoFile tmp1;
   if((r=tmp1._read_char(buf[0]))!=Wym_EBADF) {
     WY_THROW(r);
   }
*/
 }

 // mkpipe
 {
   WyFifoFile p0(TFile_Empty),p1;
   if(p0.is_default()) {
     WY_THROW( WyRet() );
   }
   CHK_NOT_DEFAULT(p0);
   CHK_DEFAULT(p1);

   if((r=WyFifoFile::mkpipe(p0,p1))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(p0);
   CHK_NOT_DEFAULT(p1);
   if((r=WyFifoFile::mkpipe(p0,p0))!=Wym_EINVAL) {
     WY_THROW(r);
   }
 }

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

  new(p1) WyFifoFile();
  if(p1->fh()==WyFileHandle(0)) {    // not modified
    p1->~WyFifoFile();
    WY_THROW( WyRet() );
  }

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

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

static void t_throw(void)
{
 // WyFifoFile(const WyFifoFile&)
 //

 // WyFifo(const char*,int)
 try {
   const char nsf[]="nosuchfilename";
   WyFifoFile( nsf,0);
   WY_THROW( WyRet() ); 
 }
 catch(const WyFifoFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

 // WyFifo(const WyStr&,int)
 try {
   WyStr nsf("nosuchfilename");
   WyFifoFile( nsf,0);
   WY_THROW( WyRet() ); 
 }
 catch(const WyFifoFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

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

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

};

static void t_error(void)
{
 WyRet r;

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

 // reset(const char*,int)
 {
  WyFifoFile tmp;
  if((r=tmp.reset("nosuchfilename",0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);

  WyFifoFile tmp2(TFile_Empty);
  if((r=tmp2.reset(FileName_Empty.c_str(),O_RDONLY))!=Ok) {
    WY_THROW(r);
  }
  CHK_SAME_SYSF(tmp2,TFile_Empty);
 }

 // reset(const WyStr&,int)
 {
  WyFifoFile tmp;
  if((r=tmp.reset(WyStr("nosuchfilename"),0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);

  WyFifoFile tmp2(TFile_Empty);
  if((r=tmp2.reset(FileName_Empty,O_RDONLY))!=Ok) {
    WY_THROW(r);
  }
  CHK_SAME_SYSF(tmp2,TFile_Empty);
 }

 // reset(WyFileHanle)
 {
  WyFifoFile tmp;
  if((r=tmp.reset( WyFileHandle(STDERR_FILENO) ))!=Wym_EBADF) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp);

  WyFifoFile tmp2(TFile_Empty);
  const WyFileHandle TmpFh( tmp2.fh() );
  if((r=tmp2.reset(tmp2.fh()))!=Ok) {
    WY_THROW(r);
  }
  CHK_SAME_SYSF(tmp2,TFile_Empty);
  if(tmp2.fh()!=TmpFh) {
    // Ok, either way
  }
 }

 // reset() base
 {
  WyFifoFile tmp;
  CHK_DEFAULT(tmp);
  WyByteFlow *bp=&tmp;
  if((r=bp->reset(TFile_Empty))!=Ok) {
    WY_THROW(r);
  }
  CHK_NOT_DEFAULT(tmp);
 }
 
 // read/write
 {
  WyFifoFile tmp;
  char buf[2];
  WyStr str;
  size_t n_rd(9);
  size_t n_wr;
  if((r=tmp.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
  n_rd=1;
  if((r=tmp.read(str,sizeof(buf),n_rd))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
/*
  if((r=tmp._read_till(buf,sizeof(buf),0))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if((r=tmp._read_till(str,sizeof(buf),0))!=Wym_EBADF) {
    WY_THROW(r);
  }
*/
  n_rd=6;
  if((r=tmp.write(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
  n_wr=1;
  if((r=tmp.write(str,n_wr))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_wr!=0) {
    WY_THROW( WyRet() );
  }
  //if((r=tmp.drain())!=Wym_EBADF) {
  //  WY_THROW(r);
  //}
 }

 // mkpipe
 {
  WyFifoFile tmp1(TFile_Empty), tmp2;
  CHK_NOT_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  if((r=WyFifoFile::mkpipe(tmp1,tmp2))!=Ok) {
    WY_THROW(r);
  }
  CHK_NOT_DEFAULT(tmp1);
  CHK_NOT_DEFAULT(tmp2);
 }

 // create(const char*,int)
 {
  WyFifoFile tmp;
  const char pn[]="nosuchfilename/nosuchfilename";
  if((r=WyFifoFile::create(pn,0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
 }

 // create(const WyStr&,int)
 {
  WyFifoFile tmp;
  WyStr pn("nosuchfilename/nosuchfilename");
  if((r=WyFifoFile::create(pn,0))!=Wym_ENOENT) {
    WY_THROW(r);
  }
 }

 // EFBIG
 {
  WyFifoFile tmp(TFile_Empty);
  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() );
  }
/*
  if((r=tmp._read_till(buf,WyStr::max_capacity()+1,0))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if((r=tmp._read_till(buf,WyStr::max_capacity()+1,0,'\n'))!=Wym_EFBIG) {
    WY_THROW(r);
  }

  if((r=tmp.read(buf,std::numeric_limits<size_t>::max(),0))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if((r=tmp._read_till(buf,std::numeric_limits<size_t>::max(),0))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if((r=tmp._read_till(buf,std::numeric_limits<size_t>::max(),0,'\n'))!=Wym_EFBIG) {
    WY_THROW(r);
  }
*/
 }

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

// Test FIFO communication (read)
// Open fname FIFO and read
//
static int porcess_read_fifo(const WyStr& fname) throw()
try {
 WyRet r;
 WyFifoFile ff;

 // Open FIFO (fname) to read
 //
 if((r=ff.reset(fname,O_RDONLY))!=Ok) {
   WY_THROW(r);
 }

 // Receive message from the FIFO (FifoMsg expected)
 //
 size_t n_rd;
 char rbuf[64];
 if(sizeof(rbuf)<FifoMsgLen) {
   WY_THROW( WyRet() );   // rbuf not long enough, reedit rbuf size.
 }
 if((r=ff.read(rbuf,sizeof(rbuf),n_rd))!=Ok) {  // note: using read_till may block
   WY_THROW(r);
 }
 if(n_rd!=FifoMsgLen) {
   WY_THROW( WyRet() ); 
 }
 if(std::memcmp(rbuf,FifoMsg,n_rd)!=0) {
   WY_THROW( WyRet() );   // not expected server message
 }
 
 // EOF test (Ok/zero byte)
 n_rd=99;
 if((r=ff.read(rbuf,sizeof(rbuf),n_rd))!=Ok) {
   WY_THROW(r);
 }
 if(n_rd!=0) {
   WY_THROW( WyRet() ); 
 }
 n_rd=99;
 if((r=ff.read(rbuf,sizeof(rbuf),n_rd))!=Ok) {
   WY_THROW(r);
 }
 if(n_rd!=0) {
   WY_THROW( WyRet() ); 
 }

 return(0);
}
catch(const WyRet& e) {
 Wy::cerr << "process_read_fifo: "  << Wy::wrd(e).c_str() << '\n';
 return(-1);
}
catch(...) {
 Wy::cerr << "process_read_fifo : caught throw\n";
 return(-1);
};

// Test read/write (in different process)
//
static void t_fifo_rw(void)
try {
 WyRet r;
 WyFifoFile ff;
 pid_t child_pid;
 int   child_status;

 // Create FIFO (FileName_Tmp)
 //
 ::unlink(FileName_Tmp.c_str());
 if((r=WyFifoFile::create(WyStr(FileName_Tmp),S_IRUSR|S_IWUSR))!=Ok) {
   WY_THROW(r);
 }

 // Fork to run process_read_fifo(FileName_Tmp)
 //
 child_pid=::fork();
 if(child_pid<0) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 if(child_pid==0) {
   // In child process
   ::exit( porcess_read_fifo(WyStr(FileName_Tmp)) );
 }

 // Open FIFO (FileName_Tmp) to write
 //
 if((r=ff.reset(WyStr(FileName_Tmp),O_WRONLY))!=Ok) {
   WY_THROW(r);
 }

 // stat
 {
   WyFileStat stt;
   if((r=ff.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_fifo()==false) {
     WY_THROW( WyRet() );
   }
   Wy::cout << "FIFO, m_blksize= " << stt.sf_blksize() << '\n';
 }

 // Send FifoMsg into the FIFO ff
 //
 size_t n_wr;
 if((r=ff.write(FifoMsg,FifoMsgLen,n_wr))!=Ok) {
   WY_THROW(r);
 }
 if(n_wr!=FifoMsgLen) {
   WY_THROW( WyRet() );
 }
 if((r=ff.reset())!=Ok) {
   WY_THROW(r);
 }

 if(::wait(&child_status)!=child_pid) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 if(WIFEXITED(child_status)==0) {
   WY_THROW( WyRet() );  // child process was not terminated voluntarily
 }
 if(WEXITSTATUS(child_status)!=0) {
   WY_THROW( WyRet() );  // child process not exist(0)
 }
 ::unlink(FileName_Tmp.c_str());
}
catch(...) {
 ::unlink(FileName_Tmp.c_str());
 throw;
};

// Test pipe
//
static void t_pipe(void)
{
  WyRet r;
  WyFifoFile pin,pout;
  CHK_DEFAULT(pin);
  CHK_DEFAULT(pout);

  if((r=WyFifoFile::mkpipe(pin,pout))!=Ok) {
    WY_THROW(r);
  }
  if(pin.is_default()) {
    WY_THROW( WyRet() ); 
  }
  if(pout.is_default()) {
    WY_THROW( WyRet() ); 
  }

  // stat
  {
    WyFileStat stt;
    if((r=pin.stat(stt))!=Ok) {
      WY_THROW(r);
    }
    if(stt.is_fifo()==false) {
      WY_THROW( WyRet() ); 
    }

    if((r=pout.stat(stt))!=Ok) {
      WY_THROW(r);
    }
    if(stt.is_fifo()==false) {
      WY_THROW( WyRet() ); 
    }
  }
};

static const WyStr chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 Wy::cout << "Checking wyfifofile.h ...\n";
 if(std::strcmp(WyFifoFile::class_name,"WyFifoFile")!=0) {
   WY_THROW( WyRet() );
 }
 try {
   setup_test();
   t1();
   t2();
   t_throw();
   t_error();
   t_fifo_rw();
   t_pipe();
   close_test();
 }
 catch(...) {
   close_test();
   throw;
 }
 Wy::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 Wy::cerr << chdr << Wy::wrd(e) << '\n';
 return(-1);
}
catch(...) {
 Wy::cerr << chdr << "unknown unwind\n";
 return(-1);
};