source: trunk/test/merge_iterator.cc @ 3387

// $Id: merge_iterator.cc 3387 2015-03-16 01:47:55Z peter $
/*
  Copyright (C) 2013 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat 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 GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include <config.h>

#include "Suite.h"

#include "yat/utility/MergeIterator.h"

#include <boost/iterator/iterator_archetypes.hpp>

#include <algorithm>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>

using namespace theplu::yat;

bool test1(test::Suite& suite)
{
  suite.out() << "test1\n";
  std::vector<int> vec1;
  vec1.push_back(2);
  vec1.push_back(1);
  vec1.push_back(2);
  std::sort(vec1.begin(), vec1.end());
  std::vector<int> vec2;
  vec2.push_back(0);
  vec2.push_back(3);
  std::sort(vec2.begin(), vec2.end());
  std::vector<int> vec3;
  vec3.push_back(10);
  vec3.push_back(1);
  std::sort(vec3.begin(), vec3.end());

  typedef std::vector<int>::const_iterator vec_iterator;
  std::vector<std::pair<vec_iterator, vec_iterator> > data;
  data.push_back(std::make_pair(vec1.begin(), vec1.end()));
  data.push_back(std::make_pair(vec2.begin(), vec2.end()));
  data.push_back(std::make_pair(vec3.begin(), vec3.end()));
  data.push_back(std::make_pair(vec3.end(), vec3.end()));
  typedef utility::MergeIterator<vec_iterator> miterator;
  miterator begin(data);
  miterator end;

  std::vector<int> result(100, 999);

  std::copy(begin, end, result.begin());

  std::vector<int> correct;
  correct.push_back(0);
  correct.push_back(1);
  correct.push_back(1);
  correct.push_back(2);
  correct.push_back(2);
  correct.push_back(3);
  correct.push_back(10);

  correct.push_back(999);
  for (size_t i=0; i<correct.size(); ++i)
    if (correct[i] != result[i]) {
      suite.err() << "error: " << i << " " << result[i] << " expected "
                << correct[i] << "\n";
      return false;
    }
  return true;
}


bool test2(test::Suite& suite)
{
  suite.out() << "test2\n";
  // using constructor passing comparator
  typedef int* base;
  std::vector<std::pair<base, base> > data;
  utility::MergeIterator<base, std::greater<int> > miterator(data);
  std::greater<int> comp;
  utility::MergeIterator<base, std::greater<int> > miterator2(data, comp);
  return true;
}


bool test3(test::Suite& suite)
{
  suite.out() << "test3\n";
  // using make_merge_iterator functions
  typedef int* base;
  std::vector<std::pair<base, base> > data;
  utility::MergeIterator<base> end;
  std::count(utility::make_merge_iterator(data), end, 0);
  utility::MergeIterator<base, std::greater<int> > end2;
  std::greater<int> comp;
  std::count(utility::make_merge_iterator(data, comp), end2, 0);
  return true;
}


void test4(test::Suite& suite)
{
  // avoid running compilation test
  if (false) {
    typedef boost::less_than_comparable_archetype
      <boost::copy_constructible_archetype<> > value_type;
    typedef boost::iterator_archetypes::readable_iterator_t access_type;
    typedef boost::single_pass_traversal_tag traversal_type;

    typedef boost::iterator_archetype<value_type, access_type, traversal_type>
      base;
    utility::MergeIterator<base> it;
    test::test_readable_iterator(it);
    test::test_single_pass_iterator(it);
  }
}


int main(int argc, char* argv[])
{
  test::Suite suite(argc, argv);
  test1(suite);
  test2(suite);
  test3(suite);
  test4(suite);
  return suite.return_value();
}