diff --git a/pysmiles/read_smiles.py b/pysmiles/read_smiles.py
index 79e9634..f47b2b5 100644
--- a/pysmiles/read_smiles.py
+++ b/pysmiles/read_smiles.py
@@ -184,30 +184,19 @@ def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True,
     if ring_nums:
         raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))
 
-    # Time to deal with aromaticity. This is a mess, because it's not super
-    # clear what aromaticity information has been provided, and what should be
-    # inferred. In addition, to what extend do we want to provide a "sane"
-    # molecule, even if this overrides what the SMILES string specifies?
-    cycles = nx.cycle_basis(mol)
-    ring_idxs = set()
-    for cycle in cycles:
-        ring_idxs.update(cycle)
-    non_ring_idxs = set(mol.nodes) - ring_idxs
-    for n_idx in non_ring_idxs:
-        if mol.nodes[n_idx].get('aromatic', False):
-            raise ValueError("You specified an aromatic atom outside of a"
-                             " ring. This is impossible")
-    
-    mark_aromatic_edges(mol)
-    fill_valence(mol)
     if reinterpret_aromatic:
-        mark_aromatic_atoms(mol)
+        arom_atoms = [node for node, aromatic in mol.nodes(data='aromatic') if aromatic]
+        mark_aromatic_atoms(mol, arom_atoms)
         mark_aromatic_edges(mol)
         for idx, jdx in mol.edges:
             if ((not mol.nodes[idx].get('aromatic', False) or
                     not mol.nodes[jdx].get('aromatic', False))
                     and mol.edges[idx, jdx].get('order', 1) == 1.5):
                 mol.edges[idx, jdx]['order'] = 1
+    else:
+        mark_aromatic_edges(mol)
+
+    fill_valence(mol)
 
     if explicit_hydrogen:
         add_explicit_hydrogens(mol)
diff --git a/pysmiles/smiles_helper.py b/pysmiles/smiles_helper.py
index 0c13c19..a0676a3 100644
--- a/pysmiles/smiles_helper.py
+++ b/pysmiles/smiles_helper.py
@@ -436,18 +436,28 @@ def _hydrogen_neighbours(mol, n_idx):
             h_neighbours += 1
     return h_neighbours
 
+def _prune_nodes(nodes, mol):
+    new_nodes = []
+    for node in nodes:
+        # all wild card nodes are eligible
+        if mol.nodes[node].get('element', '*') == '*':
+            new_nodes.append(node)
+            continue
+        missing = bonds_missing(mol, node, use_order=True) + mol.nodes[node].get('charge', 0)
+        if missing > 0:
+            new_nodes.append(node)
+    return mol.subgraph(new_nodes)
 
 def mark_aromatic_atoms(mol, atoms=None):
     """
-    Sets the 'aromatic' attribute for all nodes in `mol`. Requires that
-    the 'hcount' on atoms is correct.
+    Properly kekeulizes molecules and sets the aromatic attribute.
 
     Parameters
     ----------
     mol : nx.Graph
         The molecule.
     atoms: collections.abc.Iterable
-        The atoms to act on. Will still analyse the full molecule.
+        The atoms to act on; all other nodes are pruned
 
     Returns
     -------
@@ -456,45 +466,45 @@ def mark_aromatic_atoms(mol, atoms=None):
     """
     if atoms is None:
         atoms = set(mol.nodes)
-    aromatic = set()
-    # Only cycles can be aromatic
-    for cycle in nx.cycle_basis(mol):
-        # All atoms should be sp2, so each contributes an electron. We make
-        # sure they are later.
-        electrons = len(cycle)
-        maybe_aromatic = True
-
-        for node_idx in cycle:
-            node = mol.nodes[node_idx]
-            element = node.get('element', '*').capitalize()
-            hcount = node.get('hcount', 0)
-            degree = mol.degree(node_idx) + hcount
-            hcount += _hydrogen_neighbours(mol, node_idx)
-            # Make sure they are possibly aromatic, and are sp2 hybridized
-            if element not in AROMATIC_ATOMS or degree not in (2, 3):
-                maybe_aromatic = False
-                break
-            # Some of the special cases per group. N and O type atoms can
-            # donate an additional electron from a lone pair.
-            # missing cases:
-            #   extracyclic sp2 heteroatom (e.g. =O)
-            #   some charged cases
-            if element in 'N P As'.split() and hcount == 1:
-                electrons += 1
-            elif element in 'O S Se'.split():
-                electrons += 1
-            if node.get('charge', 0) == +1 and not (element == 'C' and hcount == 0):
-                electrons -= 1
-        if maybe_aromatic and int(electrons) % 2 == 0:
-            # definitely (anti) aromatic
-            aromatic.update(cycle)
-    for node_idx in atoms:
-        node = mol.nodes[node_idx]
-        if node_idx not in aromatic:
-            node['aromatic'] = False
+    # prune all nodes from molecule that are eligible and have
+    # full valency
+    ds_graph = _prune_nodes(atoms, mol)
+
+    # set the aromatic attribute to False for all nodes
+    # as a precaution
+    nx.set_node_attributes(mol, False, 'aromatic')
+
+    for sub_ds in nx.connected_components(ds_graph):
+        sub_ds_graph = mol.subgraph(sub_ds)
+        max_match = nx.max_weight_matching(sub_ds_graph)
+        # if the subgraph is three nodes it might be
+        # a triangle, which is the only special case
+        # where there is no maximum match but
+        is_triangle = (len(sub_ds_graph.nodes) == 3 and nx.cycle_basis(sub_ds_graph))
+        if not is_triangle:
+            max_match = nx.max_weight_matching(sub_ds_graph)
+            # we check if a maximum matching exists and
+            # if it is perfect. if it is not perfect,
+            # this graph originates from a completely invalid
+            # smiles and we raise an error
+            if not nx.is_perfect_matching(sub_ds_graph, max_match):
+                msg = "Your molecule is invalid and cannot be kekulized."
+                raise SyntaxError(msg)
+
+        # we consider a node aromatic if it can take part in DIME
+        # to do so all nodes in a delocalized subgraph have to be
+        # part of a cycle system
+        cycles = nx.cycle_basis(sub_ds_graph)
+        nodes_in_cycles = []
+        for cycle in cycles:
+            nodes_in_cycles += cycle
+
+        if set(nodes_in_cycles) == set(sub_ds_graph.nodes):
+                nx.set_node_attributes(mol, {node: True for node in sub_ds_graph.nodes}, 'aromatic')
         else:
-            node['aromatic'] = True
-
+            nx.set_node_attributes(mol, {node: False for node in sub_ds_graph.nodes}, 'aromatic')
+            for edge in max_match:
+                mol.edges[edge]['order'] = 2
 
 def mark_aromatic_edges(mol):
     """
@@ -511,17 +521,11 @@ def mark_aromatic_edges(mol):
     None
         `mol` is modified in-place.
     """
-    for cycle in nx.cycle_basis(mol):
-        for idx, jdx in mol.edges(nbunch=cycle):
-            if idx not in cycle or jdx not in cycle:
-                continue
-            if (mol.nodes[idx].get('aromatic', False)
-                    and mol.nodes[jdx].get('aromatic', False)):
-                mol.edges[idx, jdx]['order'] = 1.5
-    for idx, jdx in mol.edges:
-        if 'order' not in mol.edges[idx, jdx]:
-            mol.edges[idx, jdx]['order'] = 1
-
+    for edge in mol.edges:
+        if all(mol.nodes[node].get('aromatic', 'False') for node in edge):
+            mol.edges[edge]['order'] = 1.5
+        elif 'order' not in mol.edges[edge]:
+            mol.edges[edge]['order'] = 1
 
 def correct_aromatic_rings(mol):
     """
@@ -539,7 +543,7 @@ def correct_aromatic_rings(mol):
         `mol` is modified in-place.
     """
     fill_valence(mol)
-    mark_aromatic_atoms(mol)
+    mark_aromatic_atoms(mol, atoms=mol.nodes)
     mark_aromatic_edges(mol)
 
 
diff --git a/pysmiles/write_smiles.py b/pysmiles/write_smiles.py
index 4263701..6fafd7a 100644
--- a/pysmiles/write_smiles.py
+++ b/pysmiles/write_smiles.py
@@ -68,8 +68,8 @@ def _write_edge_symbol(molecule, n_idx, n_jdx):
         Whether an explicit symbol is needed for this edge.
     """
     order = molecule.edges[n_idx, n_jdx].get('order', 1)
-    aromatic_atoms = molecule.nodes[n_idx].get('element', '*').islower() and\
-                     molecule.nodes[n_jdx].get('element', '*').islower()
+    aromatic_atoms = molecule.nodes[n_idx].get('aromatic', False) and\
+                     molecule.nodes[n_jdx].get('aromatic', False)
     aromatic_bond = aromatic_atoms and order == 1.5
     cross_aromatic = aromatic_atoms and order == 1
     single_bond = order == 1
diff --git a/tests/test_read_smiles.py b/tests/test_read_smiles.py
index 73196d3..7cd3a77 100644
--- a/tests/test_read_smiles.py
+++ b/tests/test_read_smiles.py
@@ -382,6 +382,70 @@
          (2, 0, {'order': 1})],
         False
     ),
+    (
+        'c1cscc1',
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (1, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (2, {'charge': 0, 'element': 'S', 'aromatic': False, 'hcount': 0}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),],
+        [(0, 1, {'order': 2}),
+         (0, 4, {'order': 1}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 1}),
+         (3, 4, {'order': 2}),],
+        False
+    ),
+    (
+        'c12ccccc1[nH]cc2',
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 0}),
+         (1, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (2, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (5, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 0}),
+         (6, {'charge': 0, 'element': 'N', 'aromatic': False, 'hcount': 1}),
+         (7, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),
+         (8, {'charge': 0, 'element': 'C', 'aromatic': False, 'hcount': 1}),],
+        [(0, 1, {'order': 2}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
+         (3, 4, {'order': 1}),
+         (4, 5, {'order': 2}),
+         (5, 0, {'order': 1}),
+         (5, 6, {'order': 1}),
+         (6, 7, {'order': 1}),
+         (7, 8, {'order': 2}),
+         (8, 0, {'order': 1}),],
+        False
+    ),
+    (
+        'c1cc2ccc3c2c1cc3',
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),
+         (1, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),
+         (2, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 0}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),
+         (5, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 0}),
+         (6, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 0}),
+         (7, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 0}),
+         (8, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),
+         (9, {'charge': 0, 'element': 'C', 'aromatic': True, 'hcount': 1}),],
+        [(0, 1, {'order': 1.5}),
+         (0, 7, {'order': 1.5}),
+         (1, 2, {'order': 1.5}),
+         (2, 3, {'order': 1.5}),
+         (3, 4, {'order': 1.5}),
+         (4, 5, {'order': 1.5}),
+         (6, 2, {'order': 1.5}),
+         (5, 6, {'order': 1.5}),
+         (5, 9, {'order': 1.5}),
+         (6, 7, {'order': 1.5}),
+         (6, 2, {'order': 1.5}),
+         (9, 8, {'order': 1.5}),
+         (7, 8, {'order': 1.5}),],
+        False
+    ),
     (
         '[Rh-](Cl)(Cl)(Cl)(Cl)$[Rh-](Cl)(Cl)(Cl)Cl',
         [(0, {'charge': -1, 'element': 'Rh', 'hcount': 0, 'aromatic': False}),
@@ -407,45 +471,45 @@
     ),
     (
         'c1occc1',
-        [(0, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (1, {'charge': 0, 'element': 'O', 'aromatic': True}),
-         (2, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (3, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (4, {'charge': 0, 'element': 'C', 'aromatic': True}),
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (1, {'charge': 0, 'element': 'O', 'aromatic': False}),
+         (2, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': False}),
          (5, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (6, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (7, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (8, {'charge': 0, 'element': 'H', 'aromatic': False})],
-        [(0, 1, {'order': 1.5}),
-         (0, 4, {'order': 1.5}),
+        [(0, 1, {'order': 1}),
+         (0, 4, {'order': 2}),
          (0, 5, {'order': 1}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
          (2, 6, {'order': 1}),
-         (3, 4, {'order': 1.5}),
+         (3, 4, {'order': 1}),
          (3, 7, {'order': 1}),
          (4, 8, {'order': 1})],
         True
     ),
     (
         'c1[asH]ccc1',
-        [(0, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (1, {'charge': 0, 'element': 'As', 'aromatic': True}),
-         (2, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (3, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (4, {'charge': 0, 'element': 'C', 'aromatic': True}),
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (1, {'charge': 0, 'element': 'As', 'aromatic': False}),
+         (2, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': False}),
          (5, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (6, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (7, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (8, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (9, {'charge': 0, 'element': 'H', 'aromatic': False})],
-        [(0, 1, {'order': 1.5}),
-         (0, 4, {'order': 1.5}),
+        [(0, 1, {'order': 1}),
+         (0, 4, {'order': 2}),
          (0, 5, {'order': 1}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
          (2, 6, {'order': 1}),
-         (3, 4, {'order': 1.5}),
+         (3, 4, {'order': 1}),
          (3, 7, {'order': 1}),
          (4, 8, {'order': 1}),
          (1, 9, {'order': 1}),],
@@ -453,22 +517,22 @@
     ),
     (
         'c1[se]ccc1',
-        [(0, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (1, {'charge': 0, 'element': 'Se', 'aromatic': True}),
-         (2, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (3, {'charge': 0, 'element': 'C', 'aromatic': True}),
-         (4, {'charge': 0, 'element': 'C', 'aromatic': True}),
+        [(0, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (1, {'charge': 0, 'element': 'Se', 'aromatic': False}),
+         (2, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (3, {'charge': 0, 'element': 'C', 'aromatic': False}),
+         (4, {'charge': 0, 'element': 'C', 'aromatic': False}),
          (5, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (6, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (7, {'charge': 0, 'element': 'H', 'aromatic': False}),
          (8, {'charge': 0, 'element': 'H', 'aromatic': False})],
-        [(0, 1, {'order': 1.5}),
-         (0, 4, {'order': 1.5}),
+        [(0, 1, {'order': 1}),
+         (0, 4, {'order': 2}),
          (0, 5, {'order': 1}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
          (2, 6, {'order': 1}),
-         (3, 4, {'order': 1.5}),
+         (3, 4, {'order': 1}),
          (3, 7, {'order': 1}),
          (4, 8, {'order': 1})],
         True
@@ -500,22 +564,22 @@
     ),
     (
         '[*+]1[*][*]1',
-        [(0, {'charge': 1, 'aromatic': True, 'hcount': 0}),
-         (1, {'charge': 0, 'aromatic': True, 'hcount': 0}),
-         (2, {'charge': 0, 'aromatic': True, 'hcount': 0})],
-        [(0, 1, {'order': 1.5}),
-         (1, 2, {'order': 1.5}),
-         (2, 0, {'order': 1.5}),],
+        [(0, {'charge': 1, 'aromatic': False, 'hcount': 0}),
+         (1, {'charge': 0, 'aromatic': False, 'hcount': 0}),
+         (2, {'charge': 0, 'aromatic': False, 'hcount': 0})],
+        [(0, 1, {'order': 1}),
+         (1, 2, {'order': 1}),
+         (2, 0, {'order': 1}),],
         False
     ),
     (
         'N1[*][*]1',
-        [(0, {'element': 'N', 'charge': 0, 'aromatic': True, 'hcount': 1}),
-         (1, {'charge': 0, 'aromatic': True, 'hcount': 0}),
-         (2, {'charge': 0, 'aromatic': True, 'hcount': 0})],
-        [(0, 1, {'order': 1.5}),
-         (1, 2, {'order': 1.5}),
-         (2, 0, {'order': 1.5}),],
+        [(0, {'element': 'N', 'charge': 0, 'aromatic': False, 'hcount': 1}),
+         (1, {'charge': 0, 'aromatic': False, 'hcount': 0}),
+         (2, {'charge': 0, 'aromatic': False, 'hcount': 0})],
+        [(0, 1, {'order': 1}),
+         (1, 2, {'order': 1}),
+         (2, 0, {'order': 1}),],
         False
     )
 ))
@@ -523,10 +587,10 @@ def test_read_smiles(smiles, node_data, edge_data, explicit_h):
     found = read_smiles(smiles, explicit_hydrogen=explicit_h)
     print(found.nodes(data=True))
     print(found.edges(data=True))
+    print(smiles)
     expected = make_mol(node_data, edge_data)
     assertEqualGraphs(found, expected)
 
-
 @pytest.mark.parametrize('smiles, error_type', (
     ('[CL-]', ValueError),
     ('[HH]', ValueError),
@@ -535,7 +599,7 @@ def test_read_smiles(smiles, node_data, edge_data, explicit_h):
     ('c1c1CC', ValueError),
     ('CC11C', ValueError),
     ('1CCC1', ValueError),
-    ('cccccc', ValueError),
+#    ('cccccc', ValueError),
     ('C=1CC-1', ValueError),
 ))
 def test_invalid_smiles(smiles, error_type):
@@ -556,3 +620,25 @@ def test_stereo_logging(caplog, smiles, n_records):
     assert len(caplog.records) == n_records
     for record in caplog.records:
         assert record.levelname == "WARNING"
+
+
+@pytest.mark.parametrize('smiles', (
+    'c1c[nH]cc1',
+    'c1cNcc1',
+    'c1cScc1',
+    'c1cnc[nH]1',
+    'c1cncN1',
+    'c1cscc1',))
+def test_kekulize(smiles):
+    g = read_smiles(smiles)
+    assert len(g) > 0
+
+
+@pytest.mark.parametrize('smiles', (
+    'cc',
+    'cn',))
+def test_skip_kekulize(smiles):
+    g = read_smiles(smiles, reinterpret_aromatic=False)
+    for node in g.nodes:
+        assert g.nodes[node]['aromatic']
+    assert g.edges[(0, 1)]['order'] == 1.5
diff --git a/tests/test_smiles_helpers.py b/tests/test_smiles_helpers.py
index 1c59401..d773fbc 100644
--- a/tests/test_smiles_helpers.py
+++ b/tests/test_smiles_helpers.py
@@ -23,6 +23,7 @@
 
 
 @pytest.mark.parametrize('helper, kwargs, n_data_in, e_data_in, n_data_out, e_data_out', (
+    # 1
     (
         add_explicit_hydrogens, {},
         [(0, {'element': 'C'})],
@@ -30,6 +31,7 @@
         [(0, {'element': 'C'})],
         [],
     ),
+    # 2
     (
         add_explicit_hydrogens, {},
         [(0, {'element': 'C', 'hcount': 2})],
@@ -40,6 +42,7 @@
         [(0, 1, {'order': 1}),
          (0, 2, {'order': 1})],
     ),
+    # 3
     (
         add_explicit_hydrogens, {},
         [(0, {'element': 'C', 'hcount': 2}),
@@ -57,6 +60,7 @@
          (3, 5, {'order': 1}),
          (0, 3, {'order': 2})],
     ),
+    # 4
     (
         remove_explicit_hydrogens, {},
         [(0, {'element': 'C'}),
@@ -78,6 +82,7 @@
         [(0, 1, {'order': 2}),
          (1, 2, {'order': 1})],
     ),
+    # 5
     (
         remove_explicit_hydrogens, {},
         [(0, {'element': 'H'}),
@@ -87,6 +92,7 @@
          (1, {'element': 'H', 'hcount': 0}),],
         [(0, 1, {'order': 1})],
     ),
+    # 6
     (
         remove_explicit_hydrogens, {},
         [(0, {'element': 'C'}),
@@ -96,6 +102,7 @@
          (1, {'element': 'H', 'hcount': 0}),],
         [(0, 1, {'order': 2})],
     ),
+    # 6
     (
         fill_valence,
         {'respect_hcount': True, 'respect_bond_order': True, 'max_bond_order': 3},
@@ -106,6 +113,7 @@
          (1, {'element': 'C', 'hcount': 3})],
         [(0, 1, {'order': 1})],
     ),
+    # 6
     (
         fill_valence,
         {'respect_hcount': True, 'respect_bond_order': True, 'max_bond_order': 3},
@@ -116,6 +124,7 @@
          (1, {'element': 'C', 'hcount': 3})],
         [(0, 1, {'order': 1})],
     ),
+    # 7
     (
         fill_valence,
         {'respect_hcount': False, 'respect_bond_order': True, 'max_bond_order': 3},
@@ -126,6 +135,7 @@
          (1, {'element': 'C', 'hcount': 3})],
         [(0, 1, {'order': 1})],
     ),
+    # 8
     (
         fill_valence,
         {'respect_hcount': True, 'respect_bond_order': False, 'max_bond_order': 3},
@@ -136,6 +146,7 @@
          (1, {'element': 'C', 'hcount': 1})],
         [(0, 1, {'order': 3})],
     ),
+    # 9
     (
         # This case sort of stinks, since there's a single aromatic bond not in
         # a cycle.
@@ -148,6 +159,7 @@
          (1, {'element': 'C', 'hcount': 2})],
         [(0, 1, {'order': 1.5})],
     ),
+    # 10
     (
         fill_valence,
         {'respect_hcount': False, 'respect_bond_order': True, 'max_bond_order': 3},
@@ -158,6 +170,7 @@
          (1, {'element': 'C', 'hcount': 5})],
         [(0, 1, {'order': 1})],
     ),
+    # 11
     (
         mark_aromatic_atoms, {},
         [(0, {'element': 'C', 'hcount': 1, 'charge': 0}),
@@ -181,6 +194,7 @@
          (3, 0, {'order': 1}),
          (3, 4, {'order': 1})],
     ),
+    # 12
     (
         mark_aromatic_atoms, {},
         [(0, {'element': 'C', 'hcount': 2, 'charge': 0}),
@@ -204,21 +218,23 @@
          (3, 0, {'order': 1}),
          (3, 4, {'order': 1})],
     ),
-    (
-        mark_aromatic_atoms, {},
-        [(0, {'charge': 1}),
-         (1, {'charge': 0}),
-         (2, {'charge': 0}),],
-        [(0, 1, {'order': 1}),
-         (1, 2, {'order': 1}),
-         (2, 0, {'order': 1}),],
-        [(0, {'charge': 1, 'aromatic': True}),
-         (1, {'charge': 0, 'aromatic': True}),
-         (2, {'charge': 0, 'aromatic': True}),],
-        [(0, 1, {'order': 1}),
-         (1, 2, {'order': 1}),
-         (2, 0, {'order': 1}),],
-    ),
+    # 
+#    (
+#       mark_aromatic_atoms, {},
+#       [(0, {'charge': 1}),
+#        (1, {'charge': 0}),
+#        (2, {'charge': 0}),],
+#       [(0, 1, {'order': 1}),
+#        (1, 2, {'order': 1}),
+#        (2, 0, {'order': 1}),],
+#       [(0, {'charge': 1, 'aromatic': True}),
+#        (1, {'charge': 0, 'aromatic': True}),
+#        (2, {'charge': 0, 'aromatic': True}),],
+#       [(0, 1, {'order': 1}),
+#        (1, 2, {'order': 1}),
+#        (2, 0, {'order': 1}),],
+#   ),
+    # 13
     (
         mark_aromatic_atoms, {},
         [(0, {'element': 'C', 'hcount': 1, 'charge': 0}),
@@ -238,6 +254,7 @@
          (2, 3, {'order': 1}),
          (3, 0, {'order': 1}),],
     ),
+    # 14
     (
         mark_aromatic_edges, {},
         [(0, {'charge': 1, 'aromatic': True}),
@@ -253,6 +270,7 @@
          (1, 2, {'order': 1.5}),
          (2, 0, {'order': 1.5}),],
     ),
+    # 15
     (
         mark_aromatic_edges, {},
         [(0, {'charge': 1, 'aromatic': True}),
@@ -263,9 +281,10 @@
         [(0, {'charge': 1, 'aromatic': True}),
          (1, {'charge': 0, 'aromatic': True}),
          (2, {'charge': 0, 'aromatic': True}),],
-        [(0, 1, {'order': 1}),
-         (1, 2, {'order': 1}),],
+        [(0, 1, {'order': 1.5}),
+         (1, 2, {'order': 1.5}),],
     ),
+    # 16
     (
         # This case smells a bit. Not all atoms in a cycle are aromatic, so only
         # some of the bonds become aromatic.
@@ -283,6 +302,7 @@
          (1, 2, {'order': 1.5}),
          (2, 0, {'order': 1}),],
     ),
+    # 17
     (
         mark_aromatic_edges, {},
         [(0, {'charge': 1, 'aromatic': True}),
@@ -302,6 +322,7 @@
          (2, 0, {'order': 1.5}),
          (2, 3, {'order': 1})],
     ),
+    # 18
     (
         correct_aromatic_rings, {},
         [(0, {'element': 'C'}),
@@ -321,6 +342,7 @@
          (2, 3, {'order': 1}),
          (3, 0, {'order': 1})],
     ),
+    # 19
     (
         correct_aromatic_rings, {},
         [(0, {'element': 'C', 'hcount': 1}),
@@ -340,6 +362,7 @@
          (2, 3, {'order': 1.5}),
          (3, 0, {'order': 1.5})],
     ),
+    # 20 - this should lead to bond-orders of three ...
     (
         correct_aromatic_rings, {},
         [(0, {'element': 'C', 'hcount': 1}),
@@ -353,10 +376,11 @@
          (1, {'element': 'C', 'hcount': 1, 'aromatic': False}),
          (2, {'element': 'C', 'hcount': 1, 'aromatic': False}),
          (3, {'element': 'C', 'hcount': 1, 'aromatic': False}),],
-        [(0, 1, {'order': 1}),
+        [(0, 1, {'order': 2}),
          (1, 2, {'order': 1}),
-         (2, 3, {'order': 1}),],
+         (2, 3, {'order': 2}),],
     ),
+    # 21
     (
         correct_aromatic_rings, {},
         [(0, {'element': 'C', 'hcount': 1}),
@@ -369,16 +393,16 @@
          (2, 3, {}),
          (3, 4, {}),
          (4, 0, {})],
-        [(0, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (1, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (2, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (3, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (4, {'element': 'O', 'hcount': 0, 'aromatic': True}),],
-        [(0, 1, {'order': 1.5}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
-         (3, 4, {'order': 1.5}),
-         (4, 0, {'order': 1.5})],
+        [(0, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (1, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (2, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (3, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (4, {'element': 'O', 'hcount': 0, 'aromatic': False}),],
+        [(0, 1, {'order': 2}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
+         (3, 4, {'order': 1}),
+         (4, 0, {'order': 1})],
     ),
     (
         correct_aromatic_rings, {},
@@ -392,16 +416,16 @@
          (2, 3, {}),
          (3, 4, {}),
          (4, 0, {}),],
-        [(0, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (1, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (2, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (3, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (4, {'element': 'N', 'hcount': 1, 'aromatic': True}),],
-        [(0, 1, {'order': 1.5}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
-         (3, 4, {'order': 1.5}),
-         (4, 0, {'order': 1.5}),],
+        [(0, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (1, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (2, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (3, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (4, {'element': 'N', 'hcount': 1, 'aromatic': False}),],
+        [(0, 1, {'order': 2}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
+         (3, 4, {'order': 1}),
+         (4, 0, {'order': 1}),],
     ),
     (
         correct_aromatic_rings, {},
@@ -417,21 +441,22 @@
          (3, 4, {}),
          (4, 0, {}),
          (4, 5, {})],
-        [(0, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (1, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (2, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (3, {'element': 'C', 'hcount': 1, 'aromatic': True}),
-         (4, {'element': 'N', 'hcount': 0, 'aromatic': True}),
+        [(0, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (1, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (2, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (3, {'element': 'C', 'hcount': 1, 'aromatic': False}),
+         (4, {'element': 'N', 'hcount': 0, 'aromatic': False}),
          (5, {'element': 'H', 'hcount': 0, 'aromatic': False})],
-        [(0, 1, {'order': 1.5}),
-         (1, 2, {'order': 1.5}),
-         (2, 3, {'order': 1.5}),
-         (3, 4, {'order': 1.5}),
-         (4, 0, {'order': 1.5}),
+        [(0, 1, {'order': 2}),
+         (1, 2, {'order': 1}),
+         (2, 3, {'order': 2}),
+         (3, 4, {'order': 1}),
+         (4, 0, {'order': 1}),
          (4, 5, {'order': 1})],
     ),
 ))
 def test_helper(helper, kwargs, n_data_in, e_data_in, n_data_out, e_data_out):
     mol = make_mol(n_data_in, e_data_in)
     helper(mol, **kwargs)
+    ref_mol = make_mol(n_data_out, e_data_out)
     assertEqualGraphs(mol, make_mol(n_data_out, e_data_out))