zip_iterator_test.cpp

boost库提供标准的C++ API 配合dev c++使用,功能更加强大

    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator copy construction and equality
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator copy construction and equality: " 
            << std::flush;

  boost::zip_iterator<
    boost::tuples::tuple<
      std::vector<double>::const_iterator, 
      std::vector<double>::const_iterator
      >
    > zip_it_run_copy(zip_it_run);

  if(zip_it_run == zip_it_run && zip_it_run == zip_it_run_copy)
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator inequality
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator inequality:                     "
            << std::flush;
  
  if(!(zip_it_run != zip_it_run_copy) && zip_it_run != ++zip_it_run_copy)
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator less than
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator less than:                      "
            << std::flush;
  
  // Note: zip_it_run_copy == zip_it_run + 1
  //
  if( zip_it_run < zip_it_run_copy  &&
      !( zip_it_run < --zip_it_run_copy) && 
      zip_it_run == zip_it_run_copy
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator less than or equal
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "zip iterator less than or equal:             "
            << std::flush;
  
  // Note: zip_it_run_copy == zip_it_run
  //
  ++zip_it_run;
  zip_it_run_copy += 2;

  if( zip_it_run <= zip_it_run_copy && 
      zip_it_run <= --zip_it_run_copy && 
      !( zip_it_run <= --zip_it_run_copy) && 
      zip_it_run <= zip_it_run
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator greater than
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator greater than:                   "
            << std::flush;
  
  // Note: zip_it_run_copy == zip_it_run - 1
  //
  if( zip_it_run > zip_it_run_copy && 
      !( zip_it_run > ++zip_it_run_copy) && 
      zip_it_run == zip_it_run_copy
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator greater than or equal
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator greater than or equal:          "
            << std::flush;

  ++zip_it_run;
  
  // Note: zip_it_run == zip_it_run_copy + 1
  //
  if( zip_it_run >= zip_it_run_copy && 
      --zip_it_run >= zip_it_run_copy && 
      ! (zip_it_run >= ++zip_it_run_copy) 
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator + int
  //
  /////////////////////////////////////////////////////////////////////////////

  std::cout << "Zip iterator + int:                          "
            << std::flush;

  // Note: zip_it_run == zip_it_run_copy - 1
  //
  zip_it_run = zip_it_run + 2;
  ++zip_it_run_copy;

  if( zip_it_run == zip_it_run_copy && zip_it_run == zip_it_begin + 3 )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator - int
  //
  /////////////////////////////////////////////////////////////////////////////

  std::cout << "Zip iterator - int:                          "
            << std::flush;
  
  // Note: zip_it_run == zip_it_run_copy, and both are at end position
  // 
  zip_it_run = zip_it_run - 2;
  --zip_it_run_copy;
  --zip_it_run_copy;
  
  if( zip_it_run == zip_it_run_copy && (zip_it_run - 1) == zip_it_begin )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator +=
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator +=:                             "
            << std::flush;
            
  // Note: zip_it_run == zip_it_run_copy, and both are at begin + 1
  // 
  zip_it_run += 2;
  if( zip_it_run == zip_it_begin + 3 )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator -=
  //
  /////////////////////////////////////////////////////////////////////////////

  std::cout << "Zip iterator -=:                             "
            << std::flush;

  // Note: zip_it_run is at end position, zip_it_run_copy is at
  // begin plus one.
  // 
  zip_it_run -= 2;
  if( zip_it_run == zip_it_run_copy )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator getting member iterators
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator member iterators:               "
            << std::flush;
            
  // Note: zip_it_run and zip_it_run_copy are both at
  // begin plus one.
  // 
  if( boost::tuples::get<0>(zip_it_run.get_iterator_tuple()) == vect1.begin() + 1 &&
      boost::tuples::get<1>(zip_it_run.get_iterator_tuple()) == vect2.begin() + 1
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Making zip iterators
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Making zip iterators:                        "
            << std::flush;

  std::vector<boost::tuples::tuple<double, double> >
    vect_of_tuples(3);

  std::copy(
    boost::make_zip_iterator(
    boost::make_tuple(
      vect1.begin(), 
      vect2.begin()
      )
    ),
    boost::make_zip_iterator(
    boost::make_tuple(
      vect1.end(), 
      vect2.end()
      )
    ),
    vect_of_tuples.begin()
  );

  if( 42. == boost::tuples::get<0>(*vect_of_tuples.begin()) &&
      2.2 == boost::tuples::get<1>(*vect_of_tuples.begin()) &&
      43. == boost::tuples::get<0>(*(vect_of_tuples.begin() + 1)) &&
      3.3 == boost::tuples::get<1>(*(vect_of_tuples.begin() + 1)) &&
      44. == boost::tuples::get<0>(*(vect_of_tuples.begin() + 2)) &&
      4.4 == boost::tuples::get<1>(*(vect_of_tuples.begin() + 2))
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator non-const --> const conversion
  //
  /////////////////////////////////////////////////////////////////////////////
  
  std::cout << "Zip iterator non-const to const conversion:  "
            << std::flush;
  
  boost::zip_iterator<
    boost::tuples::tuple<
      std::set<int>::const_iterator,
      std::vector<double>::const_iterator
      >
    > 
  zip_it_const(
    boost::make_tuple(
      intset.begin(), 
      vect2.begin()
    )
  );
  //
  boost::zip_iterator<
    boost::tuples::tuple<
      std::set<int>::iterator,
      std::vector<double>::const_iterator
      >
    > 
  zip_it_half_const(
    boost::make_tuple(
      intset.begin(), 
      vect2.begin()
    )
  );
  //
  boost::zip_iterator<
    boost::tuples::tuple<
      std::set<int>::iterator,
      std::vector<double>::iterator
      >
    > 
  zip_it_non_const(
    boost::make_tuple(
      intset.begin(), 
      vect2.begin()
    )
  );

  zip_it_half_const = ++zip_it_non_const;
  zip_it_const = zip_it_half_const;
  ++zip_it_const;
//  zip_it_non_const = ++zip_it_const;  // Error: can't convert from const to non-const
  
  if( 54 == boost::tuples::get<0>(*zip_it_const) &&
      4.4 == boost::tuples::get<1>(*zip_it_const)  &&
      53 == boost::tuples::get<0>(*zip_it_half_const)  &&
      3.3 == boost::tuples::get<1>(*zip_it_half_const)
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }


  /////////////////////////////////////////////////////////////////////////////
  //
  // Zip iterator categories
  //
  /////////////////////////////////////////////////////////////////////////////

  std::cout << "Zip iterator categories:                     "
            << std::flush;
            
  // The big iterator of the previous test has vector, list, and set iterators.
  // Therefore, it must be bidirectional, but not random access.
  bool bBigItIsBidirectionalIterator = boost::is_convertible<
    boost::iterator_traversal<zip_it_12_type>::type
        , boost::bidirectional_traversal_tag
        >::value;

  bool bBigItIsRandomAccessIterator = boost::is_convertible<
    boost::iterator_traversal<zip_it_12_type>::type
        , boost::random_access_traversal_tag
        >::value;

  // A combining iterator with all vector iterators must have random access
  // traversal.
  //
  typedef boost::zip_iterator<
    boost::tuples::tuple<
      std::vector<double>::const_iterator, 
      std::vector<double>::const_iterator
      >
    > all_vects_type;
  
  bool bAllVectsIsRandomAccessIterator = boost::is_convertible<
    boost::iterator_traversal<all_vects_type>::type
        , boost::random_access_traversal_tag
    >::value;

  // The big test.
  if( bBigItIsBidirectionalIterator &&
      ! bBigItIsRandomAccessIterator &&
      bAllVectsIsRandomAccessIterator
    )
  {
    ++num_successful_tests;
    std::cout << "OK" << std::endl;
  }
  else
  {
    ++num_failed_tests = 0;
    std::cout << "not OK" << std::endl;
  }

  // Done
  //
  std::cout << "\nTest Result:"
            << "\n============"
            << "\nNumber of successful tests: " << static_cast<unsigned int>(num_successful_tests)
            << "\nNumber of failed tests: " << static_cast<unsigned int>(num_failed_tests)
            << std::endl;

  return num_failed_tests;
}