Update databaseTest.py to be the same as RMG-Py's, again...

It's poor form to have this file in both repos, but it's for
the sake of RMG-tests. Maybe someone should remove it someday.

Author: connie

testing/databaseTest.py

@@ -116,11 +116,12 @@ def test_thermo(self):
             self.compat_func_name = test_name
             yield test, group_name
 
-            test = lambda x: self.general_checkSiblingsForParents(group_name, group)
-            test_name = "Thermo groups {0}: sibling relationships are correct?".format(group_name)
-            test.description = test_name
-            self.compat_func_name = test_name
-            yield test, group_name
+            if group_name != 'polycyclic':
+                test = lambda x: self.general_checkSiblingsForParents(group_name, group)
+                test_name = "Thermo groups {0}: sibling relationships are correct?".format(group_name)
+                test.description = test_name
+                self.compat_func_name = test_name
+                yield test, group_name
 
             test = lambda x: self.general_checkCdAtomType(group_name, group)
             test_name = "Thermo groups {0}: Cd atomtype used correctly?".format(group_name)
@@ -298,6 +299,11 @@ def kinetics_checkChildParentRelationships(self, family_name):
             #top nodes and product nodes don't have parents by definition, so they get an automatic pass:
             if childNode in originalFamily.groups.top or childNode in originalFamily.forwardTemplate.products: continue
             parentNode = childNode.parent
+            
+            if parentNode is None:
+                # This is a mistake in the database, but it should be caught by kinetics_checkGroupsFoundInTree
+                # so rather than report it twice or crash, we'll just silently carry on to the next node.
+                continue
             # Check whether the node has proper parents unless it is the top reactant or product node
             # The parent should be more general than the child
             nose.tools.assert_true(family.matchNodeToChild(parentNode, childNode),
@@ -331,9 +337,9 @@ def kinetics_checkSiblingsForParents(self, family_name):
                     #Don't check a node against itself
                     if child1 is child2: continue
                     nose.tools.assert_false(family.matchNodeToChild(child1, child2),
-                                            "In family {0}, node {1} is written as a sibling of {2}, when it is actually a parent.".format(family_name, child1, child2))
+                                            "In family {0}, node {1} is a parent of {2}, but they are written as siblings.".format(family_name, child1, child2))
                     nose.tools.assert_false(family.matchNodeToChild(child2, child1),
-                                            "In family {0}, node {1} is written as a sibling of {2}, when it is actually a parent.".format(family_name, child2, child1))
+                                            "In family {0}, node {1} is a parent of {2}, but they are written as siblings.".format(family_name, child2, child1))
 
     def kinetics_checkAdjlistsNonidentical(self, database):
         """
@@ -429,7 +435,7 @@ def kinetics_checkCdAtomType(self, family_name):
                     for correctAtom in correctAtomList:
                         nose.tools.assert_true(atomTypes[correctAtom] in atom.atomType,
                                                """In family {0}, node {1} is missing the atomtype {2} in atom {3} and may be misusing the atomtype Cd, CO, CS, or Cdd.
-The following adjList may be have atoms in a different ordering than the input file:
+The following adjList may have atoms in a different ordering than the input file:
 {4}
                                             """.format(family_name, entry, correctAtom, index+1, entry.item.toAdjacencyList()))
 
@@ -496,9 +502,9 @@ def general_checkSiblingsForParents(self, group_name, group):
                     #Don't check a node against itself
                     if child1 is child2: continue
                     nose.tools.assert_false(group.matchNodeToChild(child1, child2),
-                                            "In {0} group, node {1} is written as a sibling of {2}, when it is actually a parent.".format(group_name, child1, child2))
+                                            "In {0} group, node {1} is a parent of {2}, but they are written as siblings.".format(group_name, child1, child2))
                     nose.tools.assert_false(group.matchNodeToChild(child2, child1),
-                                            "In {0} group, node {1} is written as a sibling of {2}, when it is actually a parent.".format(group_name, child2, child1))
+                                            "In {0} group, node {1} is a parent of {2}, but they are written as siblings.".format(group_name, child2, child1))
 
     def general_checkCdAtomType(self, group_name, group):
         """
@@ -536,7 +542,7 @@ def general_checkCdAtomType(self, group_name, group):
                     for correctAtom in correctAtomList:
                         nose.tools.assert_true(atomTypes[correctAtom] in atom.atomType,
                                                 """In group {0}, node {1} is missing the atomtype {2} in atom {3} and may be misusing the atomtype Cd, CO, CS, or Cdd.
-The following adjList may be have atoms in a different ordering than the input file:
+The following adjList may have atoms in a different ordering than the input file:
 {4}
                                             """.format(group_name, entry, correctAtom, index+1, entry.item.toAdjacencyList()))