ck_dirfile.cpp

一个不错

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

   Check Wy_DirFile public members

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

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

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

static const WyStr RefDirName(".");
static const WyStr TmpDirName("tmp.dirfile.tmp");

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

 if(ff.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(ff.wy_ref_count()!=0) {
   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() );
   }
 }
};

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

 if(ff.is_default()) {
   WY_THROW( WyRet() );
 }
 if(ff.wy_ref_count()==0) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()==true) {
   WY_THROW( WyRet() );
 }

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

   // stat from fh
   WyFileStat stt2;
   if((r=ff.fh().stat(stt2))!=Ok) {
     WY_THROW(r);
   }
   if(stt2!=stt) {
     WY_THROW( WyRet() );
   }
 }
};

static void assert_default(const WyDirEnt& dent)
{
 if(dent.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(dent.dt_ino()!=0) {
   WY_THROW( WyRet() );
 }
 if(dent.dt_off()!=0) {
   WY_THROW( WyRet() );
 }
 if(dent.dt_reclen()!=0) {
   WY_THROW( WyRet() );
 }
 if(dent.dt_name()[0]!=0) {
   WY_THROW( WyRet() );
 }
};

//
// Assert f1,f2 the same systerm file
//
static void assert_same_sysf(const Wy_DirFile& f1,const Wy_DirFile& 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()); }

//
// 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;

 Wy_DirFile NObj;     // non-default object for test as argument
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefDirName))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(NObj);
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }
  
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_dir()==false) {
     WY_THROW( WyRet() );
   }
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // Wy_DirFile()/Wy_DirFile(const Wy_DirFile&)
 {
   Wy_DirFile tmp0;
   Wy_DirFile tmp1(tmp0);
   CHK_DEFAULT(tmp0);
   CHK_DEFAULT(tmp1);

   Wy_DirFile tmp2(NObj);
   if(tmp2.is_default()) {
     WY_THROW( WyRet() );
   }
   if(tmp2.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp2,NObj);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }
 
 // Wy_DirFIle(const char*)
 {
  Wy_DirFile tmp(RefDirName.c_str());
  CHK_SAME_SYSF(tmp,NObj);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // Wy_DirFIle(const WyStr&)
 {
  Wy_DirFile tmp(RefDirName);
  CHK_SAME_SYSF(tmp,NObj);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // ref count
 {
   if(NObj.wy_ref_count()!=1) {
     WY_THROW( WyRet() );
   }
   Wy_DirFile tmp(NObj);
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }

   {
     Wy_DirFile tmp_tt(tmp);
     if(NObj.wy_ref_count()!=3) {
       WY_THROW( WyRet() );
     }
     if(tmp.wy_ref_count()!=3) {
       WY_THROW( WyRet() );
     }
     if(tmp_tt.wy_ref_count()!=3) {
       WY_THROW( WyRet() );
     }
   }
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

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

   Wy_DirFile tmp2(NObj);
   if(tmp2.is_default()) {
     WY_THROW( WyRet() );
   }
   if(tmp2.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if((r=tmp2.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp2);
 }
 if(NObj.wy_ref_count()!=1) {
   //std::cerr << "NObj(" << NObj.wy_ref_count() << std::endl;
   WY_THROW( WyRet() );
 }

 // read,rewind
 {
   Wy_DirFile tmp;
   CHK_DEFAULT(tmp);
   WyDirEnt dent;
   if((r=tmp.read(dent))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(dent);
   CHK_DEFAULT(tmp);
   if((r=tmp.rewind())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(dent);
   CHK_DEFAULT(tmp);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // _swap
 {
  Wy_DirFile 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_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);

  struct TmpClass : public Wy_DirFile {} tctmp;
  if((r=tctmp._swap(tmp0))!=Wym_EBADTYPE) {
    WY_THROW(r);
  }
 }

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

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

   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   if(tmp.is_default()) {
     WY_THROW( WyRet() );
   }
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }

   if((r=tmp.reset(Wy_DirFile()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // chk reset( WyStr() ) works for cwd
 {
   Wy_DirFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyStr()))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   
   WyFileStat stt1,stt2;
   if((r=tmp.stat(stt1))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   WyStr pn_cwd;
   if((r=Wy::getcwd(pn_cwd))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset(pn_cwd))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);

   if((r=tmp.stat(stt2))!=Ok) {
     WY_THROW(r);
   }
   if(stt1.sf_dev()!=stt2.sf_dev()) {
     WY_THROW( WyRet() );
   }
   if(stt1.sf_ino()!=stt2.sf_ino()) {
     WY_THROW( WyRet() );
   }
 }

 // chk reset("") works for cwd
 {
   Wy_DirFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(""))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   
   WyFileStat stt1,stt2;
   if((r=tmp.stat(stt1))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

   WyStr pn_cwd;
   if((r=Wy::getcwd(pn_cwd))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset(pn_cwd.c_str()))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);

   if((r=tmp.stat(stt2))!=Ok) {
     WY_THROW(r);
   }
   if(stt1.sf_dev()!=stt2.sf_dev()) {
     WY_THROW( WyRet() );
   }
   if(stt1.sf_ino()!=stt2.sf_ino()) {
     WY_THROW( WyRet() );
   }
 }
};

//
// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 Wy_DirFile NObj;     // non-default object for the test
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefDirName))!=Ok) {
   WY_THROW(r);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_dir()==false) {
     WY_THROW( WyRet() );
   }
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // constructor
 {
 }

 // reset
 {
   Wy_DirFile tmp(NObj);
   if(tmp.is_default()) {
     WY_THROW( WyRet() );
   }
   if(tmp.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if(NObj.wy_ref_count()!=2) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(NObj.wy_ref_count()!=1) {
     WY_THROW( WyRet() );
   }
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // read,rewind
 {
   Wy_DirFile tmp(NObj);
   WyDirEnt dent1;
   WyDirEnt dent2;
   WyDirEnt dent3;
   if(tmp.is_default()) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.read(dent1))!=Ok) { // should be at least . .. thisfile (3 files)
     WY_THROW(r);
   }
   if((r=tmp.read(dent2))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.read(dent3))!=Ok) {
     WY_THROW(r);
   }
   // rewind and read again to check
   if((r=tmp.rewind())!=Ok) {
     WY_THROW(r);
   }
   WyDirEnt dent_tt;
   if((r=tmp.read(dent_tt))!=Ok) {
     WY_THROW(r);
   }
   if(::strcmp(dent_tt.dt_name(),dent1.dt_name())!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.read(dent_tt))!=Ok) {
     WY_THROW(r);
   }
   if(::strcmp(dent_tt.dt_name(),dent2.dt_name())!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.read(dent_tt))!=Ok) {
     WY_THROW(r);
   }
   if(::strcmp(dent_tt.dt_name(),dent3.dt_name())!=0) {
     WY_THROW( WyRet() );
   }
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // reset(const char*)
 {
   Wy_DirFile tmp(NObj);
   if(tmp.is_default()) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.reset(RefDirName))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

 // reset(Wy_DirFile())
 //
 {
   Wy_DirFile tmp(NObj);
   CHK_SAME_SYSF(tmp,NObj);
   if(tmp.is_default()) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp,NObj);

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

   if((r=tmp.reset(Wy_DirFile()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }
 if(NObj.wy_ref_count()!=1) {
   WY_THROW( WyRet() );
 }

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

  new(p1) Wy_DirFile("../");
  try {
   WyFileStat stt;
   if((r=p1->stat(stt))!=Ok) {
     WY_THROW(r);
   } 
   if(stt.is_dir()==false) {
     WY_THROW(r);
   }
  }
  catch(...) {
    p1->~Wy_DirFile();
    throw;
  };

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

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

//
// Check basic operations for static functions
//
static void t3(void)
try {
 WyRet r;
 //
 // create(const WyStr&)  (create TmpDirName and unlink it)
 //
 if((r=Wy_DirFile::create(TmpDirName,S_IRUSR|S_IWUSR))!=Ok) {
   WY_THROW(r);
 }
 if(::access(TmpDirName.c_str(),F_OK)!=0) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 if((r=Wy_DirFile::unlink(TmpDirName))!=Ok) {
   WY_THROW(r);
 }
 if(::access(TmpDirName.c_str(),F_OK)==ENOENT) {
   WY_THROW( WyRet() );
 } else {
   if(errno!=ENOENT) {
     WY_THROW( WyRet(WyReply(errno)) );
   }
 }

 //
 // create(const char*)  (create TmpDirName and unlink it)
 //
 if((r=Wy_DirFile::create(TmpDirName.c_str(),S_IRUSR|S_IWUSR))!=Ok) {
   WY_THROW(r);
 }
 if(::access(TmpDirName.c_str(),F_OK)!=0) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 if((r=Wy_DirFile::unlink(TmpDirName.c_str()))!=Ok) {
   WY_THROW(r);
 }
 if(::access(TmpDirName.c_str(),F_OK)==ENOENT) {
   WY_THROW( WyRet() );
 } else {
   if(errno!=ENOENT) {
     WY_THROW( WyRet(WyReply(errno)) );
   }
 }
}
catch(...) {
 ::rmdir(TmpDirName.c_str());
 throw;
};

static void t_exception(void)
{
 //
 // Wy_DirFile(const char*)
 //
 try {
   const char nsf[]="nosuchfilename";
   Wy_DirFile tmp(nsf);
   WY_THROW( WyRet() );
 }
 catch(const Wy_DirFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

 //
 // Wy_DirFile(const WyStr&)
 //
 try {
   WyStr nsf("nosuchfilename");
   Wy_DirFile tmp(nsf);
   WY_THROW( WyRet() );
 }
 catch(const Wy_DirFile::Reply& e) {
   if(e!=Wym_ENOENT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

 //
 // Test destructor exception
 //
 {
 }
};

static void t_error(void)
{
 WyRet r;
 Wy_DirFile NObj(RefDirName);
 
 // stat
 {
   Wy_DirFile tmp;
   WyFileStat stt;
   if((r=tmp.stat(stt))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(stt.is_default()==false) {
     WY_THROW( WyRet() );
   }
 }

 // reset(const Wy_DirFile&)
 {
   Wy_DirFile tmp(NObj);
   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

 // reset(const char*)
 {
   Wy_DirFile tmp(NObj);
   if((r=tmp.reset(""))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // reset(const WyStr&)
 {
   Wy_DirFile tmp(NObj);
   if((r=tmp.reset( WyStr() ))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // read(WyDirEnt&)
 {
   Wy_DirFile tmp;
   WyDirEnt dent;
   if((r=tmp.read(dent))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.rewind())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }
};

void ck_dirfile(void)
try {
  setup_test();
  t1();
  t2();
  t3();
  t_exception();
  t_error();
  close_test();
}
catch(const WyRet& e) {
 close_test();
 throw;
}
catch(...) {
 close_test();
 throw;
};