/*
 * DescriptorUnittest.cpp
 *
 *  Created on: Feb 9, 2010
 *      Author: crueger
 */

#include "DescriptorUnittest.hpp"

#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <iostream>

#include <Descriptors/AtomDescriptor.hpp>
#include <Descriptors/AtomIdDescriptor.hpp>

#include "World.hpp"
#include "atom.hpp"

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( DescriptorUnittest );

// some stubs
class AtomStub : public atom {
public:
  AtomStub(int _id) :
  atom(),
  id(_id)
  {}

  virtual int getId(){
    return id;
  }

private:
  int id;
};


// set up and tear down
void DescriptorUnittest::setUp(){
  World::get();
  for(int i=0;i<ATOM_COUNT;++i){
    atoms[i]= new AtomStub(i);
  }
}
void DescriptorUnittest::tearDown(){
  World::destroy();
  for(int i=0;i<ATOM_COUNT;++i){
    delete atoms[i];
  }
}

// some helper functions
bool hasAll(std::vector<atom*> atoms,int min, int max, std::set<int> excluded = std::set<int>()){
  for(int i=min;i<max;++i){
    if(!excluded.count(i)){
      std::vector<atom*>::iterator iter;
      bool res=false;
      for(iter=atoms.begin();iter!=atoms.end();++iter){
        res |= (*iter)->getId() == i;
      }
      if(!res) {
        cout << "Atom " << i << " missing in returned list" << endl;
        return false;
      }
    }
  }
  return true;
}

bool hasNoDuplicates(std::vector<atom*> atoms){
  std::set<int> found;
  std::vector<atom*>::iterator iter;
  for(iter=atoms.begin();iter!=atoms.end();++iter){
    int id = (*iter)->getId();
    if(found.count(id))
      return false;
    found.insert(id);
  }
  return true;
}


void DescriptorUnittest::AtomBaseSetsTest(){
  std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
  CPPUNIT_ASSERT_EQUAL( true , hasAll(allAtoms,0,ATOM_COUNT));
  CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(allAtoms));

  std::vector<atom*> noAtoms = World::get()->getAllAtoms(NoAtoms());
  CPPUNIT_ASSERT_EQUAL( true , noAtoms.empty());
}
void DescriptorUnittest::AtomIdTest(){
  // test Atoms from boundaries and middle of the set
  atom* testAtom;
  testAtom = World::get()->getAtom(AtomById(0));
  CPPUNIT_ASSERT_EQUAL( 0, testAtom->getId());
  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT/2));
  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtom->getId());
  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT-1));
  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT-1, testAtom->getId());

  // test from outside of set
  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT));
  CPPUNIT_ASSERT(!testAtom);
}
void DescriptorUnittest::AtomCalcTest(){
  // test some elementary set operations
  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()||NoAtoms());
    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
    CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||AllAtoms());
    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
    CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()&&AllAtoms());
    CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&NoAtoms());
    CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(!AllAtoms());
    CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(!NoAtoms());
    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
    CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
  }

  // exclude and include some atoms
  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(ATOM_COUNT/2)));
    std::set<int> excluded;
    excluded.insert(ATOM_COUNT/2);
    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT,excluded));
    CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
    CPPUNIT_ASSERT_EQUAL( (size_t)(ATOM_COUNT-1), testAtoms.size());
  }

  {
    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(ATOM_COUNT/2)));
    CPPUNIT_ASSERT_EQUAL( (size_t)1, testAtoms.size());
    CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtoms[0]->getId());
  }
}

/********************************************** Main routine **************************************/

int main(int argc, char **argv)
{
  // Get the top level suite from the registry
  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();

  // Adds the test to the list of test to run
  CppUnit::TextUi::TestRunner runner;
  runner.addTest( suite );

  // Change the default outputter to a compiler error format outputter
  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
                                                       std::cerr ) );
  // Run the tests.
  bool wasSucessful = runner.run();

  // Return error code 1 if the one of test failed.
  return wasSucessful ? 0 : 1;
};