chk_sockaddrinet6.cpp

一个不错

   if(tmp3!=saddr) {
     WY_THROW( WyRet() );
   }
   if(saddr==tmp3) {
   } else {
     WY_THROW( WyRet() );
   }
   if(saddr!=tmp3) {
     WY_THROW( WyRet() );
   }
 }

 // notation / wrd
 {
  const WyCSeg IPStr("1:22:33:4::");
  WySockAddrINet6::InPortType PortNum=50000;
  WySockAddrINet6 saddr( WySockAddrINet6::IPAddr(IPStr),PortNum);
  WyStr str(WyCSeg("x"));
  if((r=saddr.notation(str))!=Ok) {
    WY_THROW(r);
  }
  WyStr str2=WyStr(IPStr)+'.'+Wy::wrd(PortNum);
  if(str!=str2) {
    WY_THROW( WyRet() );
  }
  if(Wy::wrd(saddr)!=str2) {
    WY_THROW( WyRet() );
  }
 }

 // reset()
 {
   WySockAddrINet6 a0;
   a0.reset();
   CHK_DEFAULT(a0);
   WySockAddrINet6 a1("::1",2);
   if(a1.is_default()) {
     WY_THROW( WyRet() );
   }
   a1.reset();
   CHK_DEFAULT(a1);
 }

 // reset(const WySockAddrINet6&)/reset(IPAddr&,uint16_t)
 {
   WySockAddrINet6 a0;
   WySockAddrINet6 a1;
   a1.reset(a0);
   CHK_DEFAULT(a0);
   CHK_DEFAULT(a1);
   CHK_EQU(a0,a1);

   a0.reset("::5",6);
   a1.reset(a0);
   if(a0.is_default()) {
     WY_THROW( WyRet() );
   }
   if(a1!=a0) {
     WY_THROW( WyRet() );
   }
   if(a0.port()!=6) {
     WY_THROW( WyRet() );
   }
   if(a1.port()!=6) {
     WY_THROW( WyRet() );
   }
   if(a0.ip()!=a1.ip()) {
     WY_THROW( WyRet() );
   }
   if(a0._flowinfo()!=a1._flowinfo()) {
     WY_THROW( WyRet() );
   }
   if(a0._scope_id()!=a1._scope_id()) {
     WY_THROW( WyRet() );
   }
   
   WySockAddrINet6 a2;
   a2.reset((const char*)"2::2:3:3",9);
   a0=a1=a2;
   CHK_EQU(a0,a1);
   CHK_EQU(a0,a2);
   CHK_EQU(a1,a0);
   CHK_EQU(a1,a2);
   CHK_EQU(a2,a0);
   CHK_EQU(a2,a1);
   if(a0.port()!=9) {
     WY_THROW( WyRet() );
   }
   if(a1.port()!=9) {
     WY_THROW( WyRet() );
   }
   if(a2.ip()!="2::2:3:3") {
     WY_THROW( WyRet() );
   }
 }

 // operator==/!=
 {
   WySockAddrINet6 a0,a1;
   if(a0==a1) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a0!=a1) {
     WY_THROW( WyRet() );
   }

   a1.reset("::3",4);
   if(a1==a0) {
     WY_THROW( WyRet() );
   }
   if(a1!=a0) {
   } else {
     WY_THROW( WyRet() );
   }
 }

 // operator==/!= (const ::sockaddr_in6&, const WySockAddrINet6&)
 {
   WySockAddrINet6 a0("::3:8",749);
   struct ::sockaddr_in6 a1(a0.wy_sockaddr_ref());
   if(a1==a0) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a1!=a0) {
     WY_THROW( WyRet() );
   }

   WySockAddrINet6 a2;
   struct ::sockaddr_in6 a3(a2.wy_sockaddr_ref());
   if(a3==a2) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a3!=a2) {
     WY_THROW( WyRet() );
   }
 }
 
 // operator=
 {
   WySockAddrINet6 a0;
   WySockAddrINet6 a1;
   a1=a0;
   CHK_DEFAULT(a0);
   CHK_DEFAULT(a1);

   a0.reset("::4",5);
   a1=a0;
   if(a0.is_default()) {
     WY_THROW( WyRet() );
   }
   if(a1.is_default()) {
     WY_THROW( WyRet() );
   }
   if(a1!=a0) {
     WY_THROW( WyRet() );
   }
   if(a1==a0) {
   } else {
     WY_THROW( WyRet() );
   }
   if(a0.port()!=5) {
     WY_THROW( WyRet() );
   }
   if(a1.port()!=5) {
     WY_THROW( WyRet() );
   }
 }

};

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

 CHK_DEFAULT(A0);
 CHK_DEFAULT(N0);
 N0.reset("12::34:56:78",8);
 CHK_NOT_DEFAULT(N0);

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

 // operator==/!=
 {
   WySockAddrINet6 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() );
   }
 }
 
 // reset
 {
   WySockAddrINet6 a0(N0);
   CHK_NOT_DEFAULT(a0);
   a0.reset();
   CHK_DEFAULT(a0);
 }

 // _swap
 {
  WySockAddrINet6 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* bp_tmp0(&tmp0);
  if((r=tmp1._swap(*bp_tmp0))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);
 }

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

 // reset
 {
   WySockAddrINet6 a0(N0);
   if(a0!=N0) {
     WY_THROW( WyRet() );
   }
   a0.reset(N0);
   a0.reset(A0);
   CHK_DEFAULT(a0);
   a0.reset("1:2::3:4",5);
   WySockAddrINet6 a1;
   a1.reset(a0);
   if(a1!=a0) {
     WY_THROW( WyRet() );
   }
 }

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

 // get_notation
 {
   WySockAddrINet6 a0(N0);
   if(a0.is_default()) {
     WY_THROW( WyRet() );
   }
   WyStr str,str2;
   
   if((r=a0.ip().notation(str))!=Ok) {
     WY_THROW(r);
   }
   if(str!="12::34:56:78") {   // N0 notation is "12.34.56.78"
     std::cerr << str.c_str() << std::endl;
     WY_THROW( WyRet() );
   }
   if((r=a0.ip().notation(str2))!=Ok) {
     WY_THROW(r);
   }
   if(str2!=str) {
     WY_THROW( WyRet() );
   }
   if(Wy::wrd(a0.ip())!=str) {
     WY_THROW( WyRet() );
   }
 }

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

 // chk move ctor
 {
  const WySockAddrINet6::IPAddr TstIP("::40");
  const uint16_t TstPort=567;
  char raw_buf[2*sizeof(WySockAddrINet6)];
  ::memset(raw_buf,0,sizeof(raw_buf));
  WySockAddrINet6* const p1( reinterpret_cast<WySockAddrINet6*>(raw_buf) );
  WySockAddrINet6* const p2(p1+1);

  new(p1) WySockAddrINet6(TstIP,TstPort);
  if((p1->is_default()==true)||
     (p1->port()!=TstPort)||
     (p1->ip()!=TstIP) ) {
    p1->~WySockAddrINet6();
    WY_THROW(r);
  }

  // move *p1 to p2
  try {
    new(p2) WySockAddrINet6(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~WySockAddrINet6();
    throw;
  };
  if((p2->is_default()==true)||
     (p2->port()!=TstPort)||
     (p2->ip()!=TstIP) ) {
    p2->~WySockAddrINet6();
    WY_THROW(r);
  }
  p2->~WySockAddrINet6();
 }
};

static void t_exception(void)
{
 //WyRet r;

 // Test copy constructor exception
 //
 try {
   WyStr tbuf("abc.efg.1234zaz");    // should cause error
   WySockAddrINet6 tmp(tbuf,4);
   tmp.reset();          // supress unuse warning
   WY_THROW( WyRet() );  // no expected exception
 }
 catch(const WySockAddrINet6::IPAddr::Reply& e) {
   if(e!=Wym_EADDRNOTAVAIL) {
     WyRet r=e;
     WY_THROW(r);
   }
   // FALL_THROUGH 
 }
 catch(...) {
   WyRet r;
   WY_THROW(r);
 };

 // chk WySockAddrINet6(const char*,unsigned short)
 try {
   WySockAddrINet6 tmp((const char*)0,1);
   tmp.reset();        // supress unused warning of compiler
   WY_THROW( WyRet() );
 }
 catch(const WySockAddrINet6::IPAddr::Reply& e) {
   if(e!=Wym_EFAULT) {
     WyRet r=e;
     WY_THROW(r);
   }
   // FALL_THROUGH 
 };

 {
   WySockAddrINet6 tmp;
   try {
     tmp.reset((const char*)0,1);
     WY_THROW( WyRet() );
   }
   catch(const WySockAddrINet6::IPAddr::Reply& e) {
     if(e!=Wym_EFAULT) {
       throw;
     }
     // FALLTHROUGH
   };
 }
};

static void t_sockaddr(void)
{
 const WyCSeg IPStr("1:22:33:4::");
 WySockAddrINet6::InPortType PortNum=50000;
 WySockAddrINet6 saddr( WySockAddrINet6::IPAddr(IPStr),PortNum);
 WyStr str(WyCSeg("x"));
 WyRet r;
 const Wy_SockAddr &sref( saddr );
 if(sref.family()!=AF_INET6) {
   WY_THROW( WyRet() );
 }
 if((r=sref.notation(str))!=Ok) {
   WY_THROW(r);
 }
 if(str!=WyStr(IPStr)+'.'+Wy::wrd(PortNum)) {
   WY_THROW( WyRet() );
 }
};

#include "wy_array.h"
#include "ck_array.h"

static void t_array(void)
{
 ck_array<WySockAddrINet6>();
/*
 // chk struct in6_addr { unsigned long s6_addr[16]; }
 // (simple check)
 {
   ck_array< ::in6_addr >();
   Wy_Array< ::in6_addr > tmp;
   ::in6_addr iaddr={ {1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6} };
   tmp.push_back(iaddr);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(memcmp(&tmp[0].s6_addr,&iaddr,sizeof(iaddr))) {
     WY_THROW( WyRet() );
   }
   tmp.push_back(::in6_addr());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   //if(tmp[1].s6_addr!=0) {
   //  WY_THROW( WyRet() );
   //}
 }*/
/*
 // chk struct sockaddr_in6
 {
   //ck_array< ::sockaddr_in6 > tmp;        // wont compile
   Wy_Array< ::sockaddr_in6 > tmp;
   ::sockaddr_in6 sa;
   ::in6_addr iaddr={ {21,2,3,4,5,6,7,8,9,0,1,2,3,4,5,16} };

   sa.sin6_family=AF_INET6;
   ::memcpy(&sa.sin6_addr,&iaddr,sizeof(sa.sin6_addr));
   sa.sin6_port=5678;

   tmp.push_back(sa);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sin6_family!=AF_INET6) {
     WY_THROW( WyRet() );
   }
   if(memcmp(&tmp[0].sin6_addr,&iaddr,sizeof(iaddr))) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sin6_port!=5678) {
     WY_THROW( WyRet() );
   }

   tmp.push_back(::sockaddr_in6());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sin6_family!=0) {
     WY_THROW( WyRet() );
   }
   //if(memcmp(&tmp[1].sin6_addr,&iaddr,sizeof(iaddr))) {
   //  WY_THROW( WyRet() );
   //}
   if(tmp[1].sin6_port!=0) {
     WY_THROW( WyRet() );
   }

 }*/
};

static WyStr chdr("+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wysockaddrinet6.h ...\n";
 if(WySockAddrINet6::family()!=AF_INET6) {
   WY_THROW( WyRet() );
 }
 chk_ipaddr();
 t1();
 t2();
 t_exception();
 t_sockaddr();
 {
   WySockAddrINet6::IPAddr tmp;
   WyStr str;
   WyRet r;
   if((r=tmp.notation(str))!=Ok) {
     WY_THROW(r);
   }
   if(Wy::wrd(tmp)!=str) {
     WY_THROW( WyRet() );
   }
   std::cout << "IPAddr()=\"" << str.c_str() << "\"\n";
 }

 // chk new
 {
   class CkNew {
     public:
      CkNew() : _p(new WySockAddrINet6()) {};
      ~CkNew() { if(_p) { delete _p; _p=0; } };
       WySockAddrINet6* _p;
   } cn;
   CHK_DEFAULT(*cn._p);
 }

 t_array();

 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);
};