chk_sockfile.cpp

一个不错

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

  Test WySockFile to communicate with PF_LOCAL, PF_INET, PF_INET6
*/

#include "wysockfile.h"
#include "wysockaddrlocal.h"
#include "wysockaddrinet4.h"
#include "wysockaddrinet6.h"
#include "wy_atdestroy.h"
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <new>
#include <iostream>

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

#define WY__TEST_SOCK_INET__   // we are going to test INET

// Socket address (pathname for AF_LOCAL file) for test
//
static const WyStr LocalSockFileName("tmp.chk_sockfile.local.tmp");

// Message to send to the socket for the tests
//
static const WyCSeg SvrMsg("Messages sent from the server");
static const WyCSeg CliMsg("Messages sent from the client");

#ifdef WY__TEST_SOCK_INET__
const char* TestINetIP4="127.0.0.1";
const char* TestINetIP6="::1";
const ushort TestINetPort=8080;
#endif

// Assert ff is default
//
static void assert_default(const WySockFile& 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(ff.family()!=PF_UNSPEC) {
   WY_THROW( WyRet() );
 }
 if(static_cast<const WyByteFlow&>(ff).ftype()!=0) {
   WY_THROW( WyRet() );
 }
};

static void assert_not_default(const WySockFile& 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_sock()==false) {
     WY_THROW( WyRet() );
   }
 }
 
 if(ff.family()==PF_UNSPEC) {
   WY_THROW( WyRet() );
 }
 if(static_cast<const WyByteFlow&>(ff).ftype()!=S_IFSOCK) {
   WY_THROW( WyRet() );
 }
};

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

static void exaust_cpy_ctor(const WySockFile& sktf)
{
 WySockFile tmp(sktf);
 exaust_cpy_ctor(sktf);   // 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;

 WySockFile LocalObj;     // non-default object for test as argument
 CHK_DEFAULT(LocalObj);
 if((r=LocalObj.reset(PF_LOCAL,SOCK_STREAM))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(LocalObj);
 if(LocalObj.family()!=PF_LOCAL) {
   WY_THROW( WyRet() );
 }

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

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

   WySockFile tmp2(LocalObj);
   CHK_NOT_DEFAULT(tmp2);
   CHK_SAME_SYSF(tmp2,LocalObj);
   if(tmp2.fh()==LocalObj.fh()) {
     WY_THROW( WyRet() );
   }

   WySockFile tmp3(static_cast<WyByteFlow&>(tmp2));
   CHK_SAME_SYSF(tmp2,tmp3);
 }

 // WySockFile(int,int,int=0)
 {
   WySockFile tmp(PF_INET,SOCK_STREAM);
   CHK_NOT_DEFAULT(tmp);
   if(tmp.family()!=AF_INET) {
     WY_THROW( WyRet() );
   }
   WySockFile tmp2(tmp);
   CHK_SAME_SYSF(tmp2,tmp);
 }

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

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

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

   WySockFile tmp3;
   CHK_DEFAULT(tmp3);
   if((r=tmp3.reset(static_cast<WyByteFlow&>(tmp2)))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp2,tmp3);
 }

 // reset(int,int,int=0)
 {
   WySockFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(PF_INET,SOCK_STREAM))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   if(tmp.family()!=AF_INET) {
     WY_THROW( WyRet() );
   }
 }

 // reset(WyFileHandle)
 {
  WyFileHandle h;
   WySockFile tmp;
   CHK_DEFAULT(tmp);

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

 // read,write,bind
 {
   WySockFile 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);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=2;
   if((r=tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=8;
   if((r=tmp.write(WyStr(),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   //if((r=tmp.drain())!=Wym_EBADF) {
   //  WY_THROW(r);
   //}
   if(tmp.family()!=PF_UNSPEC) {
     WY_THROW( WyRet() );
   }
 }

 // _swap
 {
  WySockFile tmp0(LocalObj),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(LocalObj);

  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,LocalObj);

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

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

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

 // shutdown
 //
 {
   WySockFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.shutdown(SHUT_RD))!=Wym_EBADF) {
     WY_THROW(r);
   }
 }

 // bind,listen,accept,connect,sockname,peername
 //
 {
   WySockFile tmp;
   WySockAddrLocal addr;
   CHK_DEFAULT(tmp);
   
   if((r=tmp.bind(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.listen(0))!=Wym_EBADF) {
     WY_THROW(r);
   }

   WySockFile tmp1;
   CHK_DEFAULT(tmp1);
   if((r=tmp.accept(tmp1,addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.connect(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.sockname(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.peername(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }

   CHK_DEFAULT(tmp);
   CHK_DEFAULT(tmp1);
 }

 // sendto(..), recvfrom(..)
 {
   WySockFile tmp;
   WySockAddrLocal addr;
   CHK_DEFAULT(tmp);
   char buf[4];
   size_t n_size=1;
   if((r=tmp.sendto(buf,sizeof(buf),0,&addr,n_size))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_size!=0) {
     WY_THROW( WyRet() );
   }
   n_size=1;
   if((r=tmp.recvfrom(buf,sizeof(buf),0,&addr,n_size))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_size!=0) {
     WY_THROW( WyRet() );
   }
 }

 // chk sockpair(..)
 {
   WySockFile s1,s2;
   if((r=WySockFile::sockpair(PF_LOCAL,SOCK_STREAM,0,s1,s2))!=Ok) {
     WY_THROW(r);
   }
   const WyStr Msg("helo3");
   size_t n_wr(0);
   WyStr str;
   if(s1.write(Msg,n_wr)!=Ok) {
     WY_THROW(r);
   }
   if(n_wr!=Msg.size()) {
     WY_THROW( WyRet() );
   }
   if((r=WySockFile::sockpair(PF_LOCAL,SOCK_STREAM,0,s1,s1))!=Wym_EINVAL) {
     WY_THROW(r);
   }
 }
};

// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 
 // non-default object for the test
 const WySockFile LocalObj(PF_LOCAL,SOCK_STREAM);
 CHK_NOT_DEFAULT(LocalObj);
 
 // stat LocalObj
 {
   WyFileStat stt;
   if((r=LocalObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_sock()==false) {
     WY_THROW( WyRet() );
   }
 }

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

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

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

 // reset(int,int,int=0)
 {
   WySockFile tmp(LocalObj);
   CHK_SAME_SYSF(tmp,LocalObj);
   if((r=tmp.reset(PF_LOCAL,SOCK_STREAM))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

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

   WySockFile tmp2;
   CHK_DEFAULT(tmp2);
   if((r=tmp2.reset(LocalObj.fh()))!=Ok) {
     WY_THROW(r);
   }   
   CHK_NOT_DEFAULT(tmp2);
   if(tmp2.family()!=LocalObj.family()) {
     WY_THROW( WyRet() );
   }
 }

 // (zero byte) read,write
 {
   WySockFile tmp(LocalObj);
   char buf[2]={-1,-1};
   WyStr str;