393 lines
8.7 KiB
C++
393 lines
8.7 KiB
C++
// switch_test.cpp -- The Boost Lambda Library --------------------------
|
|
//
|
|
// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
|
// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
|
|
//
|
|
// 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)
|
|
//
|
|
// For more information, see www.boost.org
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
|
|
#include <boost/test/minimal.hpp> // see "Header Implementation Option"
|
|
|
|
|
|
#include "boost/lambda/lambda.hpp"
|
|
#include "boost/lambda/if.hpp"
|
|
#include "boost/lambda/switch.hpp"
|
|
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
|
|
|
|
// Check that elements 0 -- index are 1, and the rest are 0
|
|
bool check(const std::vector<int>& v, int index) {
|
|
using namespace boost::lambda;
|
|
int counter = 0;
|
|
std::vector<int>::const_iterator
|
|
result = std::find_if(v.begin(), v.end(),
|
|
! if_then_else_return(
|
|
var(counter)++ <= index,
|
|
_1 == 1,
|
|
_1 == 0)
|
|
);
|
|
return result == v.end();
|
|
}
|
|
|
|
|
|
|
|
void do_switch_no_defaults_tests() {
|
|
|
|
using namespace boost::lambda;
|
|
|
|
int i = 0;
|
|
std::vector<int> v,w;
|
|
|
|
// elements from 0 to 9
|
|
std::generate_n(std::back_inserter(v),
|
|
10,
|
|
var(i)++);
|
|
std::fill_n(std::back_inserter(w), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 0));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 1));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 2));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 3));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 4));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 5));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
case_statement<6>(++var(w[6]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 6));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
case_statement<6>(++var(w[6])),
|
|
case_statement<7>(++var(w[7]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 7));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
case_statement<6>(++var(w[6])),
|
|
case_statement<7>(++var(w[7])),
|
|
case_statement<8>(++var(w[8]))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 8));
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
}
|
|
|
|
|
|
void do_switch_yes_defaults_tests() {
|
|
|
|
using namespace boost::lambda;
|
|
|
|
int i = 0;
|
|
std::vector<int> v,w;
|
|
|
|
// elements from 0 to 9
|
|
std::generate_n(std::back_inserter(v),
|
|
10,
|
|
var(i)++);
|
|
std::fill_n(std::back_inserter(w), 10, 0);
|
|
|
|
int default_count;
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, -1));
|
|
BOOST_CHECK(default_count == 10);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 0));
|
|
BOOST_CHECK(default_count == 9);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 1));
|
|
BOOST_CHECK(default_count == 8);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 2));
|
|
BOOST_CHECK(default_count == 7);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 3));
|
|
BOOST_CHECK(default_count == 6);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 4));
|
|
BOOST_CHECK(default_count == 5);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 5));
|
|
BOOST_CHECK(default_count == 4);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
case_statement<6>(++var(w[6])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 6));
|
|
BOOST_CHECK(default_count == 3);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
// ---
|
|
default_count = 0;
|
|
std::for_each(v.begin(), v.end(),
|
|
switch_statement(
|
|
_1,
|
|
case_statement<0>(++var(w[0])),
|
|
case_statement<1>(++var(w[1])),
|
|
case_statement<2>(++var(w[2])),
|
|
case_statement<3>(++var(w[3])),
|
|
case_statement<4>(++var(w[4])),
|
|
case_statement<5>(++var(w[5])),
|
|
case_statement<6>(++var(w[6])),
|
|
case_statement<7>(++var(w[7])),
|
|
default_statement(++var(default_count))
|
|
)
|
|
);
|
|
|
|
BOOST_CHECK(check(w, 7));
|
|
BOOST_CHECK(default_count == 2);
|
|
std::fill_n(w.begin(), 10, 0);
|
|
|
|
}
|
|
|
|
void test_empty_cases() {
|
|
|
|
using namespace boost::lambda;
|
|
|
|
// ---
|
|
switch_statement(
|
|
_1,
|
|
default_statement()
|
|
)(make_const(1));
|
|
|
|
switch_statement(
|
|
_1,
|
|
case_statement<1>()
|
|
)(make_const(1));
|
|
|
|
}
|
|
|
|
int test_main(int, char* []) {
|
|
|
|
do_switch_no_defaults_tests();
|
|
do_switch_yes_defaults_tests();
|
|
|
|
test_empty_cases();
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
|
|