int main() {
using namespace sprout::darkroom;
typedef pixels::color_pixels<darkcult::tile_width, darkcult::tile_height>::type image_type;
SPROUT_STATIC_CONSTEXPR auto image = pixels::generate<image_type>(
darkcult::raytracer, darkcult::renderer, darkcult::camera,
darkcult::object, darkcult::light,
darkcult::offset_x, darkcult::offset_y,
darkcult::total_width, darkcult::total_height
);
std::cout
<< "P3" << std::endl
<< image[0].size() << ' ' << image.size() << std::endl
<< 255 << std::endl
;
for (auto i = image.begin(), last = image.end(); i != last; ++i) {
auto const& line = *i;
for (auto j = line.begin(), last = line.end(); j != last; ++j) {
auto const& pixel = *j;
std::cout
<< unsigned(colors::r(pixel)) << ' '
<< unsigned(colors::g(pixel)) << ' '
<< unsigned(colors::b(pixel)) << std::endl
;
}
}
}
void random_engine_test_generic() {
using namespace sprout;
{
SPROUT_STATIC_CONSTEXPR auto eng1 = Engine(SPROUT_UNIQUE_SEED);
SPROUT_STATIC_CONSTEXPR auto eng2 = Engine(SPROUT_UNIQUE_SEED);
// min
// max
TESTSPR_BOTH_ASSERT(eng1.min() <= eng1.max());
// operator==
// operator!=
TESTSPR_BOTH_ASSERT(eng1 == eng1);
TESTSPR_BOTH_ASSERT(!(eng1 == eng2));
TESTSPR_BOTH_ASSERT(eng1 != eng2);
TESTSPR_BOTH_ASSERT(!(eng1 != eng1));
{
std::string s;
// operator<<
{
std::ostringstream os;
os << eng1;
TESTSPR_ASSERT(os);
s = os.str();
}
auto eng_temp = Engine();
// operator>>
{
std::istringstream is(s);
is >> eng_temp;
TESTSPR_ASSERT(is);
}
//TESTSPR_ASSERT(eng_temp == eng1);
}
// operator()
{
SPROUT_STATIC_CONSTEXPR auto rnd = eng1();
// result
TESTSPR_BOTH_ASSERT(eng1.min() <= rnd.result());
TESTSPR_BOTH_ASSERT(rnd.result() <= eng1.max());
// engine
TESTSPR_BOTH_ASSERT(rnd.engine().min() <= rnd.engine().max());
}
}
}
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 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 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>()));
}
}
