chk_fifofile.cpp

一个不错

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

   Check WyFifoFile public members

   Build: make chk_fifofile

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

#include "wyfifofile.h"
#include "wy_uty.h"
#include "wy_atdestroy.h"
#include <unistd.h>   // for ::exit(int)
#include <new>
#include <stdlib.h>
#include <sys/wait.h>

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

static const WyStr FileName_Empty("testfile.fifo.empty"); // size=0
static const WyStr FileName_Tmp("tmp.chk_fifofile.tmp");
static const char FifoMsg[]="Fifo test message";
static const size_t FifoMsgLen=std::strlen(FifoMsg);

static WyFifoFile TFile__Empty_;
static const WyFifoFile& TFile_Empty(TFile__Empty_);

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

 if(ff.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()==false) {
   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 WyFifoFile& 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_fifo()==false) {
     WY_THROW( WyRet() );
   }
 }

 if(static_cast<const WyByteFlow&>(ff).ftype()!=S_IFIFO) {
   WY_THROW( WyRet() );
 }
};

// Assert f1,f2 the same systerm file
//
static void assert_same_sysf(const WyFifoFile& f1,const WyFifoFile& 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& ff)
{
 WyFifoFile tmp(ff);
 exaust_cpy_ctor(ff);   // recursive until failure
};

static void exaust_cpy_ctor(const WyFifoFile& ff)
{
 WyFifoFile tmp(ff);
 exaust_cpy_ctor(ff);   // recursive until failure
};

// Setup the test 
//
static void setup_test(void)
{
 WyRet r;

 // create and reset TFile_Empty for FileName_Empty
 //
 CHK_DEFAULT(TFile_Empty);
 ::unlink(FileName_Empty.c_str());

 if((r=WyFifoFile::create(FileName_Empty,S_IRUSR|S_IWUSR))!=Ok) {
   WY_THROW(r);
 }
 if((r=TFile__Empty_.reset(FileName_Empty,O_RDWR))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(TFile_Empty);

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

// Undo setup_test
//
static void close_test(void)
{
 ::unlink(FileName_Empty.c_str());
};

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

 // WyFifoFile()/WyFifoFile(const WyFifoFile&)
 {
   WyFifoFile tobj;
   WyFifoFile tmp1(tobj);
   CHK_DEFAULT(tobj);
   CHK_DEFAULT(tmp1);

   WyFifoFile tmp2(TFile_Empty);
   CHK_NOT_DEFAULT(tmp2);
   if(tmp2.fh()==TFile_Empty.fh()) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp2,TFile_Empty);

   WyFifoFile tmp3(static_cast<const WyByteFlow&>(TFile_Empty));
   CHK_SAME_SYSF(tmp3,TFile_Empty);
 }

 // WyFifoFile(const char*,int)
 {
   WyFifoFile tmp(FileName_Empty.c_str(),O_RDONLY);  // same as TFile_Empty
   CHK_SAME_SYSF(tmp,TFile_Empty);
 }

 // WyFifoFile(const WyStr&,int)
 {
   WyFifoFile tmp(FileName_Empty,O_RDONLY);  // same as TFile_Empty
   CHK_SAME_SYSF(tmp,TFile_Empty);
 }

 // WyFifoFile(WyFileHandle)
 {
   WyFileHandle h;
   WyFifoFile tmp( h );
   CHK_DEFAULT(tmp);
 }

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

     WyRet r;
     if((r=p->_swap(tmp))!=Ok) {
       WY_THROW(r);
     }
   }

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

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

 // reset(const WyFifoFile&)
 {
   WyFifoFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(TFile_Empty))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TFile_Empty);

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

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

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

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

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

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

 // reset(WyFileHandle)
 {
   WyFifoFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset( TFile_Empty.fh() ))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TFile_Empty);

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

   if((r=tmp.reset(WyStr("tmp.a,b,1,0,z,tmp"),O_RDONLY))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // read,read_till,write,drain,reset(ENOENT)
 {
   WyFifoFile tmp;
   CHK_DEFAULT(tmp);
   char buf[2]={2,4};
   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() );
   }
   CHK_DEFAULT(tmp);
   if((buf[0]!=2)||(buf[1]!=4)) {
     WY_THROW( WyRet() );
   }
  /*
   if((r=tmp._read_till(buf,sizeof(buf),0))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((buf[0]!=2)||(buf[1]!=4)) {
     WY_THROW( WyRet() );
   }*/
   n_wr=8;
   if((r=tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   if((buf[0]!=2)||(buf[1]!=4)) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);
   n_wr=8;
   if((r=tmp.write(WyStr(),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   //if((r=tmp.drain())!=Wym_EBADF) {
   //  WY_THROW(r);
   //}
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyStr("tmp.a,b,1,0,z,tmp"),O_RDONLY))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

 // _swap
 {
  WyFifoFile tmp0(TFile_Empty),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(TFile_Empty);

  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_SAME_SYSF(tmp1,TFile_Empty);

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

};

// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 // stat EmptyFile
 {
   WyFileStat stt;
   if((r=TFile_Empty.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_default()) {
     WY_THROW( WyRet() );
   }
   if(stt.is_fifo()==false) {
     WY_THROW( WyRet() );
   }
   if(stt.sf_size()!=0) {
     WY_THROW( WyRet() );
   }
 }

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

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

 // reset(const char*,int)
 {
   WyFifoFile tmp(TFile_Empty);
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,TFile_Empty);
   if((r=tmp.reset(FileName_Empty.c_str(),O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // reset(const WyStr&,int)
 {
   WyFifoFile tmp(TFile_Empty);
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,TFile_Empty);
   if((r=tmp.reset(FileName_Empty,O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // reset(WyFileHandle)
 {
   WyFifoFile tmp(TFile_Empty);
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.reset( TFile_Empty.fh() ))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TFile_Empty);

   tmp.reset();
   CHK_DEFAULT(tmp);
   if((r=tmp.reset( TFile_Empty.fh() ))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TFile_Empty);

   if((r=tmp.reset(WyStr("tmp.a,b,1,0,z,tmp"),O_RDONLY))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TFile_Empty);
 }

 // _swap
 {
   WyFifoFile tmp0(TFile_Empty),tmp1,tmp2;
   CHK_NOT_DEFAULT(tmp0);
   CHK_DEFAULT(tmp1);
   CHK_DEFAULT(tmp2);

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

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

 // (zero byte) read,read_till,write
 {
   WyFifoFile tmp(TFile_Empty);
   char buf[2]={-1,-1};