chk_sockaddrinet4.cpp

一个不错

     WY_THROW( WyRet() );
   }

   WySockAddrINet4 a4(a3);
   CHK_EQU(a3,a4);

   const WySockAddrINet4::IPAddr ip5;
   const WySockAddrINet4 a5(ip5,0);
   CHK_DEFAULT(a5);
 }

 // chk ops on parameter const ::sockaddr_in&
 {
   struct ::sockaddr_in saddr;
   const uint16_t PortNum=2467;
   const uint32_t IPNum=0x5678abcd;
   saddr.sin_port=htons(PortNum);
   saddr.sin_addr.s_addr=htonl(IPNum);
   WySockAddrINet4 tmp(saddr);
   if(tmp.ip()!=IPNum) {
     WY_THROW( WyRet() );
   }
   if(tmp.port()!=PortNum) {
     WY_THROW( WyRet() );
   }

   WySockAddrINet4 tmp2;
   CHK_DEFAULT(tmp2);
   tmp2.reset(saddr);
   if(tmp2.ip()!=IPNum) {
     WY_THROW( WyRet() );
   }
   if(tmp2.port()!=PortNum) {
     WY_THROW( WyRet() );
   }
   CHK_EQU(tmp,tmp2);

   WySockAddrINet4 tmp3;
   tmp3=saddr;
   CHK_EQU(tmp,tmp2);

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

 // operator==/!=
 {
   WySockAddrINet4 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() );
   }
 }

 // notation/wrd
 {
  const WyCSeg IPStr("1.0.11.222");
  WySockAddrINet4::InPortType PortNum=40000;
  WySockAddrINet4 saddr( WySockAddrINet4::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()
 {
   WySockAddrINet4 a0;
   a0.reset();
   CHK_DEFAULT(a0);

   WySockAddrINet4 a1(5,6);
   CHK_NOT_DEFAULT(a1);
   a1.reset();
   CHK_DEFAULT(a1);
 }

 // reset(const WySockAddrINet4&)/reset(ulong,ushort)/reset(const WyStr&,ushort)
 {
   WySockAddrINet4 a0;
   WySockAddrINet4 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() );
   }
   
   WySockAddrINet4 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()!=0x02020303) {
     WY_THROW( WyRet() );
   }
 }

 // operator=
 {
   WySockAddrINet4 a0;
   WySockAddrINet4 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;
 WySockAddrINet4 A0;
 WySockAddrINet4 N0;

 CHK_DEFAULT(A0);
 CHK_DEFAULT(N0);
 N0.reset("12.34.56.78",8);
 CHK_NOT_DEFAULT(N0);

 // constructor
 {
   WySockAddrINet4 a0(N0);
   CHK_NOT_DEFAULT(a0);
   CHK_EQU(a0,N0);
 }

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

 // _swap
 {
  WySockAddrINet4 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,N0);

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

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

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

 // reset
 {
   WySockAddrINet4 a0(N0);
   CHK_EQU(a0,N0);
   a0.reset(N0);
   CHK_EQU(a0,N0);
   a0.reset(A0);
   CHK_EQU(a0,A0);
   CHK_DEFAULT(a0);
   a0.reset("1.2.3.4",5);
   WySockAddrINet4 a1;
   a1.reset(a0);
   CHK_EQU(a0,a1);
 }

 // operator=
 {
   WySockAddrINet4 a0(N0);
   a0=A0;
   CHK_DEFAULT(a0);
   CHK_EQU(a0,A0);
   a0=N0;
   CHK_EQU(a0,N0);
 }

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

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

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

static void t_exception(void)
{

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

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

static void t_sockaddr(void)
{
 const WyCSeg IPStr("1.0.11.222");
 WySockAddrINet4::InPortType PortNum=40000;
 WySockAddrINet4 saddr( WySockAddrINet4::IPAddr(IPStr),PortNum);
 WyStr str(WyCSeg("x"));
 WyRet r;
 const Wy_SockAddr &sref( saddr );
 if(sref.family()!=AF_INET) {
   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<WySockAddrINet4>();
/*
 // chk struct in_addr { unsigned long s_addr; }
 // (simple check)
 {
   ck_array< ::in_addr >();
   Wy_Array< ::in_addr > tmp;
   ::in_addr iaddr={ 123 };
   tmp.push_back(iaddr);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].s_addr!=iaddr.s_addr) {
     WY_THROW( WyRet() );
   }
   tmp.push_back(::in_addr());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].s_addr!=0) {
     WY_THROW( WyRet() );
   }
 }*/
/*
 // chk struct sockaddr_in
 {
   //ck_array< ::sockaddr_in > tmp;       // wont compile
   Wy_Array< ::sockaddr_in > tmp;
   ::sockaddr_in sa;
   ::in_addr iaddr={ 321 };

   sa.sin_family=AF_INET;
   ::memcpy(&sa.sin_addr,&iaddr,sizeof(sa.sin_addr));
   sa.sin_port=5678;

   tmp.push_back(sa);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sin_family!=AF_INET) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sin_addr.s_addr!=iaddr.s_addr) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].sin_port!=5678) {
     WY_THROW( WyRet() );
   }

   tmp.push_back(::sockaddr_in());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sin_family!=0) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sin_addr.s_addr!=0) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].sin_port!=0) {
     WY_THROW( WyRet() );
   }

 }*/
};

static WyStr chdr("+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wysockaddrinet4.h ...\n";
 if(WySockAddrINet4::family()!=AF_INET) {
   WY_THROW( WyRet() );
 }
 chk_ipaddr();
 t1();
 t2();
 t_exception();
 t_sockaddr();

 {
   WySockAddrINet4::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 WySockAddrINet4()) {};
      ~CkNew() { if(_p) { delete _p; _p=0; } };
       WySockAddrINet4* _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);
};