Index: src/Graph/CheckAgainstAdjacencyFile.cpp
===================================================================
--- src/Graph/CheckAgainstAdjacencyFile.cpp	(revision 3501d220b42c41a509f1636a333c1770e161d572)
+++ src/Graph/CheckAgainstAdjacencyFile.cpp	(revision 06f41f3c956f559b0c681f2d22c237c2160d0f8d)
@@ -56,15 +56,13 @@
  */
 CheckAgainstAdjacencyFile::CheckAgainstAdjacencyFile(std::istream &File) :
-  status(true),
   NonMatchNumber(0)
 {
-  ParseInExternalMap(File);
+  bool status = ParseInInternalMap(File);
+  if (!status) // remove map if failed to parse
+    InternalAtomBondMap.clear();
 }
 
 CheckAgainstAdjacencyFile::~CheckAgainstAdjacencyFile()
-{
-  ExternalAtomBondMap.clear();
-  InternalAtomBondMap.clear();
-}
+{}
 
 /** Parses the bond partners of each atom from an external file into \a AtomBondMap.
@@ -73,5 +71,5 @@
  * @return true - everything ok, false - error while parsing
  */
-bool CheckAgainstAdjacencyFile::ParseInExternalMap(std::istream &File)
+bool CheckAgainstAdjacencyFile::ParseInInternalMap(std::istream &File)
 {
   if (File.fail()) {
@@ -80,5 +78,5 @@
   }
 
-  ExternalAtomBondMap.clear();
+  InternalAtomBondMap.clear();
   char buffer[MAXSTRINGSIZE];
   int tmp;
@@ -93,12 +91,11 @@
     if (AtomNr > 0) {
       const atom *Walker = World::getInstance().getAtom(AtomById(AtomNr-1));
-      ASSERT(Walker != NULL,
-          "CheckAgainstAdjacencyFile::ParseInExternalMap() - there is no atom with id "+toString(AtomNr-1)+".");
       if (Walker == NULL)
         return false;
+      const atomId_t WalkerId = Walker->getId();
       // parse bond partner ids associated to AtomNr
       while (line >> ws >> tmp) {
-        LOG(3, "INFO: Recognized bond partner " << tmp-1);
-        ExternalAtomBondMap.insert( std::make_pair(Walker->getId(), tmp-1) );
+        LOG(3, "INFO: Recognized bond partner " << tmp-1 << " for " << WalkerId << ".");
+        InternalAtomBondMap.insert( std::make_pair(WalkerId, tmp-1) );
       }
     } else {
@@ -114,16 +111,18 @@
 /** Fills the InternalAtomBondMap from the atoms given by the two iterators.
  *
- * @param AtomMapBegin iterator pointing to begin of map (think of World's SelectionIterator)
- * @param AtomMapEnd iterator pointing past end of map (think of World's SelectionIterator)
- */
-void CheckAgainstAdjacencyFile::CreateInternalMap(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd)
-{
-  InternalAtomBondMap.clear();
+ * @param atomids set of atomic ids to check (must be global ids, i.e. from atom::getId())
+ */
+void CheckAgainstAdjacencyFile::CreateExternalMap(const atomids_t &atomids)
+{
+  ExternalAtomBondMap.clear();
   // go through each atom in the list
-  for (World::AtomSet::const_iterator iter = AtomMapBegin; iter != AtomMapEnd; ++iter) {
-    const atom *Walker = iter->second;
-    const atomId_t WalkerId = Walker->getId();
+  for (atomids_t::const_iterator iter = atomids.begin(); iter != atomids.end(); ++iter) {
+    const atomId_t WalkerId = *iter;
     ASSERT(WalkerId != (size_t)-1,
-        "CheckAgainstAdjacencyFile::CreateInternalMap() - Walker has no id.");
+        "CheckAgainstAdjacencyFile::CreateExternalMap() - Walker has no id.");
+    const atom *Walker = World::getInstance().getAtom(AtomById(WalkerId));
+    ASSERT( Walker != NULL,
+        "CheckAgainstAdjacencyFile::CreateExternalMap() - Walker id "+toString(*iter)
+        +" is not associated to any of World's atoms.");
     const BondList& ListOfBonds = Walker->getListOfBonds();
     // go through each of its bonds
@@ -133,6 +132,6 @@
       const atomId_t id = (*Runner)->GetOtherAtom(Walker)->getId();
       ASSERT(id != (size_t)-1,
-          "CheckAgainstAdjacencyFile::CreateInternalMap() - OtherAtom has not id.");
-      InternalAtomBondMap.insert( std::make_pair(WalkerId, id) );
+          "CheckAgainstAdjacencyFile::CreateExternalMap() - OtherAtom has not id.");
+      ExternalAtomBondMap.insert( std::make_pair(WalkerId, id) );
     }
   }
@@ -142,15 +141,12 @@
  * \return true - structure is equal, false - not equivalence
  */
-bool CheckAgainstAdjacencyFile::operator()(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd)
-{
-  LOG(0, "STATUS: Looking at bond structure stored in adjacency file and comparing to present one ... ");
-
-  bool status = true;
-
-  if (InternalAtomBondMap.empty())
-    CreateInternalMap(AtomMapBegin, AtomMapEnd);
-
-  status = status && CompareInternalExternalMap();
-
+bool CheckAgainstAdjacencyFile::operator()(const atomids_t &atomids)
+{
+  LOG(0, "STATUS: Looking at bond structure of given ids and comparing against stored in adjacency file... ");
+
+  // parse in external map
+  CreateExternalMap(atomids);
+
+  bool status = CompareInternalExternalMap();
   if (status) { // if equal we parse the KeySetFile
     LOG(0, "STATUS: Equal.");
@@ -182,20 +178,26 @@
 }
 
-/** Counts the number of mismatching items in each set.
- *
- * @param firstset first set
- * @param secondset second set
- * @return number of items that don't match between first and second set
+/** Counts the number of items in the second set not present in the first set.
+ *
+ * \note We assume that the sets are sorted.
+ *
+ * @param firstset check set
+ * @param secondset reference set
+ * @return number of items in the first set that are missing in the second
  */
 template <class T>
-size_t getMismatchingItems(const T &firstset, const T &secondset)
+size_t getMissingItems(const T &firstset, const T &secondset)
 {
   size_t Mismatch = 0;
   typename T::const_iterator firstiter = firstset.begin();
   typename T::const_iterator seconditer = secondset.begin();
-  for (; (firstiter != firstset.end()) && (seconditer != secondset.end());
-      ++firstiter, ++seconditer) {
-    if (*firstiter != *seconditer)
-      ++Mismatch;
+  for (; (firstiter != firstset.end()) && (seconditer != secondset.end());) {
+    if (*firstiter > *seconditer)
+      ++seconditer;
+    else {
+      if (*firstiter < *seconditer)
+        ++Mismatch;
+      ++firstiter;
+    }
   }
   return Mismatch;
@@ -209,10 +211,4 @@
 {
   NonMatchNumber = 0;
-  // check whether sizes match
-  if (ExternalAtomBondMap.size() != InternalAtomBondMap.size()) {
-    NonMatchNumber = abs((int)ExternalAtomBondMap.size() - (int)InternalAtomBondMap.size());
-    LOG(2, "INFO: " << NonMatchNumber << " entries don't match.");
-    return false;
-  }
   // extract keys and check whether they match
   const AtomBondRange Intrange(InternalAtomBondMap.begin(), InternalAtomBondMap.end());
@@ -225,13 +221,12 @@
 
   // check for same amount of keys
-  if (InternalKeys.size() != ExternalKeys.size()) {
-    NonMatchNumber = abs((int)ExternalKeys.size() - (int)InternalKeys.size());
-    LOG(2, "INFO: Number of keys don't match: "
-        << InternalKeys.size() << " != " << ExternalKeys.size());
-    return false;
-  }
-
-  // check items against one another
-  NonMatchNumber = getMismatchingItems(InternalKeys, ExternalKeys);
+  if (ExternalKeys.size() > InternalKeys.size()) {
+    NonMatchNumber = (int)ExternalKeys.size() - (int)InternalKeys.size();
+    LOG(2, "INFO: Number of external keys exceeds internal one by " << NonMatchNumber << ".");
+    return false;
+  }
+
+  // check which keys are missing in the internal set
+  NonMatchNumber = getMissingItems(ExternalKeys, InternalKeys);
 
   if (NonMatchNumber != 0) {
@@ -241,6 +236,6 @@
 
   // now check each map per key
-  for (KeysSet::const_iterator keyIter = InternalKeys.begin();
-      keyIter != InternalKeys.end();
+  for (KeysSet::const_iterator keyIter = ExternalKeys.begin();
+      keyIter != ExternalKeys.end();
       ++keyIter) {
 //    std::cout << "Current key is " << *keyIter << std::endl;
@@ -249,7 +244,16 @@
     ValuesSet InternalValues( getValues(IntRange) );
     ValuesSet ExternalValues( getValues(ExtRange) );
+    // throw out all values not present in ExternalKeys
+    ValuesSet ExternalValues_temp( ExternalValues );
+    for(KeysSet::const_iterator iter = ExternalKeys.begin();
+        iter != ExternalKeys.end(); ++iter)
+      ExternalValues_temp.erase(*iter);
+    // all remaining values must be masked out
+    for (ValuesSet::const_iterator iter = ExternalValues_temp.begin();
+        iter != ExternalValues_temp.end(); ++iter)
+      ExternalValues.erase(*iter);
 //    std::cout << "InternalValues: " << InternalValues << std::endl;
 //    std::cout << "ExternalValues: " << ExternalValues << std::endl;
-    NonMatchNumber += getMismatchingItems(InternalValues, ExternalValues);
+    NonMatchNumber += getMissingItems(ExternalValues, InternalValues);
   }
   if (NonMatchNumber != 0) {
Index: src/Graph/CheckAgainstAdjacencyFile.hpp
===================================================================
--- src/Graph/CheckAgainstAdjacencyFile.hpp	(revision 3501d220b42c41a509f1636a333c1770e161d572)
+++ src/Graph/CheckAgainstAdjacencyFile.hpp	(revision 06f41f3c956f559b0c681f2d22c237c2160d0f8d)
@@ -23,4 +23,10 @@
 class atom;
 
+/** This class contains the bond structure inside an internal map of atoms which
+ * each bond neighbor parsed from an external file.
+ *
+ * We may compare a subset of atoms against this internal bond structure. It is
+ * true it is a true subset of the bond structure.
+ */
 class CheckAgainstAdjacencyFile
 {
@@ -31,5 +37,7 @@
   ~CheckAgainstAdjacencyFile();
 
-  bool operator()(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd);
+  typedef std::vector<atomId_t> atomids_t;
+
+  bool operator()(const atomids_t &atoms);
 
 private:
@@ -41,5 +49,4 @@
   AtomBondMap InternalAtomBondMap;
   AtomBondMap ExternalAtomBondMap;
-  bool status;
   int NonMatchNumber;
 
@@ -47,6 +54,6 @@
   ValuesSet getValues(const AtomBondRange&_range) const;
 
-  void CreateInternalMap(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd);
-  bool ParseInExternalMap(std::istream &File);
+  void CreateExternalMap(const atomids_t &atoms);
+  bool ParseInInternalMap(std::istream &File);
   bool CompareInternalExternalMap();
 };
Index: src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp
===================================================================
--- src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp	(revision 3501d220b42c41a509f1636a333c1770e161d572)
+++ src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp	(revision 06f41f3c956f559b0c681f2d22c237c2160d0f8d)
@@ -39,6 +39,9 @@
 #include <cppunit/ui/text/TestRunner.h>
 
+#include <boost/lambda/lambda.hpp>
 #include <iostream>
-#include <string>
+#include <iterator>
+#include <iostream>
+#include <vector>
 
 #include "CodePatterns/Assert.hpp"
@@ -76,6 +79,6 @@
 static std::string wrongadjacencyfile1 ="\
 1 2\n\
-2 1 3\n\
-4 3 5\n\
+2 1\n\
+4 5\n\
 5 4 6\n\
 6 5 7\n\
@@ -98,4 +101,17 @@
 11 10";
 
+static std::string wrongadjacencyfile3 ="\
+1 2\n\
+2 1 3\n\
+3 2 4\n\
+4 3 5\n\
+5 4 7\n\
+6\n\
+7 5 8\n\
+8 7 9\n\
+9 8 10\n\
+10 9 11\n\
+11 10";
+
 // set up and tear down
 void CheckAgainstAdjacencyFileTest::setUp()
@@ -110,14 +126,16 @@
   CPPUNIT_ASSERT(TestMolecule != NULL);
   for(int i=0;i<ATOM_COUNT;++i){
-    atoms[i]= World::getInstance().createAtom();
-    CPPUNIT_ASSERT(atoms[i] != NULL);
-    atoms[i]->setType(hydrogen);
-    TestMolecule->AddAtom(atoms[i]);
-    atomIds[i]= atoms[i]->getId();
-  }
+    atom *_atom = World::getInstance().createAtom();
+    CPPUNIT_ASSERT(_atom != NULL);
+    _atom->setType(hydrogen);
+    TestMolecule->AddAtom(_atom);
+    atoms.push_back(_atom);
+    atomIds.push_back(_atom->getId());
+  }
+  CPPUNIT_ASSERT_EQUAL( (size_t)ATOM_COUNT, atoms.size());
+  CPPUNIT_ASSERT_EQUAL( (size_t)ATOM_COUNT, atomIds.size());
   // create linear chain
-  for(int i=0;i<ATOM_COUNT-1;++i){
+  for(int i=0;i<ATOM_COUNT-1;++i)
     atoms[i]->addBond(WorldTime::getTime(), atoms[i+1]);
-  }
 
   // create map as it should be
@@ -143,23 +161,49 @@
 }
 
-/** Unit tests for CheckAgainstAdjacencyFile::CreateInternalMap().
- *
- */
-void CheckAgainstAdjacencyFileTest::CreateInternalMapTest()
+/** Unit tests for CheckAgainstAdjacencyFile::CreateExternalMap().
+ *
+ */
+void CheckAgainstAdjacencyFileTest::CreateExternalMapTest()
 {
   std::stringstream input;
   CheckAgainstAdjacencyFile fileChecker(input);
-  World::getInstance().selectAllAtoms(AllAtoms());
-  const World &world = World::getInstance();
-  fileChecker.CreateInternalMap(world.beginAtomSelection(), world.endAtomSelection());
+  fileChecker.CreateExternalMap(atomIds);
 
   // check size (it's 8*2 + 2*1 = 18 keys)
+  CPPUNIT_ASSERT_EQUAL( (size_t)18, fileChecker.ExternalAtomBondMap.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)0, fileChecker.InternalAtomBondMap.size() );
+
+  // check equality
+  CPPUNIT_ASSERT( comparisonMap.size() == fileChecker.ExternalAtomBondMap.size() );
+//  std::cout << "comparisonMap: " << comparisonMap << std::endl;
+//  std::cout << "fileChecker.InternalAtomBondMap: " << fileChecker.InternalAtomBondMap << std::endl;
+  CPPUNIT_ASSERT( comparisonMap == fileChecker.ExternalAtomBondMap );
+
+  // check non-equality: more
+  comparisonMap.insert( std::make_pair( (atomId_t)10, (atomId_t)8) );
+  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
+  comparisonMap.erase((atomId_t)10);
+
+  // check non-equality: less
+  comparisonMap.erase((atomId_t)9);
+  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
+}
+
+/** Unit tests for CheckAgainstAdjacencyFile::ParseInInternalMap().
+ *
+ */
+void CheckAgainstAdjacencyFileTest::ParseInInternalMapTest()
+{
+  std::stringstream input(adjacencyfile);
+  CheckAgainstAdjacencyFile fileChecker(input);
+  std::vector<atomId_t> noids;
+  fileChecker.CreateExternalMap(noids);
+
+  // check size (it's 8*2 + 2*1 = 18 keys)
+  CPPUNIT_ASSERT_EQUAL( (size_t)0, fileChecker.ExternalAtomBondMap.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)18, fileChecker.InternalAtomBondMap.size() );
-  CPPUNIT_ASSERT_EQUAL( (size_t)0, fileChecker.ExternalAtomBondMap.size() );
 
   // check equality
   CPPUNIT_ASSERT( comparisonMap.size() == fileChecker.InternalAtomBondMap.size() );
-//  std::cout << "comparisonMap: " << comparisonMap << std::endl;
-//  std::cout << "fileChecker.InternalAtomBondMap: " << fileChecker.InternalAtomBondMap << std::endl;
   CPPUNIT_ASSERT( comparisonMap == fileChecker.InternalAtomBondMap );
 
@@ -174,32 +218,4 @@
 }
 
-/** Unit tests for CheckAgainstAdjacencyFile::ParseInExternalMap().
- *
- */
-void CheckAgainstAdjacencyFileTest::ParseInExternalMapTest()
-{
-  std::stringstream input(adjacencyfile);
-  World::getInstance().selectAllAtoms(NoAtoms());
-  CheckAgainstAdjacencyFile fileChecker(input);
-  fileChecker.CreateInternalMap(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection());
-
-  // check size (it's 8*2 + 2*1 = 18 keys)
-  CPPUNIT_ASSERT_EQUAL( (size_t)0, fileChecker.InternalAtomBondMap.size() );
-  CPPUNIT_ASSERT_EQUAL( (size_t)18, fileChecker.ExternalAtomBondMap.size() );
-
-  // check equality
-  CPPUNIT_ASSERT( comparisonMap.size() == fileChecker.ExternalAtomBondMap.size() );
-  CPPUNIT_ASSERT( comparisonMap == fileChecker.ExternalAtomBondMap );
-
-  // check non-equality: more
-  comparisonMap.insert( std::make_pair( (atomId_t)10, (atomId_t)8) );
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
-  comparisonMap.erase((atomId_t)10);
-
-  // check non-equality: less
-  comparisonMap.erase((atomId_t)9);
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
-}
-
 /** Unit tests for CheckAgainstAdjacencyFile::CompareInternalExternalMap().
  *
@@ -210,16 +226,15 @@
   CheckAgainstAdjacencyFile fileChecker(input);
 
-  // assert non-equality before parsing
-  CPPUNIT_ASSERT( fileChecker.InternalAtomBondMap.size() != fileChecker.ExternalAtomBondMap.size() );
-  CPPUNIT_ASSERT( fileChecker.InternalAtomBondMap != fileChecker.ExternalAtomBondMap );
-  CPPUNIT_ASSERT( !fileChecker.CompareInternalExternalMap() );
-
-  // parse
-  World::getInstance().selectAllAtoms(AllAtoms());
-  fileChecker.CreateInternalMap(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection());
+  // assert equality before parsing (empty sets should always return true)
+  CPPUNIT_ASSERT( fileChecker.ExternalAtomBondMap.size() != fileChecker.InternalAtomBondMap.size() );
+  CPPUNIT_ASSERT( fileChecker.ExternalAtomBondMap != fileChecker.InternalAtomBondMap );
+  CPPUNIT_ASSERT( fileChecker.CompareInternalExternalMap() );
+
+  // parse in external map
+  fileChecker.CreateExternalMap(atomIds);
 
   // assert equality after parsing
-  CPPUNIT_ASSERT_EQUAL( fileChecker.InternalAtomBondMap.size(), fileChecker.ExternalAtomBondMap.size() );
-  CPPUNIT_ASSERT_EQUAL( fileChecker.InternalAtomBondMap, fileChecker.ExternalAtomBondMap );
+  CPPUNIT_ASSERT_EQUAL( fileChecker.ExternalAtomBondMap.size(), fileChecker.InternalAtomBondMap.size() );
+  CPPUNIT_ASSERT_EQUAL( fileChecker.ExternalAtomBondMap, fileChecker.InternalAtomBondMap );
   CPPUNIT_ASSERT( fileChecker.CompareInternalExternalMap() );
 }
@@ -230,27 +245,37 @@
 void CheckAgainstAdjacencyFileTest::operatorTest()
 {
-  World::getInstance().selectAllAtoms(AllAtoms());
   {
     // parse right
     std::stringstream input(adjacencyfile);
     CheckAgainstAdjacencyFile fileChecker(input);
-    CPPUNIT_ASSERT( fileChecker(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection()) );
-  }
-  {
-    // parse wrong1
+    CPPUNIT_ASSERT( fileChecker(atomIds) );
+  }
+  {
+    // parse wrong1 (more atoms in the world than in file, hence wrong)
     std::stringstream input(wrongadjacencyfile1);
     CheckAgainstAdjacencyFile fileChecker(input);
-    CPPUNIT_ASSERT( !fileChecker(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection()) );
-  }
-  {
-    // parse wrong2 (there is no atom 10)
+    CPPUNIT_ASSERT( !fileChecker(atomIds) );
+  }
+  {
+    // remove third atom (index starts at 0) and test for equality then
+    std::vector<atomId_t> validids;
+    std::remove_copy_if(atomIds.begin(), atomIds.end(), std::back_inserter(validids), boost::lambda::_1 == (atomId_t)2);
+    CPPUNIT_ASSERT_EQUAL( (size_t)ATOM_COUNT-1, validids.size() );
+    // parse wrong1 (more atoms in the world than in file, hence wrong)
+    std::stringstream input(wrongadjacencyfile1);
+    CheckAgainstAdjacencyFile fileChecker(input);
+    CPPUNIT_ASSERT( fileChecker(validids) );
+  }
+  {
+    // parse wrong2 (there is no atom 10, but present in file. hence true)
     std::stringstream input(wrongadjacencyfile2);
-#ifndef NDEBUG
-    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-    CPPUNIT_ASSERT_THROW( CheckAgainstAdjacencyFile fileChecker(input), Assert::AssertionFailure );
-#else
-    CheckAgainstAdjacencyFile fileChecker(input);
-    CPPUNIT_ASSERT( !fileChecker(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection()) );
-#endif
-  }
-}
+    CheckAgainstAdjacencyFile fileChecker(input);
+    CPPUNIT_ASSERT( !fileChecker(atomIds) );
+  }
+  {
+    // parse wrong3 (6 is not connected)
+    std::stringstream input(wrongadjacencyfile3);
+    CheckAgainstAdjacencyFile fileChecker(input);
+    CPPUNIT_ASSERT( !fileChecker(atomIds) );
+  }
+}
Index: src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp
===================================================================
--- src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp	(revision 3501d220b42c41a509f1636a333c1770e161d572)
+++ src/Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp	(revision 06f41f3c956f559b0c681f2d22c237c2160d0f8d)
@@ -30,6 +30,6 @@
 {
   CPPUNIT_TEST_SUITE( CheckAgainstAdjacencyFileTest );
-  CPPUNIT_TEST ( CreateInternalMapTest );
-  CPPUNIT_TEST ( ParseInExternalMapTest );
+  CPPUNIT_TEST ( CreateExternalMapTest );
+  CPPUNIT_TEST ( ParseInInternalMapTest );
   CPPUNIT_TEST ( CompareInternalExternalMapTest );
   CPPUNIT_TEST ( operatorTest );
@@ -40,6 +40,6 @@
   void tearDown();
 
-  void CreateInternalMapTest();
-  void ParseInExternalMapTest();
+  void CreateExternalMapTest();
+  void ParseInInternalMapTest();
   void CompareInternalExternalMapTest();
   void operatorTest();
@@ -47,6 +47,6 @@
 private:
   CheckAgainstAdjacencyFile::AtomBondMap comparisonMap;
-  atom *atoms [ATOM_COUNT];
-  atomId_t atomIds [ATOM_COUNT];
+  std::vector<atom *> atoms;
+  std::vector<atomId_t> atomIds;
   molecule * TestMolecule;
 };
