source: plugins/base1/se.lu.thep.wenni/trunk/test/wenni_test.cc @ 836

// $Id: wenni_test.cc 836 2008-11-28 17:27:49Z peter $

/*
  Copyright (C) 2005, 2006 Jari Häkkinen
  Copyright (C) 2007 2008 Peter Johansson

  This file is part of WeNNI,
  http://baseplugins.thep.lu.se/wiki/se.lu.thep.WeNNI

  WeNNI 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.

  WeNNI 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 WeNNI. If not, see <http://www.gnu.org/licenses/>.
*/

#include "c++_tools/gslapi/matrix.h"

#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <unistd.h>

bool check_default_results(void);
bool check_knni_results(void);
bool check_raw_results(void);
bool check_wenni_snr_results(void);
bool cleanup(void);
bool compare(const std::string&, const std::string&, double error_bound=1e-20);
bool diff(const std::string&, const std::string&);
bool rm(const std::string& filename);


int main(const int argc,const char* argv[])
{  
  bool teststatus=false;

  teststatus|=check_raw_results();
  teststatus|=check_default_results();

  char* buf=std::getenv("srcdir");
  assert(buf);
  std::string srcdir(buf);
  std::stringstream system_call;
  system_call << "./nni -data default_results/wenni_logratio.data"
              << " -neighbours 10 -weight " << srcdir 
              << "/../data/wenni_snr.data -weight_is_snr"
              << " > wenni_imputed.data";
  if (system(system_call.str().c_str())) {
    teststatus|=true;
    std::cerr << "ERROR: system call failed:\n\t" << system_call << std::endl;
  }
  teststatus|=check_wenni_snr_results();

  system_call.str("");
  system_call << "./nni -data default_results/wenni_logratio.data -neighbours 10"
              << " -nni_algorithm kNNI -weight default_results/wenni_weight.data"
              << " -weight_cutoff 0.5 > knni_imputed.data";
  if (system(system_call.str().c_str())) {
    teststatus|=true;
    std::cerr << "ERROR: system call failed:\n\t" << system_call << std::endl;
  }
  teststatus|=check_knni_results();

  //teststatus|=cleanup();

  return (teststatus ? -1 : 0);
}


bool check_default_results(void)
{
  char* buf=std::getenv("srcdir");
  assert(buf);
  std::string srcdir(buf);

  bool teststatus=false;
  teststatus|=diff("default_results/BASEfile.data",
                   srcdir+"/../data/basefile_in.data");
  teststatus|=diff("default_results/basefile_out.data",
                   srcdir+"/../data/basefile_out.data");
  teststatus|=compare("default_results/wenni_BCh1SD.data",
                      srcdir+"/../data/wenni_BCh1SD.data");
  teststatus|=compare("default_results/wenni_BCh2SD.data",
                      srcdir+"/../data/wenni_BCh2SD.data");
  teststatus|=compare("default_results/wenni_imputed.data",
                      srcdir+"/../data/wenni_imputed.data");
  teststatus|=compare("default_results/wenni_intensity1.data",
                      srcdir+"/../data/wenni_intensity1.data");
  teststatus|=compare("default_results/wenni_intensity2.data",
                      srcdir+"/../data/wenni_intensity2.data");
  teststatus|=compare("default_results/wenni_logratio.data",
                      srcdir+"/../data/wenni_logratio.data");
  teststatus|=compare("default_results/wenni_weight.data",
                      srcdir+"/../data/wenni_weight.data");
  if (teststatus)
    std::cerr << "ERROR: check_default_results failed." << std::endl;
  return teststatus;
}


bool check_knni_results(void)
{
  char* buf=std::getenv("srcdir");
  assert(buf);
  std::string srcdir(buf);
  bool teststatus=false;
  teststatus|=diff("knni_imputed.data",srcdir+"/../data/knni_imputed.data");
  if (teststatus)
    std::cerr << "ERROR: check_knni_results failed." << std::endl;
  return teststatus;
}


bool check_raw_results(void)
{
  char* buf=std::getenv("srcdir");
  assert(buf);
  std::string srcdir(buf);

  bool teststatus=false;
  teststatus|=diff("raw_results/BASEfile.data",
                   srcdir+"/../data/basefile_in.data");
  teststatus|=diff("raw_results/basefile_out.data","../data/basefile_out.data");
  teststatus|=compare("raw_results/wenni_BCh1Mean.data",
                      srcdir+"/../data/wenni_BCh1Mean.data");
  teststatus|=compare("raw_results/wenni_BCh1SD.data",
                      srcdir+"/../data/wenni_BCh1SD.data");
  teststatus|=compare("raw_results/wenni_BCh2Mean.data",
                      srcdir+"/../data/wenni_BCh2Mean.data");
  teststatus|=compare("raw_results/wenni_BCh2SD.data",
                      srcdir+"/../data/wenni_BCh2SD.data");
  teststatus|=compare("raw_results/wenni_FCh1Mean.data",
                      srcdir+"/../data/wenni_FCh1Mean.data");
  teststatus|=compare("raw_results/wenni_FCh2Mean.data",
                      srcdir+"/../data/wenni_FCh2Mean.data");
  teststatus|=compare("raw_results/wenni_imputed.data",
                      srcdir+"/../data/wenni_imputed.data");
  teststatus|=compare("raw_results/wenni_logratio.data",
                      srcdir+"/../data/wenni_logratio.data");
  teststatus|=compare("raw_results/wenni_weight.data",
                      srcdir+"/../data/wenni_weight.data");
  if (teststatus)
    std::cerr << "ERROR: check_raw_results failed." << std::endl;
  return teststatus;
}


bool check_wenni_snr_results(void)
{
  bool teststatus=false;
  char* buf=std::getenv("srcdir");
  assert(buf);
  std::string srcdir(buf);
  teststatus|=compare("wenni_imputed.data",srcdir+"/../data/wenni_imputed.data",
                      1.1e-11);
  if (teststatus)
    std::cerr << "ERROR: check_wenni_results failed." << std::endl;
  return teststatus;
}


bool cleanup(void)
{
  bool teststatus=false;
  teststatus|=rm("BASEfile.data");
  teststatus|=rm("basefile_out.data");
  teststatus|=rm("knni_imputed.data");
  teststatus|=rm("wenni_BCh1Mean.data");
  teststatus|=rm("wenni_BCh1SD.data");
  teststatus|=rm("wenni_BCh2Mean.data");
  teststatus|=rm("wenni_BCh2SD.data");
  teststatus|=rm("wenni_FCh1Mean.data");
  teststatus|=rm("wenni_FCh2Mean.data");
  teststatus|=rm("wenni_imputed.data");
  teststatus|=rm("wenni_intensity1.data");
  teststatus|=rm("wenni_intensity2.data");
  teststatus|=rm("wenni_logratio.data");
  teststatus|=rm("wenni_weight.data");
  return teststatus;
}


bool compare(const std::string& a,const std::string& b, double error_bound)
{
  bool teststatus=false;
  std::ifstream astream(a.c_str());
  assert(astream.good());
  std::ifstream bstream(b.c_str());
  assert(bstream.good());
  theplu::gslapi::matrix adata(astream);
  theplu::gslapi::matrix bdata(bstream);
  adata-=bdata;
  for (size_t i=0; i<adata.rows(); i++)
    for (size_t j=0; j<adata.columns(); j++)
      if ((fabs(adata(i,j))>error_bound) || // result outside acceptable bounds
          (!((adata(i,j)==adata(i,j)))))    // calucaltion error detected
        teststatus=true;
  astream.close();
  bstream.close();
  if (teststatus)
    std::cerr << "ERROR: compare " << a << " " << b << std::endl;
  return teststatus;
}


bool diff(const std::string& a,const std::string& b)
{
  std::ifstream is1(a.c_str());
  assert(is1.good());
  std::ifstream is2(a.c_str());
  assert(is2.good());
  std::string str1;
  std::string str2;
  while (getline(is1,str1)){
    getline(is2,str2);
    if (str1!=str2) {
      std::cerr << "ERROR: diff " << a << " " << b << std::endl;
      return true;
    }
  }
  return false;
}


bool rm(const std::string& filename) {
  if (unlink(filename.c_str())) {
    std::cerr << "ERROR: unlink call failed for: " << filename << std::endl;
    return true;
  }
  return false;
}