Index: src/Graph/AdjacencyList.cpp
===================================================================
--- src/Graph/AdjacencyList.cpp	(revision 5197e543aadb7e0a5343495b6e246005819cd457)
+++ src/Graph/AdjacencyList.cpp	(revision 4694df82c685e4d9f1a22a75eb0c1355964be59f)
@@ -55,10 +55,20 @@
  * \param File file to parser
  */
-AdjacencyList::AdjacencyList(std::istream &File) :
-  NonMatchNumber(0)
-{
-  bool status = ParseIntoMap(File, InternalAtomBondMap);
+AdjacencyList::AdjacencyList(std::istream &File)
+{
+  bool status = ParseFromFile(File);
+  ASSERT( status,
+      "AdjacencyList::AdjacencyList() - File's contents was nor parsable");
   if (!status) // remove map if failed to parse
-    InternalAtomBondMap.clear();
+    atombondmap.clear();
+}
+
+/** Constructor of class AdjacencyList.
+ *
+ * \param File file to parser
+ */
+AdjacencyList::AdjacencyList(const atomids_t &atomids)
+{
+  CreateMap(atomids);
 }
 
@@ -66,11 +76,10 @@
 {}
 
-/** Parses the bond partners of each atom from an external file into \a atombondmap.
+/** Parses the bond partners of each atom from an external file into AdjacencyList::atombondmap.
  *
  * @param File file to parse
- * @param &atombondmap map to parse into
  * @return true - everything ok, false - error while parsing
  */
-bool AdjacencyList::ParseIntoMap(std::istream &File, AtomBondMap &atombondmap)
+bool AdjacencyList::ParseFromFile(std::istream &File)
 {
   if (File.fail()) {
@@ -83,5 +92,5 @@
   int tmp;
   // Parse the file line by line and count the bonds
-  while (!File.eof()) {
+  while (File.good()) {
     File.getline(buffer, MAXSTRINGSIZE);
     stringstream line;
@@ -91,8 +100,5 @@
     // parse into structure
     if (AtomNr > 0) {
-      const atom *Walker = World::getInstance().getAtom(AtomById(AtomNr-1));
-      if (Walker == NULL)
-        return false;
-      const atomId_t WalkerId = Walker->getId();
+      const atomId_t WalkerId = AtomNr-1;
       // parse bond partner ids associated to AtomNr
       while (line >> ws >> tmp) {
@@ -110,12 +116,12 @@
 }
 
-/** Fills the InternalAtomBondMap from the atoms given by the two iterators.
- *
- * @param &atombondmap map to create
+/** Fills the AdjacencyList::atombondmap from the atoms given by the two iterators.
+ *
  * @param atomids set of atomic ids to check (must be global ids, i.e. from atom::getId())
  */
-void AdjacencyList::CreateMap(const atomids_t &atomids, AtomBondMap &atombondmap)
+void AdjacencyList::CreateMap(atomids_t atomids)
 {
   atombondmap.clear();
+  std::sort(atomids.begin(), atomids.end());
   // go through each atom in the list
   for (atomids_t::const_iterator iter = atomids.begin(); iter != atomids.end(); ++iter) {
@@ -135,25 +141,8 @@
       ASSERT(id != (size_t)-1,
           "AdjacencyList::CreateMap() - OtherAtom has not id.");
-      atombondmap.insert( std::make_pair(WalkerId, id) );
-    }
-  }
-}
-
-/** Checks contents of adjacency file against bond structure in structure molecule.
- * \return true - structure is equal, false - not equivalence
- */
-bool AdjacencyList::CheckAgainstSubset(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
-  CreateMap(atomids, ExternalAtomBondMap);
-
-  bool status = CompareInternalExternalMap();
-  if (status) { // if equal we parse the KeySetFile
-    LOG(0, "STATUS: Equal.");
-  } else
-    LOG(0, "STATUS: Not equal by " << NonMatchNumber << " atoms.");
-  return status;
+      if (std::binary_search(atomids.begin(), atomids.end(), id))
+        atombondmap.insert( std::make_pair(WalkerId, id) );
+    }
+  }
 }
 
@@ -206,14 +195,16 @@
 }
 
-/** Compares InternalAtomBondMap and ExternalAtomBondMap and sets NonMatchNumber.
- *
- * @return true - both maps are the same, false - both maps diverge by NonMatchNumber counts.
- */
-bool AdjacencyList::CompareInternalExternalMap()
-{
-  NonMatchNumber = 0;
+/** Compares whether AdjacencyList::atombondmap in this instance is a subset of
+ * the one in \a other.
+ *
+ * @param other other instance of an adjacency list to compare against
+ * @return true - this atombondmap is subset, false - else
+ */
+bool AdjacencyList::operator<(const AdjacencyList &other) const
+{
+  int NonMatchNumber = 0;
   // extract keys and check whether they match
-  const AtomBondRange Intrange(InternalAtomBondMap.begin(), InternalAtomBondMap.end());
-  const AtomBondRange Extrange(ExternalAtomBondMap.begin(), ExternalAtomBondMap.end());
+  const AtomBondRange Intrange(atombondmap.begin(), atombondmap.end());
+  const AtomBondRange Extrange(other.atombondmap.begin(), other.atombondmap.end());
   KeysSet InternalKeys( getKeys(Intrange) );
   KeysSet ExternalKeys( getKeys(Extrange) );
@@ -222,13 +213,13 @@
 //  std::cout << "ExternalKeys: " << ExternalKeys << std::endl;
 
-  // check for same amount of keys
-  if (ExternalKeys.size() > InternalKeys.size()) {
-    NonMatchNumber = (int)ExternalKeys.size() - (int)InternalKeys.size();
-    LOG(2, "INFO: Number of external keys exceeds internal one by " << NonMatchNumber << ".");
+  // check amount of keys
+  if (ExternalKeys.size() < InternalKeys.size()) {
+    NonMatchNumber = (int)InternalKeys.size() - (int)ExternalKeys.size();
+    LOG(2, "INFO: Number of internal keys exceeds external one by " << NonMatchNumber << ".");
     return false;
   }
 
   // check which keys are missing in the internal set
-  NonMatchNumber = getMissingItems(ExternalKeys, InternalKeys);
+  NonMatchNumber = getMissingItems(InternalKeys, ExternalKeys);
 
   if (NonMatchNumber != 0) {
@@ -238,16 +229,16 @@
 
   // now check each map per key
-  for (KeysSet::const_iterator keyIter = ExternalKeys.begin();
-      keyIter != ExternalKeys.end();
+  for (KeysSet::const_iterator keyIter = InternalKeys.begin();
+      keyIter != InternalKeys.end();
       ++keyIter) {
 //    std::cout << "Current key is " << *keyIter << std::endl;
-    const AtomBondRange IntRange( InternalAtomBondMap.equal_range(*keyIter) );
-    const AtomBondRange ExtRange( ExternalAtomBondMap.equal_range(*keyIter) );
+    const AtomBondRange IntRange( atombondmap.equal_range(*keyIter) );
+    const AtomBondRange ExtRange( other.atombondmap.equal_range(*keyIter) );
     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)
+    for(KeysSet::const_iterator iter = InternalKeys.begin();
+        iter != InternalKeys.end(); ++iter)
       ExternalValues_temp.erase(*iter);
     // all remaining values must be masked out
@@ -257,5 +248,5 @@
 //    std::cout << "InternalValues: " << InternalValues << std::endl;
 //    std::cout << "ExternalValues: " << ExternalValues << std::endl;
-    NonMatchNumber += getMissingItems(ExternalValues, InternalValues);
+    NonMatchNumber += getMissingItems(InternalValues, ExternalValues);
   }
   if (NonMatchNumber != 0) {
@@ -267,2 +258,36 @@
   }
 }
+
+/** Storing the bond structure of a molecule to file.
+ * Simply stores Atom::Nr and then the Atom::Nr of all bond partners per line.
+ * @param File output stream to write to
+ * \return true - file written successfully, false - writing failed
+ */
+bool AdjacencyList::StoreToFile(std::ostream &File) const
+{
+  bool status = true;
+  std::stringstream output;
+  output << "Saving adjacency list ... ";
+  if (!File.bad()) {
+    //File << "m\tn" << endl;
+    AtomBondMap::const_iterator advanceiter = atombondmap.begin();
+    for (AtomBondMap::const_iterator iter = atombondmap.begin();
+        iter != atombondmap.end();
+        iter = advanceiter) {
+      advanceiter = atombondmap.upper_bound(iter->first);
+      File << iter->first+1;
+      for (AtomBondMap::const_iterator adjacencyiter = iter;
+          adjacencyiter != advanceiter;
+          ++adjacencyiter)
+        File << " " << adjacencyiter->second+1;
+      File << std::endl;
+    }
+    output << "done.";
+  } else {
+    output << "given stream is not good.";
+    status = false;
+  }
+  LOG(1, output.str());
+
+  return status;
+}
Index: src/Graph/AdjacencyList.hpp
===================================================================
--- src/Graph/AdjacencyList.hpp	(revision 5197e543aadb7e0a5343495b6e246005819cd457)
+++ src/Graph/AdjacencyList.hpp	(revision 4694df82c685e4d9f1a22a75eb0c1355964be59f)
@@ -37,9 +37,43 @@
   typedef std::vector<atomId_t> atomids_t;
 
+  /** Default constructor for class AdjacencyList.
+   *
+   * We simply have an empty adjacency list here.
+   */
+  AdjacencyList() {}
   AdjacencyList(std::istream &File);
   AdjacencyList(const atomids_t &atoms);
   ~AdjacencyList();
 
-  bool CheckAgainstSubset(const atomids_t &atoms);
+  bool operator<(const AdjacencyList &other) const;
+
+  /** Comparison operator whether this adjacency list is a subset of \a other.
+   *
+   * @return true - is subset, false - is not subset
+   */
+  bool operator>(const AdjacencyList &other) const {
+    return other < *this;
+  }
+  /** Equality operator, determines whether both adjacencies are the same.
+   *
+   * @return true - both are the same, false - at least one is not a subset of the other
+   */
+  bool operator==(const AdjacencyList &other) const {
+    return (other < *this) && (*this < other);
+  }
+  /** Inquality operator, determines whether both adjacencies are not equal.
+   *
+   * @return true - both are not equal, false - both are the subset of one another
+   */
+  bool operator!=(const AdjacencyList &other) const {
+    return !(*this == other);
+  }
+
+  /** Stores the adjacency contained in this instance to file.
+   *
+   * @param File stream to write to
+   * @return true - File is good, false - else
+   */
+  bool StoreToFile(std::ostream &File) const;
 
 private:
@@ -49,14 +83,11 @@
   typedef std::multimap< atomId_t, atomId_t > AtomBondMap;
   typedef std::pair<AtomBondMap::const_iterator, AtomBondMap::const_iterator> AtomBondRange;
-  AtomBondMap InternalAtomBondMap;
-  AtomBondMap ExternalAtomBondMap;
-  int NonMatchNumber;
+  AtomBondMap atombondmap;
 
   KeysSet getKeys(const AtomBondRange &_range) const;
   ValuesSet getValues(const AtomBondRange&_range) const;
 
-  void CreateMap(const atomids_t &atoms, AtomBondMap &atombondmap);
-  bool ParseIntoMap(std::istream &File, AtomBondMap &atombondmap);
-  bool CompareInternalExternalMap();
+  void CreateMap(atomids_t atoms);
+  bool ParseFromFile(std::istream &File);
 };
 
Index: src/Graph/unittests/AdjacencyListUnitTest.cpp
===================================================================
--- src/Graph/unittests/AdjacencyListUnitTest.cpp	(revision 5197e543aadb7e0a5343495b6e246005819cd457)
+++ src/Graph/unittests/AdjacencyListUnitTest.cpp	(revision 4694df82c685e4d9f1a22a75eb0c1355964be59f)
@@ -65,5 +65,5 @@
 CPPUNIT_TEST_SUITE_REGISTRATION( AdjacencyListTest );
 
-static std::string adjacencyfile ="\
+const std::string adjacencyfile ="\
 1 2\n\
 2 1 3\n\
@@ -77,5 +77,5 @@
 10 9\n";
 
-static std::string wrongadjacencyfile1 ="\
+const std::string wrongadjacencyfile1 ="\
 1 2\n\
 2 1\n\
@@ -88,5 +88,5 @@
 10 9\n";
 
-static std::string wrongadjacencyfile2 ="\
+const std::string wrongadjacencyfile2 ="\
 1 2\n\
 2 1 3\n\
@@ -99,7 +99,7 @@
 9 8 10\n\
 10 9 11\n\
-11 10";
-
-static std::string wrongadjacencyfile3 ="\
+11 10\n";
+
+const std::string wrongadjacencyfile3 ="\
 1 2\n\
 2 1 3\n\
@@ -111,6 +111,5 @@
 8 7 9\n\
 9 8 10\n\
-10 9 11\n\
-11 10";
+10 9\n";
 
 // set up and tear down
@@ -167,25 +166,25 @@
 {
   std::stringstream input;
-  AdjacencyList fileChecker(input);
-  fileChecker.CreateMap(atomIds, fileChecker.ExternalAtomBondMap);
+  AdjacencyList FileAdjacency(input);
+  AdjacencyList WorldAdjacency(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() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)18, WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)0, FileAdjacency.atombondmap.size() );
 
   // check equality
-  CPPUNIT_ASSERT( comparisonMap.size() == fileChecker.ExternalAtomBondMap.size() );
+  CPPUNIT_ASSERT( comparisonMap.size() == WorldAdjacency.atombondmap.size() );
 //  std::cout << "comparisonMap: " << comparisonMap << std::endl;
-//  std::cout << "fileChecker.InternalAtomBondMap: " << fileChecker.InternalAtomBondMap << std::endl;
-  CPPUNIT_ASSERT( comparisonMap == fileChecker.ExternalAtomBondMap );
+//  std::cout << "WorldAdjacency.atombondmap: " << WorldAdjacency.atombondmap << std::endl;
+  CPPUNIT_ASSERT( comparisonMap == WorldAdjacency.atombondmap );
 
   // check non-equality: more
   comparisonMap.insert( std::make_pair( (atomId_t)10, (atomId_t)8) );
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
+  CPPUNIT_ASSERT( comparisonMap != WorldAdjacency.atombondmap );
   comparisonMap.erase((atomId_t)10);
 
   // check non-equality: less
   comparisonMap.erase((atomId_t)9);
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.ExternalAtomBondMap );
+  CPPUNIT_ASSERT( comparisonMap != WorldAdjacency.atombondmap );
 }
 
@@ -196,46 +195,93 @@
 {
   std::stringstream input(adjacencyfile);
-  AdjacencyList fileChecker(input);
-  std::vector<atomId_t> noids;
-  fileChecker.CreateMap(noids, fileChecker.ExternalAtomBondMap);
+  AdjacencyList FileAdjacency(input);
+  AdjacencyList WorldAdjacency;
 
   // 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, WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)18, FileAdjacency.atombondmap.size() );
 
   // check equality
-  CPPUNIT_ASSERT( comparisonMap.size() == fileChecker.InternalAtomBondMap.size() );
-  CPPUNIT_ASSERT( comparisonMap == fileChecker.InternalAtomBondMap );
+  CPPUNIT_ASSERT( comparisonMap.size() == FileAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT( comparisonMap == FileAdjacency.atombondmap );
 
   // check non-equality: more
   comparisonMap.insert( std::make_pair( (atomId_t)10, (atomId_t)8) );
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.InternalAtomBondMap );
+  CPPUNIT_ASSERT( comparisonMap != FileAdjacency.atombondmap );
   comparisonMap.erase((atomId_t)10);
 
   // check non-equality: less
   comparisonMap.erase((atomId_t)9);
-  CPPUNIT_ASSERT( comparisonMap != fileChecker.InternalAtomBondMap );
-}
-
-/** Unit tests for AdjacencyList::CompareInternalExternalMap().
- *
- */
-void AdjacencyListTest::CompareInternalExternalMapTest()
+  CPPUNIT_ASSERT( comparisonMap != FileAdjacency.atombondmap );
+}
+
+/** Unit tests for AdjacencyList::StoreToFile().
+ *
+ */
+void AdjacencyListTest::StoreToFileTest()
 {
   std::stringstream input(adjacencyfile);
-  AdjacencyList fileChecker(input);
+  AdjacencyList FileAdjacency(input);
+
+  // check size (it's 8*2 + 2*1 = 18 keys)
+  CPPUNIT_ASSERT_EQUAL( (size_t)18, FileAdjacency.atombondmap.size() );
+
+  // store to file
+  std::stringstream output;
+  FileAdjacency.StoreToFile(output);
+  CPPUNIT_ASSERT_EQUAL( input.str(), output.str() );
+}
+
+/** Unit tests for AdjacencyList::operator<().
+ *
+ */
+void AdjacencyListTest::operatorGreaterLessTest()
+{
+  std::stringstream input(adjacencyfile);
+  AdjacencyList FileAdjacency(input);
+  AdjacencyList WorldAdjacency;
+
+  // assert empty set is subset of some filled set (empty sets should always return true)
+  CPPUNIT_ASSERT( FileAdjacency.atombondmap.size() != WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT( FileAdjacency.atombondmap != WorldAdjacency.atombondmap );
+  CPPUNIT_ASSERT( WorldAdjacency < FileAdjacency );
+  CPPUNIT_ASSERT( !(WorldAdjacency > FileAdjacency) );
+
+  // parse in external map
+  WorldAdjacency.CreateMap(atomIds);
+
+  // assert equality after parsing
+  CPPUNIT_ASSERT_EQUAL( FileAdjacency.atombondmap.size(), WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT_EQUAL( FileAdjacency.atombondmap, WorldAdjacency.atombondmap );
+  CPPUNIT_ASSERT( WorldAdjacency < FileAdjacency );
+  CPPUNIT_ASSERT( WorldAdjacency > FileAdjacency );
+
+  // remove one entry from the world
+  WorldAdjacency.atombondmap.erase((atomId_t)9);
+  CPPUNIT_ASSERT( WorldAdjacency < FileAdjacency );
+  CPPUNIT_ASSERT( !(WorldAdjacency > FileAdjacency) );
+}
+
+/** Unit tests for AdjacencyList::operator==().
+ *
+ */
+void AdjacencyListTest::operatorEqualTest()
+{
+  std::stringstream input(adjacencyfile);
+  AdjacencyList FileAdjacency(input);
+  AdjacencyList WorldAdjacency;
 
   // 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() );
+  CPPUNIT_ASSERT( FileAdjacency.atombondmap.size() != WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT( FileAdjacency.atombondmap != WorldAdjacency.atombondmap );
+  CPPUNIT_ASSERT( WorldAdjacency != FileAdjacency );
 
   // parse in external map
-  fileChecker.CreateMap(atomIds, fileChecker.ExternalAtomBondMap);
+  WorldAdjacency.CreateMap(atomIds);
 
   // assert equality after parsing
-  CPPUNIT_ASSERT_EQUAL( fileChecker.ExternalAtomBondMap.size(), fileChecker.InternalAtomBondMap.size() );
-  CPPUNIT_ASSERT_EQUAL( fileChecker.ExternalAtomBondMap, fileChecker.InternalAtomBondMap );
-  CPPUNIT_ASSERT( fileChecker.CompareInternalExternalMap() );
+  CPPUNIT_ASSERT_EQUAL( FileAdjacency.atombondmap.size(), WorldAdjacency.atombondmap.size() );
+  CPPUNIT_ASSERT_EQUAL( FileAdjacency.atombondmap, WorldAdjacency.atombondmap );
+  CPPUNIT_ASSERT( WorldAdjacency == FileAdjacency );
 }
 
@@ -245,15 +291,16 @@
 void AdjacencyListTest::CheckAgainstSubsetTest()
 {
+  AdjacencyList WorldAdjacency(atomIds);
   {
     // parse right
     std::stringstream input(adjacencyfile);
-    AdjacencyList fileChecker(input);
-    CPPUNIT_ASSERT( fileChecker.CheckAgainstSubset(atomIds) );
+    AdjacencyList FileAdjacency(input);
+    CPPUNIT_ASSERT( (WorldAdjacency > FileAdjacency) && (WorldAdjacency < FileAdjacency) );
   }
   {
     // parse wrong1 (more atoms in the world than in file, hence wrong)
     std::stringstream input(wrongadjacencyfile1);
-    AdjacencyList fileChecker(input);
-    CPPUNIT_ASSERT( !fileChecker.CheckAgainstSubset(atomIds) );
+    AdjacencyList FileAdjacency(input);
+    CPPUNIT_ASSERT( !(WorldAdjacency < FileAdjacency) && (WorldAdjacency > FileAdjacency) );
   }
   {
@@ -262,20 +309,23 @@
     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() );
+    AdjacencyList RestrictedWorldAdjacency(validids);
     // parse wrong1 (more atoms in the world than in file, hence wrong)
     std::stringstream input(wrongadjacencyfile1);
-    AdjacencyList fileChecker(input);
-    CPPUNIT_ASSERT( fileChecker.CheckAgainstSubset(validids) );
+    AdjacencyList FileAdjacency(input);
+    CPPUNIT_ASSERT( RestrictedWorldAdjacency == FileAdjacency );
   }
   {
     // parse wrong2 (there is no atom 10, but present in file. hence true)
     std::stringstream input(wrongadjacencyfile2);
-    AdjacencyList fileChecker(input);
-    CPPUNIT_ASSERT( !fileChecker.CheckAgainstSubset(atomIds) );
-  }
-  {
-    // parse wrong3 (6 is not connected)
+    AdjacencyList FileAdjacency(input);
+    CPPUNIT_ASSERT( !(WorldAdjacency > FileAdjacency) && (WorldAdjacency < FileAdjacency) );
+  }
+  {
+    // parse wrong3 (6 is skipped in connection, hence neither is subset)
     std::stringstream input(wrongadjacencyfile3);
-    AdjacencyList fileChecker(input);
-    CPPUNIT_ASSERT( !fileChecker.CheckAgainstSubset(atomIds) );
-  }
-}
+    AdjacencyList FileAdjacency(input);
+//    WorldAdjacency.StoreToFile((std::ostream &)std::cout);
+//    FileAdjacency.StoreToFile((std::ostream &)std::cout);
+    CPPUNIT_ASSERT( WorldAdjacency != FileAdjacency );
+  }
+}
Index: src/Graph/unittests/AdjacencyListUnitTest.hpp
===================================================================
--- src/Graph/unittests/AdjacencyListUnitTest.hpp	(revision 5197e543aadb7e0a5343495b6e246005819cd457)
+++ src/Graph/unittests/AdjacencyListUnitTest.hpp	(revision 4694df82c685e4d9f1a22a75eb0c1355964be59f)
@@ -32,5 +32,7 @@
   CPPUNIT_TEST ( CreateMapTest );
   CPPUNIT_TEST ( ParseIntoMapTest );
-  CPPUNIT_TEST ( CompareInternalExternalMapTest );
+  CPPUNIT_TEST ( StoreToFileTest );
+  CPPUNIT_TEST ( operatorGreaterLessTest );
+  CPPUNIT_TEST ( operatorEqualTest );
   CPPUNIT_TEST ( CheckAgainstSubsetTest );
   CPPUNIT_TEST_SUITE_END();
@@ -42,5 +44,7 @@
   void CreateMapTest();
   void ParseIntoMapTest();
-  void CompareInternalExternalMapTest();
+  void StoreToFileTest();
+  void operatorGreaterLessTest();
+  void operatorEqualTest();
   void CheckAgainstSubsetTest();
 
