source: branches/kendall-score/test/ranking.cc @ 4072

// $Id: ranking.cc 4072 2021-08-20 05:40:18Z peter $

/*
  Copyright (C) 2021 Peter Johansson

  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/>.
*/

#define YAT_DEBUG_RANKING 1

#include <config.h>

#include "Suite.h"

#include "yat/utility/Ranking.h"
#include "yat/utility/utility.h"

#include <algorithm>

using namespace theplu::yat;

void test1(test::Suite& suite)
{
  suite.out() << YAT_TEST_PROLOGUE;
  suite.out() << "Constructor(0)\n";
  utility::Ranking<double> ranking;
  {
    suite.out() << "Constructor(1)\n";
    utility::Ranking<double, std::less<double> > ranking2(ranking.compare());
    test::avoid_compiler_warning(ranking2);
    suite.out() << "Constructor(0)\n";
    utility::Ranking<double, std::greater<double> > ranking3;
    test::avoid_compiler_warning(ranking3);
    std::greater<double> compare;
    suite.out() << "Constructor(1)\n";
    utility::Ranking<double, std::greater<double> > ranking4(compare);
    test::avoid_compiler_warning(ranking4);
  }

  suite.out() << "::insert 0\n";
  ranking.insert(0);
  suite.out() << "::insert 1\n";
  ranking.insert(1);
  suite.out() << "::insert 2\n";
  ranking.insert(2);
  suite.out() << "::insert 1\n";
  ranking.insert(1);
  if (ranking.size() != 4) {
    suite.add(false);
    suite.err() << "error: incorrect size: " << ranking.size() << "\n";
  }
  suite.out() << "distance\n";
  int dist = std::distance(ranking.begin(), ranking.end());
  if (dist != 4) {
    suite.add(false);
    suite.err() << "error: incorrect distance: " << dist << "\n";
  }
  int cdist = std::distance(ranking.cbegin(), ranking.cend());
  if (cdist != 4) {
    suite.add(false);
    suite.err() << "error: incorrect const distance: " << cdist << "\n";
  }
  int rdist = std::distance(ranking.rbegin(), ranking.rend());
  if (rdist != 4) {
    suite.add(false);
    suite.err() << "error: incorrect reverse distance: " << rdist << "\n";
  }
  int crdist = std::distance(ranking.crbegin(), ranking.crend());
  if (crdist != 4) {
    suite.add(false);
    suite.err() << "error: incorrect const reverse distance: "
                << crdist << "\n";
  }

  // try to find lower bound for a large value
  utility::Ranking<double>::iterator lower = ranking.lower_bound(10000);
  if (lower != ranking.end()) {
    suite.add(false);
    suite.err() << "ranking.lower_bound(10000) expected ranking.end()\n";
  }
  lower = ranking.lower_bound(1);
  if (*lower != 1) {
    suite.add(false);
    suite.err() << "error: *lower returned: " << *lower << "\n";
  }

  // try to find upper bound for a large value
  utility::Ranking<double>::iterator upper = ranking.upper_bound(10000);
  if (upper != ranking.end()) {
    suite.add(false);
    suite.err() << "ranking.upper_bound(10000) expected ranking.end()\n";
  }
  upper = ranking.upper_bound(1);
  if (*upper != 2) {
    suite.add(false);
    suite.err() << "error: *upper returned: " << *upper << "\n";
  }

  dist = std::distance(lower, upper);
  if (dist != 2) {
    suite.add(false);
    suite.err() << "error: distance(lower, upper): " << dist << "\n";
  }

  std::vector<int> vec(10);
  ranking.insert(vec.begin(), vec.end());
}


void test2(test::Suite& suite)
{
  suite.out() << YAT_TEST_PROLOGUE;
  // mimick how Ranking is used in Kendall::score
  utility::Ranking<double> ranking;
  auto lower = ranking.lower_bound(2);
  int r = ranking.ranking(lower);
  suite.out() << "ranking: " << r << "\n";
  if (r != 0) {
    suite.add(false);
    suite.err() << "error: incorrect; expected 0\n";
  }
  ranking.insert(lower, 2);

  lower = ranking.lower_bound(1);
  r = ranking.ranking(lower);
  suite.out() << "ranking: " << r << "\n";
  if (r != 0) {
    suite.add(false);
    suite.err() << "error: incorrect; expected 0\n";
  }
  ranking.insert(lower, 1);

  lower = ranking.lower_bound(3);
  if (lower != ranking.cend()) {
    suite.add(false);
    suite.err() << "error: expected ranking.lower_bound(3) to return end()\n";
  }
  suite.out() << "values in ranking object:\n";
  for (auto it=ranking.cbegin(); it!=ranking.cend(); ++it)
    suite.out() << "value: " << *it << "\n";
  size_t n = ranking.size();
  if (n != 2) {
    suite.add(false);
    suite.err() << "::size() returns " << n << "; expected 2\n";
  }
  n = std::distance(ranking.cbegin(), ranking.cend());
  if (n!=2) {
    suite.add(false);
    suite.err() << "distance(begin, end) returns " << n << "; expected 2\n";
  }

  r = ranking.ranking(lower);
  suite.out() << "ranking: " << r << "\n";
  if (r != 2) {
    suite.add(false);
    suite.err() << "error: incorrect; expected 2\n";
  }
}


void test_copy(test::Suite& suite)
{
  suite.out() << YAT_TEST_PROLOGUE;
  utility::Ranking<double> ranking;
  ranking.insert(0);
  ranking.insert(1);
  ranking.insert(-1);

  suite.out() << "test copy constructor\n";
  utility::Ranking<double> ranking2(ranking);
  int n = std::distance(ranking.begin(), ranking.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "ranking distance: " << n << "\n";
  }

  n = std::distance(ranking2.begin(), ranking2.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: copy constructor failed\n";
    suite.err() << "ranking2 distance: " << n << "\n";
    for (auto it = ranking2.cbegin(); it!=ranking2.cend(); ++it)
      suite.err() << "value: " << *it << "\n";
  }

  utility::Ranking<double> ranking3;
  ranking3.insert(10);
  suite.out() << "test copy assignment\n";
  ranking3 = ranking2;
  n = std::distance(ranking3.begin(), ranking3.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: assignment failed\n";
    suite.err() << "ranking3 distance: " << n << "\n";
  }

  suite.out() << "test move constructor\n";
  utility::Ranking<double> ranking4(std::move(ranking3));
  n = std::distance(ranking4.begin(), ranking4.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: move constructor failed\n";
    suite.err() << "ranking4 distance: " << n << "\n";
  }

  suite.out() << "test move assignment\n";
  ranking4 = std::move(ranking2);
  n = std::distance(ranking4.begin(), ranking4.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: move assignment failed\n";
    suite.err() << "ranking4 distance: " << n << "\n";
  }
}


void test_erase(test::Suite& suite)
{
  suite.out() << YAT_TEST_PROLOGUE;

  utility::Ranking<double> ranking;
  ranking.insert(1);
  ranking.insert(2);
  ranking.insert(3);
  auto it = ranking.find(2);
  suite.out() << "test erase(iterator)\n";
  ranking.erase(it);
  int n = ranking.size();
  if (n != 2) {
    suite.add(false);
    suite.err() << "error: size() = " << n << "; expected 2\n";
  }
  n = std::distance(ranking.begin(), ranking.end());
  if (n != 2) {
    suite.add(false);
    suite.err() << "error: distance = " << n << "; expected 2\n";
  }

  suite.out() << "test erase(value)\n";
  ranking.insert(2);
  ranking.erase(2);
  n = ranking.size();
  if (n != 2) {
    suite.add(false);
    suite.err() << "error: size() = " << n << "; expected 2\n";
  }
  n = std::distance(ranking.begin(), ranking.end());
  if (n != 2) {
    suite.add(false);
    suite.err() << "error: distance = " << n << "; expected 2\n";
  }

  suite.out() << "test erase(iterator, iterator)\n";
  ranking.insert(2);
  ranking.insert(4);
  ranking.insert(0);
  auto lower = ranking.lower_bound(1);
  auto upper = ranking.find(3);
  // erase { 1, 2}
  ranking.erase(lower, upper);
  n = ranking.size();
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: size() = " << n << "; expected 3\n";
  }
  n = std::distance(ranking.begin(), ranking.end());
  if (n != 3) {
    suite.add(false);
    suite.err() << "error: distance = " << n << "; expected 3\n";
  }
}


int main(int argc, char* argv[])
{
  test::Suite suite(argc, argv);
  try {
    test1(suite);
    test2(suite);
    test_copy(suite);
    test_erase(suite);
  }
  catch (std::exception& e) {
    suite.add(false);
    suite.err() << "error: exception caught: what(): ";
    utility::print_what(e, suite.err());
  }
  return suite.return_value();
}