source: trunk/test/Suite.cc @ 3209

// $Id: Suite.cc 3209 2014-05-04 13:52:34Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2011, 2012 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/utility.h"

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>

#include <sys/stat.h>

namespace theplu {
namespace yat {
namespace test {

  Suite::Suite(int argc, char* argv[], bool require_bam)
    : known_issues_(0), ok_(true)
  {
    if (require_bam) {
#ifndef YAT_HAVE_LIBBAM
      out() << "no libbam\n";
      exit (EXIT_SKIP);
#endif
#ifndef HAVE_SAMTOOLS
      out() << "no samtools\n";
      exit (EXIT_SKIP);
#endif
    }
    std::string test_dir = "test/testSubDir/" + utility::basename(argv[0]);
    utility::mkdir_p(test_dir);
    chdir(test_dir.c_str());
    out() << "running '" << argv[0] << "' in '" << test_dir << "'\n";
    // synchronize cerr and cout, i.e., cout is flushed before
    // writing anything to cerr.
    std::cerr.tie(&std::cout);
  }


  Suite::~Suite(void)
  {
  }


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


  std::string filename(const std::string& path)
  {
    std::string result;
    result += YAT_ABS_TOP_SRCDIR; 
    result += "/test/"; 
    result += path; 
    return result;
  }


  std::ostream& Suite::err(void) const
  {
    return std::cerr;
  }


  bool Suite::equal(double a, double b, unsigned long int n)
  {
    double last_error_bound = n*std::numeric_limits<double>().epsilon()*
      std::min(std::abs(a), std::abs(b));
    return equal_fix(a, b, last_error_bound);
  }


  bool Suite::equal_fix(double a, double b, double margin)
  {
    // using the negated comparison to catch NaN problems
    if (!(std::abs(a-b) <= margin)){
      err() << "Error: Comparing " << a << " and " << b 
            << "\n  Difference: " << a - b
            << "\n  expected difference to be at most " << margin
            << std::endl;
      return false;
    }
    return true;
  }


  bool Suite::equal_sqrt(double a, double b, unsigned long int n)
  {
    double last_error_bound = n*
      std::sqrt(std::numeric_limits<double>().epsilon())*
      std::min(std::abs(a), std::abs(b));
    if (!(std::abs(a-b) <= last_error_bound)){
      err() << "Error: Comparing " << a << " and " << b 
            << "\n  Difference: " << a - b
            << "\n  expected difference to be at most " << last_error_bound
            << std::endl;
      return false;
    }
    return true;
  }


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


  std::ostream& Suite::out(void) const
  {
    return std::cout;
  }


  int Suite::return_value(void) const
  {
    if (known_issues_>1)
      out() << known_issues_ << " known issues were detected.\n";
    else if (known_issues_==1)
      out() << known_issues_ << " known issue was detected.\n";
    if (ok()){
      out() << "Test is ok.\n";
      return EXIT_SUCCESS;
    }
    out() << "Test failed.\n";
    return EXIT_FAILURE;
  }


  bool run_as_root(void)
  {
    std::string file("write_protected_file.txt");
    std::ofstream os(file.c_str());
    os.close();
    chmod(file.c_str(), S_IRUSR);
    os.open(file.c_str());
    bool status = os.good();
    chmod(file.c_str(), S_IWUSR);
    unlink(file.c_str());
    return status;
  }


  bool Suite::xadd(bool ok)
  {
    if (!ok)
      ++known_issues_;
    else {
      err() << " test for a known issue returned true\n";
      add(false);
    }
    return ok;
  }


}}}