chk_lnkfile.cpp

一个不错

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

   Check Wy_LnkFile public members

   Build: make chk_regfile

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

#include "wy_lnkfile.h"
#include "wy_atdestroy.h"
#include <unistd.h>
#include <iostream>

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

static const WyStr RefLnkName("testfile.lnkf.L1"); // points to "nofile"
static const WyStr RefLnkNameValue("nofile");

static const WyStr TmpLnkName("tmp.lnkfile.tmp");

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

 if(ff.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_LnkFile& ff)
{
 WyRet r;

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

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

//
// Assert f1,f2 the same systerm file
//
static void assert_same_sysf(const Wy_LnkFile& f1,const Wy_LnkFile& f2)
{
 if(f1.wy_lnkf()!=f2.wy_lnkf()) {
   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)
{
 ::unlink(RefLnkName.c_str());
 if(::symlink(RefLnkNameValue.c_str(),
              RefLnkName.c_str())!=0) {
   WY_THROW( WyRet(WyReply(errno)) );  // cannot create the test file
 }
};

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

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

 Wy_LnkFile NObj;     // non-default object for test as argument
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefLnkName))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(NObj);
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_lnk()==false) {
     WY_THROW( WyRet() );
   }
 }

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

   Wy_LnkFile tmp2(NObj);
   CHK_NOT_DEFAULT(tmp2);
   CHK_SAME_SYSF(tmp2,NObj);

   WyStr pn;
   if((r=tmp2.read(pn))!=Ok) {
     WY_THROW(r);
   }
   if(pn!=RefLnkNameValue) {
     WY_THROW( WyRet() );
   }
 }

 // Wy_LnkFile(const char*)
 {
   Wy_LnkFile tmp(RefLnkName.c_str());
   CHK_SAME_SYSF(tmp,NObj);
 }

 // Wy_LnkFile(const WyStr&)
 {
   Wy_LnkFile tmp(RefLnkName);
   CHK_SAME_SYSF(tmp,NObj);
 }

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

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

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

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

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

 // reset(const char*)
 {
   Wy_LnkFile tmp;
   if((r=tmp.reset(RefLnkName.c_str()))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

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

 // read
 {
   Wy_LnkFile tmp;
   CHK_DEFAULT(tmp);
   WyStr pn;
   if((r=tmp.read(pn))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }

};

//
// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 Wy_LnkFile NObj;     // non-default object for the test
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefLnkName))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(NObj);
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_lnk()==false) {
     WY_THROW( WyRet() );
   }
 }

 // constructor
 {
 }

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

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

 // reset(const char*)
 {
   Wy_LnkFile tmp(NObj);
   if((r=tmp.reset(RefLnkName.c_str()))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

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

 // read
 {
   Wy_LnkFile tmp(NObj);
   WyStr pn;
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.read(pn))!=Ok) {
     WY_THROW(r);
   }
   if(pn!=RefLnkNameValue) {
     WY_THROW( WyRet() );
   }
 }

 // _swap
 {
  Wy_LnkFile 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_LnkFile {} tctmp;
  if((r=tctmp._swap(tmp0))!=Wym_EBADTYPE) {
    WY_THROW(r);
  }
 }

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

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

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

  new(p1) Wy_LnkFile();
  if(p1->is_default()==false) {
    p1->~Wy_LnkFile();
    WY_THROW(r);
  }

  // move *p1 to p2
  try {
    new(p2) Wy_LnkFile(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~Wy_LnkFile();
    throw;
  };
  if(p2->is_default()==false) {
    p2->~Wy_LnkFile();
    WY_THROW(r);
  }
  p2->~Wy_LnkFile();
 }
};

//
// Check basic operations for static functions
//
static void t3_1(void)
try {
 WyRet r;
 //
 // Create TmpLnkName and unlink it
 //
 ::unlink(TmpLnkName.c_str());
 if((r=Wy_LnkFile::create("tmp.tmp.tmp",TmpLnkName))!=Ok) {
   WY_THROW(r);
 }

 // check if it's there
 {
   Wy_LnkFile tmp;
   if((r=tmp.reset(TmpLnkName.c_str()))!=Ok) {
     WY_THROW(r);
   }
 }

 ::unlink(TmpLnkName.c_str());

 // check if it's unlinked
 {
   Wy_LnkFile tmp;
   if((r=tmp.reset(TmpLnkName.c_str()))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }
}
catch(...) {
 ::unlink(TmpLnkName.c_str());
 throw;
};

//
// Check basic operations for static functions
//
static void t3_2(void)
try {
 WyRet r;
 //
 // Create TmpLnkName and unlink it
 //
 ::unlink(TmpLnkName.c_str());
 if((r=Wy_LnkFile::create(WyStr("tmp.tmp.tmp"),TmpLnkName))!=Ok) {
   WY_THROW(r);
 }

 // check if it's there
 {
   Wy_LnkFile tmp;
   if((r=tmp.reset(TmpLnkName))!=Ok) {
     WY_THROW(r);
   }
 }

 ::unlink(TmpLnkName.c_str());

 // check if it's unlinked
 {
   Wy_LnkFile tmp;
   if((r=tmp.reset(TmpLnkName))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
 }
}
catch(...) {
 ::unlink(TmpLnkName.c_str());
 throw;
};

static void t3(void)
{
 t3_1();
 t3_2();
};

static void t4(void)
{
};

static void t_exception(void)
{
 //
 // Test copy constructor exception
 //
 try {
 }
 catch(const Wy_LnkFile::Reply& e) {
   // FALL_THROUGH 
 }
 catch(...) {
   throw;
 };

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

static const WyStr chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wy_lnkfile.h ...\n";
 if(std::strcmp(Wy_LnkFile::class_name,"Wy_LnkFile")!=0) {
   WY_THROW( WyRet() );
 }
 try {
   setup_test();
   t1();
   t2();
   t3();
   t4();
   t_exception();
   close_test();
/*
   {
     WyRet r;
     Wy_LnkFile lnk(WyStr("/etc/localtime"));
     WyStr val;
     if((r=lnk.read(val))!=Ok) {
       WY_THROW(r);
     }
     std::cout << "/etc/localtime -> " << val << std::endl;
   }
*/

 }
 catch(...) {
   close_test();
   throw;
 }
 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);
};