Clean up insert tests to use more idiomatic UNORDERED_TEST macros

This commit is contained in:
Christian Mazakas
2023-01-13 12:46:00 -08:00
parent 5bfc77c3e4
commit 64721fa1ef
2 changed files with 172 additions and 177 deletions

View File

@@ -89,7 +89,7 @@ namespace insert_hint {
} }
#endif #endif
template <class X> static void insert_hint_unique_impl() template <class X> static void insert_hint_unique(X*)
{ {
typedef X container; typedef X container;
@@ -100,16 +100,7 @@ namespace insert_hint {
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
UNORDERED_AUTO_TEST (insert_hint_unique) { template <class X> static void insert_hint_unique_single(X*)
#ifdef BOOST_UNORDERED_FOA_TESTS
insert_hint_unique_impl<boost::unordered_flat_set<int> >();
insert_hint_unique_impl<boost::unordered_node_set<int> >();
#else
insert_hint_unique_impl<boost::unordered_set<int> >();
#endif
}
template <class X> static void insert_hint_unique_single_impl()
{ {
typedef X container; typedef X container;
@@ -128,14 +119,17 @@ namespace insert_hint {
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
UNORDERED_AUTO_TEST (insert_hint_unique_single) {
#ifdef BOOST_UNORDERED_FOA_TESTS #ifdef BOOST_UNORDERED_FOA_TESTS
insert_hint_unique_single_impl<boost::unordered_flat_set<int> >(); static boost::unordered_flat_set<int>* test_set;
insert_hint_unique_single_impl<boost::unordered_node_set<int> >(); static boost::unordered_node_set<int>* test_node_set;
UNORDERED_TEST(insert_hint_unique, ((test_set)(test_node_set)))
UNORDERED_TEST(insert_hint_unique_single, ((test_set)(test_node_set)))
#else #else
insert_hint_unique_single_impl<boost::unordered_set<int> >(); static boost::unordered_set<int>* test_set;
UNORDERED_TEST(insert_hint_unique, ((test_set)))
UNORDERED_TEST(insert_hint_unique_single, ((test_set)))
#endif #endif
}
} // namespace insert_hint } // namespace insert_hint
RUN_TESTS() RUN_TESTS()

View File

@@ -725,13 +725,10 @@ namespace insert_tests {
} }
}; };
template <template <class Key, class Hash, class Pred, class Allocator> template <class X>
class Set> static void set_tests2(X*)
static void set_tests2_impl()
{ {
Set<pointer_constructible, pointer_constructible_hash, X set, set2;
pointer_constructible_equal_to, test::allocator1<pointer_constructible> >
set, set2;
pointer_constructible pc(1337); pointer_constructible pc(1337);
pointer_constructible* const addr_pc = &pc; pointer_constructible* const addr_pc = &pc;
@@ -968,6 +965,13 @@ namespace insert_tests {
boost::unordered_node_map<test::movable, test::movable, test::hash, boost::unordered_node_map<test::movable, test::movable, test::hash,
test::equal_to, test::allocator2<test::movable> >* test_node_map; test::equal_to, test::allocator2<test::movable> >* test_node_map;
boost::unordered_flat_set<pointer_constructible, pointer_constructible_hash,
pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
test_pc_set;
boost::unordered_node_set<pointer_constructible, pointer_constructible_hash,
pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
test_pc_node_set;
UNORDERED_TEST(unique_insert_tests1, UNORDERED_TEST(unique_insert_tests1,
((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))( ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
(default_generator)(generate_collisions)(limited_range))) (default_generator)(generate_collisions)(limited_range)))
@@ -1004,10 +1008,7 @@ namespace insert_tests {
UNORDERED_TEST( UNORDERED_TEST(
set_tests, ((test_set_std_alloc)(test_set)(test_node_set))((default_generator))) set_tests, ((test_set_std_alloc)(test_set)(test_node_set))((default_generator)))
UNORDERED_AUTO_TEST(set_tests2) { UNORDERED_TEST(set_tests2, ((test_pc_set)(test_pc_node_set)))
set_tests2_impl<boost::unordered_flat_set>();
set_tests2_impl<boost::unordered_node_set>();
}
#else #else
boost::unordered_set<test::movable, test::hash, test::equal_to, boost::unordered_set<test::movable, test::hash, test::equal_to,
std::allocator<test::movable> >* test_set_std_alloc; std::allocator<test::movable> >* test_set_std_alloc;
@@ -1023,6 +1024,10 @@ namespace insert_tests {
boost::unordered_multimap<test::object, test::object, test::hash, boost::unordered_multimap<test::object, test::object, test::hash,
test::equal_to, test::allocator1<test::object> >* test_multimap; test::equal_to, test::allocator1<test::object> >* test_multimap;
boost::unordered_set<pointer_constructible, pointer_constructible_hash,
pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
test_pc_set;
UNORDERED_TEST(unique_insert_tests1, UNORDERED_TEST(unique_insert_tests1,
((test_set_std_alloc)(test_set)(test_map))( ((test_set_std_alloc)(test_set)(test_map))(
(default_generator)(generate_collisions)(limited_range))) (default_generator)(generate_collisions)(limited_range)))
@@ -1068,9 +1073,7 @@ namespace insert_tests {
UNORDERED_TEST( UNORDERED_TEST(
set_tests, ((test_set_std_alloc)(test_set)(test_multiset))((default_generator))) set_tests, ((test_set_std_alloc)(test_set)(test_multiset))((default_generator)))
UNORDERED_AUTO_TEST(set_tests2) { UNORDERED_TEST(set_tests2, ((test_pc_set)))
set_tests2_impl<boost::unordered_set>();
}
#endif #endif
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1161,26 +1164,30 @@ namespace insert_tests {
#endif #endif
#endif #endif
template <class Map> static void insert_initializer_list_map_impl() template <class X> static void insert_initializer_list_map(X*)
{ {
Map map; X map;
BOOST_TEST(map.empty()); BOOST_TEST(map.empty());
map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}}); map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
BOOST_TEST_EQ(map.size(), 2u); BOOST_TEST_EQ(map.size(), 2u);
} }
UNORDERED_AUTO_TEST (insert_initializer_list_map) {
#ifdef BOOST_UNORDERED_FOA_TESTS #ifdef BOOST_UNORDERED_FOA_TESTS
insert_initializer_list_map_impl< static boost::unordered_flat_map<std::string, std::string>* test_str_map;
boost::unordered_flat_map<std::string, std::string> >(); static boost::unordered_node_map<std::string, std::string>* test_str_node_map;
insert_initializer_list_map_impl<
boost::unordered_node_map<std::string, std::string> >(); // clang-format off
UNORDERED_TEST(insert_initializer_list_map,
((test_str_map)(test_str_node_map)))
// clang-format on
#else #else
insert_initializer_list_map_impl< static boost::unordered_map<std::string, std::string>* test_str_map;
boost::unordered_map<std::string, std::string> >();
// clang-format off
UNORDERED_TEST(insert_initializer_list_map, ((test_str_map)))
// clang-format on
#endif #endif
}
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
UNORDERED_AUTO_TEST (insert_initializer_list_multimap) { UNORDERED_AUTO_TEST (insert_initializer_list_multimap) {
@@ -1220,9 +1227,9 @@ namespace insert_tests {
} }
}; };
template <class Map> static void map_emplace_test_impl() template <class X> static void map_emplace_test(X*)
{ {
Map x; X x;
#if !BOOST_UNORDERED_SUN_WORKAROUNDS1 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
x.emplace(); x.emplace();
BOOST_TEST( BOOST_TEST(
@@ -1238,52 +1245,50 @@ namespace insert_tests {
x.find(5) != x.end() && x.find(5)->second == overloaded_constructor()); x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
} }
UNORDERED_AUTO_TEST (map_emplace_test) {
{
#ifdef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >
flat_map;
typedef boost::unordered_node_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >
node_map;
map_emplace_test_impl<flat_map>();
map_emplace_test_impl<node_map>();
#else
typedef boost::unordered_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >
map;
map_emplace_test_impl<map>();
#endif
}
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
{ template <class X> static void multimap_emplace_test(X*)
boost::unordered_multimap<int, overloaded_constructor, test::hash, {
test::equal_to, X x;
test::allocator1<std::pair<int const, overloaded_constructor> > >
x;
#if !BOOST_UNORDERED_SUN_WORKAROUNDS1 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
x.emplace(); x.emplace();
BOOST_TEST( BOOST_TEST(
x.find(0) != x.end() && x.find(0)->second == overloaded_constructor()); x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
#endif #endif
x.emplace(2, 3); x.emplace(2, 3);
BOOST_TEST( BOOST_TEST(
x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3)); x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
}
#endif
} }
#endif
template <class X> static void set_emplace_test_impl() #ifdef BOOST_UNORDERED_FOA_TESTS
static boost::unordered_flat_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >*
test_oc_map;
static boost::unordered_node_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >*
test_oc_node_map;
UNORDERED_TEST(map_emplace_test, ((test_oc_map)(test_oc_node_map)))
#else
static boost::unordered_map<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >*
test_oc_map;
static boost::unordered_multimap<int, overloaded_constructor, test::hash,
test::equal_to,
test::allocator1<std::pair<int const, overloaded_constructor> > >*
test_oc_multimap;
UNORDERED_TEST(map_emplace_test, ((test_oc_map)))
UNORDERED_TEST(multimap_emplace_test, ((test_oc_multimap)))
#endif
template <class X> static void set_emplace_test(X*)
{ {
X x; X x;
overloaded_constructor check; overloaded_constructor check;
@@ -1314,15 +1319,17 @@ namespace insert_tests {
BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check); BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
} }
UNORDERED_AUTO_TEST (set_emplace_test) {
#ifdef BOOST_UNORDERED_FOA_TESTS #ifdef BOOST_UNORDERED_FOA_TESTS
set_emplace_test_impl<boost::unordered_flat_set<overloaded_constructor> >(); static boost::unordered_flat_set<overloaded_constructor>* test_oc_set;
set_emplace_test_impl<boost::unordered_node_set<overloaded_constructor> >(); static boost::unordered_node_set<overloaded_constructor>* test_oc_node_set;
UNORDERED_TEST(set_emplace_test, ((test_oc_set)(test_oc_node_set)))
#else #else
set_emplace_test_impl<boost::unordered_set<overloaded_constructor> >(); static boost::unordered_set<overloaded_constructor>* test_oc_set;
static boost::unordered_multiset<overloaded_constructor>* test_oc_multiset;
UNORDERED_TEST(set_emplace_test, ((test_oc_set)(test_oc_multiset)))
#endif #endif
}
struct derived_from_piecewise_construct_t struct derived_from_piecewise_construct_t
: boost::unordered::piecewise_construct_t : boost::unordered::piecewise_construct_t
@@ -1473,6 +1480,14 @@ namespace insert_tests {
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
static boost::unordered_map<overloaded_constructor, overloaded_constructor,
boost::hash<overloaded_constructor>, std::equal_to<overloaded_constructor>,
test::allocator1<std::pair<overloaded_constructor const,
overloaded_constructor> > >* test_pw_oc_map;
static boost::unordered_set<std::pair<overloaded_constructor,
overloaded_constructor> >* test_pair_oc_set;
#define PIECEWISE_TEST_NAME boost_tuple_piecewise_tests #define PIECEWISE_TEST_NAME boost_tuple_piecewise_tests
#define PIECEWISE_NAMESPACE boost::unordered #define PIECEWISE_NAMESPACE boost::unordered
#define TUPLE_NAMESPACE boost #define TUPLE_NAMESPACE boost
@@ -1504,6 +1519,14 @@ namespace insert_tests {
#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && \ #if !defined(BOOST_NO_CXX11_HDR_TUPLE) && \
BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
#ifdef BOOST_UNORDERED_FOA_TESTS
static boost::unordered_flat_set<std::pair<overloaded_constructor,
overloaded_constructor> >* test_pair_oc_set;
static boost::unordered_node_set<std::pair<overloaded_constructor,
overloaded_constructor> >* test_pair_oc_node_set;
#endif
#define PIECEWISE_TEST_NAME std_piecewise_tests #define PIECEWISE_TEST_NAME std_piecewise_tests
#define PIECEWISE_NAMESPACE std #define PIECEWISE_NAMESPACE std
#define TUPLE_NAMESPACE std #define TUPLE_NAMESPACE std
@@ -1517,17 +1540,17 @@ RUN_TESTS_QUIET()
#else // PIECEWISE_TEST_NAME #else // PIECEWISE_TEST_NAME
#define PIECEWISE_TEST_HELPER(A, B, C) A##B##C #define MAP_PIECEWISE_TEST BOOST_PP_CAT(map_, PIECEWISE_TEST_NAME)
#define MAKE_PIECEWISE_TEST(PREFIX, X) PIECEWISE_TEST_HELPER(PREFIX, X, _impl) #define SET_PIECEWISE_TEST BOOST_PP_CAT(set_, PIECEWISE_TEST_NAME)
template <class Map> template <class X>
static void MAKE_PIECEWISE_TEST(map_, PIECEWISE_TEST_NAME)() static void MAP_PIECEWISE_TEST(X*)
{ {
#if EMULATING_PIECEWISE_CONSTRUCTION #if EMULATING_PIECEWISE_CONSTRUCTION
test::detail::disable_construction_tracking _scoped; test::detail::disable_construction_tracking _scoped;
#endif #endif
Map x; X x;
x.emplace(PIECEWISE_NAMESPACE::piecewise_construct, x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple()); TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
@@ -1572,14 +1595,14 @@ RUN_TESTS_QUIET()
overloaded_constructor(4, 5, 6)); overloaded_constructor(4, 5, 6));
} }
template <class Set> template <class X>
static void MAKE_PIECEWISE_TEST(set_, PIECEWISE_TEST_NAME)() static void SET_PIECEWISE_TEST(X*)
{ {
#if EMULATING_PIECEWISE_CONSTRUCTION #if EMULATING_PIECEWISE_CONSTRUCTION
test::detail::disable_construction_tracking _scoped; test::detail::disable_construction_tracking _scoped;
#endif #endif
Set x; X x;
std::pair<overloaded_constructor, overloaded_constructor> check; std::pair<overloaded_constructor, overloaded_constructor> check;
x.emplace(PIECEWISE_NAMESPACE::piecewise_construct, x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
@@ -1594,101 +1617,79 @@ RUN_TESTS_QUIET()
BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check); BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
} }
UNORDERED_AUTO_TEST (PIECEWISE_TEST_NAME) {
#if EMULATING_PIECEWISE_CONSTRUCTION
test::detail::disable_construction_tracking _scoped;
#endif
{
#if defined(BOOST_UNORDERED_FOA_TESTS) #if defined(BOOST_UNORDERED_FOA_TESTS)
typedef boost::unordered_flat_map<overloaded_constructor, overloaded_constructor, static boost::unordered_flat_map<overloaded_constructor,
boost::hash<overloaded_constructor>, overloaded_constructor, boost::hash<overloaded_constructor>,
std::equal_to<overloaded_constructor>, std::equal_to<overloaded_constructor>,
test::allocator1< test::allocator1<std::pair<overloaded_constructor const,
std::pair<overloaded_constructor const, overloaded_constructor> > > overloaded_constructor> > >* test_pw_oc_map;
flat_map;
typedef boost::unordered_node_map<overloaded_constructor, overloaded_constructor, static boost::unordered_node_map<overloaded_constructor,
boost::hash<overloaded_constructor>, overloaded_constructor, boost::hash<overloaded_constructor>,
std::equal_to<overloaded_constructor>, std::equal_to<overloaded_constructor>,
test::allocator1< test::allocator1<std::pair<overloaded_constructor const,
std::pair<overloaded_constructor const, overloaded_constructor> > > overloaded_constructor> > >* test_pw_oc_node_map;
node_map;
MAKE_PIECEWISE_TEST(map_, PIECEWISE_TEST_NAME)<flat_map>(); // clang-format off
MAKE_PIECEWISE_TEST(map_, PIECEWISE_TEST_NAME)<node_map>(); UNORDERED_TEST(MAP_PIECEWISE_TEST, ((test_pw_oc_map)(test_pw_oc_node_map)))
// clang-format on
#else #else
typedef boost::unordered_map<overloaded_constructor, overloaded_constructor, // clang-format off
boost::hash<overloaded_constructor>, UNORDERED_TEST(MAP_PIECEWISE_TEST, ((test_pw_oc_map)))
std::equal_to<overloaded_constructor>, // clang-format on
test::allocator1<
std::pair<overloaded_constructor const, overloaded_constructor> > >
map;
MAKE_PIECEWISE_TEST(map_, PIECEWISE_TEST_NAME)<map>();
#endif #endif
}
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
{ UNORDERED_AUTO_TEST (BOOST_PP_CAT(multimap_, PIECEWISE_TEST_NAME)) {
boost::unordered_multimap<overloaded_constructor, overloaded_constructor, {
boost::hash<overloaded_constructor>,
std::equal_to<overloaded_constructor>,
test::allocator1<
std::pair<overloaded_constructor const, overloaded_constructor> > >
x;
x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
BOOST_TEST(
x.find(overloaded_constructor()) != x.end() &&
x.find(overloaded_constructor())->second == overloaded_constructor());
x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
TUPLE_NAMESPACE::make_tuple());
BOOST_TEST(
x.find(overloaded_constructor(1)) != x.end() &&
x.find(overloaded_constructor(1))->second == overloaded_constructor());
x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
TUPLE_NAMESPACE::make_tuple(4, 5, 6));
BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
x.find(overloaded_constructor(2, 3))->second ==
overloaded_constructor(4, 5, 6));
derived_from_piecewise_construct_t d;
x.emplace(
d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
x.find(overloaded_constructor(9, 3, 1))->second ==
overloaded_constructor(10));
}
#endif
}
UNORDERED_AUTO_TEST (BOOST_PP_CAT(PIECEWISE_TEST_NAME, 2)) {
#if EMULATING_PIECEWISE_CONSTRUCTION #if EMULATING_PIECEWISE_CONSTRUCTION
test::detail::disable_construction_tracking _scoped; test::detail::disable_construction_tracking _scoped;
#endif
boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
boost::hash<overloaded_constructor>,
std::equal_to<overloaded_constructor>,
test::allocator1<
std::pair<overloaded_constructor const, overloaded_constructor> > >
x;
x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
BOOST_TEST(
x.find(overloaded_constructor()) != x.end() &&
x.find(overloaded_constructor())->second == overloaded_constructor());
x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
TUPLE_NAMESPACE::make_tuple());
BOOST_TEST(
x.find(overloaded_constructor(1)) != x.end() &&
x.find(overloaded_constructor(1))->second == overloaded_constructor());
x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
TUPLE_NAMESPACE::make_tuple(4, 5, 6));
BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
x.find(overloaded_constructor(2, 3))->second ==
overloaded_constructor(4, 5, 6));
derived_from_piecewise_construct_t d;
x.emplace(d, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
TUPLE_NAMESPACE::make_tuple(10));
BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
x.find(overloaded_constructor(9, 3, 1))->second ==
overloaded_constructor(10));
}
}
#endif #endif
#ifdef BOOST_UNORDERED_FOA_TESTS #ifdef BOOST_UNORDERED_FOA_TESTS
typedef boost::unordered_flat_set< // clang-format off
std::pair<overloaded_constructor, overloaded_constructor> > UNORDERED_TEST(SET_PIECEWISE_TEST,
flat_set; ((test_pair_oc_set)(test_pair_oc_node_set)))
// clang-format on
typedef boost::unordered_node_set<
std::pair<overloaded_constructor, overloaded_constructor> >
node_set;
MAKE_PIECEWISE_TEST(set_, PIECEWISE_TEST_NAME)<flat_set>();
MAKE_PIECEWISE_TEST(set_, PIECEWISE_TEST_NAME)<node_set>();
#else #else
typedef boost::unordered_set< // clang-format off
std::pair<overloaded_constructor, overloaded_constructor> > UNORDERED_TEST(SET_PIECEWISE_TEST, ((test_pair_oc_set)))
set_type; // clang-format on
MAKE_PIECEWISE_TEST(set_, PIECEWISE_TEST_NAME)<set_type>();
#endif #endif
}
#undef PIECEWISE_TEST_NAME #undef PIECEWISE_TEST_NAME
#undef PIECEWISE_NAMESPACE #undef PIECEWISE_NAMESPACE