Chimie Théorique » scripts_chimie4psmn » DockOnSurf

import sys

import unittest

sys.path.extend(['../', '../modules', '../examples'])

from dos_input import *

class TestStr2Lst(unittest.TestCase):

    def test_norm_behav(self):

        self.assertEqual(str2lst('45'), [45])

        self.assertEqual(str2lst('(78, 9)'), [[78, 9]])

        self.assertEqual(str2lst('128,(135 138;141) 87 {45 68}'),

                         [128, 87, [135, 138, 141], [45, 68]])

    def test_exceptions(self):

        self.assertRaises(AttributeError, str2lst, 6)

        self.assertRaises(ValueError, str2lst, 'hola')

        self.assertRaises(ValueError, str2lst, '3 ((6 7) 8) 4')

class TestCheckInpFile(unittest.TestCase):

    def test_good(self):

        self.assertEqual(check_inp_file('cp2k.inp', 'cp2k'), None)

    def test_bad(self):

        self.assertRaises(UnboundLocalError, check_inp_file, 'cp2k.sub', 'cp2k')

class TestGoodInput(unittest.TestCase):

    read_input('good.inp')

    def test_all_good(self):

        exp_dict = {'project_name': 'example',

                    'isolated': True,

                    'screening': True,

                    'refinement': True,

                    'code': 'cp2k',

                    'batch_q_sys': 'sge',

                    'subm_script': 'cp2k.sub',

                    'relaunch_err': 'geo_not_conv',

                    'max_qw': 5,

                    'special_atoms': [('Fe1', 'Fe'), ('Fe2', 'Fe'),

                                      ('O1', 'O')],

                    'isol_inp_file': 'cp2k.inp',

                    'molec_file': 'acetic.xyz',

                    'cluster_magns': ['energy', 'moi'],

                    'num_conformers': 100,

                    'min_confs': False,

                    'screen_inp_file': 'screen.inp',

                    'sites': [128, [135, 138, 141]],

                    'molec_ads_ctrs': [178, [185, 187]],

                    'try_disso': True,

                    'sample_points_per_angle': 4,

                    'collision_threshold': 0.9,

                    'collision_bottom_z': 5.2,

                    'refine_inp_file': 'refine.inp',

                    'energy_cutoff': 1.0

                    }

        self.assertEqual(read_input('good.inp'), exp_dict)

    # TODO add single tests for subm_script and project_name

    def test_run_type(self):

        self.assertEqual(get_run_type(), (True, True, True))

    def test_code(self):

        self.assertEqual(get_code(), 'cp2k')

    def test_batch_q_sys(self):

        self.assertEqual(get_batch_q_sys(), 'sge')

    def test_relaunch_err(self):

        self.assertEqual(get_relaunch_err(), 'geo_not_conv')

    def test_max_qw(self):

        self.assertEqual(get_max_qw(), 5)

    def test_special_atoms(self):

        self.assertEqual(get_special_atoms(), [('Fe1', 'Fe'), ('Fe2', 'Fe'),

                                               ('O1', 'O')])

    def test_isol_inp_file(self):

        self.assertEqual(get_isol_inp_file(), 'isolated.inp')

    def test_molec_file(self):

        print(os.getcwd())

        self.assertEqual(get_molec_file(), 'acetic.xyz')

    def test_cluster_magns(self):

        self.assertEqual(get_cluster_magns(), ['energy', 'moi'])

    def test_num_conformers(self):

        self.assertEqual(get_num_conformers(), 100)

    def test_min_confs(self):

        self.assertEqual(get_min_confs(), False)

    def test_screen_inp_file(self):

        self.assertEqual(get_screen_inp_file(), 'screen.inp')

    def test_sites(self):

        self.assertEqual(get_sites(), [128, [135, 138, 141]])

    def test_molec_ads_ctrs(self):

        self.assertEqual(get_molec_ads_ctrs(), [178, [185, 187]])

    def test_try_disso(self):

        self.assertEqual(get_try_disso(), True)

    def test_pts_per_angle(self):

        self.assertEqual(get_pts_per_angle(), 4)

    def test_coll_thrsld(self):

        self.assertEqual(get_coll_thrsld(), 0.9)

    def test_coll_bottom_z(self):

        self.assertEqual(get_coll_bottom_z(), 5.2)

    def test_refine_inp_file(self):

        self.assertEqual(get_refine_inp_file(), 'refine.inp')

    def test_energy_cutoff(self):

        self.assertEqual(get_energy_cutoff(), 1.0)

class TestBadInput(unittest.TestCase):

    dos_inp.read('wrong.inp')

    def test_run_type(self):

        self.assertRaises(ValueError, get_run_type)

    def test_code(self):

        self.assertRaises(ValueError, get_code)

    def test_batch_q_sys(self):

        self.assertRaises(ValueError, get_batch_q_sys)

    def test_relaunch_err(self):

        self.assertRaises(ValueError, get_relaunch_err)

    def test_max_qw(self):

        self.assertRaises(ValueError, get_max_qw)

    def test_special_atoms(self):

        self.assertRaises(ValueError, get_special_atoms)

    def test_isol_inp_file(self):

        self.assertRaises(FileNotFoundError, get_isol_inp_file)

    def test_cluster_magns(self):

        self.assertRaises(ValueError, get_cluster_magns)

    def test_num_conformers(self):

        self.assertRaises(ValueError, get_num_conformers)

    def test_min_confs(self):

        self.assertRaises(ValueError, get_min_confs)

    def test_screen_inp_file(self):

        self.assertRaises(FileNotFoundError, get_screen_inp_file)

    def test_sites(self):

        self.assertRaises(ValueError, get_sites)

    def test_molec_ads_ctrs(self):

        self.assertRaises(ValueError, get_molec_ads_ctrs)

    def test_try_disso(self):

        self.assertRaises(ValueError, get_try_disso)

    def test_pts_per_angle(self):

        self.assertRaises(ValueError, get_pts_per_angle)

    def test_coll_thrsld(self):

        self.assertRaises(ValueError, get_coll_thrsld)

    def test_coll_bottom_z(self):

        self.assertRaises(ValueError, get_coll_bottom_z)

    def test_refine_inp_file(self):

        self.assertRaises(FileNotFoundError, get_refine_inp_file)

    def test_energy_cutoff(self):

        self.assertRaises(ValueError, get_energy_cutoff)

if __name__ == '__main__':

    unittest.main()