source: trunk/test/Suite.cc @ 801

// $Id: Suite.cc 801 2009-07-06 02:07:42Z peter $

/*
  Copyright (C) 2008, 2009 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 svndigest. If not, see <http://www.gnu.org/licenses/>.
*/

#include <config.h>

#include "Suite.h"
#include "environment.h"

#include "Stats.h"
#include "StatsCollection.h"
#include "../lib/utility.h"

#include <cassert>
#include <fstream>
#include <iostream>
#include <string>

namespace theplu {
namespace svndigest {
namespace test {

  Suite::Suite(int argc, char* argv[], bool need_test_repo)
    : dev_null_(NULL), ok_(true), verbose_(false)
  {
    char* buffer=std::getenv("VERBOSE");
    if ( (argc>1 && (argv[1]==std::string("-v") 
                     || argv[1]==std::string("--verbose")) 
          || (buffer && buffer == std::string("1"))) ) {
      verbose_=true;
    }
    else
      dev_null_ = new std::ofstream("/dev/null");

    if (need_test_repo) {
      bool have_test_repo=false;
      #ifdef HAVE_TEST_REPO
      have_test_repo=true;
      #endif
      if (!have_test_repo) {
        out() << "Skipping test because test repository is not available\n";
        exit (77);
      }
      update_test_wc();
    }

  }


  Suite::~Suite(void)
  {
    delete dev_null_;
  }

  
  bool Suite::add(bool b)
  {
    ok_ = ok_ && b;
    return b;
  }


  bool Suite::ok(void) const
  {
    return ok_;
  }


  std::ostream& Suite::out(void) const
  {
    if (verbose())
      return std::cout;
    return *dev_null_;
  }


  bool equal(const StatsCollection& a, const StatsCollection& b, 
             Suite& suite)
  {
    if (a.stats().size() != b.stats().size()) {
      suite.out() << "size mismatch\n";
      return false;
    }
    std::map<std::string, Stats*>::const_iterator iter1 = a.stats().begin();
    std::map<std::string, Stats*>::const_iterator iter2 = b.stats().begin();
    while (iter1 != a.stats().end()) {
      if (iter1->first != iter2->first) {
        suite.out() << "key mismatch\n";
        suite.out() << iter1->first << " vs " << iter2->first << "\n";
        return false;
      }
      if (!equal(*iter1->second, *iter2->second, suite)) {
        suite.out() << "error in " << iter1->first << "\n";
        return false;
      }
      ++iter1;
      ++iter2;
    }
    return true;
  }
  

  bool equal(const Stats& a, const Stats& b, test::Suite& suite)
  {
    if (a.authors() != b.authors()) {
      suite.out() << "authors are not equal\n";
      return false;
    }
    if (a.revision() != b.revision()) {
      suite.out() << "revision mismatch\n";
      return false;
    }
    std::vector<std::string> authors;
    authors.reserve(a.authors().size()+1);
    std::copy(a.authors().begin(), a.authors().end(), 
              std::back_inserter(authors));
    authors.push_back("all");
    for (int linetype=0; linetype <= LineTypeParser::total; ++linetype) {
      for (std::vector<std::string>::const_iterator author=authors.begin(); 
           author!=authors.end(); ++author) {
        for (svn_revnum_t rev=0; rev<a.revision(); ++rev) {
          size_t ax = a(linetype, *author, rev);
          size_t bx = b(linetype, *author, rev);
          if (ax != bx) {
            suite.out() << "error: linetype: " << linetype 
                        << " author " << *author  
                        << " rev " << rev << "\n"
                        << "   a: " << ax << "\n"
                        << "   b: " << bx << "\n";
            return false;
          }
        }
      }
    }
    return true;
  }


  void Suite::update_test_wc(void) const
  {
    std::string cmd = abs_builddir()+"/svn_update.sh";
    out() << cmd << std::endl;
    int status = system(cmd.c_str());
    if (status) {
      out() << "failed with status: " << status << std::endl;
      exit (1);
    }
  }


  bool Suite::verbose(void) const
  {
    return verbose_;
  }


  std::string filename(const std::string& path)
  {
    return abs_builddir()+"/"+path;
  }


  std::string src_filename(const std::string& path)
  {
    return abs_srcdir()+"/"+path;
  }


}}}