chk_array.cpp

一个不错

     }
     if(tmp[1]!=4) {
       WY_THROW( WyRet() );
     }
     if(tmp[2]!=2) {
       WY_THROW( WyRet() );
     }
     if(tmp[3]!=2) {
       WY_THROW( WyRet() );
     }
     if(tmp[4]!=6) {
       WY_THROW( WyRet() );
     }
  
     tmp.replace(4,1,2,Element(6));
     if(tmp.size()!=6) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+6) {
       WY_THROW( WyRet() );
     }
     if(tmp[0]!=4) {
       WY_THROW( WyRet() );
     }
     if(tmp[1]!=4) {
       WY_THROW( WyRet() );
     }
     if(tmp[2]!=2) {
       WY_THROW( WyRet() );
     }
     if(tmp[3]!=2) {
       WY_THROW( WyRet() );
     }
     if(tmp[4]!=6) {
       WY_THROW( WyRet() );
     }
     if(tmp[5]!=6) {
       WY_THROW( WyRet() );
     }
  
     tmp.replace(1,4,1,Element(5));
     if(tmp.size()!=3) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+3) {
       WY_THROW( WyRet() );
     }
     if(tmp[0]!=4) {
       WY_THROW( WyRet() );
     }
     if(tmp[1]!=5) {
       WY_THROW( WyRet() );
     }
     if(tmp[2]!=6) {
       WY_THROW( WyRet() );
     }

     tmp.replace(0,1,0,Element(5));
     if(tmp.size()!=2) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+2) {
       WY_THROW( WyRet() );
     }
     if(tmp[0]!=5) {
       WY_THROW( WyRet() );
     }
     if(tmp[1]!=6) {
       WY_THROW( WyRet() );
     }

     tmp.replace(1,4,0,Element(5));
     if(tmp.size()!=1) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+1) {
       WY_THROW( WyRet() );
     }
     if(tmp[0]!=5) {
       WY_THROW( WyRet() );
     }

     tmp.replace(1,4,0,Element(5));
     if(tmp.size()!=1) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+1) {
       WY_THROW( WyRet() );
     }
     if(tmp[0]!=5) {
       WY_THROW( WyRet() );
     }

     tmp.replace(0,4,0,Element(5));
     if(tmp.size()!=0) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+0) {
       WY_THROW( WyRet() );
     }
     tmp.replace(0,4,0,Element(5));
     if(tmp.size()!=0) {
       WY_THROW( WyRet() );
     }
     if(Element::obj_cnt()!=ObjCnt+0) {
       WY_THROW( WyRet() );
     }

     tmp.reset();
   }

   tmp.reset();
   tmp.push_back(11);
   for(int loopcnt=0; loopcnt<100; ++loopcnt) {
     tmp.push_back( tmp.back() );
     if(tmp.back()!=11) {
       WY_THROW( WyRet() );
     }
   }
   for(size_t i=0; i<tmp.size(); ++i) {
     if(tmp[i]!=11) {
       WY_THROW( WyRet() );
     }
   }
 }
};

static void t2()
{
 WyRet r;
 {
  Wy_Array<Element> tmp1;
  CHK_DEFAULT(tmp1);
  
  Wy_Array< Wy_Array<Element> > tmp_a;
  CHK_DEFAULT(tmp_a);

  tmp_a.push_back(tmp1);
  if(tmp_a.size()!=1) {
    WY_THROW( WyRet() );
  }

  for(int i=0; i<1000; ++i) {
    tmp_a.push_back(tmp1);
    if(tmp_a[0]!=tmp1) {
      WY_THROW( WyRet() );
    }
    if(tmp_a.back()!=tmp1) {
      WY_THROW( WyRet() );
    }
  }
  for(; tmp_a.size(); ) {
    if(tmp_a.back()!=tmp1) {
      WY_THROW( WyRet() );
    }
    tmp_a.pop_back();
  }
  CHK_DEFAULT(tmp_a);
 }

 // chk argument type WySeg<const Element> won't cause compiler complain
 {
   const Element arr[]={};
   WySeg<const Element> seg(arr,sizeof(arr)/sizeof(Element));
   Wy_Array<Element> tmp3(seg);
   CHK_DEFAULT(tmp3);
   tmp3=seg;
   tmp3.reset(seg);
   tmp3.insert(0,seg);
 }
};

template<typename T>
static void t_qsort(Wy_Array<T>& v, size_t start, size_t end)
{
 const size_t VLen( end-start );
 if(VLen<=1) {
   return;
 }
 if(VLen==2) {
   if(v[start+1]<v[start]) {
     v[start].swap(v[start+1]);
   }
   return;
 }
 size_t ge_bgn=start;
 const T pe(v[ge_bgn]);
 for(size_t s=start+1; s<end; ++s) {
   if(v[s]<pe) {
     v[ge_bgn].swap(v[s]);
     ++ge_bgn;
   }
 }
 if(ge_bgn==start) {
   t_qsort(v,start+1,end);
   return;
 }
 t_qsort(v,start,ge_bgn);
 t_qsort(v,ge_bgn,end);
};

static void t_sort(void)
{
 WyRet r;
 Wy_Array<Element> v;
 v.push_back(2);
 v.push_back(2);
 v.push_back(1);
 v.push_back(2);
 v.push_back(3);
 v.push_back(2);
 v.push_back(5);
 v.push_back(4);
 v.push_back(2);
 v.push_back(4);
 v.push_back(2);

 t_qsort(v,0,v.size());
 for(size_t i=1; i<v.size(); ++i) {
   if(v[i]<v[i-1]) {
     WY_THROW( WyRet() );
   }
 }
};

// EleType is arithmetic type
template<typename EleType>
static void ck_array_value(void)
{
 const EleType DefaultElem( EleType(0) );

 // chk WY_Array()
 {
  Wy_Array<EleType> tmp;
  if(tmp.begin()!=tmp.end()) {
    WY_THROW( WyRet() );
  }
  if(tmp.size()!=0) {
    WY_THROW( WyRet() );
  }
  if(tmp._capacity()!=Wy_Array<EleType>::min_capacity()) {
    WY_THROW( WyRet() );
  }
  CHK_DEFAULT(tmp);
 }

 // chk Wy_Array(const Wy_Array&)
 {
  Wy_Array<EleType> tmp1;
  CHK_DEFAULT(tmp1);
  Wy_Array<EleType> tmp2(tmp1);
  CHK_DEFAULT(tmp2);

  tmp2.push_back(EleType());
  Wy_Array<EleType> tmp3(tmp2);
  if(tmp2!=tmp3) {
    WY_THROW( WyRet() );
  }
  if(tmp3.size()!=1) {
    WY_THROW( WyRet() );
  }

  for(int i=0; i<100; ++i) {
    tmp2.push_back(EleType());
  }
  Wy_Array<EleType> tmp4(tmp2);
  if(tmp4!=tmp2) {
    WY_THROW( WyRet() );
  }
  if(tmp4.size()!=tmp2.size()) {
    WY_THROW( WyRet() );
  }
  if(tmp4._capacity()<tmp4.size()) {
    WY_THROW( WyRet() );
  }
 }

 // chk Wy_Array(const WySeg<EleType>&)
 {
  const EleType ele_arr[3]={ EleType(2),EleType(1),EleType(5)};
  Wy_Array<EleType> tmp( WySeg<const EleType>(ele_arr,3) );
  if(tmp._capacity()<tmp.min_capacity()) {
    WY_THROW( WyRet() );
  };
  if(tmp.size()!=3) {
    WY_THROW( WyRet() );
  };
  for(size_t i=0; i<tmp.size(); ++i) {
    if(tmp[i]!=ele_arr[i]) {
      WY_THROW( WyRet() );
    }
  }

  EleType ele_arr2[5]={EleType(4),EleType(6),EleType(87),EleType(3),EleType(76)};
  Wy_Array<EleType> tmp2( WySeg<EleType>(ele_arr2,5) );
  if(tmp2._capacity()<tmp2.min_capacity()) {
    WY_THROW( WyRet() );
  };
  if(tmp2.size()!=5) {
    WY_THROW( WyRet() );
  };
  for(size_t i=0; i<tmp2.size(); ++i) {
    if(tmp2[i]!=ele_arr2[i]) {
      WY_THROW( WyRet() );
    }
  }

 }

 // chk Wy_Array(size_t,const EleType&)
 {
  EleType ele;
  Wy_Array<EleType> tmp1(size_t(40),ele),tmp2(tmp1);
  if(tmp1.size()!=40) {
    WY_THROW( WyRet() );
  }
  if(tmp2.size()!=tmp1.size()) {
    WY_THROW( WyRet() );
  }

  Wy_Array<EleType*> tmp3(size_t(40),&ele),tmp4(tmp3);
  if(tmp3.size()!=40) {
    WY_THROW( WyRet() );
  }
  if(tmp4.size()!=tmp3.size()) {
    WY_THROW( WyRet() );
  }

  Wy_Array<const EleType*> tmp5(size_t(40),&ele),tmp6(tmp5);
  if(tmp5.size()!=40) {
    WY_THROW( WyRet() );
  }
  if(tmp6.size()!=tmp5.size()) {
    WY_THROW( WyRet() );
  }
 
  try {
    Wy_Array<Element> tmp( Wy_Array<Element>::max_capacity()+1,Element());
    WY_THROW( WyRet() );
  }
  catch(const Wy_Array<Element>::Reply& e) {
    if(e!=Wym_EFBIG) {
      throw;
    }
  };
 }

 // chk reset(const Wy_Array&)
 {
   Wy_Array<Element> tmp1;
   CHK_DEFAULT(tmp1);
   Wy_Array<Element> tmp2;
   CHK_DEFAULT(tmp2);

   tmp2.reset(tmp2);
   CHK_DEFAULT(tmp2);
   tmp2.reset(tmp1);
   CHK_DEFAULT(tmp2);

   tmp1.push_back(8);
   tmp2.reset(tmp1);
   if(tmp2!=tmp1) {
     WY_THROW( WyRet() );
   }
   if(tmp2._capacity()<tmp2.min_capacity()) {
     WY_THROW( WyRet() );
   }

   tmp1.push_back(7);
   tmp2.reset(tmp1);
   if(tmp2==tmp1) {
   } else {
     WY_THROW( WyRet() );
   }
   if(tmp2._capacity()<tmp2.min_capacity()) {
     WY_THROW( WyRet() );
   }

   tmp2.reset(tmp2);   // self-reset
   if(tmp2!=tmp1) {
     WY_THROW( WyRet() );
   }
   if(tmp2._capacity()<tmp2.min_capacity()) {
     WY_THROW( WyRet() );
   }
 }

 // chk reset(const WySeg<EleType>&)
 {
  Element arr1[1]={};
  Element arr2[2]={};
  WySeg<Element> ss1(arr1,1);
  const WySeg<Element> ss2(arr2,2);

  Wy_Array<Element> tmp1(ss1);
  Wy_Array<Element> tmp2(ss2);
  Wy_Array<Element> tmp3;

  WY__CK_ARRAY_CHK_DEFAULT(tmp3);
  if((tmp1.size()!=1)||(tmp2.size()!=2)) {
    WY_THROW( WyRet() );
  }
  if(tmp1==tmp2) {
    WY_THROW( WyRet() );
  }
  tmp3.reset(ss1);
  if(tmp3!=tmp1) {
    WY_THROW( WyRet() );
  }
  tmp3.reset(ss2);
  if(tmp3!=tmp2) {
    WY_THROW( WyRet() );
  }

  tmp2.reset(ss2);   // non-overlapped
  try {
    tmp2.reset(tmp2.subseg());   // overlapped reset
    WY_THROW( WyRet() );
  }
  catch(const Wy_Array<Element>::Reply& e) {
    if(e!=Wym_ELOOP) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    throw;
  };
 }

 // chk reset(size_t,const T&)
 {
   Wy_Array<Element> tmp;
   CHK_DEFAULT(tmp);
   tmp.reset(0,Element());
   CHK_DEFAULT(tmp);

   int n_elem,v;
   for(n_elem=0,v=43; n_elem<65; ++n_elem,++v) {
     tmp.reset(n_elem,Element(v));
     if(tmp.size()!=size_t(n_elem)) {
       WY_THROW( WyRet() );
     }
     for(size_t i=0; i<tmp.size(); ++i) {
       if(tmp[i]!=Element(v)) {
         WY_THROW( WyRet() );
       }
     }
     if(tmp._capacity()<Wy_Array<Element>::min_capacity()) {
       WY_THROW( WyRet() );
     }
     if(tmp._capacity()<size_t(n_elem)) {
       WY_THROW( WyRet() );
     }
   }

   for(n_elem=65,v=11; n_elem>0; --n_elem,++v) {
     tmp.reset(n_elem,Element(v));
     if(tmp.size()!=size_t(n_elem)) {
       WY_THROW( WyRet() );
     }
     for(size_t i=0; i<tmp.size(); ++i) {
       if(tmp[i]!=Element(v)) {
         WY_THROW( WyRet() );
       }
     }
     if(tmp._capacity()<Wy_Array<Element>::min_capacity()) {
       WY_THROW( WyRet() );
     }
     if(tmp._capacity()<size_t(n_elem)) {
       WY_THROW( WyRet() );
     }
   }

   try {
     tmp.reset(Wy_Array<Element>::max_capacity()+1,Element());
     WY_THROW( WyRet() );
   }
   catch(const Wy_Array<Element>::Reply& e) {
     if(e!=Wym_EFBIG) {
       throw;
     }
   };
 }

 // chk subseg
 {
   Wy_Array<Element> tmp;
   CHK_DEFAULT(tmp);

   try {
     tmp.subseg(1).size();
     WY_THROW( WyRet() );
   }
   catch(const Wy_Array<Element>::Reply& e) {
     if(e!=Wym_EINVAL) {
       WY_THROW( WyRet(e) );
     }
   };
   try {
     tmp.subseg(1,1).size();
     WY_THROW( WyRet() );
   }
   catch(const Wy_Array<Element>::Reply& e) {
     if(e!=Wym_EINVAL) {
       WY_THROW( WyRet(e) );
     }
   };

   tmp.resize(3);
   if(tmp.size()!=3) {
     WY_THROW( WyRet() );
   }
 }

 // chk operator= (const WySeg<EleType>&)
 {
  Element arr1[1]={};
  Element arr2[2]={};
  WySeg<Element> ss1(arr1,1);
  const WySeg<Element> ss2(arr2,2);

  Wy_Array<Element> tmp1(ss1);
  Wy_Array<Element> tmp2(ss2);
  Wy_Array<Element> tmp3;

  WY__CK_ARRAY_CHK_DEFAULT(tmp3);
  if((tmp1.size()!=1)||(tmp2.size()!=2)) {
    WY_THROW( WyRet() );
  }
  if(tmp1==tmp2) {
    WY_THROW( WyRet() );
  }
  if(&(tmp3=ss1)!=&tmp3) {
    WY_THROW( WyRet() );
  }
  if(tmp3!=tmp1) {
    WY_THROW( WyRet() );
  }
  tmp3=ss2;
  if(tmp3!=tmp2) {
    WY_THROW( WyRet() );
  }

  tmp2=ss2;   // non-overlapped
  try {
    tmp2=tmp2.subseg();   // overlapped reset
    WY_THROW( WyRet() );
  }
  catch(const Wy_Array<Element>::Reply& e) {
    if(e!=Wym_ELOOP) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    throw;
  };
 }

 // chk err front()
 {
  Wy_Array<EleType> tmp1;
  CHK_DEFAULT(tmp1);

  EleType tmp_e(DefaultElem);
  if(tmp_e!=DefaultElem) {
    WY_THROW( WyRet() );
  }
  try {
    tmp_e=tmp1.front();
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    if(tmp_e!=DefaultElem) {
      WY_THROW( WyRet() );
    }
    if(e!=Wym_ENOENT) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };

  CHK_DEFAULT(tmp1);
  try {
    tmp1.front()=DefaultElem;  // EleType has reset() defined
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    CHK_DEFAULT(tmp1);
    if(e!=Wym_ENOENT) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };
 }

 // chk err back()
 {
  Wy_Array<EleType> tmp1;
  CHK_DEFAULT(tmp1);
  try {
    EleType tmp_e( tmp1.back() );
    tmp_e=EleType(0);    // supress warning
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    if(e!=Wym_ENOENT) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };

  try {
    tmp1.back()=DefaultElem;  // EleType has operator= defined
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    CHK_DEFAULT(tmp1);
    if(e!=Wym_ENOENT) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };
 }

 // chk err operator[]
 {
  Wy_Array<EleType> tmp1;
  CHK_DEFAULT(tmp1);
  try {
    EleType tmp_e( tmp1[0] );
    tmp_e=DefaultElem;       // supress warning message
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    CHK_DEFAULT(tmp1);
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet(e) );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };

  tmp1.push_back( EleType() );
  tmp1[0]=DefaultElem;
  if(tmp1.size()!=1) {
    WY_THROW( WyRet() );
  }
  if(tmp1[0]!=DefaultElem) {
    WY_THROW( WyRet() );
  }
  try {
    tmp1[tmp1.size()]=DefaultElem;
    WY_THROW( WyRet() );
  }
  catch(const typename Wy_Array<EleType>::Reply& e) {
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet(e) );
    }
    if(tmp1.size()!=1) {
      WY_THROW( WyRet() );
    }
    if(tmp1[0]!=DefaultElem) {
      WY_THROW( WyRet() );
    }
  }
  catch(...) {
    WY_THROW( WyRet() );
  };
 }

 // chk push_back
 {
  Wy_Array<EleType> tmp;
  CHK_DEFAULT(tmp);
  size_t cap( (tmp._capacity()<<1)+1 );
  for(size_t i=0; i<cap; ++i) {
    tmp.push_back( EleType() );
  }
  if(tmp.size()!=cap) {
    WY_THROW( WyRet() );
  }
  for(size_t i=0; i<tmp.size(); ++i) {
    if(tmp[i]!=DefaultElem) {
      WY_THROW( WyRet() );
    }