vgtl_test.h

Go to the documentation of this file.

// Test Algorithm implementation -*- C++ -*-

// $Id: vgtl_test.h 347 2008-02-06 15:20:01Z schilly $
// Copyright (C) 2003 Hermann Schichl
//
// This file is part of the Vienna Graph Template Library.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef __VGTL_TEST_H
#define __VGTL_TEST_H

#include <algorithm>
#include <vgtl_helpers.h>
#include <vgtl_gdata.h>

__VGTL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1209
#endif

template <class _Walker, class _Test>
void recursive_consistency_test(_Walker __w, const _Test& __t)
{
  typename _Walker::children_iterator __cit, __ec, __ccit;
  typename _Walker::parents_iterator __pit, __ep, __ppit;
  _Walker __wc, __wp;
  bool am_ground, am_sky, have_virtual;
  unsigned int n_cids, n_pids;

  am_ground = __w.is_ground();
  am_sky = __w.is_sky();
  if(!am_sky)
  {
    __ec = __w.child_end();
    for(__cit = __w.child_begin(); __cit != __ec; ++__cit)
    {
      __wc = __w >> __cit;
      have_virtual = __wc.is_sky();
      for(__ccit = __w.child_begin(); __ccit != __cit; ++__ccit)
        if(__wc == __w >> __ccit)
          break;
      if(__ccit != __cit)  // we have been here already!
        continue;
      n_cids = 1;
      for(++__ccit; __ccit != __ec; ++__ccit)
        if(__wc == __w >> __ccit) n_cids++;
      if(am_ground && __wc.n_parents() != 1)
      {
        if(__wc.is_sky())
          std::cerr << "sky has parent ground && n_parents != 1" << std::endl;
        else
          std::cerr << __t(*__wc) << " has n_parents != 1 && parent ground!"
            << std::endl;
      }
      __ep = __wc.parent_end();
      n_pids = 0;
      for(__pit = __wc.parent_begin(); __pit != __ep; ++__pit)
      {
        if(__w == __wc << __pit)
          n_pids++;
      }
      if(n_cids != n_pids)
      {
        if(__wc.is_sky())
        {
          if(am_ground)
            std::cerr << "child sky has " << n_pids <<
              " parent(s) ground,  needs " << n_cids << "!" << std::endl;
          else
            std::cerr << "child sky has " << n_pids << " parent(s) " <<
              __t(*__w) << ", needs " << n_cids << "!" << std::endl;
        }
        else if(am_ground)
          std::cerr << "child " << __t(*__wc) << " has " << n_pids <<
            " parent(s) ground, needs " << n_cids << "!" << std::endl;
        else
          std::cerr << "child " << __t(*__wc) << " has " << n_pids <<
            " parent(s) " << __t(*__w) << ", needs " << n_cids << "!" <<
            std::endl;
      }
      recursive_consistency_test(__wc, __t);
    }
    if(have_virtual && __w.n_children() != 1)
    {
      if(am_ground)
        std::cerr << "ground has child sky && n_children != 1" << std::endl;
      else
        std::cerr << __t(*__w) << " has n_children != 1 && child sky!"
          << std::endl;
    }
  }
  if(!am_ground)
  {
    __ep = __w.parent_end();
    for(__pit = __w.parent_begin(); __pit != __ep; ++__pit)
    {
      __wp = __w << __pit;
      have_virtual = __wp.is_ground();
      for(__ppit = __w.parent_begin(); __ppit != __pit; ++__ppit)
        if(__wp == __w << __ppit)
          break;
      if(__ppit != __pit)  // we have been here already!
        continue;
      n_pids = 1;
      for(++__ppit; __ppit != __ep; ++__ppit)
        if(__wp == __w << __ppit) n_pids++;
      if(am_sky && __wp.n_children() != 1)
      {
        if(__wp.is_ground())
          std::cerr << "ground has child sky && n_children != 1" << std::endl;
        else
          std::cerr << __t(*__wp) << " has n_children != 1 && child sky!"
            << std::endl;
      }
      __ec = __wp.child_end();
      n_cids = 0;
      for(__cit = __wp.child_begin(); __cit != __ec; ++__cit)
      {
        if(__w == __wp >> __cit)
          n_cids++;
      }
      if(n_cids != n_pids)
      {
        if(__wp.is_ground())
        {
          if(am_sky)
            std::cerr << "parent ground has " << n_cids <<
              " child(ren) sky,  needs " << n_pids << "!" << std::endl;
          else
            std::cerr << "parent ground has " << n_cids << " child(ren) " <<
              __t(*__w) << ", needs " << n_pids << "!" << std::endl;
        }
        else if(am_ground)
          std::cerr << "parent " << __t(*__wp) << " has " << n_cids <<
            " child(ren) sky, needs " << n_pids << "!" << std::endl;
        else
          std::cerr << "parent " << __t(*__wp) << " has " << n_cids <<
            " child(ren) " << __t(*__w) << ", needs " << n_pids << "!" <<
            std::endl;
      }
    }
    if(have_virtual && __w.n_parents() != 1)
    {
      if(am_sky)
        std::cerr << "sky has parent ground && n_parents != 1" << std::endl;
      else
        std::cerr << __t(*__w) << " has n_parents != 1 && parent ground!"
          << std::endl;
    }
  }
}

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1209
#endif

__VGTL_END_NAMESPACE

#endif /* __VGTL_TEST_H */

// Local Variables:
// mode:C++
// End:

---