--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/tsrc/Boost_test/multi_index/src/test_key_extractors.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,377 @@
+/* Boost.MultiIndex test for key extractors.
+ *
+ * Copyright 2003-2006 Joaquín M López Muñoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_key_extractors.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include <boost/multi_index/key_extractors.hpp>
+#include <boost/ref.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/test/test_tools.hpp>
+#include <list>
+#include <memory>
+
+using namespace boost::multi_index;
+using namespace boost::tuples;
+
+struct test_class
+{
+ int int_member;
+ const int int_cmember;
+
+ bool bool_mem_fun_const()const{return true;}
+ bool bool_mem_fun(){return false;}
+
+ test_class(int i=0):int_member(i),int_cmember(i){}
+ test_class(int i,int j):int_member(i),int_cmember(j){}
+
+ test_class& operator=(const test_class& x)
+ {
+ int_member=x.int_member;
+ return *this;
+ }
+
+ bool operator<(const test_class& x)const
+ {
+ if(int_member<x.int_member)return true;
+ if(x.int_member<int_member)return false;
+ return int_cmember<x.int_cmember;
+ }
+
+ bool operator==(const test_class& x)const
+ {
+ return int_member==x.int_member&&int_cmember==x.int_cmember;
+ }
+};
+
+struct test_derived_class:test_class
+{
+ test_derived_class(int i=0):test_class(i){}
+ test_derived_class(int i,int j):test_class(i,j){}
+};
+
+BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(test_class)
+BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(test_derived_class)
+
+typedef identity<test_class> idn;
+typedef identity<const test_class> cidn;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,int,int_member) key_m;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_member) ckey_m;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_cmember) key_cm;
+typedef BOOST_MULTI_INDEX_CONST_MEM_FUN(
+ test_class,bool,bool_mem_fun_const) key_cmf;
+typedef BOOST_MULTI_INDEX_MEM_FUN(test_class,bool,bool_mem_fun) key_mf;
+typedef composite_key<
+ test_class,
+ idn,
+ key_m,
+ key_cm,
+ key_cmf
+ > compkey;
+typedef composite_key<
+ test_class,
+ cidn,
+ ckey_m
+ > ccompkey;
+typedef composite_key<
+ boost::reference_wrapper<test_class>,
+ key_mf
+ > ccompw_key;
+
+#if !defined(BOOST_NO_SFINAE)
+/* testcases for problems with non-copyable classes reported at
+ * http://lists.boost.org/Archives/boost/2006/04/103065.php
+ */
+
+struct test_nc_class
+{
+ int int_member;
+ const int int_cmember;
+
+ bool bool_mem_fun_const()const{return true;}
+ bool bool_mem_fun(){return false;}
+
+ test_nc_class(int i=0):int_member(i),int_cmember(i){}
+ test_nc_class(int i,int j):int_member(i),int_cmember(j){}
+
+ bool operator==(const test_nc_class& x)const
+ {
+ return int_member==x.int_member&&int_cmember==x.int_cmember;
+ }
+
+private:
+ test_nc_class(const test_nc_class&);
+};
+
+struct test_nc_derived_class:test_nc_class
+{
+ test_nc_derived_class(int i=0):test_nc_class(i){}
+ test_nc_derived_class(int i,int j):test_nc_class(i,j){}
+};
+
+BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(test_nc_class)
+BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(test_nc_derived_class)
+
+typedef identity<test_nc_class> nc_idn;
+typedef identity<const test_nc_class> nc_cidn;
+typedef BOOST_MULTI_INDEX_MEMBER(test_nc_class,int,int_member) nc_key_m;
+typedef BOOST_MULTI_INDEX_MEMBER(
+ test_nc_class,const int,int_member) nc_ckey_m;
+typedef BOOST_MULTI_INDEX_CONST_MEM_FUN(
+ test_nc_class,bool,bool_mem_fun_const) nc_key_cmf;
+typedef BOOST_MULTI_INDEX_MEM_FUN(
+ test_nc_class,bool,bool_mem_fun) nc_key_mf;
+typedef composite_key<
+ test_nc_class,
+ nc_idn,
+ nc_key_m,
+ nc_ckey_m,
+ nc_key_cmf
+ > nc_compkey;
+#endif
+
+void test_key_extractors()
+{
+ idn id;
+ cidn cid;
+ key_m k_m;
+ ckey_m ck_m;
+ key_cm k_cm;
+ key_cmf k_cmf;
+ key_mf k_mf;
+ compkey cmpk;
+ ccompkey ccmpk;
+ ccompw_key ccmpk_w;
+
+ test_derived_class td(-1,0);
+ const test_derived_class& ctdr=td;
+
+ test_class& tr=td;
+ const test_class& ctr=tr;
+
+ test_derived_class* tdp=&td;
+ const test_derived_class* ctdp=&ctdr;
+
+ test_class* tp=&tr;
+ const test_class* ctp=&tr;
+
+ test_class** tpp=&tp;
+ const test_class** ctpp=&ctp;
+
+ std::auto_ptr<test_class*> tap(new test_class*(tp));
+ std::auto_ptr<const test_class*> ctap(new const test_class*(ctp));
+
+ boost::reference_wrapper<test_class> tw(tr);
+ boost::reference_wrapper<const test_class> ctw(tr);
+
+ id(tr).int_member=0;
+ BOOST_CHECK(id(tr).int_member==0);
+ BOOST_CHECK(cid(tr).int_member==0);
+ BOOST_CHECK(k_m(tr)==0);
+ BOOST_CHECK(ck_m(tr)==0);
+ BOOST_CHECK(cmpk(tr)==make_tuple(test_class(0,0),0,0,true));
+ BOOST_CHECK(ccmpk(tr)==make_tuple(test_class(0,0),0));
+ BOOST_CHECK(id(ctr).int_member==0);
+ BOOST_CHECK(cid(ctr).int_member==0);
+ BOOST_CHECK(k_m(ctr)==0);
+ BOOST_CHECK(ck_m(ctr)==0);
+ BOOST_CHECK(cmpk(ctr)==make_tuple(test_class(0,0),0,0,true));
+ BOOST_CHECK(ccmpk(ctr)==make_tuple(test_class(0,0),0));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(id(td).int_member==0);
+ BOOST_CHECK(cid(td).int_member==0);
+ BOOST_CHECK(k_m(td)==0);
+ BOOST_CHECK(ck_m(td)==0);
+ BOOST_CHECK(cmpk(td)==make_tuple(test_class(0,0),0,0,true));
+ BOOST_CHECK(ccmpk(td)==make_tuple(test_class(0,0),0));
+ BOOST_CHECK(id(ctdr).int_member==0);
+ BOOST_CHECK(cid(ctdr).int_member==0);
+ BOOST_CHECK(k_m(ctdr)==0);
+ BOOST_CHECK(ck_m(ctdr)==0);
+ BOOST_CHECK(cmpk(ctdr)==make_tuple(test_class(0,0),0,0,true));
+ BOOST_CHECK(ccmpk(ctdr)==make_tuple(test_class(0,0),0));
+#endif
+
+ k_m(tr)=1;
+ BOOST_CHECK(id(tp).int_member==1);
+ BOOST_CHECK(cid(tp).int_member==1);
+ BOOST_CHECK(k_m(tp)==1);
+ BOOST_CHECK(ck_m(tp)==1);
+ BOOST_CHECK(cmpk(tp)==make_tuple(test_class(1,0),1,0,true));
+ BOOST_CHECK(ccmpk(tp)==make_tuple(test_class(1,0),1));
+ BOOST_CHECK(cid(ctp).int_member==1);
+ BOOST_CHECK(ck_m(ctp)==1);
+ BOOST_CHECK(cmpk(ctp)==make_tuple(test_class(1,0),1,0,true));
+ BOOST_CHECK(ccmpk(ctp)==make_tuple(test_class(1,0),1));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(id(tdp).int_member==1);
+ BOOST_CHECK(cid(tdp).int_member==1);
+ BOOST_CHECK(k_m(tdp)==1);
+ BOOST_CHECK(ck_m(tdp)==1);
+ BOOST_CHECK(cmpk(tdp)==make_tuple(test_class(1,0),1,0,true));
+ BOOST_CHECK(ccmpk(tdp)==make_tuple(test_class(1,0),1));
+ BOOST_CHECK(cid(ctdp).int_member==1);
+ BOOST_CHECK(ck_m(ctdp)==1);
+ BOOST_CHECK(cmpk(ctdp)==make_tuple(test_class(1,0),1,0,true));
+ BOOST_CHECK(ccmpk(ctdp)==make_tuple(test_class(1,0),1));
+#endif
+
+ k_m(tp)=2;
+ BOOST_CHECK(id(tpp).int_member==2);
+ BOOST_CHECK(cid(tpp).int_member==2);
+ BOOST_CHECK(k_m(tpp)==2);
+ BOOST_CHECK(ck_m(tpp)==2);
+ BOOST_CHECK(cmpk(tpp)==make_tuple(test_class(2,0),2,0,true));
+ BOOST_CHECK(ccmpk(tpp)==make_tuple(test_class(2,0),2));
+ BOOST_CHECK(cid(ctpp).int_member==2);
+ BOOST_CHECK(ck_m(ctpp)==2);
+ BOOST_CHECK(cmpk(ctpp)==make_tuple(test_class(2,0),2,0,true));
+ BOOST_CHECK(ccmpk(ctpp)==make_tuple(test_class(2,0),2));
+
+ k_m(tpp)=3;
+ BOOST_CHECK(id(tap).int_member==3);
+ BOOST_CHECK(cid(tap).int_member==3);
+ BOOST_CHECK(k_m(tap)==3);
+ BOOST_CHECK(ck_m(tap)==3);
+ BOOST_CHECK(cmpk(tap)==make_tuple(test_class(3,0),3,0,true));
+ BOOST_CHECK(ccmpk(tap)==make_tuple(test_class(3,0),3));
+ BOOST_CHECK(cid(ctap).int_member==3);
+ BOOST_CHECK(ck_m(ctap)==3);
+ BOOST_CHECK(cmpk(ctap)==make_tuple(test_class(3,0),3,0,true));
+ BOOST_CHECK(ccmpk(ctap)==make_tuple(test_class(3,0),3));
+
+ k_m(tap)=4;
+ BOOST_CHECK(id(tw).int_member==4);
+ BOOST_CHECK(cid(tw).int_member==4);
+ BOOST_CHECK(k_m(tw)==4);
+ BOOST_CHECK(ck_m(tw)==4);
+ BOOST_CHECK(cmpk(tw)==make_tuple(test_class(4,0),4,0,true));
+ BOOST_CHECK(ccmpk(tw)==make_tuple(test_class(4,0),4));
+
+ k_m(tw)=5;
+ BOOST_CHECK(id(ctw).int_member==5);
+ BOOST_CHECK(cid(ctw).int_member==5);
+ BOOST_CHECK(k_m(ctw)==5);
+ BOOST_CHECK(ck_m(ctw)==5);
+ BOOST_CHECK(cmpk(ctw)==make_tuple(test_class(5,0),5,0,true));
+ BOOST_CHECK(ccmpk(ctw)==make_tuple(test_class(5,0),5));
+
+ BOOST_CHECK(k_cm(tr)==0);
+ BOOST_CHECK(k_cm(ctr)==0);
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(k_cm(td)==0);
+ BOOST_CHECK(k_cm(ctdr)==0);
+#endif
+
+ BOOST_CHECK(k_cm(tp)==0);
+ BOOST_CHECK(k_cm(ctp)==0);
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(k_cm(tdp)==0);
+ BOOST_CHECK(k_cm(ctdp)==0);
+#endif
+
+ BOOST_CHECK(k_cm(tpp)==0);
+ BOOST_CHECK(k_cm(ctpp)==0);
+ BOOST_CHECK(k_cm(tap)==0);
+ BOOST_CHECK(k_cm(ctap)==0);
+
+ BOOST_CHECK(k_cm(tw)==0);
+ BOOST_CHECK(k_cm(ctw)==0);
+
+ BOOST_CHECK(k_cmf(tr));
+ BOOST_CHECK(k_cmf(ctr));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(k_cmf(td));
+ BOOST_CHECK(k_cmf(ctdr));
+#endif
+
+ BOOST_CHECK(k_cmf(tp));
+ BOOST_CHECK(k_cmf(ctp));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(k_cmf(tdp));
+ BOOST_CHECK(k_cmf(ctdp));
+#endif
+
+ BOOST_CHECK(k_cmf(tpp));
+ BOOST_CHECK(k_cmf(ctpp));
+ BOOST_CHECK(k_cmf(tap));
+ BOOST_CHECK(k_cmf(ctap));
+
+ BOOST_CHECK(k_cmf(tw));
+ BOOST_CHECK(k_cmf(ctw));
+
+ BOOST_CHECK(!k_mf(tr));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(!k_mf(td));
+#endif
+
+ BOOST_CHECK(!k_mf(tp));
+
+#if !defined(BOOST_NO_SFINAE)
+ BOOST_CHECK(!k_mf(tdp));
+#endif
+
+ BOOST_CHECK(!k_mf(tpp));
+ BOOST_CHECK(!k_mf(tap));
+ BOOST_CHECK(!k_mf(tw));
+ BOOST_CHECK(ccmpk_w(tw)==make_tuple(false));
+
+#if !defined(BOOST_NO_SFINAE)
+/* testcases for problems with non-copyable classes reported at
+ * http://lists.boost.org/Archives/boost/2006/04/103065.php
+ */
+
+ nc_idn nc_id;
+ nc_cidn nc_cid;
+ nc_key_m nc_k_m;
+ nc_ckey_m nc_ck_m;
+ nc_key_cmf nc_k_cmf;
+ nc_key_mf nc_k_mf;
+ nc_compkey nc_cmpk;
+
+ test_nc_derived_class nc_td(-1,0);
+
+ nc_id(nc_td).int_member=0;
+ BOOST_CHECK(nc_id(nc_td).int_member==0);
+ BOOST_CHECK(nc_cid(nc_td).int_member==0);
+
+ nc_k_m(&nc_td)=1;
+ BOOST_CHECK(nc_k_m(&nc_td)==1);
+ BOOST_CHECK(nc_ck_m(&nc_td)==1);
+
+ BOOST_CHECK(nc_k_cmf(nc_td));
+ BOOST_CHECK(!nc_k_mf(nc_td));
+
+ test_nc_class nc_t(1,0);
+ BOOST_CHECK(nc_cmpk(nc_td)==make_tuple(boost::cref(nc_t),1,1,true));
+#endif
+
+ std::list<test_class> tl;
+ for(int i=0;i<20;++i)tl.push_back(test_class(i));
+
+ int j=0;
+ for(std::list<test_class>::iterator it=tl.begin();it!=tl.end();++it){
+ BOOST_CHECK(k_m(it)==j);
+ BOOST_CHECK(k_cm(it)==j);
+ BOOST_CHECK(k_cmf(it));
+ BOOST_CHECK(!k_mf(it));
+ BOOST_CHECK(cmpk(it)==make_tuple(test_class(j),j,j,true));
+ BOOST_CHECK(ccmpk(it)==make_tuple(test_class(j),j));
+ ++j;
+ }
+}