void operator () () const {
{
#ifdef USE_BANDED
M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
#endif
#ifdef USE_DIAGONAL
M m1 (N, N), m2 (N, N), m3 (N, N);
#endif
test_with (m1, m2, m3);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
}
void operator () (int) const {
#ifdef USE_ADAPTOR
{
V v1 (N), v2 (N);
M m1 (N, N);
ublas::symmetric_adaptor<M> tam1 (m1);
test_with (v1, v2, tam1);
ublas::matrix_row<ublas::symmetric_adaptor<M> > mr1 (tam1, N - 1), mr2 (tam1, N - 1);
test_with (mr1, mr2, tam1);
ublas::matrix_column<ublas::symmetric_adaptor<M> > mc1 (tam1, 0), mc2 (tam1, 0);
test_with (mc1, mc2, tam1);
#ifdef USE_RANGE
ublas::matrix_vector_range<ublas::symmetric_adaptor<M> > mvr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
mvr2 (tam1, ublas::range (0, N), ublas::range (0, N));
test_with (mvr1, mvr2, tam1);
#endif
#ifdef USE_SLICE
ublas::matrix_vector_slice<ublas::symmetric_adaptor<M> > mvs1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
mvs2 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (mvs1, mvs2, tam1);
#endif
}
#endif
}
void operator () () const {
{
V v1 (N), v2 (N);
M m1 (N, N);
test_with (v1, v2, m1);
ublas::matrix_row<M> mr1 (m1, 0), mr2 (m1, 1);
test_with (mr1, mr2, m1);
ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, 1);
test_with (mc1, mc2, m1);
#ifdef USE_RANGE
ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
test_with (mvr1, mvr2, m1);
#endif
#ifdef USE_SLICE
ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (mvs1, mvs2, m1);
#endif
}
}
rd_kafka_conf_res_t rd_kafka_conf_set (rd_kafka_conf_t *conf,
const char *name,
const char *value,
char *errstr, size_t errstr_size)
{
if(test_with()->rd_kafka_conf_set_fails_for == NULL)
return test_with()->rd_kafka_conf_set_returns;
else
return strcmp(test_with()->rd_kafka_conf_set_fails_for,
name) == 0?0:RD_KAFKA_CONF_OK;
}
void IntrusiveStripedSetHdrTest::Striped_set_basehook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::set<base_item_type, bi::compare<IntrusiveStripedSetHdrTest::less<base_item_type> > >
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type ;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(256) ) ;
test_with( s ) ;
}
void operator () () const {
{
V v1 (N, N), v2 (N, N), v3 (N, N);
test_with (v1, v2, v3);
#ifdef USE_RANGE
ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
vr2 (v2, ublas::range (0, N)),
vr3 (v3, ublas::range (0, N));
test_with (vr1, vr2, vr3);
#endif
#ifdef USE_SLICE
ublas::vector_slice<V> vs1 (v1, ublas::slice (0, 1, N)),
vs2 (v2, ublas::slice (0, 1, N)),
vs3 (v3, ublas::slice (0, 1, N));
test_with (vs1, vs2, vs3);
#endif
}
}
int zoo_get_children(zhandle_t *zh, const char *path, int watch,
struct String_vector *strings)
{
strings->count = 2;
char* i = (char*) malloc(2 * sizeof(char*));
i[0] = '1';
i[1] = 0;
strings->data = (char**) malloc(sizeof(char**));
strings->data[0] = i;
strings->data[1] = i;
return test_with()->zoo_get_children_returns;
}
void operator () (int) const {
#ifdef USE_ADAPTOR
{
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::symmetric_adaptor<M> sam1 (m1), sam2 (m2), sam3 (m3);
test_with (sam1, sam2, sam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::symmetric_adaptor<M> > mr1 (sam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (sam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (sam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::symmetric_adaptor<M> > ms1 (sam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (sam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (sam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#endif
}
void IntrusiveStripedSetHdrTest::Striped_avl_set_basehook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::avl_set<base_item_type
, bi::compare<IntrusiveStripedSetHdrTest::less<base_item_type> >
CDS_BOOST_INTRUSIVE_KEY_OF_VALUE_OPTION( base_item_type )
>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(256) );
test_with( s );
}
void IntrusiveStripedSetHdrTest::Striped_avl_set_memberhook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::avl_set<
member_item_type
, bi::member_hook< member_item_type, bi::avl_set_member_hook<>, &member_item_type::hMember>
, bi::compare<IntrusiveStripedSetHdrTest::less<member_item_type> >
>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type ;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(256) ) ;
test_with( s ) ;
}
void IntrusiveStripedSetHdrTest::Striped_sg_set_memberhook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::sg_set<
member_item_type
, bi::member_hook< member_item_type, bi::bs_set_member_hook<>, &member_item_type::hMember>
, bi::compare<IntrusiveStripedSetHdrTest::less<member_item_type> >
CDS_BOOST_INTRUSIVE_KEY_OF_VALUE_OPTION( member_item_type )
>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(256) );
test_with( s );
}
void IntrusiveStripedSetHdrTest::Striped_unordered_set_basehook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::unordered_set<base_item_type
, bi::hash< hasher >
, bi::equal< is_equal<base_item_type> >
, bi::power_2_buckets<true>
, bi::incremental<true>
>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::buffer< dyn_buffer< 256, cds::any_type, std::allocator<int> > >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(512) );
test_with( s );
}
void IntrusiveStripedSetHdrTest::Striped_unordered_set_memberhook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::unordered_set<member_item_type
, bi::member_hook< member_item_type, bi::unordered_set_member_hook<>, &member_item_type::hMember>
, bi::hash< hasher >
, bi::equal< is_equal<member_item_type> >
, bi::power_2_buckets<true>
, bi::incremental<true>
>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::buffer< co::v::static_buffer< cds::any_type, 128 > >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type;
set_type s( 64, ci::striped_set::single_bucket_size_threshold<0>(256) );
test_with( s );
}
void IntrusiveStripedSetHdrTest::Striped_list_basehook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::list<base_item_type>
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::less< IntrusiveStripedSetHdrTest::less<base_item_type> >
,co::compare< IntrusiveStripedSetHdrTest::cmp<base_item_type> >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type;
static_assert( (std::is_same<
IntrusiveStripedSetHdrTest::cmp<base_item_type>
,set_type::bucket_type::key_comparator
>::value), "Key compare function selection error" );
set_type s( 128, ci::striped_set::single_bucket_size_threshold<0>(4) );
test_with( s );
}
void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix_stat()
{
typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > > item_type ;
typedef ci::CuckooSet< item_type
,ci::cuckoo::make_traits<
ci::opt::hook< ci::cuckoo::base_hook<
ci::cuckoo::probeset_type< item_type::probeset_type >
> >
,co::mutex_policy< ci::cuckoo::refinable<> >
,co::hash< std::tuple< hash1, hash2 > >
,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
,co::stat< ci::cuckoo::stat >
>::type
> set_type ;
unsigned int nProbesetSize = set_type::node_type::probeset_size ? set_type::node_type::probeset_size : 4 ;
set_type s( 256, nProbesetSize, nProbesetSize / 2 ) ;
test_with( s ) ;
CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() ) ;
}
void IntrusiveStripedSetHdrTest::Refinable_slist_memberhook_bucket_threshold_rt()
{
typedef ci::StripedSet<
bi::slist<
member_item_type
, bi::member_hook< member_item_type, bi::slist_member_hook<>, &member_item_type::hMember>
>
,co::mutex_policy< ci::striped_set::refinable<> >
,co::hash< IntrusiveStripedSetHdrTest::hash_int >
,co::less< IntrusiveStripedSetHdrTest::less<member_item_type> >
,co::compare< IntrusiveStripedSetHdrTest::cmp<member_item_type> >
,co::resizing_policy< ci::striped_set::single_bucket_size_threshold<0> >
> set_type ;
static_assert( (std::is_same<
IntrusiveStripedSetHdrTest::cmp<member_item_type>
,set_type::bucket_type::key_comparator
>::value), "Key compare function selection error" ) ;
set_type s( 128, ci::striped_set::single_bucket_size_threshold<0>(4) ) ;
test_with( s ) ;
}
void operator () (int) const {
#ifdef USE_ADAPTOR
{
#ifdef USE_BANDED
M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
ublas::banded_adaptor<M> bam1 (m1, 1, 1), bam2 (m2, 1, 1), bam3 (m3, 1, 1);
test_with (bam1, bam2, bam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::banded_adaptor<M> > mr1 (bam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (bam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (bam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::banded_adaptor<M> > ms1 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (bam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (bam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
#endif
#ifdef USE_DIAGONAL
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::diagonal_adaptor<M> dam1 (m1), dam2 (m2), dam3 (m3);
test_with (dam1, dam2, dam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::diagonal_adaptor<M> > mr1 (dam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (dam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (dam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::diagonal_adaptor<M> > ms1 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (dam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (dam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
#endif
}
#endif
}
void operator () () const {
{
M m1 (N, N), m2 (N, N), m3 (N, N);
test_with (m1, m2, m3);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#ifdef USE_ADAPTOR
{
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::triangular_adaptor<M> tam1 (m1), tam2 (m2), tam3 (m3);
test_with (tam1, tam2, tam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::triangular_adaptor<M> > mr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (tam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (tam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::triangular_adaptor<M> > ms1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (tam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (tam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#endif
}
int rd_kafka_brokers_add (rd_kafka_t *rk, const char *brokerlist)
{ return test_with()->rd_kafka_brokers_add_returns; }
void test()
{
Stack stack;
test_with(stack);
}
rd_kafka_t *rd_kafka_new (rd_kafka_type_t type, rd_kafka_conf_t *conf,
char *errstr, size_t errstr_size)
{
static rd_kafka_t rk;
return test_with()->rd_kafka_new_returns_NULL ? NULL:&rk;
}
rd_kafka_topic_t *rd_kafka_topic_new (rd_kafka_t *rk, const char *topic,
rd_kafka_topic_conf_t *conf)
{
static rd_kafka_topic_t t;
return test_with()->rd_kafka_topic_new_returns_NULL ? NULL:&t;
}
int rd_kafka_produce (rd_kafka_topic_t *rkt, int32_t partitition,
int msgflags,
void *payload, size_t len,
const void *key, size_t keylen,
void *msg_opaque)
{ return test_with()->rd_kafka_produce_returns; }
