source: trunk/test/bam_iterator.cc @ 3209

// $Id: bam_iterator.cc 3209 2014-05-04 13:52:34Z peter $
//
// Copyright (C) 2012, 2013 Peter Johansson
//
// This program 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.
//
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.

#include <config.h>

#include "Suite.h"

#ifdef YAT_HAVE_LIBBAM
#include "yat/omic/BamFile.h"
#include "yat/omic/BamRead.h"
#include "yat/omic/BamReadIterator.h"
#include "yat/omic/BamWriteIterator.h"
#endif

#include <algorithm>
#include <cassert>
#include <fstream>
#include <string>

using namespace theplu::yat;

void test1(test::Suite& suite);

int main(int argc, char* argv[])
{
  test::Suite suite(argc, argv, true);
  try {
    test1(suite);
  }
  catch (std::runtime_error& e) {
    suite.add(false);
    suite.err() << "error: what: " << e.what() << "\n";
  }
  return suite.return_value();
}

#ifdef YAT_HAVE_LIBBAM
using namespace omic;

struct BamReadEqual
{
  bool operator()(const BamRead& lhs, const BamRead& rhs) const
  {
    // FIXME
    /*
    if (lhs.l_aux() != rhs.l_aux())
      return false;
    if (lhs.data_len() != rhs.data_len())
      return false;
    if (lhs.m_data() != rhs.m_data())
      return false;
    for (int i=0; i<lhs.data_len(); ++i)
      if (lhs.data()[i] != rhs.data()[i])
        return false;
    */

    // comparing core
    if (lhs.tid() != rhs.tid())
      return false;
    if (lhs.pos() != rhs.pos())
      return false;
    if (lhs.mtid() != rhs.mtid())
      return false;
    if (lhs.mpos() != rhs.mpos())
      return false;
    if (lhs.core().bin != rhs.core().bin)
      return false;
    if (lhs.core().qual != rhs.core().qual)
      return false;
    if (lhs.core().l_qname != rhs.core().l_qname)
      return false;
    if (lhs.core().flag != rhs.core().flag)
      return false;
    if (lhs.core().n_cigar != rhs.core().n_cigar)
      return false;
    if (lhs.core().l_qseq != rhs.core().l_qseq)
      return false;
    if (lhs.core().mtid != rhs.core().mtid)
      return false;
    if (lhs.core().mpos != rhs.core().mpos)
      return false;
    if (lhs.core().isize != rhs.core().isize)
      return false;

    return true;
  }
};


void test1(test::Suite& suite)
{
  std::string file = "../../data/foo.sorted.bam";

  InBamFile in;
  in.open(file);
  std::string outname("bam_iterator.bam");
  OutBamFile out(outname, in.header());
  BamWriteIterator bam_out(out);
  std::copy(BamReadIterator(in), BamReadIterator(), bam_out);
  if (false) // avoid running; only compile
    suite.test_output_iterator(bam_out);
  out.close();

  // compare that copy has equally many elements
  in.close();
  in.open(file);
  size_t n1 = std::distance(BamReadIterator(in), BamReadIterator());
  suite.out() << "entries in " << file << ": " << n1 << "\n";
  in.close();

  InBamFile copy(outname);
  size_t n2 = std::distance(BamReadIterator(copy), BamReadIterator());
  copy.close();
  suite.out() << "entries in " << outname << ": " << n2 << "\n";
  if (n1!=n2) {
    suite.out() << "error: not same number of entries in copy\n";
    suite.add(false);
  }

  copy.open(outname);
  in.open(file);
  if (!std::equal(BamReadIterator(in), BamReadIterator(),
                  BamReadIterator(copy), BamReadEqual())) {
    suite.out() << "error: " << file << " and " << outname << " not equal\n";
    suite.add(false);
  }
  copy.close();
  in.close();
  unlink(outname.c_str());

}
#else
void test1(test::Suite& suite) {}
#endif