molSimplify 1.7.4__py3-none-any.whl

tests/test_basic_imports.py

@@ -0,0 +1,62 @@
+"""
+Test for imports where the packges will be used in molSimplify.
+"""
+
+import sys
+import pytest
+
+
+def test_molsimplify_imported():
+    '''
+    Sample test, will always pass so long as import statement worked
+    '''
+    assert "molSimplify" in sys.modules
+
+
+@pytest.mark.skip("PSI4 is no longer on the list of required dependencies.")
+def test_psi4_import():
+    '''
+    Test whether psi4 can be imported
+    '''
+    try:
+        import psi4  # noqa: F401
+        assert "psi4" in sys.modules
+    except ImportError:
+        assert 0
+
+
+def test_tf_import():
+    '''
+    Test whether tensorflow can be imported
+    '''
+    try:
+        import tensorflow  # noqa: F401
+        assert "tensorflow" in sys.modules
+    except ImportError:
+        assert 0
+
+
+@pytest.mark.skip("Does not work on github CI workflow")
+def test_keras_import():
+    '''
+    Test whether keras can be imported
+    '''
+    try:
+        from tensorflow import keras  # noqa: F401
+        assert "keras" in sys.modules
+    except ImportError:
+        assert 0
+
+
+def test_openbabel_import():
+    '''
+    Test whether openbabel can be imported
+    '''
+    try:
+        try:
+            from openbabel import openbabel  # version 3 style import
+        except ImportError:  # fallback to version 2
+            import openbabel  # noqa: F401
+        assert "openbabel" in sys.modules
+    except ImportError:
+        assert 0

tests/test_bidentate.py

@@ -0,0 +1,25 @@
+import helperFuncs as hp
+
+
+def test_bidentate(tmpdir, resource_path_root):
+    # There are two versions of this test depending on the openbabel version.
+    # This is necessary because openbabel changed the numbering of atoms for v3.
+    try:
+        # This is the recommended method to import openbabel for v3
+        from openbabel import openbabel  # noqa: F401
+        testName = "bidentate_v3"
+    except ImportError:
+        testName = "bidentate"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 1.5
+    [passMultiFileCheck, pass_structures] = hp.runtestMulti(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passMultiFileCheck
+    for f, passNumAtoms, passMLBL, passLG, passOG, pass_report in pass_structures:
+        print(f)
+        assert passNumAtoms
+        assert passMLBL
+        assert passLG
+        assert passOG
+        assert pass_report

tests/test_cli.py

@@ -0,0 +1,20 @@
+import pytest
+from helperFuncs import compare_report_new
+from molSimplify.__main__ import main
+
+
+def test_main_empty(tmpdir, resource_path_root):
+    main(args=[f"-rundir {tmpdir}"])
+    compare_report_new(
+        tmpdir / "fe_oct_2_water_6_s_5" / "fe_oct_2_water_6_s_5_conf_1" /
+        "fe_oct_2_water_6_s_5_conf_1.report",
+        resource_path_root / "refs" / "test_cli" /
+        "fe_oct_2_water_6_s_5_conf_1.report")
+
+
+@pytest.mark.skip("Test for help not working yet.")
+def test_help(capsys):
+    main(args=["--help",])
+    captured = capsys.readouterr()
+    print(captured.out)
+    assert "Welcome to molSimplify. Only basic usage is described here." in captured.out

tests/test_distgeom.py

@@ -0,0 +1,106 @@
+import numpy as np
+from argparse import Namespace
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Scripts.distgeom import (GetCMDists, CosRule,
+                                          Metrize, findshape)
+
+
+def test_CosRule(atol=1e-6):
+    # Test simple "unit" triangle
+    assert abs(CosRule(1., 1., 90) - np.sqrt(2)) < atol
+    assert abs(CosRule(1, np.sqrt(2), 45) - 1.) < atol
+    assert abs(CosRule(np.sqrt(2), 1., 45) - 1.) < atol
+    # Test equilateral triangle
+    a = 3.456
+    assert abs(CosRule(a, a, 60) - a) < atol
+    # Test Pythagoras
+    assert abs(CosRule(3., 4., 90) - 5.) < atol
+    # Test 30-60-90 triangle
+    a = 2.345
+    assert abs(CosRule(a, 0.5*a*np.sqrt(3), 30) - 0.5*a) < atol
+    assert abs(CosRule(a, 0.5*a, 60) - 0.5*a*np.sqrt(3)) < atol
+    assert abs(CosRule(0.5*a, 0.5*a*np.sqrt(3), 90) - a) < atol
+    # Test symmetry on 30-60-90
+    assert abs(CosRule(0.5*a*np.sqrt(3), a, 30) - 0.5*a) < atol
+    assert abs(CosRule(0.5*a, a, 60) - 0.5*a*np.sqrt(3)) < atol
+    assert abs(CosRule(0.5*a*np.sqrt(3), 0.5*a, 90) - a) < atol
+
+
+def test_GetCMDists():
+    # Dummy points in 3d
+    xyzs = np.array([[0., 0., 0.],
+                     [1., 0., 0.],
+                     [0., 1., 0.],
+                     [0., 1., 1.],
+                     [0., 0., 0.]])
+
+    dist_mat = np.sqrt(np.sum(
+        (xyzs[np.newaxis, :, :] - xyzs[:, np.newaxis, :])**2, axis=-1))
+    # Calculate geometric center
+    center = np.mean(xyzs, axis=0)
+    # Distances to the center:
+    dists_ref = np.sqrt(np.sum((xyzs - center)**2, axis=-1))
+
+    dists, status = GetCMDists(dist_mat, len(xyzs))
+    assert status
+    np.testing.assert_allclose(dists, dists_ref)
+
+
+def test_Metrize():
+    """"A few tests are commented out because they would only be
+    satisfied after introducing breaking changes to Metrize()
+    (see TODO tags)"""
+    # Setup
+    natoms = 9
+    LB = np.zeros((natoms, natoms))
+    UB = 100*np.ones((natoms, natoms))
+    # Build distance matrix
+    D = Metrize(LB, UB, natoms)
+    # Test bounds
+    np.testing.assert_array_compare(np.greater_equal, D, LB)
+    np.testing.assert_array_compare(np.less_equal, D, UB)
+    # Test symmetry
+    np.testing.assert_equal(D, D.T)
+    # Diagonal should be zero
+    # np.testing.assert_equal(np.diag(D), np.zeros(natoms))
+    # Test triangle inequality. For each triangle of atoms i, j, and k:
+    # r_ij <= r_ik + r_kj. TODO the current implementation occasionally
+    # breaks the constraint on purpose for a potential speed up.
+    # for i in range(natoms):
+    #     for j in range(i, natoms):  # Test only lower triangular matrix
+    #         for k in range(natoms):
+    #             assert D[i, j] <= D[i, k] + D[k, j]
+    # Test elements for specific seed
+    # D = Metrize(LB, UB, natoms, seed=1234)
+    # Reference for the seed
+    # ref = np.array([[0.,        19.151945, 62.210877, 100.],
+    #                 [19.151945, 0.,        43.772774, 100.],
+    #                 [62.210877, 43.772774, 0.,        100.],
+    #                 [100.,      100.,      100.,      0.]])
+    # np.testing.assert_allclose(D, ref)
+
+
+def test_findshape():
+    # First trivial case of monodentate ligands:
+    args = Namespace(geometry='oct', lig=['carbonyl', 'water'],
+                     ligocc=[5, 1])
+
+    angles_dict = findshape(args, mol3D(name='carbonyl'))
+    assert angles_dict == {'0-0': 0.0}
+
+    # More interesting bidentate case:
+    args = Namespace(geometry='oct', lig=['acac', 'water'],
+                     ligocc=[2, 2])
+
+    angles_dict = findshape(args, mol3D(name='acac'))
+    assert angles_dict == {'0-0': 0.0, '0-1': 90.0,
+                           '1-0': 90.0, '1-1': 0.0}
+
+    args = Namespace(geometry='oct', lig=['porphyrine', 'water'],
+                     ligocc=[1, 2])
+
+    angles_dict = findshape(args, mol3D(name='porphyrine'))
+    assert angles_dict == {'0-0': 0.0, '0-1': 90.0, '0-2': 180.0, '0-3': 90.0,
+                           '1-0': 90.0, '1-1': 0.0, '1-2': 90.0, '1-3': 180.0,
+                           '2-0': 180.0, '2-1': 90.0, '2-2': 0.0, '2-3': 90.0,
+                           '3-0': 90.0, '3-1': 180.0, '3-2': 90.0, '3-3': 0.0}

tests/test_example_1.py

@@ -0,0 +1,29 @@
+import helperFuncs as hp
+
+
+def test_example_1(tmpdir, resource_path_root):
+    testName = "example_1"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert hp.runtest_reportonly(tmpdir, resource_path_root, testName)
+
+
+def test_example_1_No_FF(tmpdir, resource_path_root):
+    testName = "example_1"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_example_3.py

@@ -0,0 +1,31 @@
+import pytest
+import helperFuncs as hp
+
+
+@pytest.mark.skip("Skipping example 3 + FF as it is unclear to me if the core "
+                  "should be frozen during the final optimization. RM")
+def test_example_3(tmpdir, resource_path_root):
+    testName = "example_3"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin
+
+
+def test_example_3_No_FF(tmpdir, resource_path_root):
+    testName = "example_3"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin

tests/test_example_5.py

@@ -0,0 +1,43 @@
+import helperFuncs as hp
+
+
+def test_example_5(tmpdir, resource_path_root):
+    # There are two versions of this test depending on the openbabel version.
+    # This is necessary because openbabel changed the numbering of atoms for v3.
+    try:
+        # This is the recommended method to import openbabel for v3
+        from openbabel import openbabel  # noqa: F401
+        testName = "example_5_v3"
+    except ImportError:
+        testName = "example_5"
+    threshMLBL = 0.1
+    threshLG = 0.5
+    threshOG = 1.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin
+
+
+def test_example_5_No_FF(tmpdir, resource_path_root):
+    # There are two versions of this test depending on the openbabel version.
+    # This is necessary because openbabel changed the numbering of atoms for v3.
+    try:
+        # This is the recommended method to import openbabel for v3
+        from openbabel import openbabel  # noqa: F401
+        testName = "example_5_v3"
+    except ImportError:
+        testName = "example_5"
+    threshMLBL = 0.1
+    threshLG = 0.5
+    threshOG = 1.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin

tests/test_example_7.py

@@ -0,0 +1,28 @@
+import helperFuncs as hp
+
+
+def test_example_7(tmpdir, resource_path_root):
+    testName = "example_7"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 3.0  # Increased threshold from 2.0 to 3.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin
+
+
+def test_example_7_No_FF(tmpdir, resource_path_root):
+    testName = "example_7"
+    threshMLBL = 0.1
+    threshLG = 1.1
+    threshOG = 3.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin

tests/test_example_8.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_example_8(tmpdir, resource_path_root):
+    testName = "example_8"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report, pass_qcin

tests/test_example_tbp.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_example_tbp(tmpdir, resource_path_root):
+    testName = "example_tbp"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_ff_xtb.py

@@ -0,0 +1,111 @@
+import pytest
+import shutil
+import helperFuncs as hp
+
+
+# Decorator to skip test if xtb is not installed
+xtb_installed = pytest.mark.skipif(shutil.which('xtb') is None,
+                                   reason='Could not find xtb installation')
+
+
+@xtb_installed
+def test_xtb_before(tmpdir, resource_path_root):
+    testName = "xtb_H2O_before"
+    threshMLBL = 0.01
+    threshLG = 0.01
+    threshOG = 2.0
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin
+
+
+@pytest.mark.skip(reason="TODO: figure out why this test started failing suddenly")
+@xtb_installed
+def test_xtb_before_after(tmpdir, resource_path_root):
+    testName = "xtb_imidazole_BA"
+    threshMLBL = 0.01
+    threshLG = 0.01
+    threshOG = 0.05
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin
+
+
+@xtb_installed
+def test_xtb_ANC_fail(tmpdir, resource_path_root):
+    testName = "xtb_ANC_fail"
+    threshMLBL = 0.01
+    threshLG = 0.01
+    threshOG = 0.01
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin
+
+
+@xtb_installed
+def test_xtb_high_spin(tmpdir, resource_path_root):
+    testName = "xtb_bipy_spin5"
+    threshMLBL = 0.01
+    threshLG = 0.05
+    threshOG = 0.5
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin
+
+
+@xtb_installed
+def test_xtb_final_opt(tmpdir, resource_path_root):
+    testName = "xtb_final_opt"
+    threshMLBL = 0.01
+    threshLG = 0.01
+    threshOG = 0.05
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin
+
+
+@xtb_installed
+def test_gfnff(tmpdir, resource_path_root):
+    testName = "gfnff_NH3_BA"
+    threshMLBL = 0.01
+    threshLG = 0.01
+    threshOG = 2.0
+    (passNumAtoms, passMLBL, passLG,
+     passOG, pass_report, pass_qcin) = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG, seed=31415)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+    assert pass_qcin

tests/test_geocheck_oct.py

@@ -0,0 +1,26 @@
+import pytest
+import helperFuncs as hp
+
+
+@pytest.mark.parametrize("testName", [
+    "all_flying_away",
+    "broken_ligands",
+    "catom_change",
+    "H_transfer",
+    "ligand_assemble",
+    "ligand_bent",
+    "linear_broken",
+    "methane_trans",
+    "rotational_group",
+    "switch_test",
+    "compact_bonding",
+    "triplebond_linear_broken",
+    "iodine_sulfur",
+    "oct_comp_greedy",
+    "atom_ordering_mismatch",
+    "iodide_radius"
+])
+def test_geocheck_oct(tmpdir, resource_path_root, testName):
+    thresh = 0.01
+    passGeo = hp.runtestgeo(tmpdir, resource_path_root, testName, thresh)
+    assert passGeo

tests/test_geocheck_one_empty.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_example_1(tmpdir, resource_path_root):
+    testName = "one_empty_good"
+    thresh = 0.01
+    passGeo = hp.runtestgeo(tmpdir, resource_path_root, testName, thresh, geo_type="one_empty")
+    assert passGeo
+
+
+def test_example_2(tmpdir, resource_path_root):
+    testName = "one_empty_bad"
+    thresh = 0.01
+    passGeo = hp.runtestgeo(tmpdir, resource_path_root, testName, thresh, geo_type="one_empty")
+    assert passGeo

tests/test_geometry.py

@@ -0,0 +1,44 @@
+import numpy as np
+from molSimplify.Scripts.geometry import (norm,
+                                          normalize,
+                                          checkplanar,
+                                          dihedral,
+                                          )
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Classes.atom3D import atom3D
+
+
+def test_norm():
+    v = [1.2, -.2, 0.8]
+
+    assert abs(norm(v) - np.linalg.norm(v)) < 1e-6
+
+
+def test_normalize():
+    v = [1.8, 0.6, -1.8]
+    v_norm = normalize(v)
+
+    np.testing.assert_allclose(v_norm, np.array(v)/np.linalg.norm(v), atol=1e-6)
+
+
+def test_checkplanar():
+    a1 = [0.0, 0.0, 0.0]
+    a2 = [1.2, 0.6, 1.6]
+    a3 = [-1.1, 0.3, 0.8]
+    a4 = [0.4, -1.2, -0.3]
+
+    assert not checkplanar(a1, a2, a3, a4)
+    # Construct a set four point in plane with the first 3
+    a4 = [0.1, 0.9, 2.4]
+    assert checkplanar(a1, a2, a3, a4)
+
+
+def test_dihedral():
+    mol = mol3D()
+    mol.addAtom(atom3D(Sym='X', xyz=[0.5, 0.0, 1.2]))
+    mol.addAtom(atom3D(Sym='X', xyz=[0.0, 0.0, 0.0]))
+    mol.addAtom(atom3D(Sym='X', xyz=[0.0, 0.0, 1.0]))
+    mol.addAtom(atom3D(Sym='X', xyz=[0.5, 0.5, -0.2]))
+
+    d = dihedral(mol, 0, 1, 2, 3)
+    assert abs(d - 45.0) < 1e-6

tests/test_inparse.py

@@ -0,0 +1,76 @@
+import os
+from molSimplify.Scripts.inparse import (parseinputfile, checkinput,
+                                         parseall,
+                                         parseinputs_basic,
+                                         parseinputs_advanced)
+from argparse import ArgumentParser, Namespace
+
+
+def test_parseinputfile_empty():
+    defaults = {'skipANN': False, 'oldANN': False,
+                'dbvdent': False, 'dbvconns': False,
+                'dbvhyb': False, 'dbvlinks': False,
+                'rprompt': False, 'rundir': f'{os.getcwd()}/Runs'}
+
+    args = Namespace()
+    parseinputfile(args, inputfile_str=' ')
+
+    # Assert defaults are set
+    assert args.__dict__ == defaults
+
+
+def test_parseinputs_basic(monkeypatch):
+    # Monkeypatch is used to change sys.argv parsed by the Argumentparser.
+    monkeypatch.setattr('sys.argv', ['molsimplify'])
+    parser = ArgumentParser()
+    args = parseinputs_basic(parser)
+    defaults = dict(coord=False, core=None, ff='uff', ff_final_opt=None,
+                    ffoption='N', geo=False, geometry=False, keepHs=None,
+                    lig=None, ligloc=False, ligocc=False, multiplicity=None,
+                    oxstate=None, rundir=False, skipANN=None, smicat=False,
+                    spin=None, spinmultiplicity=None, custom_data_dir=None)
+    assert args.__dict__ == defaults
+
+
+def test_parseinputs_advanced(monkeypatch):
+    # Monkeypatch is used to change sys.argv parsed by the Argumentparser.
+    monkeypatch.setattr('sys.argv', ['molsimplify'])
+    parser = ArgumentParser()
+    args = parseinputs_advanced(parser)
+    defaults = dict(MLbonds=False, antigeoisomer=None, calccharge=True,
+                    charge=None, decoration=False, decoration_index=False,
+                    distort='0', genall=False, isomers=None, langles=False,
+                    ligalign=False, nconfs='1', oldANN=None, pangles=False,
+                    reportonly=None, scoreconfs=False, stereos=None)
+    assert args.__dict__ == defaults
+
+
+def test_checkinput(monkeypatch):
+    # Monkeypatch is used to change sys.argv parsed by the Argumentparser.
+    monkeypatch.setattr('sys.argv', ['molsimplify'])
+    parser = ArgumentParser()
+    # Runs all parsers and populates the args Namespace
+    args = parseall(parser)
+    checkinput(args, calctype='base')
+    # Test a few defaults:
+    assert args.core == ['Fe']
+    assert args.oxstate == '2'
+    assert args.spin == '5'
+
+
+def test_parseinputfile_inputfile_kwarg(resource_path_root):
+    """Test that both methods of calling parseinputfile
+    (with an args.i file or inputfile_str kwarg) yield the same result"""
+    infile = resource_path_root / "inputs" / "example_1.in"
+
+    args1 = Namespace(i=infile)
+    parseinputfile(args1)
+
+    with open(infile, 'r') as fin:
+        lines = fin.read()
+    args2 = Namespace()
+    parseinputfile(args2, inputfile_str=lines)
+    # Add 'i' argument for comparison
+    args2.i = infile
+
+    assert args1 == args2