chk_sockaddrlocal.cpp

一个不错

  }
  if(un_addr!=tmp0) {
    WY_THROW( WyRet() );
  }
 */
 }
};

//
// Check basic operations on non-default object
//
static void t2(void)
{
 WyRet r;
 WySockAddrLocal A0;
 WySockAddrLocal N0;

 CHK_DEFAULT(A0);
 CHK_DEFAULT(N0);
 if((r=N0.reset(WyStr("helo")))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(N0);

 // constructor
 {
   WySockAddrLocal a0(N0);
   CHK_NOT_DEFAULT(a0);
 }

 // operator==/!=
 {
   WySockAddrLocal a0(N0),a1(a0);
   CHK_NOT_DEFAULT(a0);
   CHK_NOT_DEFAULT(a1);
   if(a0==a1) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a0!=a1) {
     WY_THROW( WyRet() );
   }
   if(a0==a1._path()) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a0!=a1._path()) {
     WY_THROW( WyRet() );
   }
 }
 
 // reset
 {
   WySockAddrLocal a0(N0);
   CHK_NOT_DEFAULT(a0);
   a0.reset();
   CHK_DEFAULT(a0);
 }

 // _swap
 {
  WySockAddrLocal tmp0(N0),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(N0);

  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_EQU(tmp1,NObj);

  if((r=tmp0._swap(tmp1))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp1);
  CHK_NOT_DEFAULT(tmp0);
  //CHK_EQU(tmp0,NObj);

  Wy_SockAddr* bptr(&tmp0);
  if((r=tmp1._swap(*bptr))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);

  struct ABC : public WySockAddrLocal {} tmp3;
  if((r=tmp0._swap(tmp3))!=Wym_EBADTYPE) {
    WY_THROW( WyRet() );
  }
 }

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

 // reset
 {
   WySockAddrLocal a0(N0);
   a0.reset(N0);
   a0.reset(A0);
   CHK_DEFAULT(a0);
 }

 // operator=
 {
   WySockAddrLocal a0(N0);
   CHK_NOT_DEFAULT(a0);
   a0=A0;
   CHK_DEFAULT(a0);
 }

 // _path
 {
   WySockAddrLocal a0(N0);
   CHK_NOT_DEFAULT(a0);
   WyStr str(a0._path());

   if(str!=N0) {   // N0 _path is "helo"
     WY_THROW( WyRet() );
   }
   if(str!=Wy::wrd(a0)) {
     WY_THROW( WyRet() );
   }
 }

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

  new(p1) WySockAddrLocal(TPath);
  if((p1->is_default()==true)||
     (Wy::_strcmp(p1->_path(),TPath.cseg())!=0) ) {
    p1->~WySockAddrLocal();
    WY_THROW(r);
  }

  // move *p1 to p2
  try {
    new(p2) WySockAddrLocal(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~WySockAddrLocal();
    throw;
  };
  if((p2->is_default()==true)||
     (Wy::_strcmp(p2->_path(),TPath.cseg())!=0) ) {
    p2->~WySockAddrLocal();
    WY_THROW(r);
  }
  p2->~WySockAddrLocal();
 }
};

static void t_error(void)
{
 WyRet r;

 // WySockAddrLocal(const ::sockaddr_un&,size_t)
 //
 {
   struct ::sockaddr_un uaddr;

   try {
     WySockAddrLocal tmp(uaddr,sizeof(uaddr)+1);
     tmp.reset();
     WY_THROW( WyRet() );
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_EINVAL) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // WySockAddrLocal(const char*)
 //
 {
   try {
     WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
     WySockAddrLocal tmp(path.c_str());
     tmp.reset();          // supress warning message
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_ENAMETOOLONG) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };

   try {
     WySockAddrLocal tmp((const char*)0);
     tmp.reset();          // supress warning message
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_EFAULT) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // WySockAddrLocal(const WyStr&)
 //
 {
   try {
     WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
     WySockAddrLocal tmp(path);
     tmp.reset();          // supress warning message
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_ENAMETOOLONG) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // WySockAddrLocal(WyCSeg)
 //
 {
   try {
     WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
     WySockAddrLocal tmp(path.cseg());
     tmp.reset();          // supress warning message
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_ENAMETOOLONG) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // reset error
 {
   WyRet r;
   struct sockaddr_un uaddr;
   WySockAddrLocal tmp;

   if((r=tmp.reset(uaddr,size_t(0)))!=Wym_EINVAL) {
     WY_THROW(r);
   }
   if((r=tmp.reset(uaddr,sizeof(uaddr)+1))!=Wym_EINVAL) {
     WY_THROW(r);
   }

   WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
   if((r=tmp.reset(path.c_str()))!=Wym_ENAMETOOLONG) {
     WY_THROW(r);
   }
   if((r=tmp.reset(path))!=Wym_ENAMETOOLONG) {
     WY_THROW(r);
   }
   if((r=tmp.reset(path.cseg()))!=Wym_ENAMETOOLONG) {
     WY_THROW(r);
   }
   if((r=tmp.reset((const char*)0))!=Wym_EFAULT) {
     WY_THROW(r);
   }
 }

 // _swap error
 {
  WyRet r;
  struct T : public WySockAddrLocal {} t;
  WySockAddrLocal tmp;
  if((r=tmp._swap(t))!=Wym_EBADTYPE) {
     WY_THROW(r);
  }
 }

 // operator=(const WyStr&)
 {
   try {
     WySockAddrLocal tmp;
     const char* p=0;
     tmp=p;
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_EFAULT) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // operator=(const WyStr&)
 {
   try {
     WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
     WySockAddrLocal tmp;
     tmp=path;
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_ENAMETOOLONG) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // operator=(WyCSeg)
 {
   try {
     WyStr path(WySockAddrLocal::PathMaxLen+1,char('A'));
     WySockAddrLocal tmp;
     tmp=path.cseg();
     WY_THROW( WyRet() );  // no expected exception
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_ENAMETOOLONG) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

 // operator==(const char*)
 {
   try {
     WySockAddrLocal tmp;
     const char* p=0;
     if(tmp==p) {
       WY_THROW( WyRet() );  // no expected exception
     } else {
       WY_THROW( WyRet() );  // no expected exception
     }
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_EFAULT) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };

   try {
     WySockAddrLocal tmp;
     const char* p=0;
     if(p==tmp) {
       WY_THROW( WyRet() );  // no expected exception
     } else {
       WY_THROW( WyRet() );  // no expected exception
     }
   }
   catch(const WySockAddrLocal::Reply& e) {
     if(e!=Wym_EFAULT) {
       WY_THROW( WyRet(e) );
     }
     // FALL_THROUGH 
   };
 }

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

#include "wy_array.h"

static void t_array(void)
{
/*
 // chk struct struct sockaddr_un
 // (simple chk)
 {
   typedef struct ::sockaddr_un ElemType;
   Wy_Array<ElemType> tmp;
   ElemType ele;
   ele.sun_family=45;
   ele.sun_path[1]=123;

   tmp.push_back(ele);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sun_family!=ele.sun_family) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sun_path[1]!=ele.sun_path[1]) {
     WY_THROW( WyRet() );
   }

   tmp.push_back(ElemType());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sun_family!=0) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sun_path[1]!=0) {
     WY_THROW( WyRet() );
   }
 }*/
};

// chk Wy_SockAddr interface
static void t_sockaddr(void)
{
 WySockAddrLocal a0;
 const Wy_SockAddr &saf=a0;
 if(saf.family()!=AF_LOCAL) {
   WY_THROW( WyRet() );
 }

 WyStr str;
 WyRet r;
 str="?";
 if((r=saf.notation(str))!=Ok) {
   WY_THROW(r);
 }
 if(str.size()!=0) {
   WY_THROW( WyRet() );
 }
};

static WyStr chdr("+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wysockaddrlocal.h ...\n";
 std::cout << "PathMaxLen=" << WySockAddrLocal::PathMaxLen << std::endl;
 t1();
 t2();
 t_error();
 t_array();
 t_sockaddr();
 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);
};