void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance
(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
typedef value_cont_type orig_set_t;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
original_testset.assign(testset.begin(), testset.end());
}
{
assoc_type testset(values.begin(), values.end());
testset.rebalance();
TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin());
}
{
std::size_t numdata;
{
assoc_type testset(values.begin(), values.end());
numdata = testset.size();
}
for(int i = 0; i != (int)numdata; ++i){
assoc_type testset(values.begin(), values.end());
typename assoc_type::iterator it = testset.begin();
for(int j = 0; j != i; ++j) ++it;
testset.rebalance_subtree(it);
TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin());
}
}
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down
(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
typedef typename assoc_type::iterator iterator;
typedef value_cont_type orig_set_t;
std::size_t num_values;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
num_values = testset.size();
original_testset = value_cont_type(testset.begin(), testset.end());
}
for(std::size_t i = 0; i != num_values; ++i){
assoc_type testset (values.begin(), values.end());
BOOST_TEST(testset.size() == num_values);
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
BOOST_TEST(*it == *testset.splay_down(*it));
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_set_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_all()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<value_type> values (6);
for (int i = 0; i < 6; ++i)
values[i].value_ = random_init[i];
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
{
set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_insert_advanced(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_all ()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
value_cont_type values (6);
for (int i = 0; i < 6; ++i)
(&values[i])->value_ = random_init[i];
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type multiset_type;
{
multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
void Tester::runXQTS() {
XQTSTestSet testset(baseDir);
sednaInstance.startSedna();
sedna::Database *dbInstance = sednaInstance.getDatabase(dbName);
dbInstance->create();
dbInstance->start();
sedna::Session *session = dbInstance->createSession();
testset.initTestSet(session);
ISednaTestCase *testIt = testset.nextCase();
while (testIt != 0) {
testIt->execute(session);
testIt = testset.nextCase();
}
dbInstance->stop();
dbInstance->drop();
testset.generateReport();
sednaInstance.stopSedna();
}
void test_generic_assoc<ValueTraits, ContainerDefiner>
::test_container_from_end(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
assoc_type testset (values.begin(), values.begin() + values.size());
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend()));
}
void DocumentDecoder::runMaster(const std::string &infile) {
NistXmlTestset testset(infile);
boost::thread manager(manageTranslators, communicator_, testset);
translate();
manager.join();
testset.outputTranslation(std::cout);
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_insert_erase_burst()
{
//value_cont_type values;
const std::size_t MaxValues = 200;
value_cont_type values(MaxValues);
for(std::size_t i = 0; i != MaxValues; ++i){
(&values[i])->value_ = i;
}
typedef typename ContainerDefiner::template container
<>::type assoc_type;
typedef typename assoc_type::iterator iterator;
{ //Ordered insertion + erasure
assoc_type testset (values.begin(), values.begin() + values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
testset.check();
iterator it(testset.begin()), itend(testset.end());
for(std::size_t i = 0; it != itend; ++i){
BOOST_TEST(&*it == &values[i]);
it = testset.erase(it);
testset.check();
}
BOOST_TEST(testset.empty());
}
{ //Now random insertions + erasure
assoc_type testset;
typedef typename value_cont_type::iterator vec_iterator;
boost::container::vector<vec_iterator> it_vector;
//Random insertion
for(vec_iterator it(values.begin()), itend(values.end())
; it != itend
; ++it){
it_vector.push_back(it);
}
for(std::size_t i = 0; i != MaxValues; ++i){
testset.insert(*it_vector[i]);
testset.check();
}
TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
//Random erasure
std::random_shuffle(it_vector.begin(), it_vector.end());
for(std::size_t i = 0; i != MaxValues; ++i){
testset.erase(testset.iterator_to(*it_vector[i]));
testset.check();
}
BOOST_TEST(testset.empty());
}
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::
test_container_from_iterator(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
assoc_type testset(values.begin(), values.end());
typedef typename assoc_type::iterator it_type;
typedef typename assoc_type::const_iterator cit_type;
typedef typename assoc_type::size_type sz_type;
sz_type sz = testset.size();
for(it_type b(testset.begin()), e(testset.end()); b != e; ++b)
{
assoc_type &s = assoc_type::container_from_iterator(b);
const assoc_type &cs = assoc_type::container_from_iterator(cit_type(b));
BOOST_TEST(&s == &cs);
BOOST_TEST(&s == &testset);
s.erase(b);
BOOST_TEST(testset.size() == (sz-1));
s.insert(*b);
BOOST_TEST(testset.size() == sz);
}
}
static void testDynamicBitSet( int times, int maximum, int nofElements)
{
if (nofElements >= maximum) throw std::runtime_error("potential endless loop in test");
for (int ti=0; ti<times; ++ti)
{
strus::dynamic_bitset testset( maximum);
std::set<int> eset;
for (int ei=0; ei<nofElements; ++ei)
{
int elem = g_random.get( 0, maximum);
eset.insert( elem);
testset.set( elem, true);
}
std::set<int>::const_iterator si = eset.begin(), se = eset.end();
for (; si != se; ++si)
{
if (!testset.test( *si))
{
std::cerr << "element " << *si << " inserted not found in dynamic bitset" << std::endl;
if (++g_nof_errors >= g_max_nof_errors) throw std::runtime_error( "dynamic bitset test failed");
}
}
for (int ei=0; ei<nofElements; ++ei)
{
int elem = g_random.get( 0, maximum);
if (eset.find( elem) != eset.end())
{
--ei; continue;
}
if (testset.test( elem))
{
std::cerr << "element " << elem << " not inserted but found in dynamic bitset" << std::endl;
if (++g_nof_errors >= g_max_nof_errors) throw std::runtime_error( "dynamic bitset test failed");
}
}
}
std::cerr << "executed testDynamicBitSet( " << times << ", " << maximum << ", " << nofElements << ")" << std::endl;
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
{
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
{
typename search_const_container<set_type>::type &const_testset = testset;
std::pair<iterator,iterator> range;
std::pair<typename search_const_iterator<set_type>::type
,typename search_const_iterator<set_type>::type> const_range;
value_type cmp_val_lower, cmp_val_upper;
{
cmp_val_lower.value_ = 1;
cmp_val_upper.value_ = 2;
//left-closed, right-closed
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
}
{
cmp_val_lower.value_ = 1;
cmp_val_upper.value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 1);
BOOST_TEST (const_range.second->value_ == 2);
BOOST_TEST (std::distance (const_range.first, const_range.second) == 1);
cmp_val_lower.value_ = 1;
cmp_val_upper.value_ = 3;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
}
{
cmp_val_lower.value_ = 1;
cmp_val_upper.value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, false, true);
BOOST_TEST (const_range.first->value_ == 2);
BOOST_TEST (const_range.second->value_ == 3);
BOOST_TEST (std::distance (const_range.first, const_range.second) == 1);
}
{
cmp_val_lower.value_ = 1;
cmp_val_upper.value_ = 2;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, false, false);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 2);
BOOST_TEST (std::distance (range.first, range.second) == 0);
}
{
cmp_val_lower.value_ = 5;
cmp_val_upper.value_ = 6;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 5);
BOOST_TEST (const_range.second == const_testset.end());
BOOST_TEST (std::distance (const_range.first, const_range.second) == 1);
}
}
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(value_cont_type& values)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
{
//value_type cmp_val;
value_cont_type cmp_val_cont(1);
reference cmp_val = cmp_val_cont.front();
(&cmp_val)->value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 1);
(&cmp_val)->value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
{
typename search_const_container<set_type>::type &const_testset = testset;
std::pair<iterator,iterator> range;
std::pair<typename search_const_iterator<set_type>::type
,typename search_const_iterator<set_type>::type> const_range;
//value_type cmp_val_lower, cmp_val_upper;
value_cont_type cmp_val_cont(2);
reference cmp_val_lower = cmp_val_cont.front();
reference cmp_val_upper = cmp_val_cont.back();
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
//left-closed, right-closed
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 1);
BOOST_TEST (const_range.second->value_ == 2);
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 3;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, false, true);
BOOST_TEST (const_range.first->value_ == 2);
BOOST_TEST (const_range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, false, false);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 2);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 0);
}
{
(&cmp_val_lower)->value_ = 5;
(&cmp_val_upper)->value_ = 6;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 5);
BOOST_TEST (const_range.second == const_testset.end());
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
}
}
}
/*************************************************************************
Internal cross-validation subroutine
*************************************************************************/
static void mlpkfoldcvgeneral(const multilayerperceptron& n,
const ap::real_2d_array& xy,
int npoints,
double decay,
int restarts,
int foldscount,
bool lmalgorithm,
double wstep,
int maxits,
int& info,
mlpreport& rep,
mlpcvreport& cvrep)
{
int i;
int fold;
int j;
int k;
multilayerperceptron network;
int nin;
int nout;
int rowlen;
int wcount;
int nclasses;
int tssize;
int cvssize;
ap::real_2d_array cvset;
ap::real_2d_array testset;
ap::integer_1d_array folds;
int relcnt;
mlpreport internalrep;
ap::real_1d_array x;
ap::real_1d_array y;
//
// Read network geometry, test parameters
//
mlpproperties(n, nin, nout, wcount);
if( mlpissoftmax(n) )
{
nclasses = nout;
rowlen = nin+1;
}
else
{
nclasses = -nout;
rowlen = nin+nout;
}
if( npoints<=0||foldscount<2||foldscount>npoints )
{
info = -1;
return;
}
mlpcopy(n, network);
//
// K-fold out cross-validation.
// First, estimate generalization error
//
testset.setbounds(0, npoints-1, 0, rowlen-1);
cvset.setbounds(0, npoints-1, 0, rowlen-1);
x.setbounds(0, nin-1);
y.setbounds(0, nout-1);
mlpkfoldsplit(xy, npoints, nclasses, foldscount, false, folds);
cvrep.relclserror = 0;
cvrep.avgce = 0;
cvrep.rmserror = 0;
cvrep.avgerror = 0;
cvrep.avgrelerror = 0;
rep.ngrad = 0;
rep.nhess = 0;
rep.ncholesky = 0;
relcnt = 0;
for(fold = 0; fold <= foldscount-1; fold++)
{
//
// Separate set
//
tssize = 0;
cvssize = 0;
for(i = 0; i <= npoints-1; i++)
{
if( folds(i)==fold )
{
ap::vmove(&testset(tssize, 0), &xy(i, 0), ap::vlen(0,rowlen-1));
tssize = tssize+1;
}
else
{
ap::vmove(&cvset(cvssize, 0), &xy(i, 0), ap::vlen(0,rowlen-1));
cvssize = cvssize+1;
}
}
//
// Train on CV training set
//
if( lmalgorithm )
{
mlptrainlm(network, cvset, cvssize, decay, restarts, info, internalrep);
}
else
{
mlptrainlbfgs(network, cvset, cvssize, decay, restarts, wstep, maxits, info, internalrep);
}
if( info<0 )
{
cvrep.relclserror = 0;
cvrep.avgce = 0;
cvrep.rmserror = 0;
cvrep.avgerror = 0;
cvrep.avgrelerror = 0;
return;
}
rep.ngrad = rep.ngrad+internalrep.ngrad;
rep.nhess = rep.nhess+internalrep.nhess;
rep.ncholesky = rep.ncholesky+internalrep.ncholesky;
//
// Estimate error using CV test set
//
if( mlpissoftmax(network) )
{
//
// classification-only code
//
cvrep.relclserror = cvrep.relclserror+mlpclserror(network, testset, tssize);
cvrep.avgce = cvrep.avgce+mlperrorn(network, testset, tssize);
}
for(i = 0; i <= tssize-1; i++)
{
ap::vmove(&x(0), &testset(i, 0), ap::vlen(0,nin-1));
mlpprocess(network, x, y);
if( mlpissoftmax(network) )
{
//
// Classification-specific code
//
k = ap::round(testset(i,nin));
for(j = 0; j <= nout-1; j++)
{
if( j==k )
{
cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j)-1);
cvrep.avgerror = cvrep.avgerror+fabs(y(j)-1);
cvrep.avgrelerror = cvrep.avgrelerror+fabs(y(j)-1);
relcnt = relcnt+1;
}
else
{
cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j));
cvrep.avgerror = cvrep.avgerror+fabs(y(j));
}
}
}
else
{
//
// Regression-specific code
//
for(j = 0; j <= nout-1; j++)
{
cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j)-testset(i,nin+j));
cvrep.avgerror = cvrep.avgerror+fabs(y(j)-testset(i,nin+j));
if( ap::fp_neq(testset(i,nin+j),0) )
{
cvrep.avgrelerror = cvrep.avgrelerror+fabs((y(j)-testset(i,nin+j))/testset(i,nin+j));
relcnt = relcnt+1;
}
}
}
}
}
if( mlpissoftmax(network) )
{
cvrep.relclserror = cvrep.relclserror/npoints;
cvrep.avgce = cvrep.avgce/(log(double(2))*npoints);
}
cvrep.rmserror = sqrt(cvrep.rmserror/(npoints*nout));
cvrep.avgerror = cvrep.avgerror/(npoints*nout);
cvrep.avgrelerror = cvrep.avgrelerror/relcnt;
info = 1;
}
bool
in_struct(void *struct_ptr, struct_desc *sd
, pb_stream *ins, pb_stream *obj_pbs)
{
err_t ugh = NULL;
u_int8_t *cur = ins->cur;
if (ins->roof - cur < (ptrdiff_t)sd->size) {
ugh = builddiag("not enough room in input packet for %s", sd->name);
} else {
u_int8_t *roof = cur + sd->size; /* may be changed by a length field */
u_int8_t *outp = struct_ptr;
bool immediate = FALSE;
field_desc *fp;
for (fp = sd->fields; ugh == NULL; fp++) {
size_t i = fp->size;
passert(ins->roof - cur >= (ptrdiff_t)i);
passert(cur - ins->cur <= (ptrdiff_t)(sd->size - i));
passert(outp - (cur - ins->cur) == struct_ptr);
#if 0
DBG(DBG_PARSING, DBG_log("%d %s"
, (int) (cur - ins->cur), fp->name == NULL? "" : fp->name));
#endif
switch (fp->field_type) {
case ft_mbz: /* must be zero */
for (; i != 0; i--) {
if (*cur++ != 0) {
ugh = builddiag("byte %d of %s must be zero, but is not"
, (int) (cur - ins->cur), sd->name);
break;
}
*outp++ = '\0'; /* probably redundant */
}
break;
case ft_nat: /* natural number (may be 0) */
case ft_len: /* length of this struct and any following crud */
case ft_lv: /* length/value field of attribute */
case ft_enum: /* value from an enumeration */
case ft_loose_enum: /* value from an enumeration with only some names known */
case ft_af_enum: /* Attribute Format + value from an enumeration */
case ft_set: /* bits representing set */
{
u_int32_t n = 0;
for (; i != 0; i--)
n = (n << BITS_PER_BYTE) | *cur++;
switch (fp->field_type) {
case ft_len: /* length of this struct and any following crud */
case ft_lv: /* length/value field of attribute */
{
u_int32_t len = fp->field_type == ft_len? n
: immediate? sd->size : n + sd->size;
if (len < sd->size) {
ugh = builddiag("%s of %s is smaller than minimum"
, fp->name, sd->name);
} else if (pbs_left(ins) < len) {
ugh = builddiag("%s of %s is larger than can fit"
, fp->name, sd->name);
} else {
roof = ins->cur + len;
}
break;
}
case ft_af_enum: /* Attribute Format + value from an enumeration */
if ((n & ISAKMP_ATTR_AF_MASK) == ISAKMP_ATTR_AF_TV)
immediate = TRUE;
/* FALL THROUGH */
case ft_enum: /* value from an enumeration */
if (enum_name(fp->desc, n) == NULL) {
ugh = builddiag("%s of %s has an unknown value: %lu"
, fp->name, sd->name, (unsigned long)n);
}
/* FALL THROUGH */
case ft_loose_enum: /* value from an enumeration with only some names known */
break;
case ft_set: /* bits representing set */
if (!testset(fp->desc, n)) {
ugh = builddiag("bitset %s of %s has unknown member(s): %s"
, fp->name, sd->name, bitnamesof(fp->desc, n));
}
break;
default:
break;
}
i = fp->size;
switch (i) {
case 8/BITS_PER_BYTE:
*(u_int8_t *)outp = n;
break;
case 16/BITS_PER_BYTE:
*(u_int16_t *)outp = n;
break;
case 32/BITS_PER_BYTE:
*(u_int32_t *)outp = n;
break;
default:
impossible();
}
outp += i;
break;
}
case ft_raw: /* bytes to be left in network-order */
for (; i != 0; i--) {
*outp++ = *cur++;
}
break;
case ft_end: /* end of field list */
passert(cur == ins->cur + sd->size);
if (obj_pbs != NULL) {
init_pbs(obj_pbs, ins->cur, roof - ins->cur, sd->name);
obj_pbs->container = ins;
obj_pbs->desc = sd;
obj_pbs->cur = cur;
}
ins->cur = roof;
DBG(DBG_PARSING
, DBG_prefix_print_struct(ins, "parse ", struct_ptr, sd, TRUE));
return TRUE;
default:
impossible();
}
}
}
/* some failure got us here: report it */
loglog(RC_LOG_SERIOUS, ugh);
return FALSE;
}
int
main(){
testset();
return 0;
}
