static void array_test() { using namespace sprout; { SPROUT_STATIC_CONSTEXPR int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; SPROUT_STATIC_CONSTEXPR auto arr1 = sprout::to_array(carr); SPROUT_STATIC_CONSTEXPR auto arr2 = sprout::make_array<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); SPROUT_STATIC_CONSTEXPR auto arr3 = sprout::make_array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr1)); TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr2)); TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr3)); // begin TESTSPR_BOTH_ASSERT(carr[0] == *arr1.begin()); TESTSPR_BOTH_ASSERT(carr[0] == *arr2.begin()); // cbegin TESTSPR_BOTH_ASSERT(carr[0] == *arr1.cbegin()); TESTSPR_BOTH_ASSERT(carr[0] == *arr2.cbegin()); // end TESTSPR_BOTH_ASSERT(carr[9] == *(arr1.end() - 1)); TESTSPR_BOTH_ASSERT(carr[9] == *(arr2.end() - 1)); // cend TESTSPR_BOTH_ASSERT(carr[9] == *(arr1.cend() - 1)); TESTSPR_BOTH_ASSERT(carr[9] == *(arr2.cend() - 1)); // rbegin TESTSPR_BOTH_ASSERT(carr[9] == *arr1.rbegin()); TESTSPR_BOTH_ASSERT(carr[9] == *arr2.rbegin()); // crbegin TESTSPR_BOTH_ASSERT(carr[9] == *arr1.crbegin()); TESTSPR_BOTH_ASSERT(carr[9] == *arr2.crbegin()); // rend TESTSPR_BOTH_ASSERT(carr[0] == *(arr1.rend() - 1)); TESTSPR_BOTH_ASSERT(carr[0] == *(arr2.rend() - 1)); // crend TESTSPR_BOTH_ASSERT(carr[0] == *(arr1.crend() - 1)); TESTSPR_BOTH_ASSERT(carr[0] == *(arr2.crend() - 1)); // size TESTSPR_BOTH_ASSERT(arr1.size() == 10); TESTSPR_BOTH_ASSERT(arr2.size() == 10); // empty TESTSPR_BOTH_ASSERT(!arr1.empty()); TESTSPR_BOTH_ASSERT(!arr2.empty()); TESTSPR_BOTH_ASSERT((array<int, 0>{{}}.empty())); // max_size TESTSPR_BOTH_ASSERT(arr1.max_size() == 10); TESTSPR_BOTH_ASSERT(arr2.max_size() == 10); // operator[] TESTSPR_BOTH_ASSERT(carr[0] == arr1[0]); TESTSPR_BOTH_ASSERT(carr[0] == arr2[0]); // at TESTSPR_BOTH_ASSERT(carr[0] == arr1.at(0)); TESTSPR_BOTH_ASSERT(carr[0] == arr2.at(0)); // front TESTSPR_BOTH_ASSERT(carr[0] == arr1.front()); TESTSPR_BOTH_ASSERT(carr[0] == arr2.front()); // back TESTSPR_BOTH_ASSERT(carr[9] == arr1.back()); TESTSPR_BOTH_ASSERT(carr[9] == arr2.back()); // data TESTSPR_BOTH_ASSERT(carr[0] == *arr1.data()); TESTSPR_BOTH_ASSERT(carr[0] == *arr2.data()); { auto arr = arr1; TESTSPR_ASSERT(carr[0] == *arr.data()); } // c_array TESTSPR_BOTH_ASSERT(carr[0] == *arr1.c_array()); TESTSPR_BOTH_ASSERT(carr[0] == *arr2.c_array()); { auto arr = arr1; TESTSPR_ASSERT(carr[0] == *arr.c_array()); } // assign TESTSPR_BOTH_ASSERT(testspr::equal(arr1.assign(-1), sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}})); { auto arr = arr1; arr.assign(-1); TESTSPR_ASSERT(testspr::equal(arr, sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}})); } // fill TESTSPR_BOTH_ASSERT(testspr::equal(arr1.fill(-1), sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}})); { auto arr = arr1; arr.fill(-1); TESTSPR_ASSERT(testspr::equal(arr, sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}})); } // swap { auto arr1 = sprout::array<int, 2>{{1, 2}}; auto arr2 = sprout::array<int, 2>{{-1, -2}}; arr1.swap(arr2); TESTSPR_ASSERT(arr1[0] == -1); } // operator= { auto arr1 = sprout::array<int, 2>{{1, 2}}; arr1 = sprout::array<int, 2>{{-1, -2}}; TESTSPR_ASSERT(arr1[0] == -1); } // operator== TESTSPR_BOTH_ASSERT(arr1 == arr2); // operator!= TESTSPR_BOTH_ASSERT(!(arr1 != arr2)); // operator< TESTSPR_BOTH_ASSERT(!(arr1 < arr2)); // operator> TESTSPR_BOTH_ASSERT(!(arr1 > arr2)); // operator<= TESTSPR_BOTH_ASSERT(arr1 <= arr2); // operator>= TESTSPR_BOTH_ASSERT(arr1 >= arr2); // get TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(arr1) == 1); TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(arr1) == 2); { auto arr4 = arr1; TESTSPR_ASSERT(sprout::tuples::get<0>(arr4) == 1); TESTSPR_ASSERT(sprout::tuples::get<1>(arr4) == 2); } // tuple_size TESTSPR_BOTH_ASSERT(sprout::tuples::tuple_size<decltype(arr1)>::value == 10); // tuple_element TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<0, decltype(arr1)>::type, int const>::value)); TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<1, decltype(arr1)>::type, int const>::value)); // is_array TESTSPR_BOTH_ASSERT(sprout::is_array_class<decltype(arr1)>::value); TESTSPR_BOTH_ASSERT(!sprout::is_array_class<int>::value); // sprout::to_hash, sprout::hash TESTSPR_BOTH_ASSERT(sprout::to_hash(arr1) == sprout::hash<decltype(arr1)>()(arr1)); TESTSPR_BOTH_ASSERT(sprout::to_hash(arr1) != sprout::to_hash(sprout::array<int, 10>{{}})); } }
static void string_ref_test() { using namespace sprout; { SPROUT_STATIC_CONSTEXPR char cstr[] = "foobar1234"; SPROUT_STATIC_CONSTEXPR auto s = sprout::to_string("hogehoge"); SPROUT_STATIC_CONSTEXPR auto str1 = sprout::string_ref(cstr); SPROUT_STATIC_CONSTEXPR auto str2 = sprout::string_ref(s); // begin TESTSPR_BOTH_ASSERT(cstr[0] == *str1.begin()); // cbegin TESTSPR_BOTH_ASSERT(cstr[0] == *str1.cbegin()); // end TESTSPR_BOTH_ASSERT(cstr[9] == *(str1.end() - 1)); // cend TESTSPR_BOTH_ASSERT(cstr[9] == *(str1.cend() - 1)); // rbegin TESTSPR_BOTH_ASSERT(cstr[9] == *str1.rbegin()); // crbegin TESTSPR_BOTH_ASSERT(cstr[9] == *str1.crbegin()); // rend TESTSPR_BOTH_ASSERT(cstr[0] == *(str1.rend() - 1)); // crend TESTSPR_BOTH_ASSERT(cstr[0] == *(str1.crend() - 1)); // size TESTSPR_BOTH_ASSERT(str1.size() == 10); // empty TESTSPR_BOTH_ASSERT(!str1.empty()); TESTSPR_BOTH_ASSERT((sprout::string_ref().empty())); // max_size TESTSPR_BOTH_ASSERT(str1.max_size() == 10); // operator[] TESTSPR_BOTH_ASSERT(cstr[0] == str1[0]); // at TESTSPR_BOTH_ASSERT(cstr[0] == str1.at(0)); // front TESTSPR_BOTH_ASSERT(cstr[0] == str1.front()); // back TESTSPR_BOTH_ASSERT(cstr[9] == str1.back()); // data TESTSPR_BOTH_ASSERT(cstr[0] == *str1.data()); // c_str TESTSPR_BOTH_ASSERT(cstr[0] == *str1.c_str()); // swap { auto s1 = sprout::string_ref("abc"); auto s2 = sprout::string_ref("ABC"); s1.swap(s2); TESTSPR_ASSERT(s1[0] == 'A'); } // operator= { auto s = sprout::string_ref("abc"); s = sprout::string_ref("ABC"); TESTSPR_ASSERT(s.size() == 3); TESTSPR_ASSERT(s[0] == 'A'); } { auto s = sprout::to_string("abc"); s = "ABC"; TESTSPR_ASSERT(s.size() == 3); TESTSPR_ASSERT(s[0] == 'A'); } { auto s = sprout::to_string("abc"); s = 'A'; TESTSPR_ASSERT(s.size() == 1); TESTSPR_ASSERT(s[0] == 'A'); } // find TESTSPR_BOTH_ASSERT(str1.find(str2) == npos); TESTSPR_BOTH_ASSERT(str1.find(sprout::string_ref("bar")) == 3); TESTSPR_BOTH_ASSERT(str1.find(str2.c_str()) == npos); TESTSPR_BOTH_ASSERT(str1.find("bar") == 3); TESTSPR_BOTH_ASSERT(str1.find(str2.c_str(), 0, 3) == npos); TESTSPR_BOTH_ASSERT(str1.find("barbar", 0, 3) == 3); TESTSPR_BOTH_ASSERT(str1.find('b') == 3); // rfind TESTSPR_BOTH_ASSERT(str1.rfind(str2) == npos); TESTSPR_BOTH_ASSERT(str1.rfind(sprout::string_ref("bar")) == 3); TESTSPR_BOTH_ASSERT(str1.rfind(str2.c_str()) == npos); TESTSPR_BOTH_ASSERT(str1.rfind("bar") == 3); TESTSPR_BOTH_ASSERT(str1.rfind(str2.c_str(), npos, 3) == npos); TESTSPR_BOTH_ASSERT(str1.rfind("barbar", npos, 3) == 3); TESTSPR_BOTH_ASSERT(str1.rfind('b') == 3); // find_first_of TESTSPR_BOTH_ASSERT(str1.find_first_of(sprout::string_ref("vwxyz")) == npos); TESTSPR_BOTH_ASSERT(str1.find_first_of(sprout::string_ref("rab")) == 3); TESTSPR_BOTH_ASSERT(str1.find_first_of("vwxyz") == npos); TESTSPR_BOTH_ASSERT(str1.find_first_of("rab") == 3); TESTSPR_BOTH_ASSERT(str1.find_first_of("vwxyz", 0, 3) == npos); TESTSPR_BOTH_ASSERT(str1.find_first_of("rabrab", 0, 3) == 3); TESTSPR_BOTH_ASSERT(str1.find_first_of('b') == 3); // find_last_of TESTSPR_BOTH_ASSERT(str1.find_last_of(sprout::string_ref("vwxyz")) == npos); TESTSPR_BOTH_ASSERT(str1.find_last_of(sprout::string_ref("rab")) == 5); TESTSPR_BOTH_ASSERT(str1.find_last_of("vwxyz") == npos); TESTSPR_BOTH_ASSERT(str1.find_last_of("rab") == 5); TESTSPR_BOTH_ASSERT(str1.find_last_of("vwxyz", npos, 3) == npos); TESTSPR_BOTH_ASSERT(str1.find_last_of("rabrab", npos, 3) == 5); TESTSPR_BOTH_ASSERT(str1.find_last_of('r') == 5); // find_first_not_of TESTSPR_BOTH_ASSERT(str1.find_first_not_of(str1) == npos); TESTSPR_BOTH_ASSERT(str1.find_first_not_of(sprout::string_ref("foo")) == 3); TESTSPR_BOTH_ASSERT(str1.find_first_not_of(str1.c_str()) == npos); TESTSPR_BOTH_ASSERT(str1.find_first_not_of("foo") == 3); TESTSPR_BOTH_ASSERT(str1.find_first_not_of(str1.c_str(), 0, 10) == npos); TESTSPR_BOTH_ASSERT(str1.find_first_not_of("foofoo", 0, 3) == 3); TESTSPR_BOTH_ASSERT(str1.find_first_not_of('f') == 1); // find_last_not_of TESTSPR_BOTH_ASSERT(str1.find_last_not_of(str1) == npos); TESTSPR_BOTH_ASSERT(str1.find_last_not_of(sprout::string_ref("4321")) == 5); TESTSPR_BOTH_ASSERT(str1.find_last_not_of(str1.c_str()) == npos); TESTSPR_BOTH_ASSERT(str1.find_last_not_of("4321") == 5); TESTSPR_BOTH_ASSERT(str1.find_last_not_of(str1.c_str(), npos, 10) == npos); TESTSPR_BOTH_ASSERT(str1.find_last_not_of("43214321", npos, 4) == 5); TESTSPR_BOTH_ASSERT(str1.find_last_not_of('4') == 8); // substr { SPROUT_STATIC_CONSTEXPR auto str3 = str1.substr(); TESTSPR_BOTH_ASSERT(str3 == "foobar1234"); } { SPROUT_STATIC_CONSTEXPR auto str3 = str1.substr(6); TESTSPR_BOTH_ASSERT(str3 == "1234"); } { SPROUT_STATIC_CONSTEXPR auto str3 = str1.substr(0, 6); TESTSPR_BOTH_ASSERT(str3 == "foobar"); } // compare TESTSPR_BOTH_ASSERT(str1.compare(str1) == 0); TESTSPR_BOTH_ASSERT(str1.compare(sprout::string_ref("zzzz")) < 0); TESTSPR_BOTH_ASSERT(str2.compare(sprout::string_ref("aaaa")) > 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, sprout::string_ref("foo")) == 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, sprout::string_ref("zzzz")) < 0); TESTSPR_BOTH_ASSERT(str2.compare(0, 3, sprout::string_ref("aaaa")) > 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, sprout::string_ref("foo"), 0, 3) == 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, sprout::string_ref("zzzz"), 0, 3) < 0); TESTSPR_BOTH_ASSERT(str2.compare(0, 3, sprout::string_ref("aaaa"), 0, 3) > 0); TESTSPR_BOTH_ASSERT(str1.compare(str1.c_str()) == 0); TESTSPR_BOTH_ASSERT(str1.compare("zzzz") < 0); TESTSPR_BOTH_ASSERT(str1.compare("aaaa") > 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "foo") == 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "zzzz") < 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "aaaa") > 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "foo", 3) == 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "zzzz", 3) < 0); TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "aaaa", 3) > 0); // operator== TESTSPR_BOTH_ASSERT(!(str1 == str2)); // operator!= TESTSPR_BOTH_ASSERT(str1 != str2); // operator< TESTSPR_BOTH_ASSERT(str1 < str2); // operator> TESTSPR_BOTH_ASSERT(!(str1 > str2)); // operator<= TESTSPR_BOTH_ASSERT(str1 <= str2); // operator>= TESTSPR_BOTH_ASSERT(!(str1 >= str2)); // operator<< { std::ostringstream os; os << str1; TESTSPR_ASSERT(os.str() == cstr); } // is_string_ref TESTSPR_BOTH_ASSERT(sprout::is_string_ref<decltype(str1)>::value); TESTSPR_BOTH_ASSERT(!sprout::is_string_ref<int>::value); // sprout::to_hash, sprout::hash TESTSPR_BOTH_ASSERT(sprout::to_hash(str1) == sprout::hash<decltype(str1)>()(str1)); TESTSPR_BOTH_ASSERT(sprout::to_hash(str1) != sprout::to_hash(str2)); } }
static void variant_test() { using namespace sprout; { SPROUT_STATIC_CONSTEXPR auto var1 = sprout::variant<int, double>(1.0); SPROUT_STATIC_CONSTEXPR auto var2 = sprout::variant<int, double>(); // constructor { SPROUT_STATIC_CONSTEXPR auto var3 = sprout::variant<int, double>(); TESTSPR_BOTH_ASSERT(var3.which() == 0); TESTSPR_BOTH_ASSERT(sprout::get<int>(var3) == 0); } { SPROUT_STATIC_CONSTEXPR auto var3 = sprout::variant<int, double>(var1); TESTSPR_BOTH_ASSERT(var3.which() == 1); TESTSPR_BOTH_ASSERT(sprout::get<double>(var3) == 1.0); } { SPROUT_STATIC_CONSTEXPR auto var3 = sprout::variant<int, double>(1.0); TESTSPR_BOTH_ASSERT(var3.which() == 1); TESTSPR_BOTH_ASSERT(sprout::get<double>(var3) == 1.0); } // swap { auto var3 = var1; auto var4 = var2; var3.swap(var4); TESTSPR_ASSERT(var3.which() == 0); TESTSPR_ASSERT(sprout::get<int>(var3) == 0); TESTSPR_ASSERT(var4.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var4) == 1.0); } { auto var3 = var1; auto var4 = var2; swap(var3, var4); TESTSPR_ASSERT(var3.which() == 0); TESTSPR_ASSERT(sprout::get<int>(var3) == 0); TESTSPR_ASSERT(var4.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var4) == 1.0); } // operator= { auto var3 = var2; var3 = sprout::variant<int, double>(1.0); TESTSPR_ASSERT(var3.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var3) == 1.0); } { auto var3 = var2; var3 = 1.0; TESTSPR_ASSERT(var3.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var3) == 1.0); } // which TESTSPR_BOTH_ASSERT(var1.which() == 1); TESTSPR_BOTH_ASSERT(var2.which() == 0); // empty TESTSPR_BOTH_ASSERT(!var1.empty()); TESTSPR_BOTH_ASSERT(!var2.empty()); // operator== TESTSPR_BOTH_ASSERT(!(var1 == var2)); TESTSPR_BOTH_ASSERT((var1 == sprout::variant<int, double>(1.0))); // operator!= TESTSPR_BOTH_ASSERT(var1 != var2); TESTSPR_BOTH_ASSERT(!(var1 != sprout::variant<int, double>(1.0))); // operator< TESTSPR_BOTH_ASSERT(!(var1 < var2)); TESTSPR_BOTH_ASSERT(!(var1 < sprout::variant<int, double>(0.0))); TESTSPR_BOTH_ASSERT(!(var1 < sprout::variant<int, double>(1.0))); TESTSPR_BOTH_ASSERT((var1 < sprout::variant<int, double>(2.0))); TESTSPR_BOTH_ASSERT(!(var1 < sprout::variant<int, double>(0))); TESTSPR_BOTH_ASSERT(!(var1 < sprout::variant<int, double>(1))); TESTSPR_BOTH_ASSERT(!(var1 < sprout::variant<int, double>(2))); // operator> TESTSPR_BOTH_ASSERT(var1 > var2); TESTSPR_BOTH_ASSERT((var1 > sprout::variant<int, double>(0.0))); TESTSPR_BOTH_ASSERT(!(var1 > sprout::variant<int, double>(1.0))); TESTSPR_BOTH_ASSERT(!(var1 > sprout::variant<int, double>(2.0))); TESTSPR_BOTH_ASSERT((var1 > sprout::variant<int, double>(0))); TESTSPR_BOTH_ASSERT((var1 > sprout::variant<int, double>(1))); TESTSPR_BOTH_ASSERT((var1 > sprout::variant<int, double>(2))); // operator<= TESTSPR_BOTH_ASSERT(!(var1 <= var2)); TESTSPR_BOTH_ASSERT(!(var1 <= sprout::variant<int, double>(0.0))); TESTSPR_BOTH_ASSERT((var1 <= sprout::variant<int, double>(1.0))); TESTSPR_BOTH_ASSERT((var1 <= sprout::variant<int, double>(2.0))); TESTSPR_BOTH_ASSERT(!(var1 <= sprout::variant<int, double>(0))); TESTSPR_BOTH_ASSERT(!(var1 <= sprout::variant<int, double>(1))); TESTSPR_BOTH_ASSERT(!(var1 <= sprout::variant<int, double>(2))); // operator>= TESTSPR_BOTH_ASSERT(var1 >= var2); TESTSPR_BOTH_ASSERT((var1 >= sprout::variant<int, double>(0.0))); TESTSPR_BOTH_ASSERT((var1 >= sprout::variant<int, double>(1.0))); TESTSPR_BOTH_ASSERT(!(var1 >= sprout::variant<int, double>(2.0))); TESTSPR_BOTH_ASSERT((var1 >= sprout::variant<int, double>(0))); TESTSPR_BOTH_ASSERT((var1 >= sprout::variant<int, double>(1))); TESTSPR_BOTH_ASSERT((var1 >= sprout::variant<int, double>(2))); // get_at TESTSPR_BOTH_ASSERT(var1.get_at<1>() == 1.0); TESTSPR_BOTH_ASSERT(var2.get_at<0>() == 0); { auto var3 = var1; TESTSPR_ASSERT(var3.get_at<1>() == 1.0); } { auto var3 = var2; TESTSPR_ASSERT(var3.get_at<0>() == 0); } // get TESTSPR_BOTH_ASSERT(sprout::get<double>(var1) == 1.0); TESTSPR_BOTH_ASSERT(sprout::get<int>(var2) == 0); { auto var3 = var1; TESTSPR_ASSERT(sprout::get<double>(var3) == 1.0); } { auto var3 = var2; TESTSPR_ASSERT(sprout::get<int>(var3) == 0); } // apply_visitor TESTSPR_BOTH_ASSERT(var1.apply_visitor(testspr::x2_visitor<double>()) == 2.0); TESTSPR_BOTH_ASSERT(var2.apply_visitor(testspr::x2_visitor<double>()) == 0.0); { auto var3 = var1; TESTSPR_ASSERT(var3.apply_visitor(testspr::x2_assign_visitor<double>()) == 2.0); TESTSPR_ASSERT(var3.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var3) == 2.0); } { auto var3 = var2; TESTSPR_ASSERT(var3.apply_visitor(testspr::x2_assign_visitor<double>()) == 0.0); TESTSPR_ASSERT(var3.which() == 0); TESTSPR_ASSERT(sprout::get<int>(var3) == 0); } // apply_visitor TESTSPR_BOTH_ASSERT(sprout::apply_visitor(testspr::x2_visitor<double>(), var1) == 2.0); TESTSPR_BOTH_ASSERT(sprout::apply_visitor(testspr::x2_visitor<double>(), var2) == 0.0); { auto var3 = var1; TESTSPR_ASSERT(sprout::apply_visitor(testspr::x2_assign_visitor<double>(), var3) == 2.0); TESTSPR_ASSERT(var3.which() == 1); TESTSPR_ASSERT(sprout::get<double>(var3) == 2.0); } { auto var3 = var2; TESTSPR_ASSERT(sprout::apply_visitor(testspr::x2_assign_visitor<double>(), var3) == 0.0); TESTSPR_ASSERT(var3.which() == 0); TESTSPR_ASSERT(sprout::get<int>(var3) == 0); } { testspr::x2_visitor<double> visitor1 = {}; TESTSPR_BOTH_ASSERT(sprout::apply_visitor(visitor1, var1) == 2.0); TESTSPR_BOTH_ASSERT(sprout::apply_visitor(visitor1, var2) == 0.0); } { auto var3 = var2; testspr::x2_assign_visitor<double> visitor1 = {}; TESTSPR_ASSERT(sprout::apply_visitor(visitor1, var3) == 0.0); TESTSPR_ASSERT(var3.which() == 0); TESTSPR_ASSERT(sprout::get<int>(var3) == 0); } // operator<< { std::ostringstream os; os << var1; TESTSPR_ASSERT(os.str() == "1"); } { std::ostringstream os; os << var2; TESTSPR_ASSERT(os.str() == "0"); } // tuples::get TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(var1) == 1.0); TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(var2) == 0); { auto var3 = var1; TESTSPR_ASSERT(sprout::tuples::get<1>(var3) == 1.0); } { auto var3 = var2; TESTSPR_ASSERT(sprout::tuples::get<0>(var3) == 0); } // tuple_size TESTSPR_BOTH_ASSERT(sprout::tuples::tuple_size<decltype(var1)>::value == 2); // tuple_element TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<0, decltype(var1)>::type, int const>::value)); TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<1, decltype(var1)>::type, double const>::value)); // is_variant TESTSPR_BOTH_ASSERT(sprout::is_variant<decltype(var1)>::value); TESTSPR_BOTH_ASSERT(!sprout::is_variant<int>::value); // sprout::to_hash, sprout::hash TESTSPR_BOTH_ASSERT(sprout::to_hash(var1) == sprout::hash<decltype(var1)>()(var1)); TESTSPR_BOTH_ASSERT(sprout::to_hash(var1) != sprout::to_hash(sprout::variant<int, double>())); } }