From: Michael R. Crusoe <crusoe@debian.org>
Subject: skip tests relying on CC *-NC data that we don't distribute
Forwarded: not-needed
--- macsylib.orig/tests/test_Config.py
+++ macsylib/tests/test_Config.py
@@ -411,24 +411,6 @@
             else:
                 self.assertEqual(getattr(cfg, opt)(), exp_val)
 
-
-    def test_model_conf(self):
-        self.parsed_args.models_dir = self.find_data('models')
-        self.parsed_args.models = "Model_w_conf all"
-        cfg = Config(self.defaults, self.parsed_args)
-        expected_weights = {'mandatory': 13.0,
-                            'accessory': 14.0,
-                            'neutral': 0.0,
-                            'itself': 11.0,
-                            'exchangeable': 12.0,
-                            'out_of_cluster': 10.0}
-        self.assertDictEqual(cfg.hit_weights(), expected_weights)
-        self.assertEqual(cfg.i_evalue_sel(), 0.012)
-        self.assertEqual(cfg.e_value_search(), 0.12)
-        self.assertEqual(cfg.coverage_profile(), 0.55)
-        self.assertFalse(cfg.cut_ga())
-
-
     def test_bad_values(self):
         invalid_syntax = {'inter_gene_max_space': 'set_1/Flagellum 4 2',
                           'max_nb_genes': 'set_1/Flagellum set_1/T3SS 3',
@@ -558,33 +540,6 @@
         self.assertEqual(str(ctx.exception),
                          f"Previous run: No config file (macsylib.conf) found in dir {self.parsed_args.previous_run}")
 
-    def test_cut_ga(self):
-        # default value
-        cfg = Config(self.defaults, self.parsed_args)
-        self.assertTrue(cfg.cut_ga())
-        # user specify --no-cu-ga
-        self.parsed_args.no_cut_ga = True
-        cfg = Config(self.defaults, self.parsed_args)
-        self.assertFalse(cfg.cut_ga())
-
-        # the user does not specify anything
-        # the modeler set cut-ga false in model_conf
-        self.parsed_args.cut_ga = None
-        self.parsed_args.no_cut_ga = None
-        self.parsed_args.models_dir = self.find_data('models')
-        self.parsed_args.models = ['TFF-SF', 'all']
-        cfg = Config(self.defaults, self.parsed_args)
-        self.assertFalse(cfg.cut_ga())
-
-        # the user specify --cut-ga
-        # the modeler set cut-ga false in model_conf
-        self.parsed_args.cut_ga = True
-        self.parsed_args.no_cut_ga = None
-        self.parsed_args.models_dir = self.find_data('models')
-        self.parsed_args.models = ['TFF-SF', 'all']
-        cfg = Config(self.defaults, self.parsed_args)
-        self.assertTrue(cfg.cut_ga())
-
     def test_models(self):
         self.parsed_args.models = ['TFF-SF', 'all']
         cfg = Config(self.defaults, self.parsed_args)
--- macsylib.orig/tests/test_DefinitionParser.py
+++ macsylib/tests/test_DefinitionParser.py
@@ -64,563 +64,3 @@
 
     def tearDown(self):
         self.tmp_dir.cleanup()
-
-
-    def test_parse_with_exchangeable(self):
-        model_name = 'model_1'
-        model_family = 'foo'
-        fqn = f"{model_family}/{model_name}"
-        # def_2_parse = set()
-        # def_2_parse.add(fqn)
-        models_2_detect = [self.model_registry['foo'].get_definition(fqn)]
-        self.parser.parse(models_2_detect)
-        self.assertEqual(len(self.model_bank), 1)
-
-        m1 = self.model_bank[fqn]
-        self.assertEqual(m1.name, model_name)
-        self.assertEqual(m1.fqn, fqn)
-        self.assertEqual(m1.inter_gene_max_space, 20)
-        self.assertEqual(m1.min_mandatory_genes_required, 2)
-        self.assertEqual(m1.min_genes_required, 4)
-        self.assertTrue(m1.multi_loci)
-
-        self.assertEqual(len(m1.mandatory_genes), 2)
-        mandatory_genes_name = sorted([g.name for g in m1.mandatory_genes])
-        theoric_list = sorted(["sctJ_FLG", "sctN_FLG"])
-        self.assertListEqual(mandatory_genes_name, theoric_list)
-
-        self.assertEqual(len(m1.accessory_genes), 2)
-        accessory_genes_name = sorted([g.name for g in m1.accessory_genes])
-        theoric_list = sorted(["flgB", "flgC"])
-        self.assertListEqual(accessory_genes_name, theoric_list)
-
-        self.assertEqual(len(m1.neutral_genes), 2)
-        neutral_genes_name = sorted([g.name for g in m1.neutral_genes])
-        theoric_list = sorted(["fliE", "tadZ"])
-        self.assertListEqual(neutral_genes_name, theoric_list)
-
-        self.assertEqual(len(m1.forbidden_genes), 1)
-        forbidden_genes_name = sorted([g.name for g in m1.forbidden_genes])
-        theoric_list = sorted(["sctC"])
-        self.assertListEqual(forbidden_genes_name, theoric_list)
-
-        sctJ_FLG = m1.get_gene('sctJ_FLG')
-        sctJ_FLG_exchangeables = sctJ_FLG.exchangeables
-        self.assertEqual(len(sctJ_FLG_exchangeables), 2)
-        self.assertEqual(sctJ_FLG_exchangeables[0].name, 'sctJ')
-        self.assertEqual(sctJ_FLG_exchangeables[1].name, 'abc')
-        self.assertTrue(isinstance(sctJ_FLG_exchangeables[0], Exchangeable))
-        self.assertTrue(isinstance(sctJ_FLG_exchangeables[0]._gene, CoreGene))
-        self.assertTrue(isinstance(sctJ_FLG_exchangeables[0].alternate_of(), ModelGene))
-        self.assertTrue(sctJ_FLG_exchangeables[0].loner)
-        self.assertFalse(sctJ_FLG.is_exchangeable)
-        sctJ = m1.get_gene('sctJ')
-        self.assertTrue(sctJ.is_exchangeable)
-
-
-    def test_exchangeable_inheritance(self):
-        def_2_parse = set()
-        def_2_parse.add('foo/model_1')
-        models_2_detect = [self.model_registry['foo'].get_definition('foo/model_1')]
-        self.parser.parse(models_2_detect)
-        m1 = self.model_bank['foo/model_1']
-
-        sctJ = m1.get_gene('sctJ')
-        self.assertTrue(sctJ.is_exchangeable)
-        self.assertTrue(sctJ.loner)
-        self.assertTrue(sctJ.multi_system)
-        self.assertFalse(sctJ.multi_model)
-        sctJ_FLG = m1.get_gene('sctJ_FLG')
-        self.assertTrue(sctJ_FLG.multi_system)
-        abc = m1.get_gene('abc')
-        self.assertFalse(abc.multi_system)
-
-        sctN = m1.get_gene('sctN')
-        sctN_FLG = m1.get_gene('sctN_FLG')
-
-        self.assertFalse(sctN_FLG.loner)
-        self.assertTrue(sctN.loner)
-        self.assertIsNone(sctN_FLG.inter_gene_max_space)
-        self.assertEqual(sctN.inter_gene_max_space, 10)
-        self.assertFalse(sctN_FLG.multi_model)
-        self.assertFalse(sctN.multi_model)
-        gspD = m1.get_gene('gspD')
-        self.assertFalse(sctN_FLG.multi_system)
-        self.assertTrue(gspD.multi_model)
-        self.assertTrue(gspD.multi_system)
-
-    def test_no_vers(self):
-        fam_name = 'foo'
-        def_name = 'model_no_vers'
-        fqn =  f'{fam_name}/{def_name}'
-        model_2_detect = [self.model_registry[fam_name].get_definition(fqn)]
-        with self.assertRaises(MacsylibError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         f"Unable to parse model definition '{fqn}' : "
-                         f"The model definition {def_name}.xml is not versioned. Please update your model."
-                         )
-
-    def test_vers_with_minor(self):
-        fam_name = 'foo'
-        def_name = 'model_vers_minor'
-        fqn = f'{fam_name}/{def_name}'
-        model_2_detect = [self.model_registry[fam_name].get_definition(fqn)]
-        self.parser.parse(model_2_detect)
-        m = self.model_bank[fqn]
-        self.assertTrue(isinstance(m, Model))
-
-    def test_unsupported_vers(self):
-        fam_name = 'foo'
-        def_name = 'model_unsupported_vers'
-        fqn = f'{fam_name}/{def_name}'
-        model_2_detect = [self.model_registry[fam_name].get_definition(fqn)]
-        with self.assertRaises(MacsylibError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.maxDiff = None
-        self.assertEqual(str(context.exception),
-                         f"Unable to parse model definition '{fqn}' : The model definition {def_name}.xml "
-                              f"has unsupported version: 3 . Supported versions are >=2, <3 . Please update your model."
-                         )
-
-    def test_model_w_unkown_attr(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/model_w_unknown_attribute')]
-        with self.assertRaises(MacsylibError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Unable to parse model definition 'foo/model_w_unknown_attribute' : "
-                         "The model definition model_w_unknown_attribute.xml has an unknow attribute 'multi-loci'. "
-                         "Please fix the definition.")
-
-    def test_gene_w_unkown_attr(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/gene_w_unknown_attribute')]
-        with self.assertRaises(MacsylibError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Unable to parse model definition 'foo/gene_w_unknown_attribute' : "
-                         "The model definition gene_w_unknown_attribute.xml has an unknown attribute 'multi-system' for a gene."
-                         " Please fix the definition.")
-
-    def test_wo_presence(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/fail_wo_presence')]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition 'foo/fail_wo_presence': gene 'sctN_FLG' without presence")
-
-
-    def test_invalid_presence(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/fail_invalid_presence')]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Invalid model 'foo/fail_invalid_presence' definition: presence value must be either: "
-                         "'mandatory', 'accessory', 'neutral', 'forbidden' not foo_bar")
-
-    def test_gene_no_name(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/gene_no_name')]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition 'foo/gene_no_name': gene without name")
-
-    def test_invalid_exchangeable(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/invalid_homolog')]
-        with self.assertRaises(MacsylibError) as context:
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "'foo/foo_bar': No such profile")
-
-    def test_invalid_exchangeable_2(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/invalid_homolog_2')]
-        with self.assertRaises(SyntaxError) as ctx:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(ctx.exception), "Invalid model definition 'foo/invalid_homolog_2': gene without name")
-
-
-    def test_bad_min_genes_required(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_genes_required')]
-        with self.assertRaises(ModelInconsistencyError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         'model \'bad_min_genes_required\' is not consistent: min_genes_required 16 must be lesser '
-                         'or equal than the number of "accessory" and "mandatory" components in the model: 6')
-
-    def test_bad_min_genes_required_2(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_genes_required_2')]
-        with self.catch_log():
-            with self.assertRaisesRegex(SyntaxError, "Invalid model definition (.*): "
-                                                     "min_genes_required must be an integer: 16.5"):
-                self.parser.parse(model_2_detect)
-
-    def test_bad_min_mandatory_genes_required(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_mandatory_genes_required')]
-        with self.catch_log():
-            with self.assertRaises(ModelInconsistencyError) as context:
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         'model \'bad_min_mandatory_genes_required\' is not consistent: min_genes_required 16 must '
-                         'be lesser or equal than the number of "accessory" and "mandatory" components in the model: 6')
-
-    def test_bad_min_mandatory_genes_required_2(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_mandatory_genes_required_2')]
-        with self.assertRaises(ModelInconsistencyError) as context:
-            with self.catch_log():
-                # error raised by System initialization
-                # which occur before check_consistency
-                # the last test : not(model.min_mandatory_genes_required <= model.min_genes_required)
-                # seems to be useless
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "foo/bad_min_mandatory_genes_required_2: min_genes_required '6' must be greater or equal"
-                         " than min_mandatory_genes_required '8'")
-
-    def test_bad_min_mandatory_genes_required_4(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_mandatory_genes_required_4')]
-        with self.assertRaisesRegex(SyntaxError, "Invalid model definition (.*): "
-                                                  "min_mandatory_genes_required must be an integer: 12.5"):
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-
-
-    def test_min_mandatory_genes_required_lesser_than_mandatory_genes(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_min_mandatory_genes_required_3')]
-        with self.assertRaises(ModelInconsistencyError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "model 'bad_min_mandatory_genes_required_3' is not consistent:"
-                         " 'min_mandatory_genes_required': 6 must be lesser or equal than the number of 'mandatory' "
-                         "components in the model: 5")
-
-    def test_only_one_accessory(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/only_one_accessory')]
-        with self.assertRaises(ModelInconsistencyError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "model 'only_one_accessory' is not consistent: there is only one gene in your model. " \
-                         "So its status should be 'mandatory'.")
-
-
-    def test_bad_max_nb_genes(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/bad_max_nb_genes')]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        model_name, def_name = model_2_detect[0].split_fqn(model_2_detect[0].fqn)
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition ({0}.xml): max_nb_genes must be an integer: HOHOHO".format(
-                             os.path.join(self.cfg.models_dir()[0],
-                                          model_name,
-                                          'definitions',
-                                          def_name)))
-
-
-    def test_bad_inter_gene_max_space(self):
-        fqn = 'foo/bad_inter_gene_max_space'
-        model_family, model_name = fqn.split('/')
-        model_2_detect = [self.model_registry['foo'].get_definition(fqn)]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition ({}): inter_gene_max_space must be an integer: 12.5".format(
-                             os.path.join(self.cfg.models_dir()[0],
-                                          model_family, 'definitions', model_name + ".xml")
-                         )
-                         )
-
-    def test_no_inter_gene_max_space(self):
-        model_2_detect = [self.model_registry['foo'].get_definition('foo/no_inter_gene_max_space')]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition ({}): inter_gene_max_space must be defined".format(
-                             os.path.join(self.cfg.models_dir()[0], "foo/definitions/no_inter_gene_max_space.xml")
-                         )
-                         )
-
-
-    def test_loner(self):
-        model_fqn = 'foo/model_5'
-        model_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(model_2_detect)
-
-        m5 = self.model_bank[model_fqn]
-        m5_flgC = m5.get_gene('flgC')
-        self.assertFalse(m5_flgC.loner)
-        m5_tadZ = m5.get_gene('tadZ')
-        self.assertTrue(m5_tadZ.loner)
-
-        model_fqn = 'foo/model_6'
-        model_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(model_2_detect)
-        m6 = self.model_bank[model_fqn]
-        m6_flgC = m6.get_gene('flgC')
-        self.assertFalse(m6_flgC.loner)
-        m6_tadZ = m6.get_gene('tadZ')
-        self.assertFalse(m6_tadZ.loner)
-
-
-    def test_multi_system(self):
-        model_fqn = 'foo/model_5'
-        model_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(model_2_detect)
-
-        m = self.model_bank[model_fqn]
-        flgC = m.get_gene('flgC')
-        self.assertFalse(flgC.multi_system)
-        fliE = m.get_gene('fliE')
-        self.assertTrue(fliE.multi_system)
-
-
-    def test_multi_model(self):
-        model_fqn = 'foo/model_5'
-        model_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(model_2_detect)
-
-        m = self.model_bank[model_fqn]
-        flgC = m.get_gene('flgC')
-        self.assertFalse(flgC.multi_model)
-        abc = m.get_gene('abc')
-        self.assertTrue(abc.multi_model)
-
-
-    def test_gene_inter_gene_max_space(self):
-        model_fqn = ['foo/model_5', 'foo/model_6']
-        models_2_detect = [self.model_registry['foo'].get_definition(fqn) for fqn in model_fqn]
-        self.parser.parse(models_2_detect)
-
-        m5 = self.model_bank['foo/model_5']
-        self.assertEqual(m5.name, 'model_5')
-        self.assertEqual(m5.fqn, 'foo/model_5')
-        self.assertEqual(m5.inter_gene_max_space, 20)
-        m5_flgB = m5.get_gene('flgB')
-        m5_flgC = m5.get_gene('flgC')
-        self.assertIsNone(m5_flgB.inter_gene_max_space)
-        self.assertEqual(m5_flgC.inter_gene_max_space, 2)
-        m6 = self.model_bank['foo/model_6']
-        m6_flgC = m6.get_gene('flgC')
-        self.assertEqual(m6_flgC.inter_gene_max_space, 12)
-
-
-    def test_inter_gene_max_space_cfg(self):
-        # test inter_gene_max_space is specified from configuration
-        # so this value must overload the value read from xml
-        model_fqn = 'foo/model_5'
-
-        inter_gene_max_space_cfg = [[model_fqn, '222']]
-        self.args.inter_gene_max_space = inter_gene_max_space_cfg
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_bank = ModelBank()
-        self.gene_bank = GeneBank()
-        self.model_registry = ModelRegistry()
-        models_location = scan_models_dir(self.args.models_dir)
-        for ml in models_location:
-            self.model_registry.add(ml)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertEqual(m.inter_gene_max_space, 222)
-
-
-    def test_min_mandatory_genes_required_cfg(self):
-        # test min_mandatory_genes_required is specified from configuration
-        # so this value must overload the value read from xml
-        model_fqn = 'foo/model_5'
-
-        min_mandatory_genes_required = [[model_fqn, '3']]
-        self.args.min_mandatory_genes_required = min_mandatory_genes_required
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_bank = ModelBank()
-        self.gene_bank = GeneBank()
-        self.model_registry = ModelRegistry()
-        models_location = scan_models_dir(self.args.models_dir)
-        for ml in models_location:
-            self.model_registry.add(ml)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertEqual(m.min_mandatory_genes_required, 3)
-
-
-    def test_min_genes_required_cfg(self):
-        # test min_genes_required is specified from configuration
-        # so this value must overload the value read from xml
-        def_2_parse = set()
-        model_fqn = 'foo/model_5'
-        def_2_parse.add(model_fqn)
-
-        min_genes_required = [[model_fqn, '4']]
-        self.args.min_genes_required = min_genes_required
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_bank = ModelBank()
-        self.gene_bank = GeneBank()
-        self.model_registry = ModelRegistry()
-        models_location = scan_models_dir(self.args.models_dir)
-        for ml in models_location:
-            self.model_registry.add(ml)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertEqual(m.min_genes_required, 4)
-
-
-    def test_max_nb_genes_cfg(self):
-        self.model_bank = ModelBank()
-        self.gene_bank = GeneBank()
-        self.model_registry = ModelRegistry()
-        models_location = scan_models_dir(self.args.models_dir)
-        for ml in models_location:
-            self.model_registry.add(ml)
-
-        # max_nb_genes is specified in xml
-        # no user configuration on this
-        self.cfg = Config(MacsyDefaults(), self.args)
-        model_fqn = 'foo/model_6'  # 4 genes in this model but xml specify 3
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertEqual(m.max_nb_genes, 3)
-
-        # max_nb_genes is specified from configuration
-        # so this value must overload the value read from xml
-        model_fqn = 'foo/model_5' # 4 genes in this model
-        max_nb_genes = [[model_fqn, '6']]
-        self.args.max_nb_genes = max_nb_genes
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertEqual(m.max_nb_genes, 6)
-
-
-    def test_multi_loci_cfg(self):
-        # test multi_loci is specified from configuration
-        # so this value must overload the value read from xml
-        model_fqn = 'foo/model_5'
-
-        self.args.multi_loci = model_fqn
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_bank = ModelBank()
-        self.gene_bank = GeneBank()
-        self.model_registry = ModelRegistry()
-        models_location = scan_models_dir(self.args.models_dir)
-        for ml in models_location:
-            self.model_registry.add(ml)
-        self.parser = DefinitionParser(self.cfg, self.model_bank, self.gene_bank,
-                                       self.model_registry, self.profile_factory)
-
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        self.parser.parse(models_2_detect)
-        m = self.model_bank[model_fqn]
-        self.assertTrue(m.multi_loci)
-
-
-    def test_bad_gene_inter_gene_max_space_2(self):
-        model_fqn = 'foo/bad_inter_gene_max_space_2'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.assertRaises(SyntaxError) as ctx:
-            with self.catch_log():
-                self.parser.parse(models_2_detect)
-
-        self.assertEqual(str(ctx.exception), "Invalid model definition 'foo/bad_inter_gene_max_space_2': "
-                                             "inter_gene_max_space must be an integer: 2.5")
-
-
-    def test_bad_exchangeable_inter_gene_max_space(self):
-        fqn = 'foo/bad_exchangeable_inter_gene_max_space'
-        model_2_detect = [self.model_registry['foo'].get_definition(fqn)]
-        with self.assertRaises(SyntaxError) as context:
-            with self.catch_log():
-                self.parser.parse(model_2_detect)
-        self.assertEqual(str(context.exception),
-                         "Invalid model definition 'foo/bad_exchangeable_inter_gene_max_space': "
-                         "inter_gene_max_space must be an integer: 1.5")
-
-
-    def test_parse_model_old_syntax(self):
-        # the attribute root node of definition is 'system' instead of 'model'
-        model_fqn = 'foo/model_old_1'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                self.parser.parse(models_2_detect)
-        # test the err msg not the log
-        # otherwise the olg differ of test are ran from run_test.py or setup.py
-        self.assertEqual(str(ctx.exception),
-                         "Unable to parse model definition 'foo/model_old_1' : "
-                         "The model definition model_old_1.xml is obsolete. Please update your model.")
-
-        # the root is system instead of model
-        model_fqn = 'foo/model_old_2'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                self.parser.parse(models_2_detect)
-        self.assertEqual(str(ctx.exception),
-                         f"Unable to parse model definition '{model_fqn}' : "
-                         "The model definition model_old_2.xml is obsolete. Please update your model.")
-
-        # there still system_ref attribute
-        model_fqn = 'foo/model_old_3'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                self.parser.parse(models_2_detect)
-        self.assertEqual(str(ctx.exception),
-                         f"Unable to parse model definition '{model_fqn}' : "
-                         "The model definition model_old_3.xml is obsolete. Please update your model.")
-
-        # there still homologs tag
-        model_fqn = 'foo/model_old_4'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                self.parser.parse(models_2_detect)
-        self.assertEqual(str(ctx.exception),
-                         f"Unable to parse model definition '{model_fqn}' : "
-                         "The model definition model_old_4.xml is obsolete. Please update your model.")
-
-        # there still analogs tag
-        model_fqn = 'foo/model_old_5'
-        models_2_detect = [self.model_registry['foo'].get_definition(model_fqn)]
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                self.parser.parse(models_2_detect)
-        self.assertEqual(str(ctx.exception),
-                         f"Unable to parse model definition '{model_fqn}' : "
-                         "The model definition model_old_5.xml is obsolete. Please update your model.")
--- macsylib.orig/tests/test_Exchangeable.py
+++ macsylib/tests/test_Exchangeable.py
@@ -37,110 +37,3 @@
 from macsylib.error import MacsylibError
 from tests import MacsyTest
 
-
-class TestExchangeable(MacsyTest):
-
-    def setUp(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_Exchangeable_')
-        args.res_search_dir = os.path.join(self.tmp_dir.name, 'res_search_dir')
-        args.log_level = 30
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def tearDown(self):
-        self.tmp_dir.cleanup()
-
-
-    def test_alternate_of(self):
-        model = Model("T2SS", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-        gene_ref.add_exchangeable(homolog_1)
-
-        self.assertEqual(homolog_1.alternate_of(), gene_ref)
-
-    def test_is_exchangeable(self):
-        model = Model("T2SS", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-
-        self.assertTrue(homolog_1.is_exchangeable)
-
-    def test_add_exchangeable(self):
-        model = Model("T2SS", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-        homolog_2 = Exchangeable(c_gene, gene_ref)
-
-        with self.assertRaises(MacsylibError) as ctx:
-            homolog_1.add_exchangeable(homolog_2)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot add 'Exchangeable' to an Exchangeable")
-
-    def test_model(self):
-        model = Model("T2SS", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-
-        self.assertEqual(homolog_1.model, gene_ref.model)
-
-
-    def test_loner(self):
-        model = Model("T2SS", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-        gene_ref_loner = ModelGene(c_gene_ref, model, loner=True)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-        homolog_2 = Exchangeable(c_gene, gene_ref_loner)
-
-        self.assertFalse(homolog_1.loner)
-        self.assertTrue(homolog_2.loner)
-
-
-    def test_multi_system(self):
-        model = Model("T2SS", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref, model)
-        gene_ref_multi_system = ModelGene(c_gene_ref, model, multi_system=True)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        homolog_1 = Exchangeable(c_gene, gene_ref)
-        homolog_2 = Exchangeable(c_gene, gene_ref_multi_system)
-
-        self.assertFalse(homolog_1.multi_system)
-        self.assertTrue(homolog_2.multi_system)
--- macsylib.orig/tests/test_GeneBank.py
+++ macsylib/tests/test_GeneBank.py
@@ -40,83 +40,4 @@
 from tests import MacsyTest
 
 
-class Test(MacsyTest):
 
-    def setUp(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_GeneBank_')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 30
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.gene_bank = GeneBank()
-        self.profile_factory = ProfileFactory(self.cfg)
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_add_get_gene(self):
-        gene_name = 'sctJ_FLG'
-        with self.assertRaises(KeyError) as ctx:
-            self.gene_bank[f"foo/{gene_name}"]
-        self.assertEqual(str(ctx.exception),
-                         f"\"No such gene 'foo/{gene_name}' in this bank\"")
-        model_foo = Model(self.model_name, 10)
-
-        self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-
-        gene_from_bank = self.gene_bank[(model_foo.family_name, gene_name)]
-        self.assertTrue(isinstance(gene_from_bank, CoreGene))
-        self.assertEqual(gene_from_bank.name, gene_name)
-        gbk_contains_before = list(self.gene_bank)
-        self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-        gbk_contains_after = list(self.gene_bank)
-        self.assertEqual(gbk_contains_before, gbk_contains_after)
-
-        gene_name = "bar"
-        with self.assertRaises(MacsylibError) as ctx:
-            self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-        self.assertEqual(str(ctx.exception),
-                         f"'{self.model_name}/{gene_name}': No such profile")
-
-
-    def test_contains(self):
-        model_foo = Model("foo/bar", 10)
-        gene_name = 'sctJ_FLG'
-
-        self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-        gene_in = self.gene_bank[(model_foo.family_name, gene_name)]
-        self.assertIn(gene_in, self.gene_bank)
-
-        gene_name = 'abc'
-        c_gene_out = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_out = ModelGene(c_gene_out, model_foo)
-        self.assertNotIn(gene_out, self.gene_bank)
-
-
-    def test_iter(self):
-        genes_names = ['sctJ_FLG', 'abc']
-        for g in genes_names:
-            self.gene_bank.add_new_gene(self.model_location, g, self.profile_factory)
-        self.assertListEqual([g.name for g in self.gene_bank],
-                             genes_names)
-
-    def test_genes_fqn(self):
-        genes_names = ['sctJ_FLG', 'abc']
-        for g in genes_names:
-            self.gene_bank.add_new_gene(self.model_location, g, self.profile_factory)
-        self.assertSetEqual(set(self.gene_bank.genes_fqn()),
-                             {f"{self.model_location.name}/{g.name}" for g in self.gene_bank})
-
-
-    def test_get_uniq_object(self):
-        gene_name = 'sctJ_FLG'
-        self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-        self.gene_bank.add_new_gene(self.model_location, gene_name, self.profile_factory)
-        self.assertEqual(len(self.gene_bank), 1)
--- macsylib.orig/tests/test_LikelySystem.py
+++ macsylib/tests/test_LikelySystem.py
@@ -38,223 +38,4 @@
 from tests import MacsyTest
 
 
-class LikelySystemTest(MacsyTest):
 
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def test_init(self):
-        model = Model("foo/model_A", 10)
-        # test if id is well incremented
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2], [], [])
-        self.assertTrue(ls_1.id.startswith('replicon_id_model_A_'))
-
-        ls_2 = LikelySystem(model, [v_hit_1, v_hit_2], [], [], [])
-        # check if the id of the second likelysystem is well increased
-        self.assertEqual(int(ls_2.id.split('_')[-1]), int(ls_1.id.split('_')[-1]) + 1)
-
-    def test_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [])
-
-        self.assertListEqual(ls_1.hits, [v_hit_1, v_hit_2, v_hit_3])
-
-    def test_str(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [])
-        expected_str = ', '.join([f"({h.id}, {h.gene.name}, {h.position})" for h in (v_hit_1, v_hit_2, v_hit_3)])
-        self.assertEqual(str(ls_1), expected_str)
-
-    def test_forbidden_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_forbidden_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_forbidden_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.FORBIDDEN)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.FORBIDDEN)
-        ls_1 = LikelySystem(model, [v_hit_1], [], [], [v_hit_2, v_hit_3])
-        self.assertListEqual(ls_1.forbidden_hits, [v_hit_2, v_hit_3])
-
-    def test_allowed_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2], [], [v_hit_3])
-        self.assertListEqual(ls_1.allowed_hits, [v_hit_1, v_hit_2])
-
-
-class UnlikelySystemTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-    def test_init(self):
-        model = Model("foo/model_A", 10)
-        # test if id is well incremented
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        uls_1 = UnlikelySystem(model, [v_hit_1], [v_hit_2], [], [], ["reason"])
-        self.assertTrue(uls_1.id.startswith('replicon_id_model_A_'))
-
-        uls_2 = UnlikelySystem(model, [v_hit_1], [v_hit_2], [], [], ["reason"])
-        self.assertEqual(int(uls_2.id.split('_')[-1]), int(uls_1.id.split('_')[-1]) + 1)
-
-    def test_reason(self):
-        model = Model("foo/model_A", 10)
-        # test if id is well incremented
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_forbidden_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.FORBIDDEN)
-        reason_2 = ["forbidden gene"]
-        uls_2 = UnlikelySystem(model, [v_hit_1], [], [], [v_hit_2], reason_2)
-        self.assertEqual(uls_2.reasons, reason_2)
-
-
-    def test_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        uls_1 = UnlikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [], ["reason"])
-
-        self.assertListEqual(uls_1.hits, [v_hit_1, v_hit_2, v_hit_3])
-
-
-    def test_str(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        uls_1 = UnlikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [], ["reason"])
-
-        expected_str = """(hit_1, gspD, 1), (hit_2, sctJ, 2), (hit_3, sctN, 3): These hits does not probably constitute a system because:
-reason"""
-        self.assertEqual(str(uls_1), expected_str)
--- macsylib.orig/tests/test_MatchMaker.py
+++ macsylib/tests/test_MatchMaker.py
@@ -39,349 +39,3 @@
 from macsylib.error import MacsylibError
 
 from tests import MacsyTest
-
-
-class MatchMakerTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-        self.model = Model("foo/model_A", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, self.model)
-
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, self.model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, self.model)
-
-        c_gene_flgb = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_ex = Exchangeable(c_gene_flgb, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_ex)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, self.model)
-        c_gene_tadz = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ex = Exchangeable(c_gene_tadz, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ex)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, self.model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ex = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ex)
-
-        self.model.add_mandatory_gene(gene_sctn)
-        self.model.add_mandatory_gene(gene_sctj)
-        self.model.add_accessory_gene(gene_gspd)
-        self.model.add_neutral_gene(gene_toto)
-        self.model.add_forbidden_gene(gene_abc)
-
-        self.c_hits = {
-                    'ch_sctj': CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_sctj_flg': CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_sctn': CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_sctn_flg': CoreHit(c_gene_sctn_flg, "hit_sctn_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_gspd': CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_gspd_ex': CoreHit(c_gene_flgb, "hit_gspd_an", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_abc': CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_abc_ex': CoreHit(c_gene_tadz, "hit_abc_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_toto': CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    'ch_toto_ex': CoreHit(c_gene_totote, "hit_toto_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20),
-                    }
-        self.m_hits = {
-            'mh_sctj': ModelHit(self.c_hits['ch_sctj'], gene_sctj, GeneStatus.MANDATORY),
-            'mh_sctj_flg': ModelHit(self.c_hits['ch_sctj_flg'], gene_sctj_flg, GeneStatus.MANDATORY),
-            'mh_sctn': ModelHit(self.c_hits['ch_sctn'], gene_sctn, GeneStatus.MANDATORY),
-            'mh_sctn_flg': ModelHit(self.c_hits['ch_sctn_flg'], gene_sctn_flg, GeneStatus.MANDATORY),
-            'mh_gspd': ModelHit(self.c_hits['ch_gspd'], gene_gspd, GeneStatus.ACCESSORY),
-            'mh_gspd_ex': ModelHit(self.c_hits['ch_gspd_ex'], gene_gspd_ex, GeneStatus.ACCESSORY),
-            'mh_abc': ModelHit(self.c_hits['ch_abc'], gene_abc, GeneStatus.FORBIDDEN),
-            'mh_abc_ex': ModelHit(self.c_hits['ch_abc_ex'], gene_abc_ex, GeneStatus.FORBIDDEN),
-            'mh_toto': ModelHit(self.c_hits['ch_toto'], gene_toto, GeneStatus.NEUTRAL),
-            'mh_toto_ex': ModelHit(self.c_hits['ch_toto_ex'], gene_toto_ex, GeneStatus.NEUTRAL)
-        }
-
-
-    def test_sort_hits_by_status(self):
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        mandatory_exp = [self.m_hits['mh_sctn'], self.m_hits['mh_sctj']]
-        accessory_exp = [self.m_hits['mh_gspd']]
-        neutral_exp = [self.m_hits['mh_toto']]
-        forbidden_exp = [self.m_hits['mh_abc']]
-
-        mandatory, accessory, neutral, forbidden = ordered_match_maker.sort_hits_by_status(mandatory_exp + accessory_exp + neutral_exp + forbidden_exp)
-        self.assertListEqual([h.gene.name for h in mandatory_exp], [h.gene.name for h in mandatory])
-        self.assertListEqual([h.gene.name for h in accessory_exp], [h.gene.name for h in accessory])
-        self.assertListEqual([h.gene.name for h in neutral_exp], [h.gene.name for h in neutral])
-        self.assertListEqual([h.gene.name for h in forbidden_exp], [h.gene.name for h in forbidden])
-
-        # do the same but with exchangeable
-        mandatory_exp_exch = [self.m_hits['mh_sctn_flg'], self.m_hits['mh_sctj_flg']]
-        accessory_exp_exch = [self.m_hits['mh_gspd_ex']]
-        neutral_exp_exch = [self.m_hits['mh_toto_ex']]
-        forbidden_exp_exch = [self.m_hits['mh_abc_ex']]
-
-        mandatory, accessory, neutral, forbidden = ordered_match_maker.sort_hits_by_status(mandatory_exp_exch +
-                                                                                           accessory_exp_exch +
-                                                                                           neutral_exp_exch +
-                                                                                           forbidden_exp_exch)
-        self.assertListEqual([h.gene.name for h in mandatory_exp_exch], [h.gene.name for h in mandatory])
-        self.assertListEqual([h.gene.name for h in accessory_exp_exch], [h.gene.name for h in accessory])
-        self.assertListEqual([h.gene.name for h in neutral_exp_exch], [h.gene.name for h in neutral])
-        self.assertListEqual([h.gene.name for h in forbidden_exp_exch], [h.gene.name for h in forbidden])
-
-        # test if gene_ref is the ModelGene
-        # alternate_of return the ModelGene of the function
-        self.assertListEqual([h.gene.name for h in mandatory_exp], [h.gene_ref.alternate_of().name for h in mandatory])
-        self.assertListEqual([h.gene.name for h in accessory_exp], [h.gene_ref.alternate_of().name for h in accessory])
-        self.assertListEqual([h.gene.name for h in neutral_exp], [h.gene_ref.alternate_of().name for h in neutral])
-        self.assertListEqual([h.gene.name for h in forbidden_exp], [h.gene_ref.alternate_of().name for h in forbidden])
-
-        # test if the hit does not refer to gene belonging to the model
-        model2 = Model("foo/model_B", 10)
-        cg_fliE = CoreGene(self.model_location, "fliE", self.profile_factory)
-        ch_fliE = CoreHit(cg_fliE, "hit_fliE", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        mg_fliE = ModelGene(cg_fliE, model2)
-        mh_fliE = ModelHit(ch_fliE, mg_fliE, GeneStatus.NEUTRAL)
-        with self.assertRaises(MacsylibError) as ctx:
-            with self.catch_log():
-                ordered_match_maker.sort_hits_by_status([mh_fliE])
-        self.assertEqual(str(ctx.exception),
-                         "Gene 'fliE' not found in model 'foo/model_B'")
-
-    def test_ordered_match(self):
-
-        #####################
-        # test single locus #
-        #####################
-
-        # it lack one mandatory gene
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 3
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertEqual(res.reasons,
-                         ["The quorum of mandatory genes required (2) is not reached: 1",
-                          "The quorum of genes required (3) is not reached: 2"])
-
-        # all quorum are reached
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, System)
-
-        # with one mandatory analog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj_flg'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, System)
-
-        # with one accessory analog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd_ex']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, System)
-
-        # the min_gene_required quorum is not reached
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertListEqual(res.reasons,
-                             ["The quorum of genes required (4) is not reached: 3"])
-
-        # the min_gene_required quorum is not reached even there is a neutral
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd'], self.m_hits['mh_toto']],
-                     self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertEqual(res.reasons,
-                         ["The quorum of genes required (4) is not reached: 3"])
-
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd'], self.m_hits['mh_toto_ex']],
-                     self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertEqual(res.reasons,
-                         ["The quorum of genes required (4) is not reached: 3"])
-
-        # the cluster contain a forbidden gene
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd'], self.m_hits['mh_abc']],
-                     self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertEqual(res.reasons, ["There is 1 forbidden genes occurrence(s): abc"])
-
-        # the cluster contain a forbidden gene homolog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd'], self.m_hits['mh_abc_ex']],
-                     self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1])
-        self.assertIsInstance(res, RejectedCandidate)
-        self.assertEqual(res.reasons, ["There is 1 forbidden genes occurrence(s): tadZ"])
-
-        #####################
-        # test multi loci   #
-        #####################
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj'], self.m_hits['mh_sctn']], self.model, self.cfg.hit_weights())
-        c2 = Cluster([self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1, c2])
-        self.assertIsInstance(res, System)
-
-        # with one analog an one homolog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj_flg'], self.m_hits['mh_sctn_flg']], self.model, self.cfg.hit_weights())
-        c2 = Cluster([self.m_hits['mh_gspd_ex']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1, c2])
-        self.assertIsInstance(res, System)
-
-        # with one analog an one homolog and one forbidden in 3 clusters
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        c1 = Cluster([self.m_hits['mh_sctj_flg'], self.m_hits['mh_sctn_flg']], self.model, self.cfg.hit_weights())
-        c2 = Cluster([self.m_hits['mh_gspd']], self.model, self.cfg.hit_weights())
-        c3 = Cluster([self.m_hits['mh_abc']], self.model, self.cfg.hit_weights())
-        ordered_match_maker = OrderedMatchMaker(self.model, self.cfg.redundancy_penalty())
-        res = ordered_match_maker.match([c1, c2, c3])
-        self.assertEqual(res.reasons, ["There is 1 forbidden genes occurrence(s): abc"])
-
-    def test_unordered_match(self):
-
-        # it lack one mandatory gene
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 3
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_gspd']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, UnlikelySystem)
-        self.assertEqual(res.reasons,
-                         ["The quorum of mandatory genes required (2) is not reached: 1",
-                          "The quorum of genes required (3) is not reached: 2"])
-
-        # all quorum are reached
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, LikelySystem)
-
-        # with one mandatory analog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        hits = [self.m_hits['mh_sctj_flg'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, LikelySystem)
-
-        # with one accessory analog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd_ex']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, LikelySystem)
-
-        # the min_gene_required quorum is not reached
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, UnlikelySystem)
-        self.assertEqual(res.reasons,
-                         ["The quorum of genes required (4) is not reached: 3"])
-
-        # the min_gene_required quorum is not reached even there is a neutral
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd'], self.m_hits['mh_toto']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, UnlikelySystem)
-        self.assertEqual(res.reasons,
-                         ["The quorum of genes required (4) is not reached: 3"])
-
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 4
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn_flg'], self.m_hits['mh_gspd'], self.m_hits['mh_toto_ex']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, UnlikelySystem)
-        self.assertEqual(res.reasons,
-                         ["The quorum of genes required (4) is not reached: 3"])
-
-        # the hits contain a forbidden gene
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        allowed_hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd']]
-        forbidden_hits = [self.m_hits['mh_abc']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(allowed_hits + forbidden_hits)
-        self.assertIsInstance(res, LikelySystem)
-        self.assertListEqual([(h.id, h.position) for h in res.hits],
-                             [(h.id, h.position) for h in allowed_hits + forbidden_hits])
-        self.assertListEqual(res._forbidden_hits, [self.m_hits['mh_abc']])
-
-        # the hits contain a forbidden gene homolog
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        hits = [self.m_hits['mh_sctj'], self.m_hits['mh_sctn'], self.m_hits['mh_gspd'], self.m_hits['mh_abc_ex']]
-
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(hits)
-        self.assertIsInstance(res, LikelySystem)
-        self.assertListEqual(res._forbidden_hits, [self.m_hits['mh_abc_ex']])
-
-        # only one forbidden hit (no mandatory, accessory, neutral)
-        self.model._min_mandatory_genes_required = 2
-        self.model._min_genes_required = 1
-        allowed_hits = []
-        forbidden_hits = [self.m_hits['mh_abc']]
-        unordered_match_maker = UnorderedMatchMaker(self.model)
-        res = unordered_match_maker.match(allowed_hits + forbidden_hits)
-        self.assertIsNone(res)
--- macsylib.orig/tests/test_Model.py
+++ macsylib/tests/test_Model.py
@@ -37,286 +37,3 @@
 from macsylib.hit import CoreHit
 from macsylib.registries import ModelLocation
 from tests import MacsyTest
-
-
-class TestModel(MacsyTest):
-
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_Model_')
-        self.args = argparse.Namespace()
-        self.args.sequence_db = self.find_data("base", "test_1.fasta")
-        self.args.db_type = 'gembase'
-        self.args.models_dir = self.find_data('models')
-        self.args.res_search_dir = self._tmp_dir.name
-        self.args.log_level = 30
-        self.args.out_dir = os.path.join(self.args.res_search_dir,
-                                         'test_macsylib_Model')
-        if os.path.exists(self.args.out_dir):
-            shutil.rmtree(self.args.out_dir)
-        os.mkdir(self.args.out_dir)
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(self.args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_fqn(self):
-        fqn = 'foo/bla'
-        model = Model(fqn, 10)
-        self.assertEqual(model.fqn, fqn)
-
-        self.assertEqual(model.name, 'bla')
-
-
-    def test_inter_gene_max_space(self):
-        model_fqn = 'foo/bar'
-        inter_gene_max_space_xml = 40
-        # test inter_gene_max_space from xml
-        model = Model(model_fqn, inter_gene_max_space_xml)
-        self.assertEqual(model.inter_gene_max_space, inter_gene_max_space_xml)
-
-
-    def test_min_genes_required(self):
-        model_fqn = 'foo/model_1'
-        min_genes_required_xml = 40
-        model = Model(model_fqn, 10, min_genes_required=min_genes_required_xml)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        model.add_mandatory_gene(gene)
-        self.assertEqual(model.min_genes_required, min_genes_required_xml)
-        model = Model(model_fqn, 10)
-        self.assertEqual(model.min_genes_required, len(model.mandatory_genes))
-
-
-    def test_min_mandatory_genes_required(self):
-        model_fqn = 'foo/bar'
-        min_mandatory_genes_required_xml = 40
-        model = Model(model_fqn, 10, min_mandatory_genes_required=min_mandatory_genes_required_xml)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        model.add_mandatory_gene(gene)
-        self.assertEqual(model.min_mandatory_genes_required, min_mandatory_genes_required_xml)
-
-        system = Model(model_fqn, 10)
-        self.assertEqual(system.min_mandatory_genes_required, len(system.mandatory_genes))
-
-
-    def test_max_nb_genes(self):
-        model_fqn = 'foo/bar'
-        inter_gene_max_space = 40
-        max_nb_genes_xml = 10
-        model = Model(model_fqn, inter_gene_max_space, max_nb_genes=max_nb_genes_xml)
-        self.assertEqual(model.max_nb_genes, max_nb_genes_xml)
-
-        model = Model(model_fqn, inter_gene_max_space)
-        self.assertEqual(model.max_nb_genes, 0)
-
-        c_gene_sctc = CoreGene(self.model_location, "sctC", self.profile_factory)
-        gene_sctc = ModelGene(c_gene_sctc, model)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-
-        model.add_mandatory_gene(gene_sctc)
-        model.add_accessory_gene(gene_abc)
-        self.assertEqual(model.max_nb_genes, 2)
-
-
-    def test_multi_loci(self):
-        model_fqn = 'foo/True'
-        inter_gene_max_space = 40
-        model = Model(model_fqn, inter_gene_max_space, multi_loci=True)
-        self.assertTrue(model.multi_loci)
-        model_fqn = 'foo/False'
-        inter_gene_max_space = 40
-        model = Model(model_fqn, inter_gene_max_space)
-        self.assertFalse(model.multi_loci)
-
-        self.args.multi_loci = 'foo/False'
-        model_fqn = 'foo/False'
-        inter_gene_max_space = 40
-        model = Model(model_fqn, inter_gene_max_space, multi_loci=False)
-        self.assertFalse(model.multi_loci)
-
-
-    def test_accessor_mutator(self):
-        model = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        categories = set(model.gene_category)
-        for cat in categories:
-            other_cat = categories - {cat}
-            getattr(model, f'add_{cat}_gene')(gene)
-            self.assertEqual(getattr(model, f'{cat}_genes'), [gene])
-            for other in other_cat:
-                self.assertEqual(getattr(model, f'{other}_genes'), [])
-            # don't forget to reset the model to avoid
-            # to accumulate genes
-            model = Model("foo", 10)
-
-    def test_get_gene(self):
-        model = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        for meth in [getattr(model, f'add_{cat}_gene') for cat in model.gene_category]:
-            for cat in model.gene_category:
-                setattr(model, f'_{cat}_genes', [])
-            meth(gene)
-            self.assertEqual(gene, model.get_gene(gene_name))
-
-        self.assertRaises(KeyError, model.get_gene, 'bar')
-
-        homolog_name = 'sctJ'
-        c_gene_homolog = CoreGene(self.model_location, homolog_name, self.profile_factory)
-        homolog = Exchangeable(c_gene_homolog, gene)
-        gene.add_exchangeable(homolog)
-        for meth in [getattr(model, f'add_{cat}_gene') for cat in model.gene_category]:
-            for cat in model.gene_category:
-                setattr(model, f'_{cat}_genes', [])
-            meth(gene)
-            self.assertEqual(homolog, model.get_gene(homolog_name))
-
-
-    def test_str(self):
-        model_fqn = "foo/bar"
-        model = Model(model_fqn, 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        mandatory_gene = ModelGene(c_gene, model)
-        model.add_mandatory_gene(mandatory_gene)
-        homolog_name = 'sctJ'
-        c_gene_homolg = CoreGene(self.model_location, homolog_name, self.profile_factory)
-        homolog = Exchangeable(c_gene_homolg, mandatory_gene)
-        mandatory_gene.add_exchangeable(homolog)
-
-        gene_name = 'sctN_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        accessory_gene = ModelGene(c_gene, model)
-        model.add_accessory_gene(accessory_gene)
-        analog_name = 'sctN'
-        c_gene_analog = CoreGene(self.model_location, analog_name, self.profile_factory)
-        analog = Exchangeable(c_gene_analog, accessory_gene)
-        accessory_gene.add_exchangeable(analog)
-
-        gene_name = 'toto'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        neutral_gene = ModelGene(c_gene, model)
-        model.add_neutral_gene(neutral_gene)
-
-        gene_name = 'sctC'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        forbidden_gene = ModelGene(c_gene, model)
-        model.add_forbidden_gene(forbidden_gene)
-
-        exp_str = """name: bar
-fqn: foo/bar
-==== mandatory genes ====
-sctJ_FLG
-==== accessory genes ====
-sctN_FLG
-==== neutral genes ====
-toto
-==== forbidden genes ====
-sctC
-============== end pprint model ================
-"""
-        self.assertEqual(str(model), exp_str)
-
-    def test_eq(self):
-        aa1 = Model("aaa", 10)
-        aa2 = Model("aaa", 10)
-        self.assertEqual(aa1, aa2)
-
-    def test_lt(self):
-        aaa = Model("aaa", 10)
-        zzz = Model("zzz", 10)
-        self.assertLess(aaa, zzz)
-
-    def test_gt(self):
-        aaa = Model("aaa", 10)
-        zzz = Model("zzz", 10)
-        self.assertGreater(zzz, aaa)
-
-    def test_filter(self):
-        model_fqn = "foo/bar"
-        model = Model(model_fqn, 10)
-        model_2 = Model("foo/buz", 10)
-
-        gene_name = 'sctJ_FLG'
-        sctJ_FLG_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(sctJ_FLG_core, model)
-        model.add_mandatory_gene(sctJ_FLG)
-
-        gene_name = 'sctJ'
-        sctJ_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctj = Exchangeable(sctJ_core, sctJ_FLG)
-        sctJ_FLG.add_exchangeable(sctj)
-
-        gene_name = 'sctN_FLG'
-        sctN_FLG_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctN_FLG = ModelGene(sctN_FLG_core, model)
-        model.add_accessory_gene(sctN_FLG)
-
-        gene_name = 'sctN'
-        sctN_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctn = Exchangeable(sctN_core, sctN_FLG)
-        sctN_FLG.add_exchangeable(sctn)
-
-        gene_name = 'sctC'
-        sctC_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctC = ModelGene(sctC_core, model)
-        model.add_forbidden_gene(sctC)
-
-        gene_name = 'toto'
-        toto_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        toto = ModelGene(toto_core, model)
-        model.add_neutral_gene(toto)
-
-        gene_name = 'totote'
-        totote_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        totote = Exchangeable(totote_core, toto)
-        toto.add_exchangeable(totote)
-
-        gene_name = 'gspD'
-        gspd_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gspd = ModelGene(gspd_core, model_2)
-
-        gene_name = 'tadZ'
-        tadz_core = CoreGene(self.model_location, gene_name, self.profile_factory)
-        tadz = Exchangeable(tadz_core, gspd)
-        gspd.add_exchangeable(tadz)
-
-        hit_to_keep = []
-        for gene in (sctJ_FLG, sctN_FLG, sctC, toto, totote):
-            hit_to_keep.append(CoreHit(gene,
-                                   f"PSAE001c01_{gene.name}",
-                                       1, "PSAE001c01", 1, 1.0, 1.0, 1.0, 1.0, 1, 2)
-                               )
-        hit_to_filter_out = []
-        for gene in (gspd, tadz):
-            hit_to_filter_out.append(CoreHit(gene,
-                                     f"PSAE001c01_{gene.name}",
-                                             1, "PSAE001c01", 1, 1.0, 1.0, 1.0, 1.0, 1, 2)
-                                     )
-
-        filtered_hits = model.filter(hit_to_keep + hit_to_filter_out)
-
-        self.assertListEqual(sorted(hit_to_keep), sorted(filtered_hits))
-
-
-    def test_hash(self):
-        model_bar = Model('Foo/bar', 10)
-        model_bar_bis = Model('Foo/bar', 10)
-        model_buz = Model('Foo/buz', 10)
-        self.assertTrue(isinstance(hash(model_bar), int))
-        self.assertEqual(hash(model_bar), hash(model_bar_bis))
-        self.assertNotEqual(hash(model_bar), hash(model_buz))
--- macsylib.orig/tests/test_Profile.py
+++ macsylib/tests/test_Profile.py
@@ -41,324 +41,3 @@
 from macsylib.error import MacsylibError
 
 from tests import MacsyTest
-
-
-class TestProfile(MacsyTest):
-
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_macsy_Profile_')
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 50
-        self.cfg = Config(MacsyDefaults(), args)
-
-        if os.path.exists(self.cfg.working_dir()):
-            shutil.rmtree(self.cfg.working_dir())
-        os.makedirs(self.cfg.working_dir())
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_len(self):
-        model = Model("functional/T12SS-simple-exch", 10)
-
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-
-        path = self.model_location.get_profile("abc")
-        profile = Profile(gene, self.cfg, path)
-        self.assertEqual(len(profile), 501)
-
-        ###########################
-        # test compressed profile #
-        ###########################
-        model = Model("functional_gzip/T12SS-simple-exch", 10)
-
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-
-        path = self.model_location.get_profile(gene_name)
-        profile = Profile(gene, self.cfg, path)
-        self.assertEqual(len(profile), 501)
-
-        model = Model("foo/compressed_profile", 10)
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        for ext in 'bz2', 'zip':
-            with self.subTest(ext=ext):
-                path = self.find_data('models', 'foo', 'profiles', f'{ext}.hmm.{ext}')
-                with self.catch_log(log_name='macsylib'):
-                    with self.assertRaises(MacsylibError) as ctx:
-                        Profile(gene, self.cfg, path)
-                    self.assertEqual(str(ctx.exception),
-                                     f"Cannot read profile {path}: MacSyLib does not support '{ext}' compression "
-                                     f"(only gzip).")
-
-        ###################
-        # unreadable gzip #
-        ###################
-        path = self.find_data('models', 'foo', 'profiles', 'bad_ext.hmm.gz')
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                Profile(gene, self.cfg, path)
-            self.assertEqual(str(ctx.exception),
-                            f"Cannot read profile {path}: Not a gzipped file (b'BZ')"
-                             )
-
-    def test_ga_threshold(self):
-        # No GA threshold
-        model = Model("foo/T2SS", 10)
-
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        path = self.model_location.get_profile(gene_name)
-        profile = Profile(gene, self.cfg, path)
-        self.assertFalse(profile.ga_threshold)
-
-        model = Model("foo/T2SS", 10)
-        # GA threshold line ends with ;
-        gene_name = 'T5aSS_PF03797'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        path = self.model_location.get_profile(gene_name)
-        profile = Profile(gene, self.cfg, path)
-        self.assertTrue(profile.ga_threshold)
-
-        # GA threshold line do NOT ends with ;
-        gene_name = 'PF05930.13'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        path = self.model_location.get_profile(gene_name)
-        profile = Profile(gene, self.cfg, path)
-        self.assertTrue(profile.ga_threshold)
-
-        # GA threshold invalid format string instead float
-        gene_name = 'bad_GA'
-        with self.catch_log(log_name='macsylib'):
-            # When a CoreGene is created a Profile is automatically instanciated
-            # So I mute the log to do not polute output
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        path = self.model_location.get_profile(gene_name)
-
-        with self.catch_log(log_name='macsylib') as log:
-            profile = Profile(gene, self.cfg, path)
-            catch_msg = log.get_value().strip()
-        self.assertFalse(profile.ga_threshold)
-        self.assertEqual(catch_msg,
-                         "bad_GA GA score is not well formatted expected 2 floats got ''22.00'' ''23.00''.\n"
-                         "GA score will not used for gene 'bad_GA'.")
-
-        # GA threshold invalid format only one score
-        gene_name = 'bad_GA_2'
-        with self.catch_log(log_name='macsylib'):
-            # When a CoreGene is created a Profile is automatically instanciated
-            # So I mute the log to do not polute output
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-        path = self.model_location.get_profile(gene_name)
-
-        with self.catch_log(log_name='macsylib') as log:
-            profile = Profile(gene, self.cfg, path)
-            catch_msg = log.get_value().strip()
-        self.assertFalse(profile.ga_threshold)
-        self.assertEqual(catch_msg,
-                         "bad_GA_2 GA score is not well formatted. expected: 'GA float float' got 'GA    22.00'.\n"
-                         "GA score will not used for gene 'bad_GA_2'.")
-
-    def test_str(self):
-        model = Model("foo/T2SS", 10)
-
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-
-        path = self.model_location.get_profile("abc")
-        profile = Profile(gene, self.cfg, path)
-        s = "{0} : {1}".format(gene.name, path)
-        self.assertEqual(str(profile), s)
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_execute_hmm_with_GA(self):
-        for db_type in ("gembase", "ordered_replicon", "unordered"):
-            self.cfg._set_db_type(db_type)
-            model = Model("foo/T2SS", 10)
-
-            gene_name = 'T5aSS_PF03797'
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-            gene = ModelGene(c_gene, model)
-
-            # case GA threshold in profile
-            profile_path = self.model_location.get_profile("T5aSS_PF03797")
-            profile = Profile(gene, self.cfg, profile_path)
-            report = profile.execute()
-            hmmer_raw_out = profile.hmm_raw_output
-            with open(hmmer_raw_out, 'r') as hmmer_raw_out_file:
-                first_l = hmmer_raw_out_file.readline()
-                # a hmmsearch output file has been produced
-                self.assertTrue(first_l.startswith("# hmmsearch :: search profile(s) against a sequence database"))
-                for _ in range(5):
-                    # skip 4 lines
-                    line = hmmer_raw_out_file.readline()
-                # a hmmsearch used the abc profile line should become with: "# query HMM file: {the path tp hmm profile used}"
-                self.assertTrue(line.find(profile_path) != -1)
-                for _ in range(3):
-                    # skip 2 lines
-                    line = hmmer_raw_out_file.readline()
-                self.assertEqual("# model-specific thresholding:     GA cutoffs", line.strip())
-            # test if profile is executed only once per run
-            report_bis = profile.execute()
-            self.assertIs(report, report_bis)
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_execute_hmm_protected_path(self):
-        # create a hmmdir with space in name
-        self.cfg.hmmer_dir = lambda: 'hmmer results'
-        # create sequence_db path with space in path
-        seq_path = os.path.join(self.cfg.working_dir(), "test_1.fasta")
-        shutil.copyfile(self.find_data("base", "test_1.fasta"),
-                        seq_path)
-        self.cfg._set_sequence_db(seq_path)
-
-        model = Model("foo/T2SS", 10)
-        gene_name = 'T5aSS_PF03797'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-
-        # case GA threshold in profile
-        profile_path = self.model_location.get_profile("T5aSS_PF03797")
-        profile = Profile(gene, self.cfg, profile_path)
-        profile.execute()
-        hmmer_raw_out = profile.hmm_raw_output
-        with open(hmmer_raw_out, 'r') as hmmer_raw_out_file:
-            first_l = hmmer_raw_out_file.readline()
-            # a hmmsearch output file has been produced
-            self.assertTrue(first_l.startswith("# hmmsearch :: search profile(s) against a sequence database"))
-            for _ in range(5):
-                # skip 4 lines
-                line = hmmer_raw_out_file.readline()
-            # a hmmsearch used the abc profile line should become with: "# query HMM file: {the path tp hmm profile used}"
-            self.assertTrue(line.find(profile_path) != -1)
-            for _ in range(3):
-                # skip 2 lines
-                line = hmmer_raw_out_file.readline()
-            self.assertEqual("# model-specific thresholding:     GA cutoffs", line.strip())
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_execute_hmm_w_GA_n_nocutga(self):
-            # case GA threshold in profile but --no-cut-ga is set
-            args = argparse.Namespace()
-            args.sequence_db = self.find_data("base", "test_1.fasta")
-            args.db_type = 'gembase'
-            args.models_dir = self.find_data('models')
-            args.res_search_dir = self._tmp_dir.name
-            args.log_level = 0
-            args.e_value_search = 0.5
-            args.no_cut_ga = True
-            cfg = Config(MacsyDefaults(), args)
-
-            model = Model("foo/T2SS", 10)
-            gene_name = 'T5aSS_PF03797'
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-            gene = ModelGene(c_gene, model)
-            profile_path = self.model_location.get_profile("T5aSS_PF03797")
-            profile = Profile(gene, cfg, profile_path)
-            profile.execute()
-            hmmer_raw_out = profile.hmm_raw_output
-            with open(hmmer_raw_out, 'r') as hmmer_raw_out_file:
-                for i in range(9):
-                    line = hmmer_raw_out_file.readline()
-                self.assertEqual("# sequence reporting threshold:    E-value <= 0.5", line.strip())
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_execute_hmm_wo_GA(self):
-            # case cut-ga but no GA threshold in hmmprofile
-            model = Model("foo/T2SS", 10)
-            gene_name = 'abc'
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-            gene = ModelGene(c_gene, model)
-
-            # case -cut-ga and GA threshold in profile
-            profile_path = self.model_location.get_profile("abc")
-            profile = Profile(gene, self.cfg, profile_path)
-
-            with self.catch_log():
-                profile.execute()
-
-            hmmer_raw_out = profile.hmm_raw_output
-            with open(hmmer_raw_out, 'r') as hmmer_raw_out_file:
-                first_l = hmmer_raw_out_file.readline()
-                # a hmmsearch output file has been produced
-                self.assertTrue(first_l.startswith("# hmmsearch :: search profile(s) against a sequence database"))
-                for _ in range(5):
-                    # skip 4 lines
-                    line = hmmer_raw_out_file.readline()
-                # a hmmsearch used the abc profile line should become with: "# query HMM file: {the path tp hmm profile used}"
-                self.assertTrue(line.find(profile_path) != -1)
-                for _ in range(3):
-                    # skip 2 lines
-                    line = hmmer_raw_out_file.readline()
-                self.assertEqual('# sequence reporting threshold:    E-value <= 0.1', line.strip())
-
-
-    def test_execute_unknown_binary(self):
-        self.cfg._options['hmmer'] = "Nimportnaoik"
-        model = Model("foo/T2SS", 10)
-
-        gene_name = 'abc'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model)
-
-        path = self.model_location.get_profile("abc", )
-        profile = Profile(gene, self.cfg, path)
-        with self.catch_log():
-            with self.assertRaises(RuntimeError):
-                profile.execute()
-
-
-    def test_execute_hmmer_failed(self):
-        fake_hmmer = os.path.join(self._tmp_dir.name, 'hmmer_failed')
-        with open(fake_hmmer, 'w') as hmmer:
-            hmmer.write("""#! {}
-import sys
-sys.exit(127)
-""".format(sysconfig.sys.executable))
-        try:
-            os.chmod(hmmer.name, 0o755)
-            self.cfg._options['hmmer'] = hmmer.name
-            model = Model("foo/T2SS", 10)
-
-            gene_name = 'abc'
-            c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-            gene = ModelGene(c_gene, model)
-
-            path = self.model_location.get_profile("abc", )
-            profile = Profile(gene, self.cfg, path)
-            with self.catch_log():
-                with self.assertRaisesRegex(RuntimeError,
-                                            "an error occurred during Hmmer "
-                                            "execution: command = .* : return code = 127 .*"):
-                    profile.execute()
-
-        finally:
-            try:
-                os.unlink(fake_hmmer)
-            except Exception:
-                pass
--- macsylib.orig/tests/test_ProfileFactory.py
+++ macsylib/tests/test_ProfileFactory.py
@@ -35,49 +35,3 @@
 from macsylib.registries import ModelLocation
 from macsylib.error import MacsylibError
 from tests import MacsyTest
-
-
-class TestProfileFactory(MacsyTest):
-
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_ProfileFactory_')
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 30
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.models_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_get_profile(self):
-        gene_name = 'sctJ_FLG'
-        gene = CoreGene(self.models_location, gene_name, self.profile_factory)
-        profile = self.profile_factory.get_profile(gene, self.models_location)
-        self.assertTrue(isinstance(profile, Profile))
-        self.assertEqual(profile.gene.name, gene_name)
-
-
-    def test_get_uniq_object(self):
-        gene_name = 'sctJ_FLG'
-        gene = CoreGene(self.models_location, gene_name, self.profile_factory)
-        profile1 = self.profile_factory.get_profile(gene, self.models_location)
-        profile2 = self.profile_factory.get_profile(gene, self.models_location)
-        self.assertEqual(profile1, profile2)
-
-
-    def test_unknow_profile(self):
-        gene_name = 'sctJ_FLG'
-        gene = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene._name = "bar"
-        with self.assertRaises(MacsylibError) as ctx:
-            self.profile_factory.get_profile(gene, self.models_location)
-        self.assertEqual(str(ctx.exception),
-                         f"'{self.model_name}/{gene.name}': No such profile")
--- macsylib.orig/tests/test_RejectedCandiate.py
+++ macsylib/tests/test_RejectedCandiate.py
@@ -37,105 +37,3 @@
 from macsylib.system import RejectedCandidate
 
 from tests import MacsyTest
-
-
-class TestRejectedCandidate(MacsyTest):
-
-    def setUp(self) -> None:
-        self.args = argparse.Namespace()
-        self.args.sequence_db = self.find_data("base", "test_1.fasta")
-        self.args.db_type = 'gembase'
-        self.args.models_dir = self.find_data('models')
-        self.args.res_search_dir = "blabla"
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(self.args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.hit_weights = HitWeight(self.cfg.hit_weights())
-
-
-    def test_init(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_1 = ModelGene(c_gene_1, model)
-        model.add_mandatory_gene(gene_1)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        gene_2 = ModelGene(c_gene_2, model)
-        model.add_accessory_gene(gene_2)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h20 = ModelHit(h20, gene_2, GeneStatus.ACCESSORY)
-        c1 = Cluster([v_h10, v_h20], model, self.hit_weights)
-        r_c = RejectedCandidate(model, c1, ["bla"])
-        self.assertListEqual(r_c.clusters, [c1])
-        self.assertEqual(r_c.reasons, ['bla'])
-
-
-    def test_str(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_1 = ModelGene(c_gene_1, model)
-        model.add_mandatory_gene(gene_1)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        gene_2 = ModelGene(c_gene_2, model)
-        model.add_accessory_gene(gene_2)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h20 = ModelHit(h20, gene_2, GeneStatus.ACCESSORY)
-        h40 = CoreHit(c_gene_1, "h40", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h40 = ModelHit(h40, gene_1, GeneStatus.MANDATORY)
-        h50 = CoreHit(c_gene_2, "h50", 10, "replicon_1", 50, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h50 = ModelHit(h50, gene_2, GeneStatus.ACCESSORY)
-        c1 = Cluster([v_h10, v_h20], model, self.hit_weights)
-        c2 = Cluster([v_h40, v_h50], model, self.hit_weights)
-        r_c = RejectedCandidate(model, [c1, c2], ["bla"])
-
-        expected_str = """Cluster:
-- model = T2SS
-- replicon = replicon_1
-- hits = (h10, gspD, 10), (h20, sctC, 20)
-Cluster:
-- model = T2SS
-- replicon = replicon_1
-- hits = (h40, gspD, 40), (h50, sctC, 50)
-This candidate has been rejected because:
-\t- bla
-"""
-        self.assertEqual(expected_str, str(r_c))
-
-
-    def test_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        rc = RejectedCandidate(model, [Cluster([v_hit_1, v_hit_2], model, self.hit_weights),
-                                      Cluster([v_hit_3], model, self.hit_weights)],
-                                      ["bla bla"])
-
-        self.assertEqual(rc.hits, [v_hit_1, v_hit_2, v_hit_3])
-        self.assertEqual(rc.reasons, ["bla bla"])
--- macsylib.orig/tests/test_Report.py
+++ macsylib/tests/test_Report.py
@@ -41,530 +41,3 @@
 from macsylib.registries import ModelLocation
 from macsylib.error import MacsylibError
 from tests import MacsyTest
-
-
-class TestReport(MacsyTest):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.cwd = os.getcwd()
-
-
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_Report_')
-        os.chdir(self._tmp_dir.name)
-        args = argparse.Namespace()
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 30
-        args.out_dir = os.path.join(args.res_search_dir,
-                                    'test_macsylib_Report')
-        os.mkdir(args.out_dir)
-
-        self.seq_db = self.find_data("base", "test_base.fa")
-        shutil.copy(self.seq_db, args.out_dir)
-        args.sequence_db = os.path.join(args.out_dir, os.path.basename(self.seq_db))
-        self.cfg = Config(MacsyDefaults(), args)
-
-        os.mkdir(os.path.join(self.cfg.out_dir(), self.cfg.hmmer_dir()))
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        self.profile_factory = ProfileFactory(self.cfg)
-
-        idx = Indexes(self.cfg)
-        idx.build()
-
-
-    def tearDown(self):
-        os.chdir(self.cwd)
-        self._tmp_dir.cleanup()
-
-
-class TestHMMReport(TestReport):
-
-    def test_HMMReport(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        self.assertRaises(TypeError, HMMReport, c_gene, report_path, self.cfg)
-
-    def test_str(self):
-        gene_name = 'gspD'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        report.extract()
-
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, "PSAE001c01", 68, float(1.2e-234),
-                        float(779.2), float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, "PSAE001c01", 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, "PSAE001c01", 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, "PSAE001c01", 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, "PSAE001c01", 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-
-        s = f"# gene: {c_gene.name} extract from {report_path} hmm output\n"
-        s += f"# profile length= {len(c_gene.profile):d}\n"
-        s += f"# i_evalue threshold= {self.cfg.i_evalue_sel():.3f}\n"
-        s += f"# coverage threshold= {self.cfg.coverage_profile():.3f}\n"
-        s += "# hit_id\treplicon_name\tposition_hit\thit_sequence_length\tgene_name\ti_eval\tscore\t" \
-             "profile_coverage\tsequence_coverage\tbegin\tend\n"
-        for h in hits:
-            s += str(h)
-        self.assertMultiLineEqual(str(report), s)
-
-
-    def test_save_extract(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(gene, report_path, self.cfg)
-        report.extract()
-        report.save_extract()
-        extract_filename = gene_name + self.cfg.res_extract_suffix()
-        extract_path = os.path.join(self.cfg.working_dir(), self.cfg.hmmer_dir(), extract_filename)
-        self.assertTrue(os.path.exists(extract_path))
-        self.assertTrue(os.path.isfile(extract_path))
-
-        hits = [CoreHit(gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 68, float(1.2e-234),
-                        float(779.2), float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(gene, "PSAE001c01_013980", 759, "PSAE001c01", 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(gene, "PSAE001c01_017350", 600, "PSAE001c01", 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(gene, "PSAE001c01_018920", 776, "PSAE001c01", 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(gene, "PSAE001c01_031420", 658, "PSAE001c01", 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-
-        expected_extract_path = os.path.join(self.cfg.working_dir(), 'expected_extract')
-        with open(expected_extract_path, 'w') as expected_extract:
-            extract = """# gene: {name} extract from {path} hmm output
-# profile length= {len_profile:d}
-# i_evalue threshold= {i_evalue:.3f}
-# coverage threshold= {cov:.3f}
-# hit_id\treplicon_name\tposition_hit\thit_sequence_length\tgene_name\ti_eval\tscore\tprofile_coverage\tsequence_coverage\tbegin\tend
-""".format(name=gene.name, path=report_path, len_profile=len(gene.profile),
-           i_evalue=self.cfg.i_evalue_sel(), cov=self.cfg.coverage_profile())
-            expected_extract.write(extract)
-            for h in hits:
-                expected_extract.write(str(h))
-
-        self.assertFileEqual(extract_path, expected_extract_path)
-
-
-    def test_best_hit(self):
-        gene_name = 'gspD'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        self.assertIsNone(report.best_hit())
-        report.extract()
-        best_hit = report.best_hit()
-        hit_expected = CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                               float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        self.assertEqual(hit_expected, best_hit)
-
-
-    def test_hit_start(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-
-        self.assertFalse(report._hit_start("NOT starting hit"))
-        self.assertTrue(report._hit_start(">> starting hit"))
-
-
-    def test_build_my_db(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        gspD_hmmer_path = self.find_data(os.path.join('hmm', 'gspD.search_hmm.out'))
-
-        db = report._build_my_db(gspD_hmmer_path)
-        self.assertDictEqual(db, {'PSAE001c01_031420': None,
-                                  'PSAE001c01_051090': None,
-                                  'PSAE001c01_018920': None,
-                                  'PSAE001c01_043580': None,
-                                  'PSAE001c01_017350': None,
-                                  'PSAE001c01_013980': None,
-                                  'PSAE001c01_026600': None,
-                                  'NC_xxxxx_xx_056141': None,
-                                  'PSAE001c01_006940': None})
-
-    def test_fill_my_db(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        Indexes(self.cfg)
-        gspD_hmmer_path = self.find_data(os.path.join('hmm', 'gspD.search_hmm.out'))
-        db = report._build_my_db(gspD_hmmer_path)
-        report._fill_my_db(db)
-        self.assertDictEqual(db, {'PSAE001c01_031420': (658, 73),
-                                  'PSAE001c01_051090': (714, 75),
-                                  'PSAE001c01_018920': (776, 71),
-                                  'PSAE001c01_043580': (416, 74),
-                                  'PSAE001c01_017350': (600, 70),
-                                  'PSAE001c01_013980': (759, 69),
-                                  'PSAE001c01_026600': (273, 72),
-                                  'NC_xxxxx_xx_056141': (803, 141),
-                                  'PSAE001c01_006940': (803, 68)})
-
-
-    def test_parse_hmm_header(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-
-        hmm_hit = [">> NC_xxxxx_xx_056141  C ATG TAA 6260390 6261757 Valid PA5567 1368 _NP_254254.1_ PA5567 1 6260390 6261757 | tRNA modific"]
-        hit_id = report._parse_hmm_header(hmm_hit)
-        self.assertEqual(hit_id, 'NC_xxxxx_xx_056141')
-
-
-    def test_parse_hmm_body(self):
-        def make_hmm_group(hmm_string):
-            hmm_file = StringIO(hmm_string)
-            hmm_hits = (x[1] for x in groupby(hmm_file, lambda line: line.startswith('>>')))
-            next(hmm_hits)  # garbage header
-            body = next(hmm_hits)
-            return body
-
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-
-        # with one significant hit
-        hmm = """>> NC_xxxxx_xx_056141  C ATG TAA 6260390 6261757 Valid PA5567 1368 _NP_254254.1_ PA5567 1 6260390 6261757 | tRNA modific
-   #    score  bias  c-Evalue  i-Evalue hmmfrom  hmm to    alifrom  ali to    envfrom  env to     acc
- ---   ------ ----- --------- --------- ------- -------    ------- -------    ------- -------    ----
-   1 !  779.2   5.5  1.4e-237    2e-236       1     596 []     104     741 ..     104     741 .. 0.93
-
-  Alignments for each domain:
-"""
-        body = make_hmm_group(hmm)
-        hits = report._parse_hmm_body('NC_xxxxx_xx_056141', 596, 803, 0.5, 'NC_xxxxx_xx', 141, 0.5, body)
-        expected_hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                                 float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)]
-        self.assertListEqual(hits, expected_hits)
-        # with no significant hit
-        hmm = """>> PSAE001c01_051090  C ATG TGA 5675714 5677858 Valid pilQ 2145 _PA5040_NP_253727.1_ PA5040 1 5675714 5677858 | type 4 f
-   #    score  bias  c-Evalue  i-Evalue hmmfrom  hmm to    alifrom  ali to    envfrom  env to     acc
- ---   ------ ----- --------- --------- ------- -------    ------- -------    ------- -------    ----
-   1 !   27.1   0.2   6.3e-10   6.6e-07       1     120 [.     286     402 ..     286     407 .. 0.86
-   2 !  186.2   0.1   4.2e-58   4.3e-55     294     590 ..     405     709 ..     397     712 .. 0.84
-
-  Alignments for each domain:
-"""
-        body = make_hmm_group(hmm)
-        hits = report._parse_hmm_body('NC_xxxxx_xx_056141', 596, 803, 0.5, 'NC_xxxxx_xx', 141, 0.5, body)
-        expected_hits = []
-        self.assertListEqual(hits, expected_hits)
-
-        # with no hit
-        hmm = """>> PSAE001c01_051090  C ATG TGA 5675714 5677858 Valid pilQ 2145 _PA5040_NP_253727.1_ PA5040 1 5675714 5677858 | type 4 f
-        bla bla
-        """
-        body = make_hmm_group(hmm)
-        hits = report._parse_hmm_body('NC_xxxxx_xx_056141', 596, 803, 0.5, 'NC_xxxxx_xx', 141, 0.5, body)
-        expected_hits = []
-        self.assertListEqual(hits, expected_hits)
-
-        # with invalid hmm
-        hmm = """>> NC_xxxxx_xx_056141  C ATG TAA 6260390 6261757 Valid PA5567 1368 _NP_254254.1_ PA5567 1 6260390 6261757 | tRNA modific
-   #    score  bias  c-Evalue  i-Evalue hmmfrom  hmm to    alifrom  ali to    envfrom  env to     acc
- ---   ------ ----- --------- --------- ------- -------    ------- -------    ------- -------    ----
-   1 !  779.2   5.5  1.4e-237    foo       1     596 []     104     741 ..     104     741 .. 0.93
-
-  Alignments for each domain:
-"""
-        body = make_hmm_group(hmm)
-        with self.assertRaises(ValueError) as ctx:
-            report._parse_hmm_body('NC_xxxxx_xx_056141', 596, 803, 0.5, 'NC_xxxxx_xx', 141, 0.5, body)
-        self.assertEqual(str(ctx.exception), """Invalid line to parse :   1 !  779.2   5.5  1.4e-237    foo       1     596 []     104     741 ..     104     741 .. 0.93
-:could not convert string to float: 'foo'""")
-
-
-class TestGembaseHMMReport(TestReport):
-
-    def test_extract(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        report.extract()
-        self.assertEqual(len(report.hits), 6)
-        #           gene, model,     hit_id,         hit_seq_ length   replicon_name, pos_hit, i_eval,
-        #           score,       profile_coverage, sequence_coverage, begin_match, end_match
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, "PSAE001c01", 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, "PSAE001c01", 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, "PSAE001c01", 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, "PSAE001c01", 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, "PSAE001c01", 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        self.assertListEqual(hits, report.hits)
-
-        report = GembaseHMMReport(c_gene, report_path, self.cfg)
-        report.hits = hits
-        self.assertIsNone(report.extract())
-
-
-    def test_extract_concurent(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        reports = []
-        for i in range(5):
-            report = GembaseHMMReport(c_gene, report_path, self.cfg)
-            reports.append(report)
-
-        import threading
-
-        def worker(report):
-            report.extract()
-
-        for report in reports:
-            t = threading.Thread(target=worker, args=(report,))
-            t.start()
-        main_thread = threading.current_thread()
-        for t in threading.enumerate():
-            if t is main_thread:
-                continue
-            t.join()
-
-        #          gene, model,     hit_id,        hit_seq_length replicon_name, pos_hit, i_eval,  score,
-        #          profile_coverage, sequence_coverage, begin_match, end_match
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, "NC_xxxxx_xx", 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, "PSAE001c01", 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, "PSAE001c01", 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, "PSAE001c01", 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, "PSAE001c01", 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, "PSAE001c01", 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        for report in reports:
-            report.save_extract()
-            self.assertEqual(len(report.hits), len(hits))
-            self.assertListEqual(report.hits, hits)
-
-
-class TestOrderedHMMReport(TestReport):
-
-    def test_extract(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = OrderedHMMReport(c_gene, report_path, self.cfg)
-        report.extract()
-        self.assertEqual(len(report.hits), 6)
-        #           gene, model,     hit_id,         hit_seq_ length   replicon_name, pos_hit, i_eval,
-        #           score,       profile_coverage, sequence_coverage, begin_match, end_match
-        replicon_name = os.path.splitext(os.path.basename(self.seq_db))[0]
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, replicon_name, 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, replicon_name, 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, replicon_name, 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, replicon_name, 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, replicon_name, 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, replicon_name, 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        self.assertListEqual(hits, report.hits)
-
-        report = OrderedHMMReport(c_gene, report_path, self.cfg)
-        report.hits = hits
-        self.assertIsNone(report.extract())
-
-        index_file = self.cfg.sequence_db() + '.idx'
-        with open(index_file, 'r') as idx_file:
-            idx = idx_file.readlines()
-        idx = idx[:-1]
-        with open(index_file, 'w') as idx_file:
-            idx_file.writelines(idx)
-        report = OrderedHMMReport(c_gene, report_path, self.cfg)
-        with self.assertRaises(MacsylibError) as ctx:
-            with self.catch_log():
-                report.extract()
-            self.assertEqual(str(ctx.exception),
-                             "hit id 'NC_xxxxx_xx_056141' was not indexed, rebuild sequence 'test_base.fa' index")
-
-    def test_extract_concurent(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        reports = []
-        for i in range(5):
-            report = OrderedHMMReport(c_gene, report_path, self.cfg)
-            reports.append(report)
-
-        import threading
-
-        def worker(report):
-            report.extract()
-
-        for report in reports:
-            t = threading.Thread(target=worker, args=(report,))
-            t.start()
-        main_thread = threading.current_thread()
-        for t in threading.enumerate():
-            if t is main_thread:
-                continue
-            t.join()
-        replicon_name = os.path.splitext(os.path.basename(self.seq_db))[0]
-        #          gene, model,     hit_id,        hit_seq_length replicon_name, pos_hit, i_eval,  score,
-        #          profile_coverage, sequence_coverage, begin_match, end_match
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, replicon_name, 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, replicon_name, 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, replicon_name, 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, replicon_name, 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, replicon_name, 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, replicon_name, 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        for report in reports:
-            report.save_extract()
-            self.assertEqual(len(report.hits), len(hits))
-            self.assertListEqual(report.hits, hits)
-
-
-class TestGeneralHMMReport(TestReport):
-
-    def test_extract(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        report = GeneralHMMReport(c_gene, report_path, self.cfg)
-        report.extract()
-        self.assertEqual(len(report.hits), 6)
-        #           gene, model,     hit_id,         hit_seq_ length   replicon_name, pos_hit, i_eval,
-        #           score,       profile_coverage, sequence_coverage, begin_match, end_match
-        replicon_name = os.path.splitext(os.path.basename(self.seq_db))[0]
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, replicon_name, 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, replicon_name, 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, replicon_name, 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, replicon_name, 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, replicon_name, 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, replicon_name, 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        self.assertListEqual(hits, report.hits)
-
-        report = GeneralHMMReport(c_gene, report_path, self.cfg)
-        report.hits = hits
-        self.assertIsNone(report.extract())
-
-
-    def test_extract_concurent(self):
-        gene_name = "gspD"
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        shutil.copy(self.find_data("hmm", gene_name + self.cfg.res_search_suffix()),
-                    self.cfg.working_dir())
-        report_path = os.path.join(self.cfg.working_dir(), gene_name + self.cfg.res_search_suffix())
-        reports = []
-        for i in range(5):
-            report = GeneralHMMReport(c_gene, report_path, self.cfg)
-            reports.append(report)
-
-        import threading
-
-        def worker(report):
-            report.extract()
-
-        for report in reports:
-            t = threading.Thread(target=worker, args=(report,))
-            t.start()
-        main_thread = threading.current_thread()
-        for t in threading.enumerate():
-            if t is main_thread:
-                continue
-            t.join()
-
-        #          gene, model,     hit_id,        hit_seq_length replicon_name, pos_hit, i_eval,  score,
-        #          profile_coverage, sequence_coverage, begin_match, end_match
-        replicon_name = os.path.splitext(os.path.basename(self.seq_db))[0]
-        hits = [CoreHit(c_gene, "NC_xxxxx_xx_056141", 803, replicon_name, 141, float(2e-236), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_006940", 803, replicon_name, 68, float(1.2e-234), float(779.2),
-                        float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741),
-                CoreHit(c_gene, "PSAE001c01_013980", 759, replicon_name, 69, float(3.7e-76), float(255.8),
-                        float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736),
-                CoreHit(c_gene, "PSAE001c01_017350", 600, replicon_name, 70, float(3.2e-27), float(94.2),
-                        float(0.500000), (506.0 - 226.0 + 1) / 600, 226, 506),
-                CoreHit(c_gene, "PSAE001c01_018920", 776, replicon_name, 71, float(6.1e-183), float(608.4),
-                        float(1.000000), (606.0 - 48.0 + 1) / 776, 48, 606),
-                CoreHit(c_gene, "PSAE001c01_031420", 658, replicon_name, 73, float(1.8e-210), float(699.3),
-                        float(1.000000), (614.0 - 55.0 + 1) / 658, 55, 614)
-                ]
-        for report in reports:
-            report.save_extract()
-            self.assertEqual(len(report.hits), len(hits))
-            self.assertListEqual(report.hits, hits)
--- macsylib.orig/tests/test_System.py
+++ macsylib/tests/test_System.py
@@ -37,1296 +37,3 @@
 from macsylib.system import System, HitSystemTracker
 from macsylib.error import MacsylibError
 from tests import MacsyTest
-
-
-class SystemTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.verbosity = 3
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.hit_weights = HitWeight(**self.cfg.hit_weights())
-
-
-    def test_init(self):
-        model = Model("foo/T2SS", 10)
-        # test if id is well incremented
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        system_1 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, self.hit_weights)],
-                          self.cfg.redundancy_penalty())
-        self.assertTrue(system_1.id.startswith('replicon_id_T2SS_'))
-
-        system_2 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, self.hit_weights)],
-                          self.cfg.redundancy_penalty())
-        self.assertEqual(int(system_2.id.split('_')[-1]), int(system_1.id.split('_')[-1]) + 1)
-
-    def test_hits(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        system_1 = System(model, [Cluster([v_hit_1, v_hit_2], model, self.hit_weights),
-                                  Cluster([v_hit_3], model, self.hit_weights)],
-                          self.cfg.redundancy_penalty())
-
-        self.assertEqual(system_1.hits, [v_hit_1, v_hit_2, v_hit_3])
-
-
-    def test_position(self):
-        model = Model("foo/mod1", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        system_1 = System(model, [Cluster([v_hit_1, v_hit_2], model, self.hit_weights),
-                                  Cluster([v_hit_3], model, self.hit_weights)],
-                          self.cfg.redundancy_penalty())
-        # loner are not to take in account to compute position if system contains none loner hit
-        self.assertEqual(system_1.position, (10, 20))
-
-        model = Model("foo/mod2", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model, loner=True)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        model.add_accessory_gene(gene_sctn)
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        system_1 = System(model, [Cluster([v_hit_1, v_hit_2], model, self.hit_weights),
-                                  Cluster([v_hit_3], model, self.hit_weights)],
-                          self.cfg.redundancy_penalty())
-        # loner are not to take in account to compute position if system contains none loner hit
-        self.assertEqual(system_1.position, (1, 20))
-
-
-    def test_loci_nb(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c1 = Cluster([m_hit_1, m_hit_2], model, self.hit_weights)
-        c2 = Cluster([m_hit_1, m_hit_3], model, self.hit_weights)
-        sys_single_locus = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertEqual(sys_single_locus.loci_nb, 1)
-        sys_multi_loci = System(model, [c1, c2], self.cfg.redundancy_penalty())
-        self.assertEqual(sys_multi_loci.loci_nb, 2)
-        c1 = Cluster([m_hit_1, m_hit_2], model, self.hit_weights)
-        h_loner = Loner(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c3 = Cluster([h_loner], model, self.hit_weights)
-        sys_single_locus_plus_loner = System(model, [c1, c3], self.cfg.redundancy_penalty())
-        self.assertEqual(sys_single_locus_plus_loner.loci_nb, 1)
-        # if max_gene_requird == 1 we authorize cluster with one gene
-        c4 = Cluster([m_hit_1], model, self.hit_weights)
-        sys_single_locus_of_one_hit_not_loner = System(model, [c4], self.cfg.redundancy_penalty())
-        self.assertEqual(sys_single_locus_of_one_hit_not_loner.loci_nb, 1)
-
-    def test_loci_num(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c1 = Cluster([v_hit_1, v_hit_2], model, self.hit_weights)
-        c2 = Cluster([v_hit_1, v_hit_3], model, self.hit_weights)
-        sys_single_locus = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertListEqual(sys_single_locus.loci_num, [1])
-        sys_multi_loci = System(model, [c1, c2], self.cfg.redundancy_penalty())
-        self.assertListEqual(sys_multi_loci.loci_num, [1, 2])
-        c1 = Cluster([v_hit_1, v_hit_2], model, self.hit_weights)
-        h_loner = Loner(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c3 = Cluster([h_loner], model, self.hit_weights)
-        sys_single_locus_plus_loner = System(model, [c1, c3], self.cfg.redundancy_penalty())
-        self.assertListEqual(sys_single_locus_plus_loner.loci_num, [1, -1])
-
-        c4 = Cluster([v_hit_1], model, self.hit_weights)
-        sys_single_locus_of_one_hit_not_loner = System(model, [c4], self.cfg.redundancy_penalty())
-        self.assertEqual(sys_single_locus_of_one_hit_not_loner.loci_num, [1])
-
-    def test_wholeness(self):
-        model_1 = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model_1)
-        model_1.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model_1)
-        model_1.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model_1, loner=True)
-        model_1.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m1_v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m1_v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        m1_v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c1 = Cluster([m1_v_hit_1, m1_v_hit_2], model_1, self.hit_weights)
-        c2 = Cluster([m1_v_hit_1, m1_v_hit_3], model_1, self.hit_weights)
-        s = System(model_1, [c1])
-        self.assertEqual(s.wholeness, 2 / 3)
-        s = System(model_1, [c1, c2])
-        self.assertEqual(s.wholeness, 3 / 3)
-
-        model_2 = Model("foo/T2SS", 10, max_nb_genes=2)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        m2_gene_gspd = ModelGene(c_gene_gspd, model_2)
-        model_2.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        m2_gene_sctj = ModelGene(c_gene_sctj, model_2)
-        model_2.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        m2_gene_sctn = ModelGene(c_gene_sctn, model_2, loner=True)
-        model_2.add_accessory_gene(gene_sctn)
-
-        m2_v_hit_1 = ModelHit(hit_1, m2_gene_gspd, GeneStatus.MANDATORY)
-        m2_v_hit_2 = ModelHit(hit_2, m2_gene_sctj, GeneStatus.ACCESSORY)
-        c3 = Cluster([m2_v_hit_1, m2_v_hit_2], model_2, self.hit_weights)
-        s = System(model_2, [c3])
-        self.assertEqual(s.wholeness, 1)
-
-    def test_occurrence(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        model.add_accessory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        c = Cluster([v_hit_1, v_hit_2, v_hit_3], model, self.hit_weights)
-        s = System(model, [c])
-        self.assertEqual(s.occurrence(), 1)
-        c1 = Cluster([v_hit_1, v_hit_2, v_hit_3], model, self.hit_weights)
-        c2 = Cluster([v_hit_2, v_hit_3], model, self.hit_weights)
-        s = System(model, [c1, c2], self.cfg.redundancy_penalty())
-        # The estimation of occurrence number is based on mandatory only
-        self.assertEqual(s.occurrence(), 1)
-        c1 = Cluster([v_hit_1, v_hit_2, v_hit_3], model, self.hit_weights)
-        c2 = Cluster([v_hit_1, v_hit_3], model, self.hit_weights)
-        s = System(model, [c1, c2], self.cfg.redundancy_penalty())
-        self.assertEqual(s.occurrence(), 2)
-
-        ##########################
-        # with multi system gene #
-        ##########################
-        # the multi_system genes should not count in the occurence
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_tadz = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model)
-        model.add_mandatory_gene(gene_tadz)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_mandatory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, multi_system=True)
-        model.add_mandatory_gene(gene_sctn)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_tadz, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_tadz, GeneStatus.MANDATORY)
-        hit_3_1 = CoreHit(c_gene_sctj, "hit_3_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3_1 = ModelHit(hit_3_1, gene_sctj, GeneStatus.MANDATORY)
-        hit_3_2 = CoreHit(c_gene_sctj, "hit_3_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3_2 = ModelHit(hit_3_2, gene_sctj, GeneStatus.MANDATORY)
-        hit_4_1 = CoreHit(c_gene_sctn, "hit_4_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4_1 = ModelHit(hit_4_1, gene_sctn, GeneStatus.MANDATORY)
-        hit_4_2 = CoreHit(c_gene_sctn, "hit_4_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4_2 = ModelHit(hit_4_2, gene_sctn, GeneStatus.MANDATORY)
-        hit_4_3 = CoreHit(c_gene_sctn, "hit_4_3", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4_3 = ModelHit(hit_4_3, gene_sctn, GeneStatus.MANDATORY)
-
-        c = Cluster([v_hit_1, v_hit_2, v_hit_3_1, v_hit_3_2, v_hit_4_1, v_hit_4_2, v_hit_4_3], model, self.hit_weights)
-        s = System(model, [c], self.cfg.redundancy_penalty())
-        self.assertEqual(s.occurrence(), 1)
-
-
-    def test_score(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model)
-        model.add_mandatory_gene(gene_tadZ)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctJ_FLG = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        sctJ_FLG = Exchangeable(c_gene_sctJ_FLG, gene_sctj)
-        gene_sctj.add_exchangeable(sctJ_FLG)
-        model.add_accessory_gene(gene_sctj)
-
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        c_gene_sctn_FLG = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        sctn_FLG = Exchangeable(c_gene_sctn_FLG, gene_sctj)
-        gene_sctn.add_exchangeable(sctn_FLG)
-        model.add_accessory_gene(gene_sctn)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        model.add_neutral_gene(gene_abc)
-
-        c_gene_flie = CoreGene(self.model_location, "fliE", self.profile_factory)
-        gene_flie = ModelGene(c_gene_flie, model, loner=True)
-        model.add_mandatory_gene(gene_flie)
-
-        c_gene_flgb = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_flgb = ModelGene(c_gene_flgb, model, multi_system=True)
-        model.add_accessory_gene(gene_flgb)
-
-        c_gene_flgc = CoreGene(self.model_location, "flgC", self.profile_factory)
-        gene_flgc = ModelGene(c_gene_flgb, model, loner=True, multi_system=True)
-        model.add_accessory_gene(gene_flgc)
-
-        h_gspd = CoreHit(c_gene_gspd, "h_gspd", 10, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.MANDATORY)
-
-        h_tadz = CoreHit(c_gene_tadZ, "h_tadz", 20, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_tadz = ModelHit(h_tadz, gene_tadZ, GeneStatus.MANDATORY)
-
-        h_sctj = CoreHit(c_gene_sctj, "h_sctj", 30, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.ACCESSORY)
-        h_sctj_an = CoreHit(c_gene_sctJ_FLG, "h_sctj_an", 30, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctj_an = ModelHit(h_sctj_an, sctJ_FLG, GeneStatus.ACCESSORY)
-
-        h_sctn = CoreHit(c_gene_sctn, "sctn", 40, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.ACCESSORY)
-        l_sctn = Loner(h_sctn, gene_sctn, GeneStatus.ACCESSORY)
-        h_sctn_hom = CoreHit(c_gene_sctn_FLG, "h_scth_hom", 30, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctn_hom = ModelHit(h_sctn_hom, sctn_FLG, GeneStatus.ACCESSORY)
-        l_sctn_hom = ModelHit(h_sctn_hom, sctn_FLG, GeneStatus.ACCESSORY)
-
-        h_abc = CoreHit(c_gene_abc, "h_abc", 50, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_abc = ModelHit(h_abc, gene_abc, GeneStatus.NEUTRAL)
-
-        h_flie_1 = CoreHit(c_gene_flie, "h_flie_1", 150, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_flie_2 = CoreHit(c_gene_flie, "h_flie_2", 300, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        # mh_flie_1 is a false loner (gene tag as loner hit in cluster)
-        mh_flie_1 = ModelHit(h_flie_1, gene_flie, GeneStatus.MANDATORY)
-        mh_flie_2 = ModelHit(h_flie_2, gene_flie, GeneStatus.MANDATORY)
-
-        # l_h_flie_1 is a True Loner gene tag as loner, hit  outside cluster
-        # mh_flie_2 is a counterpart of l_h_flie_1
-        l_h_flie_1 = Loner(h_flie_1, gene_flie, GeneStatus.MANDATORY, counterpart=[mh_flie_2])
-        l_h_flie_2 = Loner(h_flie_2, gene_flie, GeneStatus.MANDATORY, counterpart=[mh_flie_1])
-
-        # mh_flie_3 is used as False loner (loner in cluster)
-        h_flie_3 = CoreHit(c_gene_flie, "h_flie_3", 25, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_flie_3 = ModelHit(h_flie_3, gene_flie, GeneStatus.MANDATORY)
-
-        # mh_flgb is used as multi_system in cluster
-        h_flgb = CoreHit(c_gene_flgb, "h_flgb", 60, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_flgb = MultiSystem(h_flgb, gene_flgb, GeneStatus.ACCESSORY)
-
-        # mh_flgc is used as multi_system in cluster
-        h_flgc = CoreHit(c_gene_flgc, "h_flgc", 80, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_flgc = LonerMultiSystem(h_flgc, gene_flgc, GeneStatus.ACCESSORY)
-
-        # system with
-        # 1 cluster
-        # 2 mandatory, 2 accessory no analog/homolog sctn is a loner included in cluster
-        #    2 * 1   +     2 * 0.5 = 3
-        s = System(model,
-                   [Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 3)
-
-        # system with
-        # 2 clusters
-        # 2 mandatory, 2 accessory no analog/homolog no duplicates
-        #     [1 + 0.5] + [1 + 0.5] = 3
-        s = System(model, [Cluster([mh_gspd, mh_tadz], model, self.hit_weights),
-                           Cluster([mh_sctj, mh_sctn], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 3)
-
-        # system with
-        # 1 cluster
-        # 2 mandatory gspd + tadZ + 1 mandatory duplicated 1 time gspd
-        # 1 accessory sctj + sctn + 1 accessory duplicated 1 times sctn
-        # no analog/homolog
-        #  1 + 1 + 0 + 0.5 + 0.5 + 0 = 3
-        s = System(model,
-                   [Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn, mh_gspd, mh_sctn], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 3)
-
-        # system with 2 clusters
-        # 1rst cluster 1 mandatory gspd + 1 accessory sctj
-        #                  1       +   0.5
-        # 2nd cluster 1 mandatory tadZ  + 1 accessory sctj already in first cluster
-        #                  1      +    0.5
-        # [1 + .5] + [1 + .5]
-        # 3 - (2 - 1) * 1.5 = 1.5
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj], model, self.hit_weights),
-                    Cluster([mh_tadz, mh_sctj], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 1.5)
-
-        # system with 1 cluster
-        # 2 mandatory gspd + tadZ
-        # 1 accessory sctn + 1 accessory exchangeable sctj_an
-        #  1 + 1 + .5 + (.5 * .8) = 2.9
-        s = System(model,
-                   [Cluster([mh_gspd, mh_tadz, mh_sctj_an, mh_sctn], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 2.9)
-
-        # system with 2 clusters
-        # 1 mandatory + 1 accessory
-        #    1        +      0.5
-        # 1 mandatory + 1 accessory exchangeable same role as cluster_1 accessory
-        #    1        +      0.4
-        # system penalty due to 2 genes with same role in 2 clusters: -1.5
-        #    2.9 - 1.5 = 1.8
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj], model, self.hit_weights),
-                    Cluster([mh_tadz, mh_sctj_an], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 1.4)
-
-        # system with 2 cluster
-        # 1 mandatory + 1 accessory + 1 neutral + same gene as accessory
-        #    gspd            sctj        abc           sctj
-        #    1        +      0.5          0             0
-        # 1 mandatory true loner (loner alone)
-        #       flie_1
-        #    + (1 * 0.7)
-        # system penalty: 0
-        #    2.2
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj, mh_abc, mh_sctj], model, self.hit_weights),
-                    Cluster([l_h_flie_1], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 2.2)
-
-        # system with 2 cluster
-        # 1 mandatory + 1 accessory + 1 neutral + same gene as accessory + mandatory "faux loner"
-        #    1        +      0.5        0             0                  +   1
-        # 1 cluster of true loner already in first cluster
-        #    + 0
-        # system penalty: 0
-        #    2.5
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj, mh_abc, mh_sctj, mh_flie_1], model, self.hit_weights),
-                    Cluster([l_h_flie_2], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 2.5)
-
-        # system with 2 clusters
-        # 1 mandatory gspd + 1 accessory sctj
-        #        1                 0.5
-        # 1 mandatory tadz + 1 accessory multisystems (in this cluster)
-        #        1                 0.5
-        # system penalty: 0
-        #      3.0
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj], model, self.hit_weights),
-                    Cluster([mh_tadz, mh_flgb], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 3.0)
-
-        # system with 1 cluster + 1 multi system out of cluster
-        # 1 mandatory gspd + 1 accessory sctj
-        #        1                 0.5
-        # 1 accessory multisystems flgb (out of cluster)
-        #      0.5   *   0.7  = 0.35
-        # system penalty: 0
-        #      1.85
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj], model, self.hit_weights),
-                    Cluster([mh_flgb], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 1.85)
-
-        # system with 1 cluster + 1 Loner multi system (out of cluster)
-        # 1 mandatory gspd + 1 accessory sctj
-        #        1                 0.5
-        # 1 accessory multisystems flgc (out of cluster)
-        #      0.5   *   0.7  = 0.35
-        # system penalty: 0
-        #      1.85
-        s = System(model,
-                   [Cluster([mh_gspd, mh_sctj], model, self.hit_weights),
-                    Cluster([mh_flgc], model, self.hit_weights)],
-                   self.cfg.redundancy_penalty())
-        self.assertEqual(s.score, 1.85)
-
-    def test_is_compatible(self):
-        model_A = Model("foo/A", 10)
-        model_B = Model("foo/B", 10)
-        model_C = Model("foo/C", 10)
-        model_D = Model("foo/D", 10)
-        model_E = Model("foo/E", 10)
-        model_F = Model("foo/F", 10)
-
-        cg_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        cg_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        cg_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        cg_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        cg_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        cg_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        cg_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        cg_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-
-        mg_A_sctn = ModelGene(cg_sctn, model_A, multi_system=True)
-        mg_A_sctn_hom = Exchangeable(cg_sctn_flg, mg_A_sctn, multi_system=True)
-        mg_A_sctn.add_exchangeable(mg_A_sctn_hom)
-        mg_A_sctj = ModelGene(cg_sctj, model_A)
-        mg_A_sctj_an = Exchangeable(cg_sctj_flg, mg_A_sctj)
-        mg_A_sctj.add_exchangeable(mg_A_sctj_an)
-        mg_A_gspd = ModelGene(cg_gspd, model_A)
-        mg_A_gspd_an = Exchangeable(cg_flgB, mg_A_gspd)
-        mg_A_gspd.add_exchangeable(mg_A_gspd_an)
-        mg_A_abc = ModelGene(cg_abc, model_A)
-        mg_A_abc_ho = Exchangeable(cg_tadZ, mg_A_abc)
-        mg_A_abc.add_exchangeable(mg_A_abc_ho)
-
-        mg_B_sctn_flg = ModelGene(cg_sctn_flg, model_B)
-        mg_B_sctj_flg = ModelGene(cg_sctj_flg, model_B)
-        mg_B_flgB = ModelGene(cg_flgB, model_B)
-        mg_B_tadZ = ModelGene(cg_tadZ, model_B, loner=True)
-
-        mg_C_sctn_flg = ModelGene(cg_sctn_flg, model_C)
-        mg_C_sctj_flg = ModelGene(cg_sctj_flg, model_C)
-        mg_C_flgB = ModelGene(cg_flgB, model_C)
-        mg_C_tadZ = ModelGene(cg_tadZ, model_C)
-        mg_C_gspd = ModelGene(cg_gspd, model_C)
-
-        mg_D_abc = ModelGene(cg_abc, model_D)
-        mg_D_sctn = ModelGene(cg_sctn, model_D, multi_system=True)
-
-        mg_E_abc = ModelGene(cg_abc, model_E)
-        mg_E_sctn = ModelGene(cg_sctn, model_E, multi_model=True)
-
-        mg_F_abc = ModelGene(cg_abc, model_F)
-        mg_F_sctn = ModelGene(cg_sctn, model_F, multi_model=True)
-
-        model_A.add_mandatory_gene(mg_A_sctn)  # multi system
-        model_A.add_mandatory_gene(mg_A_sctj)
-        model_A.add_accessory_gene(mg_A_gspd)
-        model_A.add_forbidden_gene(mg_A_abc)
-
-        model_B.add_mandatory_gene(mg_B_sctn_flg)
-        model_B.add_mandatory_gene(mg_B_sctj_flg)
-        model_B.add_accessory_gene(mg_B_flgB)
-        model_B.add_accessory_gene(mg_B_tadZ)  # loner
-
-        model_C.add_mandatory_gene(mg_C_sctn_flg)
-        model_C.add_mandatory_gene(mg_C_sctj_flg)
-        model_C.add_mandatory_gene(mg_C_flgB)
-        model_C.add_accessory_gene(mg_C_tadZ)
-        model_C.add_accessory_gene(mg_C_gspd)
-
-        model_D.add_mandatory_gene(mg_D_abc)
-        model_D.add_accessory_gene(mg_D_sctn)
-
-        model_E.add_mandatory_gene(mg_E_abc)
-        model_E.add_accessory_gene(mg_E_sctn)
-
-        model_F.add_mandatory_gene(mg_F_abc)
-        model_F.add_accessory_gene(mg_F_sctn)
-
-        ch_sctj = CoreHit(cg_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_sctn = CoreHit(cg_sctn, "hit_sctn", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_gspd = CoreHit(cg_gspd, "hit_gspd", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_sctj_flg = CoreHit(cg_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_flgB = CoreHit(cg_flgB, "hit_flgB", 803, "replicon_id", 5, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_tadZ = CoreHit(cg_tadZ, "hit_tadZ", 803, "replicon_id", 6, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_abc = CoreHit(cg_abc, "hit_abc", 803, "replicon_id", 7, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        ch_sctj_2 = CoreHit(cg_sctj, "hit_sctj_2", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_sctn_2 = CoreHit(cg_sctn, "hit_sctn_2", 803, "replicon_id", 21, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_gspd_2 = CoreHit(cg_gspd, "hit_gspd_2", 803, "replicon_id", 22, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        ch_abc_2 = CoreHit(cg_abc, "hit_abc_2", 803, "replicon_id", 23, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model_A._min_mandatory_genes_required = 2
-        model_A._min_genes_required = 2
-        c1_A = Cluster([ModelHit(ch_sctj, mg_A_sctj, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn, mg_A_sctn, GeneStatus.MANDATORY),
-                        ModelHit(ch_gspd, mg_A_gspd, GeneStatus.ACCESSORY)
-                        ],
-                       model_A, self.hit_weights)
-
-        c2_A = Cluster([ModelHit(ch_sctj, mg_A_sctj, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn, mg_A_sctn, GeneStatus.MANDATORY)],
-                       model_A, self.hit_weights)
-
-        c3_A = Cluster([ModelHit(ch_sctj_2, mg_A_sctj, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn_2, mg_A_sctn, GeneStatus.MANDATORY),
-                        ModelHit(ch_gspd_2, mg_A_gspd, GeneStatus.ACCESSORY)
-                        ],
-                       model_A, self.hit_weights)
-
-        c4_A = Cluster([ModelHit(ch_sctj, mg_A_sctj, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn_2, mg_A_sctn, GeneStatus.MANDATORY),
-                        ModelHit(ch_gspd_2, mg_A_gspd, GeneStatus.ACCESSORY)
-                        ],
-                       model_A, self.hit_weights)
-        c5_A = Cluster([ModelHit(ch_sctj_2, mg_A_sctj, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn_2, mg_A_sctn, GeneStatus.MANDATORY),
-                        ModelHit(ch_gspd, mg_A_gspd, GeneStatus.ACCESSORY)
-                        ],
-                       model_A, self.hit_weights)
-
-        model_B._min_mandatory_genes_required = 1
-        model_B._min_genes_required = 2
-        c6_B = Cluster([ModelHit(ch_sctj_flg, mg_B_sctj_flg, GeneStatus.MANDATORY),
-                        ModelHit(ch_tadZ, mg_B_tadZ, GeneStatus.ACCESSORY),
-                        ModelHit(ch_flgB, mg_B_flgB, GeneStatus.ACCESSORY)],
-                       model_B, self.hit_weights)
-
-        model_C._min_mandatory_genes_required = 1
-        model_C._min_genes_required = 2
-        c7_C = Cluster([ModelHit(ch_sctj_flg, mg_C_sctj_flg, GeneStatus.MANDATORY),
-                        ModelHit(ch_tadZ, mg_C_tadZ, GeneStatus.ACCESSORY),
-                        ModelHit(ch_flgB, mg_C_flgB, GeneStatus.MANDATORY),
-                        ModelHit(ch_gspd, mg_C_gspd, GeneStatus.ACCESSORY)],
-                       model_C, self.hit_weights)
-
-        model_D._min_mandatory_genes_required = 1
-        model_D._min_genes_required = 1
-        c8_D = Cluster([ModelHit(ch_abc, mg_D_abc, GeneStatus.MANDATORY),
-                        MultiSystem(ch_sctn, mg_D_sctn, GeneStatus.ACCESSORY)],
-                       model_D, self.hit_weights)
-
-        model_E._min_mandatory_genes_required = 1
-        model_E._min_genes_required = 1
-        c9_E = Cluster([ModelHit(ch_abc, mg_E_abc, GeneStatus.MANDATORY),
-                        ModelHit(ch_sctn, mg_E_sctn, GeneStatus.ACCESSORY)],
-                       model_E, self.hit_weights)
-
-        model_F._min_mandatory_genes_required = 1
-        model_F._min_genes_required = 1
-        c10_F = Cluster([ModelHit(ch_abc_2, mg_F_abc, GeneStatus.MANDATORY),
-                        ModelHit(ch_sctn, mg_F_sctn, GeneStatus.ACCESSORY)],
-                       model_F, self.hit_weights)
-
-        sys_A1 = System(model_A, [c1_A, c2_A], self.cfg.redundancy_penalty())
-        # we need to tweek the replicon_id to have stable results
-        # whatever the number of tests ran
-        # or the tests order
-        sys_A1.id = "replicon_id_A1"
-        sys_A2 = System(model_A, [c3_A], self.cfg.redundancy_penalty())
-        sys_A2.id = "replicon_id_A2"
-        sys_A3 = System(model_A, [c4_A], self.cfg.redundancy_penalty())
-        sys_A3.id = "replicon_id_A3"
-        sys_A4 = System(model_A, [c5_A], self.cfg.redundancy_penalty())
-        sys_A4.id = "replicon_id_A4"
-        sys_B = System(model_B, [c6_B], self.cfg.redundancy_penalty())
-        sys_B.id = "replicon_id_B"
-        sys_C = System(model_C, [c7_C], self.cfg.redundancy_penalty())
-        sys_C.id = "replicon_id_C"
-        sys_D = System(model_D, [c8_D], self.cfg.redundancy_penalty())
-        sys_D.id = "replicon_id_D"
-        sys_E = System(model_E, [c9_E], self.cfg.redundancy_penalty())
-        sys_E.id = "replicon_id_E"
-        sys_F = System(model_F, [c10_F], self.cfg.redundancy_penalty())
-        sys_F.id = "replicon_id_F"
-        self.assertFalse(sys_A1.is_compatible(sys_A3))  # False: same model: share sctj (not multi_system)
-        self.assertTrue(sys_A3.is_compatible(sys_A4))  # True: same model: share sctn (multi_system)
-        self.assertTrue(sys_A1.is_compatible(sys_A2))   # True: same model: do not share any hit
-        self.assertTrue(sys_A1.is_compatible(sys_B))    # True: different models: do not share any hit
-        self.assertFalse(sys_A1.is_compatible(sys_C))   # False: diffrent models: share h_gspd
-        self.assertFalse(sys_A1.is_compatible(sys_D))   # False: different models: share h_sctn (which is multi_system im model A but not multi model)
-        self.assertFalse(sys_D.is_compatible(sys_E))    # False: different modesls: share sctn but sctn is multi_model only in E
-        self.assertTrue(sys_E.is_compatible(sys_F))     # True: different Model: share sctn which is multi_model in E and F
-
-
-    def test_HitSystemTracker(self):
-        model_1 = Model("foo/T2SS", 10)
-        model_2 = Model("foo/T3SS", 10)
-
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = ModelGene(c_gene_sctn_flg, model_2)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = ModelGene(c_gene_sctj_flg, model_2)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_flgB = ModelGene(c_gene_flgB, model_2)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model_2)
-
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model_1)
-        gene_sctn_hom = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_hom)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model_1)
-        gene_sctj_an = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_an)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model_1)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model_1)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        model_1.add_mandatory_gene(gene_sctn)
-        model_1.add_mandatory_gene(gene_sctj)
-        model_1.add_accessory_gene(gene_gspd)
-        model_1.add_forbidden_gene(gene_abc)
-
-        model_2.add_mandatory_gene(gene_sctn_flg)
-        model_2.add_mandatory_gene(gene_sctj_flg)
-        model_2.add_accessory_gene(gene_flgB)
-        model_2.add_accessory_gene(gene_tadZ)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_sctj_flg = CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_flgB = CoreHit(c_gene_flgB, "hit_flgB", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_tadZ = CoreHit(c_gene_tadZ, "hit_tadZ", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model_1._min_mandatory_genes_required = 2
-        model_1._min_genes_required = 2
-        c1 = Cluster([ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY),
-                      ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-                      ],
-                     model_1,
-                     self.hit_weights)
-
-        c2 = Cluster([ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY),
-                      ModelHit(h_flgB, gene_gspd, GeneStatus.ACCESSORY)],
-                     model_1,
-                     self.hit_weights)
-
-        model_2._min_mandatory_genes_required = 1
-        model_2._min_genes_required = 2
-        c3 = Cluster([ModelHit(h_sctj_flg, gene_sctj_flg, GeneStatus.MANDATORY),
-                      ModelHit(h_tadZ, gene_tadZ, GeneStatus.ACCESSORY),
-                      ModelHit(h_flgB, gene_flgB, GeneStatus.ACCESSORY)],
-                     model_2,
-                     self.hit_weights)
-        s1 = System(model_1, [c1], self.cfg.redundancy_penalty())
-        s2 = System(model_1, [c1, c2], self.cfg.redundancy_penalty())
-        s3 = System(model_2, [c3], self.cfg.redundancy_penalty())
-
-        track_multi_systems_hit = HitSystemTracker([s1, s2, s3])
-        self.assertSetEqual({s1, s2}, track_multi_systems_hit[h_sctj])
-        self.assertSetEqual({s1, s2}, track_multi_systems_hit[h_gspd])
-        self.assertSetEqual({s3}, track_multi_systems_hit[h_tadZ])
-        self.assertSetEqual({s2, s3}, track_multi_systems_hit[h_flgB])
-
-    def test_count(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ho = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ho)
-
-        c_gene_not_in_model = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_not_in_model = ModelGene(c_gene_not_in_model, model)
-
-        model.add_mandatory_gene(gene_sctn)
-        model.add_mandatory_gene(gene_sctj)
-        model.add_accessory_gene(gene_gspd)
-        model.add_neutral_gene(gene_toto)
-        model.add_forbidden_gene(gene_abc)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd_an = CoreHit(c_gene_flgB, "hit_gspd_an", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc = CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_toto = CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_toto_ho = CoreHit(c_gene_totote, "hit_toto_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_not_in_model = CoreHit(c_gene_not_in_model, "hit_not_in_model", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model._min_mandatory_genes_required = 2
-        model._min_genes_required = 1
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        mh_abc = ModelHit(h_abc, gene_abc, GeneStatus.FORBIDDEN)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_abc,
-                      mh_toto],
-                     model, self.hit_weights)
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-
-        self.assertDictEqual(s1.mandatory_occ, {'sctJ': [mh_sctj], 'sctN': [mh_sctn]})
-        self.assertDictEqual(s1.accessory_occ, {'gspD': [mh_gspd]})
-        self.assertDictEqual(s1.neutral_occ, {'toto': [mh_toto]})
-
-        # test with homolog and analog
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd_an, gene_gspd, GeneStatus.ACCESSORY)
-        mh_abc = ModelHit(h_abc, gene_abc, GeneStatus.FORBIDDEN)
-        mh_toto = ModelHit(h_toto_ho, gene_toto, GeneStatus.NEUTRAL)
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_abc,
-                      mh_toto],
-                     model, self.hit_weights)
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-
-        self.assertDictEqual(s1.mandatory_occ, {'sctJ': [mh_sctj], 'sctN': [mh_sctn]})
-        self.assertDictEqual(s1.accessory_occ, {'gspD': [mh_gspd]})
-        self.assertDictEqual(s1.neutral_occ, {'toto': [mh_toto]})
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_not_in_model = ModelHit(h_not_in_model, gene_not_in_model, GeneStatus.MANDATORY)
-        c1 = Cluster([mh_sctj, mh_not_in_model], model, self.hit_weights)
-        with self.assertRaises(MacsylibError) as ctx:
-            s1 = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertEqual(str(ctx.exception),
-                         "gene 'toto' does not belong to 'mandatory' genes in model 'T2SS'")
-
-    def test_multi_loci(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd, loner=True)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ho = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ho)
-
-        model.add_mandatory_gene(gene_sctn)
-        model.add_mandatory_gene(gene_sctj)
-        model.add_accessory_gene(gene_gspd)
-        model.add_neutral_gene(gene_toto)
-        model.add_forbidden_gene(gene_abc)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_toto = CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model._min_mandatory_genes_required = 2
-        model._min_genes_required = 1
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_h_gspd = Loner(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 1 cluster
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertFalse(s1.multi_loci)
-
-        c2 = Cluster([mh_sctj,
-                      mh_sctn],
-                     model, self.hit_weights)
-
-        c3 = Cluster([mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 2 clusters of 2 hits each
-        s2 = System(model, [c2, c3], self.cfg.redundancy_penalty())
-        self.assertTrue(s2.multi_loci)
-
-        # c2 contains 2 hits
-        # c4 one hit  one loner
-        c4 = Cluster([l_h_gspd], model, self.hit_weights)
-        s3 = System(model, [c2, c4], self.cfg.redundancy_penalty())
-        self.assertFalse(s3.multi_loci)
-
-        # c2 contains (2 hits)
-        # c5 contains one hit not loner
-        model._min_mandatory_genes_required = 1
-        model._min_genes_required = 1
-        c5 = Cluster([mh_toto], model, self.hit_weights)
-        s4 = System(model, [c2, c5], self.cfg.redundancy_penalty())
-        self.assertTrue(s4.multi_loci)
-
-
-    def test_get_loners(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model, loner=True, multi_system=True)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ho = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ho)
-
-        model.add_mandatory_gene(gene_sctn)
-        model.add_mandatory_gene(gene_sctj)
-        model.add_accessory_gene(gene_gspd)
-        model.add_accessory_gene(gene_abc)
-        model.add_neutral_gene(gene_toto)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctj_flg = CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn_flg = CoreHit(c_gene_sctn_flg, "hit_sctn_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd_an = CoreHit(c_gene_flgB, "hit_gspd_an", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_abc = CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc_ho = CoreHit(c_gene_tadZ, "hit_abc_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_toto = CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_toto_ho = CoreHit(c_gene_totote, "hit_toto_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model._min_mandatory_genes_required = 2
-        model._min_genes_required = 1
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_h_gspd = Loner(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_ms_abc = LonerMultiSystem(h_abc, gene_abc, GeneStatus.ACCESSORY)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 1 cluster
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertSetEqual(set(),
-                            s1.get_loners())
-
-        c2 = Cluster([mh_sctj,
-                      mh_sctn],
-                     model, self.hit_weights)
-        c3 = Cluster([mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 2 clusters of 2 hits each
-        s2 = System(model, [c2, c3], self.cfg.redundancy_penalty())
-        self.assertTrue(s2.multi_loci)
-
-        # c2 contains 2 hits
-        # c4 one hit one loner
-        # c5 one hit Loner Multi Systems
-        c4 = Cluster([l_h_gspd], model, self.hit_weights)
-        c5 = Cluster([l_ms_abc], model, self.hit_weights)
-        s3 = System(model, [c2, c4, c5], self.cfg.redundancy_penalty())
-        self.assertSetEqual({l_h_gspd, l_ms_abc},
-                            s3.get_loners())
-
-
-    def test_get_hits_encoding_multisystem(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd, loner=True)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model, loner=True, multi_system=True)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc, loner=True, multi_system=True)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ho = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ho)
-
-        model.add_mandatory_gene(gene_sctn)
-        model.add_mandatory_gene(gene_sctj)
-        model.add_accessory_gene(gene_gspd)
-        model.add_accessory_gene(gene_abc)
-        model.add_neutral_gene(gene_toto)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_abc = CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc_ho = CoreHit(c_gene_tadZ, "hit_abc_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_toto = CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model._min_mandatory_genes_required = 2
-        model._min_genes_required = 1
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_h_gspd = Loner(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_ms_abc = Loner(h_abc, gene_abc, GeneStatus.ACCESSORY)
-        ms_tadZ = ModelHit(h_abc_ho, gene_abc_ho, GeneStatus.ACCESSORY)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 1 cluster
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertSetEqual(set(),
-                            s1.get_hits_encoding_multisystem())
-
-        c2 = Cluster([mh_sctj,
-                      mh_sctn],
-                     model, self.hit_weights)
-
-        c3 = Cluster([mh_sctj,
-                      mh_sctn,
-                      ms_tadZ,
-                      mh_toto],
-                     model, self.hit_weights)
-        c4 = Cluster([l_h_gspd], model, self.hit_weights)
-        c5 = Cluster([l_ms_abc], model, self.hit_weights)
-
-        # c2 2 regular hits
-        # c3 4 hits with 1 multi_systems (homolog)
-        s2 = System(model, [c2, c3], self.cfg.redundancy_penalty())
-        self.assertSetEqual({ms_tadZ},
-                            s2.get_hits_encoding_multisystem())
-
-        # c2 contains 2 hits
-        # c4 one hit one loner
-        # c5 one hit Loner MultiSystems
-        s3 = System(model, [c2, c4, c5], self.cfg.redundancy_penalty())
-        self.assertSetEqual({l_ms_abc},
-                            s3.get_hits_encoding_multisystem())
-
-
-    def test_get_multisystems(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        c_gene_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_flg)
-
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-        c_gene_flgB = CoreGene(self.model_location, "flgB", self.profile_factory)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd, loner=True)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model, loner=True, multi_system=True)
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc, loner=True, multi_system=True)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        c_gene_totote = CoreGene(self.model_location, "totote", self.profile_factory)
-        gene_toto_ho = Exchangeable(c_gene_totote, gene_toto)
-        gene_toto.add_exchangeable(gene_toto_ho)
-
-        model.add_mandatory_gene(gene_sctn)
-        model.add_mandatory_gene(gene_sctj)
-        model.add_accessory_gene(gene_gspd)
-        model.add_accessory_gene(gene_abc)
-        model.add_neutral_gene(gene_toto)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_abc = CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc_ho = CoreHit(c_gene_tadZ, "hit_abc_ho", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_toto = CoreHit(c_gene_toto, "hit_toto", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model._min_mandatory_genes_required = 2
-        model._min_genes_required = 1
-
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_h_gspd = Loner(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-        l_ms_abc = LonerMultiSystem(h_abc, gene_abc, GeneStatus.ACCESSORY)
-        ms_tadZ = MultiSystem(h_abc_ho, gene_abc_ho, GeneStatus.ACCESSORY)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-
-        c1 = Cluster([mh_sctj,
-                      mh_sctn,
-                      mh_gspd,
-                      mh_toto],
-                     model, self.hit_weights)
-        # 1 cluster
-        s1 = System(model, [c1], self.cfg.redundancy_penalty())
-        self.assertSetEqual(set(),
-                            s1.get_multisystems())
-
-        c2 = Cluster([mh_sctj,
-                      mh_sctn],
-                     model, self.hit_weights)
-
-        c3 = Cluster([mh_sctj,
-                      mh_sctn,
-                      ms_tadZ,
-                      mh_toto],
-                     model, self.hit_weights)
-        c4 = Cluster([l_h_gspd], model, self.hit_weights)
-        c5 = Cluster([l_ms_abc], model, self.hit_weights)
-
-        # c2 2 regular hits
-        # c3 4 hits with 1 multi_systems (homolog)
-        s2 = System(model, [c2, c3], self.cfg.redundancy_penalty())
-        self.assertSetEqual({ms_tadZ},
-                            s2.get_multisystems())
-
-        # c2 contains 2 hits
-        # c4 one hit one loner
-        # c5 one hit Loner MultiSystems
-        s3 = System(model, [c2, c4, c5], self.cfg.redundancy_penalty())
-        self.assertSetEqual({l_ms_abc},
-                            s3.get_multisystems())
-
-    def test_fulfilled_function(self):
-        model = Model("foo/T2SS", 11)
-
-        cg_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        cg_sctc = CoreGene(self.model_location, "sctC", self.profile_factory)
-        cg_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        cg_sctj_flg = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-        cg_tadz = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        cg_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-
-        mg_gspd = ModelGene(cg_gspd, model)
-        mg_sctc = ModelGene(cg_sctc, model)
-        mg_sctj = ModelGene(cg_sctj, model)
-        mg_sctj_flg = Exchangeable(cg_sctj_flg, mg_sctj)
-        mg_sctj.add_exchangeable(mg_sctj_flg)
-        mg_tadz = ModelGene(cg_tadz, model)
-        mg_sctn = ModelGene(cg_sctn, model)
-
-        model.add_mandatory_gene(mg_gspd)
-        model.add_mandatory_gene(mg_sctc)
-        model.add_accessory_gene(mg_sctj)
-        model.add_accessory_gene(mg_tadz)
-        model.add_accessory_gene(mg_sctn)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        ch_gspd = CoreHit(cg_gspd, "gspD", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        ch_sctc = CoreHit(cg_sctc, "sctC", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        ch_sctj = CoreHit(cg_sctj, "sctJ", 10, "replicon_1", 30, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        ch_sctj_flg = CoreHit(cg_sctj_flg, "sctJ_FLG", 10, "replicon_1", 40, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        ch_tadz = CoreHit(cg_tadz, "tadZ", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-
-        mh_gspd = ModelHit(ch_gspd, mg_gspd, GeneStatus.MANDATORY)
-        mh_sctc = ModelHit(ch_sctc, mg_sctc, GeneStatus.MANDATORY)
-        mh_sctj = ModelHit(ch_sctj, mg_sctj, GeneStatus.ACCESSORY)
-        mh_sctj_flg = ModelHit(ch_sctj_flg, mg_sctj_flg, GeneStatus.ACCESSORY)
-        mh_tadz = ModelHit(ch_tadz, mg_tadz, GeneStatus.ACCESSORY)
-
-        c1 = Cluster([mh_gspd, mh_sctc], model, self.hit_weights)
-        c2 = Cluster([mh_sctj, mh_tadz], model, self.hit_weights)
-        c3 = Cluster([mh_tadz, mh_sctj_flg], model, self.hit_weights)
-
-        # One system with 2 regular clusters, No exchangeable
-        s1 = System(model, [c1, c2])
-        self.assertSetEqual(s1.fulfilled_function(mg_gspd),
-                            {mg_gspd.name})
-        self.assertFalse(s1.fulfilled_function(mg_sctn))
-
-        # test with several genes
-        self.assertSetEqual(s1.fulfilled_function(mg_gspd, mg_sctn, mg_tadz),
-                            {mg_gspd.name, mg_tadz.name})
-
-        # One cluster contains exchangeable
-        s2 = System(model, [c1, c3])
-        self.assertSetEqual(s2.fulfilled_function(mg_sctj),
-                            {mg_sctj.name})
-
-        # Test with function as string
-        self.assertSetEqual(s1.fulfilled_function(mg_gspd.name),
-                            {mg_gspd.name})
--- macsylib.orig/tests/test_cluster.py
+++ macsylib/tests/test_cluster.py
@@ -40,1482 +40,3 @@
                               scaffold_to_cluster, is_a, closest_hit, split_cluster_on_key_genes,
                               clusterize_hits_around_key_genes)
 from tests import MacsyTest
-
-
-class TestBuildCluster(MacsyTest):
-
-    def setUp(self) -> None:
-        self.args = argparse.Namespace()
-        self.args.sequence_db = self.find_data("base", "test_1.fasta")
-        self.args.db_type = 'gembase'
-        self.args.models_dir = self.find_data('models')
-        self.args.res_search_dir = "blabla"
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(self.args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.hit_weights = HitWeight(**self.cfg.hit_weights())
-
-
-    def test_build_clusters(self):
-        # handle name, topology type, and min/max positions in the sequence dataset for a replicon and list of genes.
-        # each genes is representing by a tuple (seq_id, length)"""
-        rep_info = RepliconInfo('linear', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 11)
-
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model_genes[4]._loner = True
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_neutral_gene(model_genes[4])
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                     pos     score
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h11 = CoreHit(core_genes[0], "h11", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh11 = ModelHit(h11, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-
-        h20 = CoreHit(core_genes[1], "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h21 = CoreHit(core_genes[2], "h21", 10, "replicon_1", 20, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh21 = ModelHit(h21, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h31 = CoreHit(core_genes[1], "h31", 10, "replicon_1", 30, 1.0, 31.0, 1.0, 1.0, 10, 20)
-        mh31 = ModelHit(h31, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h50 = CoreHit(core_genes[2], "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h51 = CoreHit(core_genes[2], "h51", 10, "replicon_1", 50, 1.0, 51.0, 1.0, 1.0, 10, 20)
-        mh51 = ModelHit(h51, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-
-        h60 = CoreHit(core_genes[2], "h60", 10, "replicon_1", 60, 1.0, 60.0, 1.0, 1.0, 10, 20)
-        mh60 = ModelHit(h60, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h61 = CoreHit(core_genes[3], "h61", 10, "replicon_1", 60, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh61 = ModelHit(h61, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-
-        # case replicon is linear, 2 clusters
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh51, mh61])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear with a single hit (not loner) between 2 clusters
-        h70 = CoreHit(core_genes[3], "h70", 10, "replicon_1", 70, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh70 = ModelHit(h70, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        hits = [mh10, mh11, mh20, mh21, mh50, mh51, mh70, mh80]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh11, mh21])
-        self.assertListEqual(true_clusters[1].hits, [mh70, mh80])
-        self.assertEqual(special_clusters, {})
-
-        # replicon is linear, 3 clusters, the last one contains only one hit (loner h80)
-        rep_info = RepliconInfo('linear', 1, 100, [(f"g_{i}", i*10) for i in range(1, 101)])
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh51, mh61])
-        self.assertEqual(len(special_clusters), 1)
-        self.assertListEqual(special_clusters['abc'].hits, [mh80])
-
-        # replicon is circular contains only one cluster
-        rep_info = RepliconInfo('circular', 1, 60, [(f"g_{i}", i*10) for i in range(1, 7)])
-        hits = [mh10, mh20, mh30]
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 1)
-        self.assertListEqual(true_clusters[0].hits, [mh10, mh20, mh30])
-        self.assertEqual(special_clusters, {})
-
-        # replicon is circular the last cluster is merge  with the first So we have only one cluster
-        rep_info = RepliconInfo('circular', 1, 60, [(f"g_{i}", i*10) for i in range(1, 7)])
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 1)
-        self.assertListEqual(true_clusters[0].hits, [mh51, mh61, mh11, mh21, mh31])
-        self.assertEqual(special_clusters, {})
-
-        # replicon is circular the last hit is incorporate to the first cluster
-        # mh80 is not considered as loner it is included in a cluster
-        rep_info = RepliconInfo('circular', 1, 80, [(f"g_{i}", i*10) for i in range(1, 9)])
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh80, mh11, mh21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh51, mh61])
-        self.assertEqual(special_clusters, {})
-
-        # replicon is linear the last hit is not merged with the first cluster
-        # mh80 is link to gene_4 'abc'. So, in this test, it's not a loner.
-        rep_info = RepliconInfo('linear', 1, 62, [(f"g_{i}", i*10) for i in range(1, 7)])
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh51, mh61])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear, 2 clusters, the hits 11,21,31 and 51,61 are contiguous
-        #                                                              pos
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h11 = CoreHit(core_genes[2], "h11", 10, "replicon_1", 11, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh11 = ModelHit(h11, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h12 = CoreHit(core_genes[1], "h12", 10, "replicon_1", 12, 1.0, 31.0, 1.0, 1.0, 10, 20)
-        mh12 = ModelHit(h12, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h50 = CoreHit(core_genes[2], "h50", 10, "replicon_1", 50, 1.0, 51.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h51 = CoreHit(core_genes[3], "h51", 10, "replicon_1", 51, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh51 = ModelHit(h51, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh12, mh50, mh51]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh10, mh11, mh12])
-        self.assertListEqual(true_clusters[1].hits, [mh50, mh51])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear
-        # one cluster with one hit loner
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        hits = [mh80]
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 0)
-        self.assertListEqual(special_clusters['abc'].hits, [mh80])
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required == 1
-        # last hit is a cluster
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=1)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh80]
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 1)
-        self.assertListEqual(true_clusters[0].hits, [mh80])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required == 1
-        # first hit is a cluster
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=1)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh80]
-        random.shuffle(hits)
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh10])
-        self.assertListEqual(true_clusters[1].hits, [mh80])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required != 1
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=2)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh80]
-        true_clusters, special_clusters = build_clusters(hits, rep_info, model, self.hit_weights)
-        self.assertListEqual(true_clusters, [])
-        self.assertEqual(special_clusters, {})
-
-        # case replicon is linear, no hits
-        true_clusters, special_clusters = build_clusters([], rep_info, model, self.hit_weights)
-        self.assertListEqual(true_clusters, [])
-        self.assertEqual(special_clusters, {})
-
-
-    def test_colocates(self):
-        rep_info = RepliconInfo('linear', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 7)
-
-        core_genes = {}
-        model_genes = {}
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes[g_name] = core_gene
-            model_genes[g_name] = ModelGene(core_gene, model)
-
-        model.add_mandatory_gene(model_genes['gspD'])
-        model.add_mandatory_gene(model_genes['sctC'])
-        model.add_accessory_gene(model_genes['sctJ'])
-        model.add_accessory_gene(model_genes['sctN'])
-
-        h10 = CoreHit(core_genes['gspD'], "h10", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes['gspD'], gene_status=GeneStatus.MANDATORY)
-
-        h15 = CoreHit(core_genes['sctC'], "h15", 10, "replicon_1", 15, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh15 = ModelHit(h15, gene_ref=model_genes['sctC'], gene_status=GeneStatus.ACCESSORY)
-        self.assertTrue(_colocates(mh10, mh15, rep_info))
-
-        h20 = CoreHit(core_genes['sctJ'], "h20", 10, "replicon_1", 20, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        self.assertFalse(_colocates(mh10, mh20, rep_info))
-
-        model_genes['sctJ']._inter_gene_max_space = 10
-        self.assertTrue(_colocates(mh10, mh20, rep_info))
-
-        # case inter_gene_max_space is define at gene level sctJ and > than model intergene_max_space
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 30, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        model_genes['sctJ']._inter_gene_max_space = 30
-        self.assertTrue(_colocates(mh10, mh30, rep_info))
-
-        # same case but inter_gene_max_space is define in first gene
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 30, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        model_genes['sctJ']._inter_gene_max_space = 5
-        h35 = CoreHit(core_genes['sctN'], "h35", 10, "replicon_1", 35, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh35 = ModelHit(h35, gene_ref=model_genes['sctN'], gene_status=GeneStatus.ACCESSORY)
-        self.assertTrue(_colocates(mh30, mh35, rep_info))
-
-        # case inter_gene_max_sapce is define at gene level sctJ and > than model intergene_max_space
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 15, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        model_genes['sctJ']._inter_gene_max_space = 5
-        self.assertTrue(_colocates(mh10, mh30, rep_info))
-
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 17, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        model_genes['sctJ']._inter_gene_max_space = 5
-        self.assertFalse(_colocates(mh10, mh30, rep_info))
-
-        # case inter_gene_max_sapce is define at gene level sctJ and gspD use the smallest one
-        model_genes['gspD']._inter_gene_max_space = 7
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 17, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        self.assertFalse(_colocates(mh10, mh30, rep_info))
-
-        h30 = CoreHit(core_genes['sctJ'], "h30", 10, "replicon_1", 15, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes['sctJ'], gene_status=GeneStatus.ACCESSORY)
-        model_genes['sctJ']._inter_gene_max_space = 5
-        self.assertTrue(_colocates(mh10, mh30, rep_info))
-
-
-    def test_clusterize_hits_on_distance_only(self):
-        # handle name, topology type, and min/max positions in the sequence dataset for a replicon and list of genes.
-        # each genes is representing by a tuple (seq_id, length)"""
-        rep_info = RepliconInfo('linear', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 11)
-
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model_genes[4]._loner = True
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_accessory_gene(model_genes[4])  # loner
-        model.add_neutral_gene(model_genes[5])
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                     pos     score
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h11 = CoreHit(core_genes[0], "h11", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh11 = ModelHit(h11, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-
-        h20 = CoreHit(core_genes[1], "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h21 = CoreHit(core_genes[2], "h21", 10, "replicon_1", 20, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh21 = ModelHit(h21, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h31 = CoreHit(core_genes[1], "h31", 10, "replicon_1", 30, 1.0, 31.0, 1.0, 1.0, 10, 20)
-        mh31 = ModelHit(h31, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h50 = CoreHit(core_genes[2], "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h51 = CoreHit(core_genes[2], "h51", 10, "replicon_1", 50, 1.0, 51.0, 1.0, 1.0, 10, 20)
-        mh51 = ModelHit(h51, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-
-        h60 = CoreHit(core_genes[3], "h60", 10, "replicon_1", 60, 1.0, 60.0, 1.0, 1.0, 10, 20)
-        mh60 = ModelHit(h60, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h61 = CoreHit(core_genes[3], "h61", 10, "replicon_1", 60, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh61 = ModelHit(h61, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-
-        # case replicon is linear, 2 clusters
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-
-        # case replicon is linear with a single hit (not loner) between 2 clusters
-        h70 = CoreHit(core_genes[3], "h70", 10, "replicon_1", 70, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh70 = ModelHit(h70, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh20, mh21, mh50, mh51, mh70, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21])
-        self.assertListEqual(got_clusters[1].hits, [mh70, mh80])
-
-        # replicon is linear, 3 clusters, the last one contains only one hit (loner h80)
-        rep_info = RepliconInfo('linear', 1, 100, [(f"g_{i}", i * 10) for i in range(1, 101)])
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 3)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-        self.assertListEqual(got_clusters[2].hits, [mh80])
-
-        # replicon is circular contains only one cluster
-        rep_info = RepliconInfo('circular', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-        hits = [mh10, mh20, mh30]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh10, mh20, mh30])
-
-        # replicon is circular the last cluster is merge  with the first So we have only one cluster
-        rep_info = RepliconInfo('circular', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh51, mh61, mh11, mh21, mh31])
-
-        # replicon is linear the last cluster SHOULD NOT be merged with the first So we have 2 clusters
-        rep_info = RepliconInfo('linear', 1, 60, [(f"g_{i}", i * 10) for i in range(1, 7)])
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-
-        # replicon is circular the last hit is incorporate to the first cluster
-        # mh80 is not considered as loner it is included in a cluster
-        rep_info = RepliconInfo('circular', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh80, mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-
-        # replicon is linear the last hit SHOULD NOT be incorporated to the first cluster
-        # mh80 is not considered as loner it is included in a cluster
-        rep_info = RepliconInfo('linear', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-
-        # replicon is circular
-        # last hit colocalize with first hit which is not in a cluster
-        rep_info = RepliconInfo('circular', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh51, mh61])
-        self.assertListEqual(got_clusters[1].hits, [mh11, mh80])
-
-        # replicon is circular
-        # last hit mh80 colocalize with first hit mh10_alt which is not in a cluster but the 2 hits are neutral: it's not a cluster
-        rep_info = RepliconInfo('circular', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-
-        h10_alt = CoreHit(core_genes[3], "h10_alt", 10, "replicon_1", 10, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh10_alt = ModelHit(h10_alt, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10_alt, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh51, mh61])
-
-        # replicon is circular
-        # last hit mh80 does not colocates whit first one mh50
-        rep_info = RepliconInfo('circular', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-
-        h10_alt = CoreHit(core_genes[3], "h10_alt", 10, "replicon_1", 10, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh10_alt = ModelHit(h10_alt, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10_alt,  mh50]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 0)
-
-        # # replicon is linear
-        # # last hit DO NOT colocalize with first hit which is not in a cluster
-        rep_info = RepliconInfo('linear', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-        h80 = CoreHit(core_genes[3], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh30, mh31, mh50, mh51, mh60, mh61, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh51, mh61])
-
-
-        # replicon is linear the last hit is not merged with the first cluster
-        # mh80 is link to gene_4 'abc'. So, in this test, it's not a loner.
-        rep_info = RepliconInfo('linear', 1, 62, [(f"g_{i}", i * 10) for i in range(1, 7)])
-        hits = [mh10, mh11, mh20, mh21, mh30, mh31, mh50, mh51, mh60, mh61]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh11, mh21, mh31])
-        self.assertListEqual(got_clusters[1].hits, [mh51, mh61])
-
-        # case replicon is linear, 2 clusters, the hits 11,21,31 and 51,61 are contiguous
-        #                                                              pos
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h11 = CoreHit(core_genes[2], "h11", 10, "replicon_1", 11, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh11 = ModelHit(h11, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h12 = CoreHit(core_genes[1], "h12", 10, "replicon_1", 12, 1.0, 31.0, 1.0, 1.0, 10, 20)
-        mh12 = ModelHit(h12, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h50 = CoreHit(core_genes[2], "h50", 10, "replicon_1", 50, 1.0, 51.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h51 = CoreHit(core_genes[3], "h51", 10, "replicon_1", 51, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh51 = ModelHit(h51, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh11, mh12, mh50, mh51]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh10, mh11, mh12])
-        self.assertListEqual(got_clusters[1].hits, [mh50, mh51])
-
-        # case replicon is linear
-        # one cluster with one hit loner
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh80]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh80])
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required == 1
-        # last hit is a cluster
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=1)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh80]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh80])
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required == 1
-        # first hit is a cluster
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=1)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh10, mh80]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 2)
-        self.assertListEqual(got_clusters[0].hits, [mh10])
-        self.assertListEqual(got_clusters[1].hits, [mh80])
-
-        # case replicon is linear
-        # one cluster with one hit min_gene_required != 1
-        model = Model("foo/T2SS", 11, min_mandatory_genes_required=1, min_genes_required=2)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model.add_mandatory_gene(model_genes[0])
-        model.add_accessory_gene(model_genes[1])
-        h80 = CoreHit(core_genes[1], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[1], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh80]
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertListEqual(got_clusters, [])
-
-        # case replicon is linear, no hits
-        got_clusters = clusterize_hits_on_distance_only([], model, self.hit_weights, rep_info)
-        self.assertListEqual(got_clusters, [])
-
-        #############################################
-        model = Model("foo/T2SS", 11)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model_genes[4]._loner = True
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_accessory_gene(model_genes[4])  # loner
-        model.add_neutral_gene(model_genes[5])
-
-        # case replicon is linear
-        # one cluster composed of only loners
-        h80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh80 = ModelHit(h80, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        h85 = CoreHit(core_genes[4], "h85", 10, "replicon_1", 85, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh85 = ModelHit(h85, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        h89 = CoreHit(core_genes[4], "h89", 10, "replicon_1", 89, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh89 = ModelHit(h89, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-
-        hits = [mh80, mh85, mh89]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-
-        # The squash of cluster of loner is done after clusterize_hits_on_distance_only step
-        # in _get_tue_loners
-        # I should get one cluster of 3 loners
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh80, mh85, mh89])
-
-        # case replicon is linear
-        # one cluster composed of only one type of gene
-        # I should not get cluster
-        h10 = CoreHit(core_genes[1], "h10", 10, "replicon_1", 10, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h15 = CoreHit(core_genes[1], "h15", 10, "replicon_1", 15, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh15 = ModelHit(h15, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        h19 = CoreHit(core_genes[1], "h19", 10, "replicon_1", 19, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh19 = ModelHit(h19, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        hits = [mh10, mh15, mh19]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertListEqual(got_clusters, [])
-
-        # case replicon is linear
-        # one cluster composed of only one type of gene and it's exhangeable
-        core_flgB = CoreGene(self.model_location, 'flgB', self.profile_factory)
-        exchangeable = Exchangeable(core_flgB, model_genes[2])
-        h20 = CoreHit(core_genes[2], "h20", 10, "replicon_1", 20, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h25 = CoreHit(core_genes[2], "h25", 10, "replicon_1", 25, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh25 = ModelHit(h25, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h29 = CoreHit(core_flgB, "h29", 10, "replicon_1", 29, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh29 = ModelHit(h29, gene_ref=exchangeable, gene_status=GeneStatus.ACCESSORY)
-
-        hits = [mh20, mh25, mh29]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh20, mh25, mh29])
-
-        # case replicon is circular
-        # there is one cluster with 2 hits
-        # but the replicon is so small that colocates works directly or over origin
-        #   ori h1 h2    d(h1, h2) < inter_genes_max_spces  d(h2, h1) < inter_genes_max_space
-
-        rep_info = RepliconInfo('circular', 1, 20, [(f"g_{i}", i ) for i in range(1, 20)])
-        h05 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 5, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh05 = ModelHit(h05, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h15 = CoreHit(core_genes[1], "h15", 10, "replicon_1", 15, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh15 = ModelHit(h15, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        hits = [mh05, mh15]
-        random.shuffle(hits)
-        got_clusters = clusterize_hits_on_distance_only(hits, model, self.hit_weights, rep_info)
-        self.assertEqual(len(got_clusters), 1)
-        self.assertListEqual(got_clusters[0].hits, [mh05, mh15])
-
-
-    def test_split_cluster_on_key_genes(self):
-        model = Model("foo/T2SS", 11)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ', 'flgB'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1]) # integrase
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_accessory_gene(model_genes[4])
-        model.add_accessory_gene(model_genes[5]) # integrase
-        model.add_accessory_gene(model_genes[6])
-
-        int_20 = CoreHit(core_genes[1], "int_h20", 10, "replicon_1", 20, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_20 = ModelHit(int_20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        int_60 = CoreHit(core_genes[5], "int_h20", 10, "replicon_1", 60, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_60 = ModelHit(int_60, gene_ref=model_genes[5], gene_status=GeneStatus.MANDATORY)
-        key_genes = [mh_int_20, mh_int_60]
-
-        h_10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_10 = ModelHit(h_10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h_30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_30 = ModelHit(h_30, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h_40 = CoreHit(core_genes[3], "h40", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_40 = ModelHit(h_40, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h_50 = CoreHit(core_genes[4], "h50", 10, "replicon_1", 50, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_50 = ModelHit(h_50, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        h_70 = CoreHit(core_genes[6], "h70", 10, "replicon_1", 70, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_70 = ModelHit(h_70, gene_ref=model_genes[6], gene_status=GeneStatus.ACCESSORY)
-        c = Cluster([mh_10, mh_int_20, mh_30, mh_40, mh_50, mh_int_60, mh_70], model, self.hit_weights)
-        clusters = split_cluster_on_key_genes({h.gene_ref.name for h in key_genes}, c)
-        self.assertEqual(len(clusters), 2)
-        self.assertEqual(clusters[0].hits, [mh_10, mh_int_20, mh_30, mh_40])
-        self.assertEqual(clusters[1].hits, [mh_50, mh_int_60, mh_70])
-
-        c = Cluster([mh_10, mh_30, mh_40, mh_50, mh_70], model, self.hit_weights)
-        clusters = split_cluster_on_key_genes({h.gene_ref.name for h in (mh_int_20, mh_int_60)}, c)
-        self.assertEqual(clusters, [])
-
-
-    def test_clusterize_hits_around_key_genes(self):
-        rep_info = RepliconInfo('linear', 1, 80, [(f"g_{i}", i * 10) for i in range(1, 9)])
-        model = Model("foo/T2SS", 11)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ', 'flgB'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])  # integrase
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_accessory_gene(model_genes[4])
-        model.add_accessory_gene(model_genes[5])  # integrase
-        model.add_accessory_gene(model_genes[6])
-
-        int_20 = CoreHit(core_genes[1], "int_h20", 10, "replicon_1", 20, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_20 = ModelHit(int_20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        int_60 = CoreHit(core_genes[5], "int_h20", 10, "replicon_1", 60, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_60 = ModelHit(int_60, gene_ref=model_genes[5], gene_status=GeneStatus.MANDATORY)
-        key_genes = [mh.gene_ref.name for mh in (mh_int_20, mh_int_60)]
-
-        # mh_10 -> mh_70 colocalize and contains 2 integrases the cluster must be split in 2
-        h_10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_10 = ModelHit(h_10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h_30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_30 = ModelHit(h_30, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h_40 = CoreHit(core_genes[3], "h40", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_40 = ModelHit(h_40, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h_50 = CoreHit(core_genes[4], "h50", 10, "replicon_1", 50, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_50 = ModelHit(h_50, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-        h_70 = CoreHit(core_genes[6], "h70", 10, "replicon_1", 70, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_70 = ModelHit(h_70, gene_ref=model_genes[6], gene_status=GeneStatus.ACCESSORY)
-
-        # mh_100, mh_110, mh_120 colocalize but it does not contains an integrase so it's not a cluster
-        h_100 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 100, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_100 = ModelHit(h_100, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-        h_110 = CoreHit(core_genes[3], "h110", 10, "replicon_1", 110, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_110 = ModelHit(h_110, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        h_120 = CoreHit(core_genes[4], "h120", 10, "replicon_1", 120, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_120 = ModelHit(h_120, gene_ref=model_genes[4], gene_status=GeneStatus.ACCESSORY)
-
-        # One cluster with 2 integrases which need to be split
-        # Plus one set of colocating hits but without integrase
-        clusters = clusterize_hits_around_key_genes(key_genes,
-                                            [mh_10, mh_int_20, mh_30, mh_40, mh_50, mh_int_60, mh_70, mh_100, mh_110,
-                                             mh_120],
-                                             model, self.hit_weights, rep_info)
-
-        self.assertEqual(len(clusters), 2)
-        self.assertEqual(clusters[0].hits, [mh_10, mh_int_20, mh_30, mh_40])
-        self.assertEqual(clusters[1].hits, [mh_50, mh_int_60, mh_70])
-
-        # One cluster with One integrase
-        clusters = clusterize_hits_around_key_genes(key_genes,
-                                            [mh_10, mh_int_20, mh_30, mh_40],
-                                             model, self.hit_weights, rep_info)
-
-        self.assertEqual(len(clusters), 1)
-        self.assertEqual(clusters[0].hits, [mh_10, mh_int_20, mh_30, mh_40])
-
-
-    def test_closest_hit(self):
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 11)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_accessory_gene(model_genes[4])
-        model.add_accessory_gene(model_genes[5])
-
-        int_20 = CoreHit(core_genes[1], "int_h20", 10, "replicon_1", 20, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_20 = ModelHit(int_20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-        int_60 = CoreHit(core_genes[5], "int_h20", 10, "replicon_1", 60, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_int_60 = ModelHit(int_60, gene_ref=model_genes[5], gene_status=GeneStatus.MANDATORY)
-        ref_hits = [mh_int_20, mh_int_60]  # 'sctC', 'abc'
-
-        h_10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_10 = ModelHit(h_10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(closest_hit(mh_10, ref_hits), mh_int_20)
-
-        h_30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_30 = ModelHit(h_30, gene_ref=model_genes[2], gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(closest_hit(mh_30, ref_hits), mh_int_20)
-
-        h_50 = CoreHit(core_genes[4], "h50", 10, "replicon_1", 50, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_50 = ModelHit(h_50, gene_ref=model_genes[4], gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(closest_hit(mh_50, ref_hits), mh_int_60)
-
-        # h40 is at same distance from int_20 and int_60
-        # but algorithm favor the first solution
-        h_40 = CoreHit(core_genes[3], "h40", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_40 = ModelHit(h_40, gene_ref=model_genes[3], gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(closest_hit(mh_40, ref_hits), mh_int_20)
-
-
-    def test_is_a(self):
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 11)
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                     pos     score
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-
-        h20 = CoreHit(core_genes[1], "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        self.assertFalse(is_a(mh10, {'sctC', 'sctN'}))
-        self.assertTrue(is_a(mh20, {'sctC', 'sctN'}))
-
-
-    def test_scaffold_to_cluster(self):
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", inter_gene_max_space=11, min_genes_required=4)
-
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc', 'tadZ'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model_genes[3]._loner = True
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])  # loner
-        model.add_neutral_gene(model_genes[4])
-        model.add_neutral_gene(model_genes[5])
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                     pos     score
-        h10 = CoreHit(core_genes[0], "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-
-        h20 = CoreHit(core_genes[1], "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h30 = CoreHit(core_genes[2], "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-
-        h40 = CoreHit(core_genes[3], "h40", 10, "replicon_1", 40, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh40 = ModelHit(h40, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-
-        h50 = CoreHit(core_genes[4], "h50", 10, "replicon_1", 50, 1.0, 60.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-
-        h60 = CoreHit(core_genes[5], "h60", 10, "replicon_1", 60, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh60 = ModelHit(h60, gene_ref=model_genes[5], gene_status=GeneStatus.NEUTRAL)
-
-        hits = [mh10, mh20, mh30, mh40, mh50, mh60]
-
-        # case several hits mandatory, accessory (with one loner), and neutral
-        # should be a cluster
-        c = scaffold_to_cluster(hits, model, self.hit_weights)
-        self.assertTrue(isinstance(c, Cluster))
-        self.assertEqual(len(c), len(hits))
-        self.assertEqual(c.hits, hits)
-
-        # 1 hit model min_gene_required > 1
-        c = scaffold_to_cluster([mh10], model, self.hit_weights)
-        self.assertIsNone(c)
-
-        # 1 hit but a Loner
-        # it's a cluster
-        c = scaffold_to_cluster([mh40], model, self.hit_weights)
-        self.assertEqual(c.hits, [mh40])
-
-        # several hits but all Loner
-        # it's a cluster
-        h400 = CoreHit(core_genes[3], "h400", 10, "replicon_1", 400, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh400 = ModelHit(h400, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        hits = [mh40, mh400]
-        c = scaffold_to_cluster([mh40, mh400], model, self.hit_weights)
-        self.assertEqual(c.hits, [mh40, mh400])
-
-
-        # several hits but only neutral
-        # it's not a cluster
-        c = scaffold_to_cluster([mh50, mh60], model, self.hit_weights)
-        self.assertIsNone(c)
-
-        # several hits but same type of gene
-        # it's not a cluster
-        h100 = CoreHit(core_genes[0], "h100", 10, "replicon_1", 100, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh100 = ModelHit(h100, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h200 = CoreHit(core_genes[0], "h200", 10, "replicon_1", 200, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh200 = ModelHit(h200, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        h300 = CoreHit(core_genes[0], "h300", 10, "replicon_1", 300, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh300 = ModelHit(h300, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-        c = scaffold_to_cluster([mh100, mh200, mh300], model, self.hit_weights)
-        self.assertIsNone(c)
-
-        # 1 hit model min_gene_required == 1
-        # it's a cluster
-        model._min_genes_required = 1
-        c = scaffold_to_cluster([mh10], model, self.hit_weights)
-        self.assertEqual(c.hits, [mh10])
-
-        # 1 hit NEUTRAL model min_gene_required == 1
-        # it's NOT a cluster
-        c = scaffold_to_cluster([mh50], model, self.hit_weights)
-        self.assertIsNone(c)
-
-    def test_get_true_loners(self):
-        #              fqn      , inter_gene_max_sapce
-        model = Model("foo/T2SS", 11)
-
-        core_genes = []
-        model_genes = []
-        for g_name in ('gspD', 'sctC', 'sctJ', 'sctN', 'abc',  'flgB'):
-            core_gene = CoreGene(self.model_location, g_name, self.profile_factory)
-            core_genes.append(core_gene)
-            model_genes.append(ModelGene(core_gene, model))
-        model_genes[4]._loner = True
-        model_genes[5]._loner = True
-        model_genes[5]._multi_system = True
-
-        model.add_mandatory_gene(model_genes[0])
-        model.add_mandatory_gene(model_genes[1])
-        model.add_accessory_gene(model_genes[2])
-        model.add_accessory_gene(model_genes[3])
-        model.add_neutral_gene(model_genes[4])
-        model.add_accessory_gene(model_genes[5])
-
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                     pos     score
-        ch_11 = CoreHit(core_genes[0], "h11", 10, "replicon_1", 10, 1.0, 11.0, 1.0, 1.0, 10, 20)
-        mh_11 = ModelHit(ch_11, gene_ref=model_genes[0], gene_status=GeneStatus.MANDATORY)
-
-        ch_21 = CoreHit(core_genes[2], "h21", 10, "replicon_1", 20, 1.0, 21.0, 1.0, 1.0, 10, 20)
-        mh_21 = ModelHit(ch_21, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        h31 = CoreHit(core_genes[1], "h31", 10, "replicon_1", 30, 1.0, 31.0, 1.0, 1.0, 10, 20)
-        mh31 = ModelHit(h31, gene_ref=model_genes[1], gene_status=GeneStatus.MANDATORY)
-
-        ch_51 = CoreHit(core_genes[2], "h51", 10, "replicon_1", 50, 1.0, 51.0, 1.0, 1.0, 10, 20)
-        mh_51 = ModelHit(ch_51, gene_ref=model_genes[2], gene_status=GeneStatus.ACCESSORY)
-
-        ch_61 = CoreHit(core_genes[3], "h61", 10, "replicon_1", 60, 1.0, 61.0, 1.0, 1.0, 10, 20)
-        mh_61 = ModelHit(ch_61, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-
-        # case replicon is linear with a single hit (not loner) between 2 clusters
-        ch_70 = CoreHit(core_genes[3], "h70", 10, "replicon_1", 70, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh_70 = ModelHit(ch_70, gene_ref=model_genes[3], gene_status=GeneStatus.ACCESSORY)
-        ch_80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh_80 = ModelHit(ch_80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        c0 = Cluster([mh_11, mh_21], model, self.hit_weights)
-        c1 = Cluster([mh_70, mh_80], model, self.hit_weights)
-        true_loners, true_clusters = _get_true_loners([c0, c1])
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh_11, mh_21])
-        self.assertListEqual(true_clusters[1].hits, [mh_70, mh_80])
-        self.assertEqual(true_loners, {})
-
-        # replicon is linear, 3 clusters, the last one contains only one hit (loner h80)
-        ch_80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh_80 = ModelHit(ch_80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-
-        c0 = Cluster([mh_11, mh_21, mh31], model, self.hit_weights)
-        c1 = Cluster([mh_51, mh_61], model, self.hit_weights)
-        c2 = Cluster([mh_80], model, self.hit_weights)
-        true_loners, true_clusters = _get_true_loners([c0, c1, c2])
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh_11, mh_21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh_51, mh_61])
-        self.assertEqual(len(true_loners), 1)
-        self.assertListEqual(true_loners['abc'].hits, [mh_80])
-
-        # replicon is linear, 2 clusters, the last one contains 3 hits including one loner
-        # although the gene is mark as loner as the hit is in cluster
-        # it is not considered as True Loner
-        # so it's type should be a ModelHit not Loner
-        ch_80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh_80 = ModelHit(ch_80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-
-        c0 = Cluster([mh_11, mh_21, mh31], model, self.hit_weights)
-        c1 = Cluster([mh_51, mh_61, mh_80], model, self.hit_weights)
-        true_loners, true_clusters = _get_true_loners([c0, c1])
-        self.assertEqual(len(true_clusters), 2)
-        self.assertListEqual(true_clusters[0].hits, [mh_11, mh_21, mh31])
-        self.assertListEqual(true_clusters[1].hits, [mh_51, mh_61, mh_80])
-        self.assertEqual(len(true_loners), 0)
-        self.assertTrue(isinstance(true_clusters[1].hits[-1], ModelHit))
-        self.assertFalse(isinstance(true_clusters[1].hits[-1], Loner))
-
-        # case replicon is linear
-        # one cluster with one hit loner
-        ch_80 = CoreHit(core_genes[4], "h80", 10, "replicon_1", 80, 1.0, 80.0, 1.0, 1.0, 10, 20)
-        mh_80 = ModelHit(ch_80, gene_ref=model_genes[4], gene_status=GeneStatus.NEUTRAL)
-        c0 = Cluster([mh_80], model, self.hit_weights)
-        true_loners, true_clusters = _get_true_loners([c0])
-        self.assertEqual(len(true_clusters), 0)
-        self.assertTrue(isinstance(true_loners['abc'], Cluster))
-        self.assertTrue(isinstance(true_loners['abc'][0], Loner))
-        self.assertListEqual(true_loners['abc'].hits, [mh_80])
-
-        # replicon is linear,
-        # 2 clusters,
-        #  - one regular cluster
-        #  - 3 loner multisystem (same gene)
-        ch_90 = CoreHit(core_genes[5], "h90", 10, "replicon_1", 90, 1.0, 90.0, 1.0, 1.0, 10, 20)
-        ch_100 = CoreHit(core_genes[5], "h100", 10, "replicon_1", 100, 1.0, 100.0, 1.0, 1.0, 10, 20)
-        ch_110 = CoreHit(core_genes[5], "h110", 10, "replicon_1", 110, 1.0, 110.0, 1.0, 1.0, 10, 20)
-        mh_90 = MultiSystem(ch_90, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        mh_100 = MultiSystem(ch_100, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-        mh_110 = MultiSystem(ch_110, gene_ref=model_genes[5], gene_status=GeneStatus.ACCESSORY)
-
-        ms_90 = MultiSystem(mh_90, counterpart=[mh_100, mh_110])
-        ms_100 = MultiSystem(mh_100, counterpart=[mh_90, mh_110])
-        ms_110 = MultiSystem(mh_110, counterpart=[mh_90, mh_100])
-        c0 = Cluster([mh_11, mh_21, mh31], model, self.hit_weights)
-        c1 = Cluster([ms_90], model, self.hit_weights)
-        c2 = Cluster([ms_100], model, self.hit_weights)
-        c3 = Cluster([ms_110], model, self.hit_weights)
-
-        true_loners, true_clusters = _get_true_loners([c0, c1, c2, c3])
-        self.assertEqual(len(true_clusters), 1)
-        self.assertEqual(len(true_loners), 1)
-        # check that the loner is a LonerMultiSystem
-        # that is the hit with best score mh110 110.0
-        # and hold the right counterpart
-        self.assertTrue(isinstance(true_loners['flgB'], Cluster))
-        self.assertTrue(isinstance(true_loners['flgB'][0], LonerMultiSystem))
-        self.assertListEqual(true_loners['flgB'].hits, [ms_110])
-        self.assertSetEqual(set(true_loners['flgB'][0].counterpart), set([mh_90, mh_100]))
-
-
-class TestCluster(MacsyTest):
-
-    def setUp(self) -> None:
-        self.args = argparse.Namespace()
-        self.args.sequence_db = self.find_data("base", "test_1.fasta")
-        self.args.db_type = 'gembase'
-        self.args.models_dir = self.find_data('models')
-        self.args.res_search_dir = "blabla"
-
-        self.cfg = Config(MacsyDefaults(), self.args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(self.args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.hit_weights = HitWeight(**self.cfg.hit_weights())
-
-
-    def test_init(self):
-        model_1 = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model_1)
-
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_1, GeneStatus.MANDATORY)
-        h30 = CoreHit(c_gene_3, "h30", 10, "replicon_2", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_1, GeneStatus.ACCESSORY)
-        h50 = CoreHit(c_gene_3, "h50", 10, "replicon_2", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_1, GeneStatus.ACCESSORY)
-
-        with self.assertRaises(MacsylibError) as ctx:
-            with self.catch_log():
-                Cluster([mh10, mh20, mh30, mh50], model_1, self.hit_weights)
-        msg = "Cannot build a cluster from hits coming from different replicons"
-        self.assertEqual(str(ctx.exception), msg)
-
-
-    def test_replicon_name(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-
-        replicon_name = "replicon_1"
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, replicon_name, 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, replicon_name, 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        self.assertEqual(c1.replicon_name, replicon_name)
-
-
-    def test_len(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        self.assertEqual(len(c1), 2)
-
-    def test_loner(self):
-        model = Model("foo/bar", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model, loner=True)
-        gene_2 = ModelGene(c_gene_2, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        l_h10 = Loner(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-
-        c1 = Cluster([l_h10], model, self.hit_weights)
-        c2 = Cluster([mh20], model, self.hit_weights)
-        c3 = Cluster([mh10, mh20], model, self.hit_weights)
-        self.assertTrue(c1.loner)
-        self.assertFalse(c2.loner)
-        self.assertFalse(c3.loner)
-
-
-    def test_multi_system(self):
-        model = Model("foo/bar", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model, multi_system=True)
-        gene_2 = ModelGene(c_gene_2, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        l_h10 = MultiSystem(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-
-        c1 = Cluster([l_h10], model, self.hit_weights)
-        c2 = Cluster([mh20], model, self.hit_weights)
-        c3 = Cluster([mh10, mh20], model, self.hit_weights)
-        self.assertTrue(c1.multi_system)
-        self.assertFalse(c2.multi_system)
-        self.assertFalse(c3.multi_system)
-
-
-    def test_contains(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-        gene_3 = ModelGene(c_gene_3, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-        h30 = CoreHit(c_gene_3, "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_3, GeneStatus.ACCESSORY)
-        h50 = CoreHit(c_gene_3, "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_3, GeneStatus.ACCESSORY)
-        c1 = Cluster([mh10, mh20, mh50], model, self.hit_weights)
-
-        self.assertTrue(mh10 in c1)
-        self.assertFalse(mh30 in c1)
-
-
-    def test_fulfilled_function(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        c_gene_4 = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-        gene_3 = ModelGene(c_gene_3, model)
-        gene_4 = Exchangeable(c_gene_4, gene_3)
-        gene_3.add_exchangeable(gene_4)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-
-        c = Cluster([mh10, mh20], model, self.hit_weights)
-
-        self.assertSetEqual(c.fulfilled_function(gene_1),
-                            {'gspD'})
-        self.assertSetEqual(c.fulfilled_function(gene_3),
-                            set())
-
-        # test with several genes
-        self.assertSetEqual(c.fulfilled_function(gene_3, gene_1),
-                            {'gspD'})
-
-        # The cluster contains exchangeable
-        h50 = CoreHit(c_gene_4, "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_4, GeneStatus.ACCESSORY)
-        c = Cluster([mh10, mh50], model, self.hit_weights)
-        self.assertSetEqual(c.fulfilled_function(gene_3),
-                            {'sctJ'})
-
-
-    def test_score(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-
-        c_gene_tadZ = CoreGene(self.model_location, "tadZ", self.profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model)
-        model.add_mandatory_gene(gene_tadZ)
-
-        c_gene_sctj = CoreGene(self.model_location, "sctC", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-
-        c_gene_sctJ_FLG = CoreGene(self.model_location, "sctJ_FLG", self.profile_factory)
-
-        analog_sctJ_FLG = Exchangeable(c_gene_sctJ_FLG, gene_sctj)
-        gene_sctj.add_exchangeable(analog_sctJ_FLG)
-        model.add_accessory_gene(gene_sctj)
-
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        c_gene_sctn_FLG = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        homolog_sctn_FLG = Exchangeable(c_gene_sctn_FLG, gene_sctn)
-        gene_sctn.add_exchangeable(homolog_sctn_FLG)
-        model.add_accessory_gene(gene_sctn)
-
-        c_gene_toto = CoreGene(self.model_location, "toto", self.profile_factory)
-        gene_toto = ModelGene(c_gene_toto, model)
-        model.add_neutral_gene(gene_toto)
-
-        c_gene_flie = CoreGene(self.model_location, "fliE", self.profile_factory)
-        gene_flie = ModelGene(c_gene_flie, model, loner=True, multi_system=True)
-        model.add_mandatory_gene(gene_flie)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h_gspd = CoreHit(c_gene_gspd, "h_gspd", 10, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.MANDATORY)
-        h_tadz = CoreHit(c_gene_tadZ, "h_tadz", 20, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_tadz = ModelHit(h_tadz, gene_tadZ, GeneStatus.MANDATORY)
-
-        h_sctj = CoreHit(c_gene_sctj, "h_sctj", 30, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.ACCESSORY)
-
-        h_sctn = CoreHit(c_gene_sctn, "sctn", 40, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.ACCESSORY)
-        h_sctn_hom = CoreHit(c_gene_sctn_FLG, "h_scth_hom", 30, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctn_hom = ModelHit(h_sctn_hom, homolog_sctn_FLG, GeneStatus.ACCESSORY)
-
-        h_toto = CoreHit(c_gene_sctn, "toto", 50, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_toto = ModelHit(h_toto, gene_toto, GeneStatus.NEUTRAL)
-
-        h_flie = CoreHit(c_gene_flie, "h_flie", 100, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        l_flie = Loner(h_flie, gene_flie, GeneStatus.MANDATORY)
-        ms_flie = MultiSystem(h_flie, gene_flie, GeneStatus.MANDATORY)
-        lms_flie = LonerMultiSystem(h_flie, gene_flie, GeneStatus.MANDATORY)
-
-        # 2 mandatory, 2 accessory no analog/homolog
-        c1 = Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn], model, self.hit_weights)
-        self.assertEqual(c1.score, 3.0)
-
-        # 2 mandatory, 2 accessory 1 neutral, no analog/homolog
-        c1 = Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn, mh_toto], model, self.hit_weights)
-        self.assertEqual(c1.score, 3.0)
-
-        # 1 mandatory + 1 mandatory duplicated 1 time
-        # 1 accessory + 1 accessory duplicated 1 times
-        # no analog/homolog
-        c1 = Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn, mh_gspd, mh_sctn], model, self.hit_weights)
-        self.assertEqual(c1.score, 3.0)
-
-        # 2 mandatory
-        # 1 accessory + 1 accessory homolog
-        c1 = Cluster([mh_gspd, mh_tadz, mh_sctj, mh_sctn_hom], model, self.hit_weights)
-        self.assertEqual(c1.score, 2.9)
-
-        # 2 mandatory
-        # 1 accessory homolog + 2 accessory (check that the score used is the accessory not homolg)
-        c1 = Cluster([mh_sctn_hom, mh_gspd, mh_tadz, mh_sctj, mh_sctn], model, self.hit_weights)
-        self.assertEqual(c1.score, 3.0)
-
-        # test true loners
-        c1 = Cluster([l_flie], model, self.hit_weights)
-        self.assertEqual(c1.score, 0.7)
-
-        # test multi system out of cluster
-        c1 = Cluster([ms_flie], model, self.hit_weights)
-        self.assertEqual(c1.score, 0.7)
-
-        # test multi system out of cluster
-        c1 = Cluster([lms_flie], model, self.hit_weights)
-        self.assertEqual(c1.score, 0.7)
-
-        # test the cache score
-        c1 = Cluster([ms_flie], model, self.hit_weights)
-        self.assertEqual(c1.score, 0.7)
-
-        non_valid_hit = ModelHit(h_sctn, gene_sctn, GeneStatus.FORBIDDEN)
-        c1 = Cluster([mh_gspd, non_valid_hit, mh_tadz], model, self.hit_weights)
-        with self.assertRaises(MacsylibError) as ctx:
-            c1.score
-        self.assertEqual(str(ctx.exception),
-                         "a Cluster contains hit sctN 1 which is neither mandatory nor accessory: forbidden")
-
-
-    def test_merge(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-        gene_3 = ModelGene(c_gene_3, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-        h30 = CoreHit(c_gene_3, "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_3, GeneStatus.ACCESSORY)
-        h50 = CoreHit(c_gene_3, "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_3, GeneStatus.ACCESSORY)
-
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        c2 = Cluster([mh30, mh50], model, self.hit_weights)
-        c1.merge(c2)
-        self.assertListEqual(c1.hits, [mh10, mh20, mh30, mh50])
-
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        c2 = Cluster([mh30, mh50], model, self.hit_weights)
-        c2.merge(c1)
-        self.assertListEqual(c2.hits, [mh30, mh50, mh10, mh20])
-
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        c2 = Cluster([mh30, mh50], model, self.hit_weights)
-        c1.merge(c2, before=True)
-        self.assertListEqual(c1.hits, [mh30, mh50, mh10, mh20])
-
-        model_2 = Model("foo/T3SS", 11)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_3 = ModelGene(c_gene_3, model)
-
-        h30 = CoreHit(c_gene_3, "h30", 10, "replicon_2", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        mh30 = ModelHit(h30, gene_3, GeneStatus.ACCESSORY)
-        h50 = CoreHit(c_gene_3, "h50", 10, "replicon_2", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh50 = ModelHit(h50, gene_3, GeneStatus.ACCESSORY)
-        c3 = Cluster([mh30, mh50], model_2, self.hit_weights)
-        with self.assertRaises(MacsylibError) as ctx:
-            c1.merge(c3)
-        self.assertEqual(str(ctx.exception), "Try to merge Clusters from different model")
-
-
-    def test_str(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-        c1 = Cluster([mh10, mh20], model, self.hit_weights)
-        s ="""Cluster:
-- model = T2SS
-- replicon = replicon_1
-- hits = (h10, gspD, 10), (h20, sctC, 20)"""
-        self.assertEqual(str(c1), s)
-
-
-    def test_replace(self):
-        model = Model("foo/T2SS", 11)
-
-        c_gene_1 = CoreGene(self.model_location, "gspD", self.profile_factory)
-        c_gene_2 = CoreGene(self.model_location, "sctC", self.profile_factory)
-        c_gene_3 = CoreGene(self.model_location, "sctJ", self.profile_factory)
-
-        gene_1 = ModelGene(c_gene_1, model)
-        gene_2 = ModelGene(c_gene_2, model)
-        gene_3 = ModelGene(c_gene_3, model)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_1, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        h20 = CoreHit(c_gene_2, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        h30 = CoreHit(c_gene_3, "h30", 10, "replicon_1", 30, 1.0, 30.0, 1.0, 1.0, 10, 20)
-        h50 = CoreHit(c_gene_3, "h50", 10, "replicon_1", 50, 1.0, 50.0, 1.0, 1.0, 10, 20)
-        mh10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        mh20 = ModelHit(h20, gene_2, GeneStatus.MANDATORY)
-        mh30 = ModelHit(h30, gene_3, GeneStatus.ACCESSORY)
-        mh50 = ModelHit(h50, gene_3, GeneStatus.ACCESSORY)
-
-        c1 = Cluster([mh10, mh20, mh30], model, self.hit_weights)
-        c1.replace(mh20, mh50)
-        self.assertEqual(c1.hits,
-                         [mh10, mh50, mh30])
--- macsylib.orig/tests/test_gene.py
+++ macsylib/tests/test_gene.py
@@ -37,381 +37,6 @@
 from tests import MacsyTest
 
 
-class TestCoreGene(MacsyTest):
-
-    def setUp(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_CoreGene_')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 30
-        self.cfg = Config(MacsyDefaults(), args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_core_gene(self):
-        model_fqn = "foo/bar"
-        model = Model(model_fqn, 10)
-        gene_name = 'toto'
-        cg = CoreGene(self.model_location, gene_name, self.profile_factory)
-        self.assertEqual(cg.name, gene_name)
-        self.assertEqual(cg.model_family_name, model.family_name)
-        self.assertEqual(cg.profile, self.profile_factory.get_profile(cg, self.model_location))
-        cg2 = CoreGene(self.model_location, gene_name, self.profile_factory)
-        self.assertTrue(isinstance(hash(cg), int))
-        self.assertEqual(hash(cg), hash(cg2))
-        gene_name = 'totote'
-        cg3 = CoreGene(self.model_location, gene_name, self.profile_factory)
-        self.assertNotEqual(hash(cg), hash(cg3))
-
-
-class TestModelGene(MacsyTest):
-
-    def setUp(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_CoreGene_')
-        args.res_search_dir = self._tmp_dir.name
-        args.log_level = 30
-        self.cfg = Config(MacsyDefaults(), args)
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def test_init(self):
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_1 = ModelGene(c_gene, model_foo)
-        with self.assertRaises(MacsylibError) as ctx:
-            ModelGene(gene_1, model_foo)
-        self.assertEqual(str(ctx.exception),
-                         "The ModeleGene gene argument must be a CoreGene not <class 'macsylib.gene.ModelGene'>.")
-
-    def test_hash(self):
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_1 = ModelGene(c_gene, model_foo)
-        gene_2 = ModelGene(c_gene, model_foo)
-
-        self.assertTrue(isinstance(hash(gene_1), int))
-        self.assertEqual(hash(gene_1), hash(gene_1))
-        self.assertNotEqual(hash(gene_1), hash(gene_2))
-
-    def test_unknown_attribute(self):
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene = ModelGene(c_gene, model_foo)
-        with self.assertRaises(AttributeError) as ctx:
-            gene.foo
-        self.assertEqual(str(ctx.exception), "'ModelGene' object has no attribute 'foo'")
-
-
-    def test_add_exchangeable(self):
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ'
-        c_gene_ref = CoreGene(self.model_location, gene_name, self.profile_factory)
-        gene_ref = ModelGene(c_gene_ref,  model_foo)
-
-        h_gene_name = 'sctJ_FLG'
-        h_c_gene = CoreGene(self.model_location, h_gene_name, self.profile_factory)
-
-        homolog = Exchangeable(h_c_gene, gene_ref)
-        gene_ref.add_exchangeable(homolog)
-        self.assertEqual(len(gene_ref.exchangeables), 1)
-        self.assertEqual(gene_ref.exchangeables[0], homolog)
-
-
-    def test_exchangeables(self):
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctN'
-        c_sctn = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctn = ModelGene(c_sctn, model_foo)
-
-        gene_name = 'sctJ_FLG'
-        c_sctJ_FLG = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        gene_name = 'sctJ'
-        c_sctJ = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        homolog_1 = Exchangeable(c_sctJ, sctn)
-        sctn.add_exchangeable(homolog_1)
-        homolog_2 = Exchangeable(c_sctJ_FLG, sctn)
-        sctn.add_exchangeable(homolog_2)
-        self.assertEqual(sctn.exchangeables, [homolog_1, homolog_2])
-
-        gene_name = 'flgB'
-        c_flgb = CoreGene(self.model_location, gene_name, self.profile_factory)
-        flgb = ModelGene(c_flgb, model_foo)
-        gene_name = 'flgC'
-        c_flgc = CoreGene(self.model_location, gene_name, self.profile_factory)
-        exch_1 = Exchangeable(c_flgc, flgb)
-        flgb.add_exchangeable(exch_1)
-        model_foo.add_mandatory_gene(flgb)
-        self.assertEqual(flgb.status, GeneStatus.MANDATORY)
-        self.assertEqual(exch_1.status, GeneStatus.MANDATORY)
-        # test the cache
-        self.assertEqual(exch_1.status, GeneStatus.MANDATORY)
-
-
-    def test_is_exchangeable(self):
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctN'
-        c_sctn = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctn = ModelGene(c_sctn, model_foo)
-
-        gene_name = 'sctJ_FLG'
-        c_sctj_flg = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctj_flg = ModelGene(c_sctj_flg, model_foo)
-
-        gene_name = 'sctJ'
-        c_sctj = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctj = ModelGene(c_sctj, model_foo)
-        homolog = Exchangeable(c_sctj_flg, sctj)
-        sctj.add_exchangeable(homolog)
-
-        self.assertFalse(sctj_flg.is_exchangeable)
-        self.assertFalse(sctj.is_exchangeable)
-        self.assertTrue(homolog.is_exchangeable)
-        self.assertFalse(sctn.is_exchangeable)
-
-
-    def test_alternate_of(self):
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctj = ModelGene(c_gene, model_foo)
-
-        gene_name = 'sctJ_FLG'
-        c_sctj_flg = CoreGene(self.model_location, gene_name, self.profile_factory)
-        analog = Exchangeable(c_sctj_flg, sctj)
-        sctj.add_exchangeable(analog)
-        self.assertEqual(sctj.alternate_of(), sctj)
-
-
-    def test_model(self):
-        """
-        test getter/setter for model property
-        """
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertEqual(sctJ_FLG.model, model_foo)
-
-
-    def test_core_gene(self):
-        """
-        test getter/setter for core_gene property
-        """
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertEqual(sctJ_FLG.core_gene, c_gene)
-
-
-    def test_loner(self):
-        """
-        test getter for loner property
-        """
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertFalse(sctJ_FLG.loner)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo, loner=True)
-        self.assertTrue(sctJ.loner)
-
-
-    def test_is_mandatory(self):
-        """
-        test if gene belong to model mandatory genes
-        """
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        model_foo.add_mandatory_gene(sctJ_FLG)
-        self.assertTrue(sctJ_FLG.is_mandatory())
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo)
-        model_foo.add_accessory_gene(sctJ)
-        self.assertFalse(sctJ.is_mandatory())
-
-
-    def test_is_accessory(self):
-        """
-        test if gene belong to model mandatory genes
-        """
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        model_foo.add_mandatory_gene(sctJ_FLG)
-        self.assertFalse(sctJ_FLG.is_accessory())
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo)
-        model_foo.add_accessory_gene(sctJ)
-        self.assertTrue(sctJ.is_accessory())
-
-
-    def test_is_Forbidden(self):
-        """
-        test if gene belong to model mandatory genes
-        """
-        model_foo = Model("foo", 10)
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        model_foo.add_mandatory_gene(sctJ_FLG)
-        self.assertFalse(sctJ_FLG.is_forbidden())
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo)
-        model_foo.add_forbidden_gene(sctJ)
-        self.assertTrue(sctJ.is_forbidden())
-
-
-    def test_multi_system(self):
-        """
-        test getter for multi_system property
-        """
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertFalse(sctJ_FLG.multi_system)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo, multi_system=True)
-        self.assertTrue(sctJ.multi_system)
-
-
-    def test_multi_model(self):
-        """
-        test getter for multi_modelproperty
-        """
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertFalse(sctJ_FLG.multi_model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo, multi_model=True)
-        self.assertTrue(sctJ.multi_model)
-
-
-    def test_status(self):
-        """
-        test getter for multi_modelproperty
-        """
-        model_foo = Model("foo", 10)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertFalse(sctJ_FLG.multi_model)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo)
-        self.assertIsNone(sctJ.status)
-
-        sctJ.set_status(GeneStatus.MANDATORY)
-        self.assertEqual(sctJ.status, GeneStatus.MANDATORY)
-
-
-    def test_inter_gene_max_space(self):
-        """
-        test getter for inter_gene_max_space property
-        """
-        system_inter_gene_max_space = 40
-        gene_inter_gene_max_space = 50
-        model_foo = Model("foo", system_inter_gene_max_space)
-
-        gene_name = 'sctJ_FLG'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ_FLG = ModelGene(c_gene, model_foo)
-        self.assertIsNone(sctJ_FLG.inter_gene_max_space, None)
-
-        gene_name = 'sctJ'
-        c_gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-        sctJ = ModelGene(c_gene, model_foo, inter_gene_max_space=gene_inter_gene_max_space)
-        self.assertEqual(sctJ.inter_gene_max_space, gene_inter_gene_max_space)
-
-
-    def test_str(self):
-        """
-        """
-        model_foo = Model("foo", 10)
-
-        c_sctJ_FLG = CoreGene(self.model_location, 'sctJ_FLG', self.profile_factory)
-        c_sctJ = CoreGene(self.model_location, 'sctJ', self.profile_factory)
-        c_sctN = CoreGene(self.model_location, 'sctN', self.profile_factory)
-        c_tadZ = CoreGene(self.model_location, 'tadZ', self.profile_factory)
-
-        sctJ_FLG = ModelGene(c_sctJ_FLG, model_foo)
-        homolog = Exchangeable(c_sctJ, sctJ_FLG)
-        sctJ_FLG.add_exchangeable(homolog)
-        analog = Exchangeable(c_sctN, sctJ_FLG)
-        sctJ_FLG.add_exchangeable(analog)
-
-        s = """name : sctJ_FLG
-inter_gene_max_space: None
-    exchangeables: sctJ, sctN"""
-        self.assertEqual(str(sctJ_FLG), s)
-
-        sctJ_FLG = ModelGene(c_sctJ_FLG, model_foo, loner=True, multi_system=True, inter_gene_max_space=10)
-        s = """name : sctJ_FLG
-inter_gene_max_space: 10
-loner
-multi_system"""
-        self.assertEqual(str(sctJ_FLG), s)
-
-        tadZ = ModelGene(c_tadZ, model_foo, loner=True, multi_system=False, multi_model=True, inter_gene_max_space=10)
-        s = """name : tadZ
-inter_gene_max_space: 10
-loner
-multi_model"""
-        self.assertEqual(str(tadZ), s)
-
-
 class TestGeneStatus(MacsyTest):
 
     def test_str(self):
--- macsylib.orig/tests/test_hit.py
+++ macsylib/tests/test_hit.py
@@ -38,731 +38,6 @@
 from tests import MacsyTest
 
 
-class CoreHitTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        self.profile_factory = ProfileFactory(self.cfg)
-
-
-    def test_cmp(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        # compare hit with different id (comparison based on seq identifier)
-        h0 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234),
-                     float(779.2), float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene, "PSAE001c01_013980", 759, "PSAE001c01", 4146, float(3.7e-76),
-                     float(255.8), float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-        self.assertGreater(h1, h0)
-        self.assertLess(h0, h1)
-        # compare hit with different same id (comparison based on score)
-        # score = 779.2
-        h0 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234),
-                     float(779.2), float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        # score = 255.8
-        h1 = CoreHit(gene, "PSAE001c01_006940", 759, "PSAE001c01", 4146, float(3.7e-76),
-                     float(255.8), float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-        self.assertGreater(h0, h1)
-        self.assertLess(h1, h0)
-
-
-    def test_eq(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        h0 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h2 = CoreHit(gene, "PSAE001c01_013980", 759, "PSAE001c01", 4146, float(3.7e-76), float(255.8),
-                     float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-        self.assertEqual(h0, h1)
-        self.assertNotEqual(h0, h2)
-
-
-    def test_str(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        hit_prop = {'id': "PSAE001c01_006940",
-                    'hit_seq_len': 803,
-                    'replicon_name': "PSAE001c01",
-                    'position': 694,
-                    'i_eval': float(1.2e-234),
-                    'score': float(779.2),
-                    'gene_name': gene.name,
-                    'profil_coverage': float(1.0),
-                    'sequence_coverage': float(638.000000),
-                    'begin': 104,
-                    'end': 741
-                    }
-
-        hit = CoreHit(gene, hit_prop['id'], hit_prop['hit_seq_len'], hit_prop['replicon_name'],
-                      hit_prop['position'], hit_prop['i_eval'], hit_prop['score'],
-                      hit_prop['profil_coverage'], hit_prop['sequence_coverage'], hit_prop['begin'], hit_prop['end'])
-        s = "{id}\t{replicon_name}\t{position:d}\t{hit_seq_len:d}\t{gene_name}\t{i_eval:.3e}" \
-            "\t{score:.3f}\t{profil_coverage:.3f}\t{sequence_coverage:.3f}\t{begin:d}\t{end:d}\n".format(**hit_prop)
-        self.assertEqual(s, str(hit))
-
-
-    def test_position(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        h0 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        self.assertEqual(h0.position, 3450)
-
-
-    def test_hash(self):
-        gene_name = "gspD"
-        gene = CoreGene(self.model_location, gene_name, self.profile_factory)
-
-        h0 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h2 = CoreHit(gene, "PSAE001c01_006941", 803, "PSAE001c01", 3450, float(1.2e-234), float(779.2),
-                     float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        self.assertTrue(isinstance(hash(h0), int))
-        self.assertEqual(hash(h0), hash(h1))
-        self.assertNotEqual(hash(h0), hash(h2))
-
-
-class ModelHitTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        model = Model("foo/T2SS", 10)
-        profile_factory = ProfileFactory(cfg)
-
-        gene_name = "gspD"
-        self.cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_gspd = ModelGene(self.cg_gspd, model, multi_system=True)
-
-        gene_name = "sctJ"
-        self.cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_sctj = ModelGene(self.cg_sctj, model, loner=True)
-
-        gene_name = "abc"
-        self.cg_abc = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_abc = ModelGene(self.cg_abc, model, multi_model=True)
-
-        model.add_mandatory_gene(self.mg_gspd)
-        model.add_accessory_gene(self.mg_sctj)
-        model.add_accessory_gene(self.mg_abc)
-
-        self.chit_1 = CoreHit(self.cg_gspd, "hit_1", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_2 = CoreHit(self.cg_sctj, "hit_2", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_3 = CoreHit(self.cg_abc, "hit_3", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-
-    def test_init(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(mhit_1.gene_ref, self.mg_gspd)
-        self.assertEqual(mhit_1.status, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_2, self.mg_gspd, GeneStatus.ACCESSORY)
-        self.assertEqual(mhit_2.gene_ref, self.mg_gspd)
-        self.assertEqual(mhit_2.status, GeneStatus.ACCESSORY)
-
-        with self.assertRaises(MacsylibError) as ctx:
-            ModelHit(mhit_1, self.cg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "The ModelHit 'hit' argument must be a CoreHit not <class 'macsylib.hit.ModelHit'>.")
-        with self.assertRaises(MacsylibError) as ctx:
-            ModelHit(self.chit_1, self.cg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "The ModelHit 'gene_ref' argument must be a ModelGene not <class 'macsylib.gene.CoreGene'>.")
-
-    def test_hash(self):
-        self.assertEqual(hash(self.chit_1), hash(self.chit_1))
-        self.assertNotEqual(hash(self.chit_1), hash(self.chit_2))
-
-    def test_delegation(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(mhit_1.position, 2)
-        with self.assertRaises(AttributeError) as ctx:
-            mhit_1.nimportnaoik()
-        self.assertEqual(str(ctx.exception),
-                         "'ModelHit' object has no attribute 'nimportnaoik'")
-
-    def test_eq(self):
-        mhit_0 = ModelHit(self.chit_1, self.mg_sctj, GeneStatus.MANDATORY)
-        mhit_1 = ModelHit(self.chit_1, self.mg_sctj, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_2, self.mg_gspd, GeneStatus.ACCESSORY)
-
-        self.assertEqual(mhit_0, mhit_1)
-        self.assertNotEqual(mhit_0, mhit_2)
-
-    def test_gt(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_2, self.mg_sctj, GeneStatus.ACCESSORY)
-
-        self.assertTrue(mhit_2 > mhit_1)
-        self.assertFalse(mhit_1 > mhit_2)
-
-    def test_lq(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_2, self.mg_sctj, GeneStatus.ACCESSORY)
-
-        self.assertTrue(mhit_1 < mhit_2)
-        self.assertFalse(mhit_2 < mhit_1)
-
-
-    def test_multi_system(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_sctj, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_2, self.mg_gspd, GeneStatus.MANDATORY)
-        self.assertTrue(mhit_2.multi_system)
-        self.assertFalse(mhit_1.multi_system)
-
-    def test_multi_model(self):
-        mhit_1 = ModelHit(self.chit_1, self.mg_sctj, GeneStatus.MANDATORY)
-        mhit_2 = ModelHit(self.chit_3, self.mg_abc, GeneStatus.ACCESSORY)
-        self.assertFalse(mhit_1.multi_model)
-        self.assertTrue(mhit_2.multi_model)
-
-
-    def test_loner(self):
-        mhit_2 = ModelHit(self.chit_2, self.mg_gspd, GeneStatus.MANDATORY)
-        self.assertFalse(mhit_2.loner)
-
-
-class LonerTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        model = Model("foo/T2SS", 10)
-        profile_factory = ProfileFactory(cfg)
-
-        gene_name = "gspD"
-        self.cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_gspd = ModelGene(self.cg_gspd, model, loner=True)
-
-        gene_name = "sctJ"
-        self.cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_sctj = ModelGene(self.cg_sctj, model)
-
-        model.add_mandatory_gene(self.mg_gspd)
-        model.add_accessory_gene(self.mg_sctj)
-
-        self.chit_1 = CoreHit(self.cg_gspd, "hit_1", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_2 = CoreHit(self.cg_sctj, "hit_2", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_3 = CoreHit(self.cg_gspd, "hit_3", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        self.mhit_2 = ModelHit(self.chit_2, self.mg_sctj, GeneStatus.ACCESSORY)
-        self.mhit_3 = ModelHit(self.chit_3, self.mg_gspd, GeneStatus.MANDATORY)
-
-    def test_init(self):
-        # create loner from a CoreHit
-        l1 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(l1.gene_ref, self.mg_gspd)
-        self.assertEqual(l1.status, GeneStatus.MANDATORY)
-        # create loner from a CoreHit with counterpart
-        _ = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-
-        # try to create Loner from cCoreHit but without gene_ref nor gene_status
-        with self.assertRaises(MacsylibError) as ctx:
-            Loner(self.chit_1, gene_ref=self.mg_gspd)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a Loner hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-        with self.assertRaises(MacsylibError) as ctx:
-            Loner(self.chit_1, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a Loner hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-
-        # create loner from a ModelHit
-        mh1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        l3 = Loner(mh1)
-        self.assertEqual(l3.gene_ref, self.mg_gspd)
-        self.assertEqual(l3.status, GeneStatus.MANDATORY)
-
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                Loner(self.chit_2, gene_ref=self.mg_sctj, gene_status=GeneStatus.ACCESSORY)
-        self.assertEqual(str(ctx.exception),
-                         "hit_2 cannot be a loner gene_ref 'sctJ' not tag as loner")
-
-        with self.assertRaises(MacsylibError) as ctx:
-            Loner(self.chit_1, self.cg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "The Loner 'gene_ref' argument must be a ModelGene not <class 'macsylib.gene.CoreGene'>.")
-
-
-    def test_counterpart(self):
-        l1 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertSetEqual(l1.counterpart, set())
-        l2 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertSetEqual(l2.counterpart, set([self.mhit_3]))
-
-    def test_len(self):
-        l1 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(len(l1), 1)
-        l2 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertEqual(len(l2), 2)
-
-
-    def test_loner(self):
-        l1 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertTrue(l1.loner)
-
-    def test_multi_system(self):
-        l1 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertFalse(l1.multi_system)
-
-    def test_str(self):
-        l2 = Loner(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertEqual(str(l2),
-                         '\t'.join(['hit_1', 'replicon_id', '2', '803', 'gspD', '1.000e+00',
-                                    '1.000', '1.000', '1.000', '10', '20', 'hit_3'])
-                         )
-
-
-class MultiSystemTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        model = Model("foo/T2SS", 10)
-        profile_factory = ProfileFactory(cfg)
-
-        gene_name = "gspD"
-        self.cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_gspd = ModelGene(self.cg_gspd, model, multi_system=True)
-
-        gene_name = "sctJ"
-        self.cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_sctj = ModelGene(self.cg_sctj, model)
-
-        model.add_mandatory_gene(self.mg_gspd)
-        model.add_accessory_gene(self.mg_sctj)
-
-        #              CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #                       profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                                   pos     score
-        self.chit_1 = CoreHit(self.cg_gspd, "hit_1", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_2 = CoreHit(self.cg_sctj, "hit_2", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_3 = CoreHit(self.cg_gspd, "hit_3", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        self.mhit_2 = ModelHit(self.chit_2, self.mg_sctj, GeneStatus.ACCESSORY)
-        self.mhit_3 = ModelHit(self.chit_3, self.mg_gspd, GeneStatus.MANDATORY)
-
-    def test_init(self):
-        # create loner from a CoreHit
-        ms1 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(ms1.gene_ref, self.mg_gspd)
-        self.assertEqual(ms1.status, GeneStatus.MANDATORY)
-        # create loner from a CoreHit with counterpart
-        # test the creation, the content of counterpart is test in test_counterpart
-        _ = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-
-        # try to create MS from cCoreHit but without gene_ref nor gene_status
-        with self.assertRaises(MacsylibError) as ctx:
-            MultiSystem(self.chit_1, gene_ref=self.mg_gspd)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a MultiSystem hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-        with self.assertRaises(MacsylibError) as ctx:
-            MultiSystem(self.chit_1, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a MultiSystem hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-
-        # create MultiSystem from a ModelHit
-        mh1 = ModelHit(self.chit_1, gene_ref=self.mg_gspd,  gene_status=GeneStatus.MANDATORY)
-        ms3 = MultiSystem(mh1)
-        self.assertEqual(ms3.gene_ref, self.mg_gspd)
-        self.assertEqual(ms3.status, GeneStatus.MANDATORY)
-
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                MultiSystem(self.chit_2, gene_ref=self.mg_sctj, gene_status=GeneStatus.ACCESSORY)
-        self.assertEqual(str(ctx.exception),
-                         "hit_2 cannot be a multi systems, gene_ref 'sctJ' not tag as multi_system")
-
-        with self.assertRaises(MacsylibError) as ctx:
-            MultiSystem(self.chit_1, self.cg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "The MultiSystem 'gene_ref' argument must be a ModelGene not <class 'macsylib.gene.CoreGene'>.")
-
-
-    def test_counterpart(self):
-        ms1 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertSetEqual(ms1.counterpart, set())
-        ms2 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertSetEqual(ms2.counterpart, set([self.mhit_3]))
-
-    def test_len(self):
-        ms1 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(len(ms1), 1)
-        ms2 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertEqual(len(ms2), 2)
-
-
-    def test_loner(self):
-        ms1 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertFalse(ms1.loner)
-
-    def test_multi_system(self):
-        ms1 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertTrue(ms1.multi_system)
-
-    def test_str(self):
-        ms2 = MultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY, counterpart=[self.mhit_3])
-        self.assertEqual(str(ms2),
-                         '\t'.join(['hit_1', 'replicon_id', '2', '803', 'gspD', '1.000e+00',
-                                    '1.000', '1.000', '1.000', '10', '20', 'hit_3'])
-                         )
-
-
-class LonerMultiSystemTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        model = Model("foo/T2SS", 10)
-        profile_factory = ProfileFactory(cfg)
-
-        gene_name = "gspD"
-        self.cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_gspd = ModelGene(self.cg_gspd, model, loner=True, multi_system=True)
-
-        gene_name = "sctJ"
-        self.cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        self.mg_sctj = ModelGene(self.cg_sctj, model)
-
-        model.add_mandatory_gene(self.mg_gspd)
-        model.add_accessory_gene(self.mg_sctj)
-
-        self.chit_1 = CoreHit(self.cg_gspd, "hit_1", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_2 = CoreHit(self.cg_sctj, "hit_2", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_3 = CoreHit(self.cg_gspd, "hit_3", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.chit_4 = CoreHit(self.cg_gspd, "hit_4", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        self.mhit_1 = ModelHit(self.chit_1, self.mg_gspd, GeneStatus.MANDATORY)
-        self.mhit_2 = ModelHit(self.chit_2, self.mg_sctj, GeneStatus.ACCESSORY)
-        self.mhit_3 = ModelHit(self.chit_3, self.mg_gspd, GeneStatus.MANDATORY)
-        self.mhit_4 = ModelHit(self.chit_4, self.mg_gspd, GeneStatus.MANDATORY)
-
-    def test_init(self):
-        # create loner from a CoreHit
-        lms1 = LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(lms1.gene_ref, self.mg_gspd)
-        self.assertEqual(lms1.status, GeneStatus.MANDATORY)
-        # create loner from a CoreHit with counterpart
-        # test the creation, the content of counterpart is test in test_counterpart
-        _ = LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd,
-                             gene_status=GeneStatus.MANDATORY,
-                             counterpart=[self.mhit_3])
-
-        # try to create MS from CoreHit but without gene_ref nor gene_status
-        with self.assertRaises(MacsylibError) as ctx:
-            LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a LonerMultiSystem hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-        with self.assertRaises(MacsylibError) as ctx:
-            LonerMultiSystem(self.chit_1, gene_status=GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "Cannot Create a LonerMultiSystem hit from CoreHit (gspD, 2) "
-                         "without specifying 'gene_ref' and 'gene_status'")
-
-        # create MultiSystem from a ModelHit
-        mh1 = ModelHit(self.chit_1, gene_ref=self.mg_gspd,  gene_status=GeneStatus.MANDATORY)
-        lms = LonerMultiSystem(mh1)
-        self.assertEqual(lms.gene_ref, self.mg_gspd)
-        self.assertEqual(lms.status, GeneStatus.MANDATORY)
-
-        with self.catch_log(log_name='macsylib'):
-            with self.assertRaises(MacsylibError) as ctx:
-                LonerMultiSystem(self.chit_2, gene_ref=self.mg_sctj, gene_status=GeneStatus.ACCESSORY)
-        self.assertEqual(str(ctx.exception),
-                         "hit_2 cannot be a multi systems, gene_ref 'sctJ' not tag as multi_system")
-
-        with self.assertRaises(MacsylibError) as ctx:
-            LonerMultiSystem(self.chit_1, self.cg_gspd, GeneStatus.MANDATORY)
-        self.assertEqual(str(ctx.exception),
-                         "The LonerMultiSystem 'gene_ref' argument must be a ModelGene"
-                         " not <class 'macsylib.gene.CoreGene'>.")
-
-        # create from a MultiSystem
-        mh1 = MultiSystem(self.chit_1,
-                          gene_ref=self.mg_gspd,
-                          gene_status=GeneStatus.MANDATORY,
-                          counterpart=[self.mhit_3, self.mhit_4])
-        lms = LonerMultiSystem(mh1)
-        self.assertEqual(lms.gene_ref, self.mg_gspd)
-        self.assertEqual(lms.status, GeneStatus.MANDATORY)
-        self.assertSetEqual(set(lms.counterpart), set([self.mhit_3, self.mhit_4]))
-
-    def test_loner(self):
-        lms1 = LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertTrue(lms1.loner)
-
-    def test_multi_system(self):
-        lms1 = LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd, gene_status=GeneStatus.MANDATORY)
-        self.assertTrue(lms1.multi_system)
-
-    def test_str(self):
-        lms2 = LonerMultiSystem(self.chit_1, gene_ref=self.mg_gspd,
-                                gene_status=GeneStatus.MANDATORY,
-                                counterpart=[self.mhit_3])
-        self.assertEqual(str(lms2),
-                         '\t'.join(['hit_1', 'replicon_id', '2', '803', 'gspD', '1.000e+00',
-                                    '1.000', '1.000', '1.000', '10', '20', 'hit_3'])
-                         )
-
-
-    def test_counterpart(self):
-        mh1 = MultiSystem(self.chit_1,
-                          gene_ref=self.mg_gspd,
-                          gene_status=GeneStatus.MANDATORY)
-
-        mh1.counterpart = [self.mhit_3, self.mhit_4]
-        self.assertSetEqual(mh1.counterpart,
-                            {self.mhit_3, self.mhit_4})
-
-        with self.assertRaises(MacsylibError) as ctx:
-            with self.catch_log():
-                mh1.counterpart = [self.mhit_3, self.mhit_2]
-        self.assertEqual(str(ctx.exception),
-                         "Try to set counterpart for hit 'gspD' with non compatible hits: ['gspD', 'sctJ']")
-
-
-class GetBestHitTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        self.models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        ProfileFactory(cfg)
-
-        model = Model(model_name, 10)
-        self.profile_factory = ProfileFactory(cfg)
-
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, multi_system=True)
-
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model, multi_system=True)
-
-        gene_name = "sctN"
-        c_gene_sctn = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene_sctn = Exchangeable(c_gene_sctn, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctn)
-
-        model.add_mandatory_gene(gene_gspd)
-        model.add_accessory_gene(gene_sctj)
-
-        #        CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #                       profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                        pos      score
-        chit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_3 = CoreHit(c_gene_gspd, "hit_3", 803, "replicon_id", 10, 1.0, 3.0, 1.0, 1.0, 10, 20)
-        chit_4 = CoreHit(c_gene_sctn, "hit_4", 803, "replicon_id", 14, 1.0, 4.0, 1.0, 1.0, 10, 20)
-        chit_5 = CoreHit(c_gene_gspd, "hit_5", 803, "replicon_id", 20, 1.0, 2.0, 1.0, 1.0, 10, 20)
-
-        self.mhit_1 = ModelHit(chit_1, gene_gspd, GeneStatus.MANDATORY)
-        self.mhit_2 = ModelHit(chit_2, gene_sctj, GeneStatus.ACCESSORY)
-        self.mhit_3 = ModelHit(chit_3, gene_gspd, GeneStatus.MANDATORY)
-        self.mhit_4 = ModelHit(chit_4, gene_sctn, GeneStatus.ACCESSORY)
-        self.mhit_5 = ModelHit(chit_5, gene_gspd, GeneStatus.MANDATORY)
-
-        self.ms_1 = MultiSystem(chit_1, gene_ref=gene_gspd, gene_status=GeneStatus.MANDATORY)
-        self.ms_2 = MultiSystem(chit_2, gene_ref=gene_sctj, gene_status=GeneStatus.ACCESSORY)
-        self.ms_3 = MultiSystem(chit_3, gene_ref=gene_gspd, gene_status=GeneStatus.MANDATORY)
-        self.ms_4 = MultiSystem(chit_4, gene_ref=gene_sctn, gene_status=GeneStatus.ACCESSORY)
-        self.ms_5 = MultiSystem(chit_5, gene_ref=gene_gspd, gene_status=GeneStatus.MANDATORY)
-
-    def test_get_best_hits(self):
-        model = Model("foo/T2SS", 10)
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-
-        #        gene, model, id,            hit_seq_len, replicon_name, position, i_eval,
-        #        score,      profil_coverage,      sequence_coverage,     begin,end
-        ######################
-        # based on the score #
-        ######################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234),
-                     10, float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, float(3.7e-76),
-                     11, float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-
-        h = get_best_hits([h0, h1])
-        self.assertEqual(h[0], h1)
-
-        #######################
-        # based on the i_eval #
-        #######################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, 10,
-                     10, float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, 11,
-                     10, float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-
-        h = get_best_hits([h0, h1], key='i_eval')
-        self.assertEqual(h[0], h0)
-
-        #################################
-        # based on the profile_coverage #
-        #################################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, 10,
-                     10, 10, (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, 10,
-                     10, 11, (736.0 - 105.0 + 1) / 759, 105, 736)
-
-        h = get_best_hits([h0, h1], key='profile_coverage')
-        self.assertEqual(h[0], h1)
-
-        # bad criterion
-        with self.assertRaises(MacsylibError) as ctx:
-            get_best_hits([h0, h1], key='nimportnaoik')
-        self.assertEqual('The criterion for Hits comparison nimportnaoik does not exist or is not available.\n'
-                         'It must be either "score", "i_eval" or "profile_coverage".', str(ctx.exception))
-
-
-    def test_get_best_hits_4_func(self):
-        model = Model("foo/T2SS", 10)
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(self.models_location, gene_name, self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model, loner=True)
-
-        #        gene, model, id,            hit_seq_len, replicon_name, position, i_eval,
-        #        score,      profil_coverage,      sequence_coverage,     begin,end
-        ######################
-        # based on the score #
-        ######################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, float(1.2e-234),
-                     10, float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, float(3.7e-76),
-                     11, float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-        m0 = ModelHit(h0, gene_gspd, GeneStatus.ACCESSORY)
-        m1 = ModelHit(h1, gene_gspd, GeneStatus.ACCESSORY)
-        l0 = Loner(h0, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m1])
-        l1 = Loner(h1, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m0])
-        loners = get_best_hit_4_func(gene_name, [l0, l1])
-        self.assertEqual(loners, l1)
-
-        #######################
-        # based on the i_eval #
-        #######################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, 10,
-                     10, float(1.000000), (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, 11,
-                     10, float(1.000000), (736.0 - 105.0 + 1) / 759, 105, 736)
-        m0 = ModelHit(h0, gene_gspd, GeneStatus.ACCESSORY)
-        m1 = ModelHit(h1, gene_gspd, GeneStatus.ACCESSORY)
-        l0 = Loner(h0, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m1])
-        l1 = Loner(h1, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m0])
-
-        loners = get_best_hit_4_func(gene_name, [l0, l1], key='i_eval')
-        self.assertEqual(loners, l0)
-
-        #################################
-        # based on the profile_coverage #
-        #################################
-        h0 = CoreHit(gene_gspd, "PSAE001c01_006940", 803, "PSAE001c01", 3450, 10,
-                     10, 10, (741.0 - 104.0 + 1) / 803, 104, 741)
-        h1 = CoreHit(gene_gspd, "PSAE001c01_013980", 759, "PSAE001c01", 3450, 10,
-                     10, 11, (736.0 - 105.0 + 1) / 759, 105, 736)
-        m0 = ModelHit(h0, gene_gspd, GeneStatus.ACCESSORY)
-        m1 = ModelHit(h1, gene_gspd, GeneStatus.ACCESSORY)
-        l0 = Loner(h0, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m1])
-        l1 = Loner(h1, gene_ref=gene_gspd, gene_status=GeneStatus.ACCESSORY, counterpart=[m0])
-
-        loners = get_best_hit_4_func(gene_name, [l0, l1], key='profile_coverage')
-        self.assertEqual(loners, l1)
-
-        # bad criterion
-        with self.assertRaises(MacsylibError) as ctx:
-            get_best_hits([l0, l1], key='nimportnaoik')
-        self.assertEqual('The criterion for Hits comparison nimportnaoik does not exist or is not available.\n'
-                         'It must be either "score", "i_eval" or "profile_coverage".', str(ctx.exception))
-
-
-
-    def test_sort_multisystem_hits(self):
-        # scores                        gspd 1.0     sctj 1.0     gspd 3.0  sctn 4.0 Ex sctj gspd 2.0
-        sorted_hits = sort_model_hits([self.mhit_1, self.mhit_2, self.mhit_3, self.mhit_4, self.mhit_5])
-        expected = {'gspD': [self.mhit_1, self.mhit_3, self.mhit_5],
-                    'sctJ': [self.mhit_2, self.mhit_4]}
-        self.assertDictEqual(sorted_hits,
-                             expected)
-
-        sorted_hits = sort_model_hits([])
-        self.assertDictEqual(sorted_hits,
-                             {})
-
-
-    def test_compute_best_MSHit(self):
-        # scores                       gspd 1.0    sctj 1.0   gspd 3.0 sctn 4.0 Ex sctj  gspd 2.0
-        sorted_hits = sort_model_hits([self.ms_1, self.ms_2, self.ms_3, self.ms_4, self.ms_5])
-        best_hits = compute_best_MSHit(sorted_hits)
-        # The order does not matter
-        self.assertSetEqual({self.ms_3, self.ms_2}, set(best_hits))
-        self.assertSetEqual(self.ms_3.counterpart,
-                            {self.ms_1, self.ms_5})
-        self.assertSetEqual(self.ms_2.counterpart,
-                            {self.ms_4})
-
-
 class HitWeightTest(MacsyTest):
 
     def test_hit_weight_default(self):
--- macsylib.orig/tests/test_io.py
+++ macsylib/tests/test_io.py
@@ -87,516 +87,6 @@
         header = io.outfile_header(models, model_vers, prog_name=prog)
         self.assertEqual(header, expected_header_begin.format(prog=prog))
 
-    def test_system_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        system_1 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        system_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-"""
-        system_tsv += "\t".join(["replicon", "hit_id", "gene_name", "hit_pos", "model_fqn", "sys_id",
-                                 "sys_loci", "locus_num", "sys_wholeness", "sys_score", "sys_occ",
-                                 "hit_gene_ref", "hit_status", "hit_seq_len", "hit_i_eval", "hit_score",
-                                 "hit_profile_cov", "hit_seq_cov", "hit_begin_match", "hit_end_match", "counterpart",
-                                 "used_in"])
-        system_tsv += "\n"
-        system_tsv += "\t".join(["replicon_id", "hit_1", "gspD", "1", "foo/T2SS", system_1.id,
-                                 "1", "1", "1.000", "1.500", "1", "gspD", "mandatory", "803", "1.0", "1.000",
-                                 "1.000", "1.000", "10", "20", "", ""])
-        system_tsv += "\n"
-        system_tsv += "\t".join(["replicon_id", "hit_2", "sctJ", "1", "foo/T2SS", system_1.id,
-                                 "1", "1", "1.000", "1.500", "1", "sctJ", "accessory", "803", "1.0", "1.000",
-                                 "1.000", "1.000", "10", "20", "", ""])
-        system_tsv += "\n\n"
-
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_1])
-        systems_to_tsv(model_fam_name, model_vers, [system_1], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(system_tsv, f_out.getvalue())
-
-        # test No system found
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No System found
-"""
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([])
-        systems_to_tsv(model_fam_name, model_vers, [], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        # test No system found replicon skipped
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-#
-# WARNING: The replicon 'rep_1' has been SKIPPED. Cannot be solved before timeout.
-# WARNING: The replicon 'rep_2' has been SKIPPED. Cannot be solved before timeout.
-#
-# No System found
-"""
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([])
-        systems_to_tsv(model_fam_name, model_vers, [], track_multi_systems_hit, f_out, skipped_replicons=['rep_1', 'rep_2'])
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        gene_name = "tadZ"
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model, loner=True)
-        model.add_accessory_gene(gene_tadz)
-        hit_3 = CoreHit(c_gene_tadz, "hit_3", 803, "replicon_id", 30, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        loner_1 = Loner(hit_3, gene_tadz, GeneStatus.ACCESSORY)
-        system_2 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        hit_4 = CoreHit(c_gene_gspd, "hit_4", 803, "replicon_id", 40, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_4 = ModelHit(hit_4, gene_gspd, GeneStatus.MANDATORY)
-        hit_5 = CoreHit(c_gene_sctj, "hit_5", 803, "replicon_id", 41, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_5 = ModelHit(hit_5, gene_sctj, GeneStatus.ACCESSORY)
-        system_3 = System(model,
-                          [Cluster([mhit_4, mhit_5], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_2, system_3])
-        systems_to_tsv(model_fam_name, model_vers, [system_2, system_3], track_multi_systems_hit, f_out)
-
-        system_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-replicon\thit_id\tgene_name\thit_pos\tmodel_fqn\tsys_id\tsys_loci\tlocus_num\tsys_wholeness\tsys_score\tsys_occ\thit_gene_ref\thit_status\thit_seq_len\thit_i_eval\thit_score\thit_profile_cov\thit_seq_cov\thit_begin_match\thit_end_match\tcounterpart\tused_in
-replicon_id\thit_1\tgspD\t1\tfoo/T2SS\treplicon_id_T2SS_2\t1\t1\t1.000\t1.850\t1\tgspD\tmandatory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-replicon_id\thit_2\tsctJ\t1\tfoo/T2SS\treplicon_id_T2SS_2\t1\t1\t1.000\t1.850\t1\tsctJ\taccessory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-replicon_id\thit_3\ttadZ\t30\tfoo/T2SS\treplicon_id_T2SS_2\t1\t-1\t1.000\t1.850\t1\ttadZ\taccessory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-
-replicon_id\thit_4\tgspD\t40\tfoo/T2SS\treplicon_id_T2SS_3\t1\t1\t1.000\t1.850\t1\tgspD\tmandatory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-replicon_id\thit_5\tsctJ\t41\tfoo/T2SS\treplicon_id_T2SS_3\t1\t1\t1.000\t1.850\t1\tsctJ\taccessory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-replicon_id\thit_3\ttadZ\t30\tfoo/T2SS\treplicon_id_T2SS_3\t1\t-1\t1.000\t1.850\t1\ttadZ\taccessory\t803\t1.0\t1.000\t1.000\t1.000\t10\t20\t\t
-
-# WARNING Loner: there is only 1 occurrence(s) of loner 'tadZ' and 2 potential systems [replicon_id_T2SS_2, replicon_id_T2SS_3]
-"""
-        self.assertMultiLineEqual(system_tsv, f_out.getvalue())
-
-
-
-    def test_system_to_txt(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        system_1 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        system_txt = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-
-system id = replicon_id_T2SS_1
-model = foo/T2SS
-replicon = replicon_id
-clusters = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 1)]
-occ = 1
-wholeness = 1.000
-loci nb = 1
-score = 1.500
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-
-neutral genes:
-
-{"=" * 60}
-"""
-
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_1])
-        systems_to_txt(model_fam_name, model_vers,
-                       [system_1], track_multi_systems_hit, f_out)
-
-        self.assertMultiLineEqual(system_txt, f_out.getvalue())
-
-        # test No system found
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No System found
-"""
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([])
-        systems_to_txt(model_fam_name, model_vers,
-                       [], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        # test No system found replicon skipped
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-#
-# WARNING: The replicon 'rep_1' has been SKIPPED. Cannot be solved before timeout.
-# WARNING: The replicon 'rep_2' has been SKIPPED. Cannot be solved before timeout.
-#
-# No System found
-"""
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([])
-        systems_to_txt(model_fam_name, model_vers, [], track_multi_systems_hit, f_out,
-                       skipped_replicons=['rep_1', 'rep_2'])
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        gene_name = "tadZ"
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model, loner=True)
-        model.add_accessory_gene(gene_tadz)
-        hit_3 = CoreHit(c_gene_tadz, "hit_3", 803, "replicon_id", 30, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        loner_1 = Loner(hit_3, gene_tadz, GeneStatus.ACCESSORY)
-        system_2 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        hit_4 = CoreHit(c_gene_gspd, "hit_4", 803, "replicon_id", 40, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_4 = ModelHit(hit_4, gene_gspd, GeneStatus.MANDATORY)
-        hit_5 = CoreHit(c_gene_sctj, "hit_5", 803, "replicon_id", 41, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_5 = ModelHit(hit_5, gene_sctj, GeneStatus.ACCESSORY)
-        system_3 = System(model,
-                          [Cluster([mhit_4, mhit_5], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-
-system id = replicon_id_T2SS_2
-model = foo/T2SS
-replicon = replicon_id
-clusters = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 1)], [('hit_3', 'tadZ', 30)]
-occ = 1
-wholeness = 1.000
-loci nb = 1
-score = 1.850
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-\t- tadZ: 1 (tadZ)
-
-neutral genes:
-
-============================================================
-system id = replicon_id_T2SS_3
-model = foo/T2SS
-replicon = replicon_id
-clusters = [('hit_4', 'gspD', 40), ('hit_5', 'sctJ', 41)], [('hit_3', 'tadZ', 30)]
-occ = 1
-wholeness = 1.000
-loci nb = 1
-score = 1.850
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-\t- tadZ: 1 (tadZ)
-
-neutral genes:
-
-============================================================
-# WARNING Loner: there is only 1 occurrence(s) of loner 'tadZ' and 2 potential systems [replicon_id_T2SS_2, replicon_id_T2SS_3]
-"""
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_2, system_3])
-        systems_to_txt(model_fam_name, model_vers, [system_2, system_3], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-
-    def test_solution_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model_A = Model("foo/A", 10)
-        model_B = Model("foo/B", 10)
-        model_C = Model("foo/C", 10)
-
-        c_gene_sctn_flg = CoreGene(models_location, "sctN_FLG", profile_factory)
-        gene_sctn_flg = ModelGene(c_gene_sctn_flg, model_B)
-        c_gene_sctj_flg = CoreGene(models_location, "sctJ_FLG", profile_factory)
-        gene_sctj_flg = ModelGene(c_gene_sctj_flg, model_B)
-        c_gene_flgB = CoreGene(models_location, "flgB", profile_factory)
-        gene_flgB = ModelGene(c_gene_flgB, model_B)
-        c_gene_tadZ = CoreGene(models_location, "tadZ", profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model_B)
-
-        c_gene_sctn = CoreGene(models_location, "sctN", profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model_A)
-        gene_sctn_hom = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_hom)
-
-        c_gene_sctj = CoreGene(models_location, "sctJ", profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model_A)
-        gene_sctj_an = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_an)
-
-        c_gene_gspd = CoreGene(models_location, "gspD", profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model_A)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(models_location, "abc", profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model_A)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        model_A.add_mandatory_gene(gene_sctn)
-        model_A.add_mandatory_gene(gene_sctj)
-        model_A.add_accessory_gene(gene_gspd)
-        model_A.add_forbidden_gene(gene_abc)
-
-        model_B.add_mandatory_gene(gene_sctn_flg)
-        model_B.add_mandatory_gene(gene_sctj_flg)
-        model_B.add_accessory_gene(gene_flgB)
-        model_B.add_accessory_gene(gene_tadZ)
-
-        model_C.add_mandatory_gene(gene_sctn_flg)
-        model_C.add_mandatory_gene(gene_sctj_flg)
-        model_C.add_mandatory_gene(gene_flgB)
-        model_C.add_accessory_gene(gene_tadZ)
-        model_C.add_accessory_gene(gene_gspd)
-
-        #                    gene,     hit_id, hit_seq_len, rep_name, pos, i_eval
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctj2 = CoreHit(c_gene_sctj, "hit_sctj2", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn2 = CoreHit(c_gene_sctn, "hit_sctn2", 803, "replicon_id", 5, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_sctj_flg = CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 6, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_tadZ = CoreHit(c_gene_tadZ, "hit_tadZ", 803, "replicon_id", 7, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_flgB = CoreHit(c_gene_flgB, "hit_flgB", 803, "replicon_id", 8, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctj_flg2 = CoreHit(c_gene_sctj_flg, "hit_sctj_flg2", 803, "replicon_id", 14, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_tadZ2 = CoreHit(c_gene_tadZ, "hit_tadZ2", 803, "replicon_id", 15, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_flgB2 = CoreHit(c_gene_flgB, "hit_flgB2", 803, "replicon_id", 16, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd2 = CoreHit(c_gene_gspd, "hit_gspd2", 803, "replicon_id", 17, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model_A._min_mandatory_genes_required = 2
-        model_A._min_genes_required = 2
-        hit_weights = HitWeight(**cfg.hit_weights())
-        c1 = Cluster([ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY),
-                      ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-                      ],
-                     model_A, hit_weights)
-
-        c2 = Cluster([ModelHit(h_sctj2, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn2, gene_sctn, GeneStatus.MANDATORY)],
-                     model_A, hit_weights)
-
-        model_B._min_mandatory_genes_required = 1
-        model_B._min_genes_required = 2
-        c3 = Cluster([ModelHit(h_sctj_flg, gene_sctj_flg, GeneStatus.MANDATORY),
-                      ModelHit(h_tadZ, gene_tadZ, GeneStatus.ACCESSORY),
-                      ModelHit(h_flgB, gene_flgB, GeneStatus.ACCESSORY)],
-                     model_B, hit_weights)
-
-        model_C._min_mandatory_genes_required = 1
-        model_C._min_genes_required = 2
-        c4 = Cluster([ModelHit(h_sctj_flg2, gene_sctj_flg, GeneStatus.MANDATORY),
-                      ModelHit(h_tadZ2, gene_tadZ, GeneStatus.ACCESSORY),
-                      ModelHit(h_flgB2, gene_flgB, GeneStatus.MANDATORY),
-                      ModelHit(h_gspd2, gene_gspd, GeneStatus.ACCESSORY)],
-                     model_C, hit_weights)
-
-        sys_A = System(model_A, [c1, c2], cfg.redundancy_penalty())
-        sys_A.id = "sys_id_A"
-        sys_B = System(model_B, [c3], cfg.redundancy_penalty())
-        sys_B.id = "sys_id_B"
-        sys_C = System(model_C, [c4], cfg.redundancy_penalty())
-        sys_C.id = "sys_id_C"
-
-        sol_1 = Solution([sys_A, sys_C])
-        sol_2 = Solution([sys_A, sys_B])
-        sol_id_1 = '1'
-        sol_id_2 = '2'
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        sol_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-"""
-        sol_tsv += "\t".join(["sol_id", "replicon", "hit_id", "gene_name", "hit_pos", "model_fqn", "sys_id",
-                              "sys_loci", "locus_num",
-                              "sys_wholeness", "sys_score", "sys_occ", "hit_gene_ref", "hit_status",
-                              "hit_seq_len", "hit_i_eval", "hit_score", "hit_profile_cov", "hit_seq_cov",
-                              "hit_begin_match", "hit_end_match", "counterpart", "used_in"])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_sctj', 'sctJ', '1', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'sctJ', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_sctn', 'sctN', '2', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'sctN', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_gspd', 'gspD', '3', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'gspD', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_sctj2', 'sctJ', '4', 'foo/A', 'sys_id_A',
-                              '2', '2', '1.000', '1.500', '2', 'sctJ', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_sctn2', 'sctN', '5', 'foo/A', 'sys_id_A',
-                              '2', '2', '1.000', '1.500', '2', 'sctN', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_sctj_flg2', 'sctJ_FLG', '14', 'foo/C', 'sys_id_C',
-                              '1', '1', '0.800', '3.000', '1', 'sctJ_FLG', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_tadZ2', 'tadZ', '15', 'foo/C', 'sys_id_C',
-                              '1', '1', '0.800', '3.000', '1', 'tadZ', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_flgB2', 'flgB', '16', 'foo/C', 'sys_id_C',
-                              '1', '1', '0.800', '3.000', '1', 'flgB', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_1, 'replicon_id', 'hit_gspd2', 'gspD', '17', 'foo/C', 'sys_id_C',
-                              '1', '1', '0.800', '3.000', '1', 'gspD', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_sctj', 'sctJ', '1', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'sctJ', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_sctn', 'sctN', '2', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'sctN', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_gspd', 'gspD', '3', 'foo/A', 'sys_id_A',
-                              '2', '1', '1.000', '1.500', '2', 'gspD', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_sctj2', 'sctJ', '4', 'foo/A', 'sys_id_A',
-                              '2', '2', '1.000', '1.500', '2', 'sctJ', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_sctn2', 'sctN', '5', 'foo/A', 'sys_id_A',
-                              '2', '2', '1.000', '1.500', '2', 'sctN', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_sctj_flg', 'sctJ_FLG', '6', 'foo/B', 'sys_id_B',
-                              '1', '1', '0.750', '2.000', '1', 'sctJ_FLG', 'mandatory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_tadZ', 'tadZ', '7', 'foo/B', 'sys_id_B',
-                              '1', '1', '0.750', '2.000', '1', 'tadZ', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([sol_id_2, 'replicon_id', 'hit_flgB', 'flgB', '8', 'foo/B', 'sys_id_B',
-                              '1', '1', '0.750', '2.000', '1', 'flgB', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-
-        f_out = StringIO()
-        hit_multi_sys_tracker = HitSystemTracker([sys_A, sys_B, sys_C])
-        solutions_to_tsv(model_fam_name, model_vers, [sol_1, sol_2], hit_multi_sys_tracker, f_out)
-        self.maxDiff = None
-        self.assertMultiLineEqual(sol_tsv, f_out.getvalue())
-
-        # No solutions
-        solution_file = StringIO()
-        solutions_to_tsv(model_fam_name, model_vers, [], hit_multi_sys_tracker, solution_file)
-        solution_file.seek(0)
-        self.assertMultiLineEqual(sol_tsv, f_out.getvalue())
-
-
     def test_summary_best_solution(self):
         best_solution_path = self.find_data('best_solution.tsv')
         expected_summary_path = self.find_data('best_solution_summary.tsv')
@@ -682,818 +172,3 @@
         summary_best_solution(model_fam_name, model_vers, best_solution_path, computed_summary_file, models_fqn, replicon_names)
         computed_summary_file.seek(0)
         self.assertTsvEqual(expected_summary_path, computed_summary_file, tsv_type='best_solution_summary.tsv')
-
-
-    def test_rejected_candidates_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = "blabla"
-
-        cfg = Config(MacsyDefaults(), args)
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 11)
-
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_1 = ModelGene(c_gene_gspd, model)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_2 = ModelGene(c_gene_sctc, model)
-        model.add_mandatory_gene(gene_1)
-        model.add_accessory_gene(gene_2)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h20 = ModelHit(h20, gene_2, GeneStatus.ACCESSORY)
-        h40 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h40 = ModelHit(h40, gene_1, GeneStatus.MANDATORY)
-        h50 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 50, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h50 = ModelHit(h50, gene_2, GeneStatus.ACCESSORY)
-        hit_weights = HitWeight(**cfg.hit_weights())
-        c1 = Cluster([v_h10, v_h20], model, hit_weights)
-        c2 = Cluster([v_h40, v_h50], model, hit_weights)
-        r_c = RejectedCandidate(model, [c1, c2], ["The reasons to reject these candidate"])
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Rejected candidates found:
-"""
-        rej_cand_str += '\t'.join(
-            ['candidate_id', 'replicon', 'model_fqn', 'cluster_id', 'hit_id', 'hit_pos', 'gene_name', 'function',
-             'reasons'])
-        rej_cand_str += '\n'
-        rej_cand_str += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c1.id, 'h10', '10', 'gspD', 'gspD',
-                                   'The reasons to reject these candidate'])
-        rej_cand_str += '\n'
-        rej_cand_str += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c1.id, 'h20', '20', 'sctC', 'sctC',
-                                   'The reasons to reject these candidate'])
-        rej_cand_str += '\n'
-        rej_cand_str += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c2.id, 'h10', '40', 'gspD', 'gspD',
-                                   'The reasons to reject these candidate'])
-        rej_cand_str += '\n'
-        rej_cand_str += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c2.id, 'h20', '50', 'sctC', 'sctC',
-                                   'The reasons to reject these candidate'])
-        rej_cand_str += '\n'
-        rej_cand_str += '\n'
-
-        f_out = StringIO()
-        rejected_candidates_to_tsv(model_fam_name, model_vers, [r_c], f_out)
-        self.maxDiff = None
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Rejected candidates
-"""
-        f_out = StringIO()
-        rejected_candidates_to_tsv(model_fam_name, model_vers, [], f_out)
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-        # test with skipped replicons
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-#
-# WARNING: The replicon 'rep_1' has been SKIPPED. Cannot be solved before timeout.
-# WARNING: The replicon 'rep_2' has been SKIPPED. Cannot be solved before timeout.
-#
-# No Rejected candidates
-"""
-        f_out = StringIO()
-        rejected_candidates_to_tsv(model_fam_name, model_vers, [], f_out, skipped_replicons=['rep_1', 'rep_2'])
-        self.maxDiff = None
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-
-    def test_rejected_candidates_to_txt(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = "blabla"
-
-        cfg = Config(MacsyDefaults(), args)
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 11)
-
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_1 = ModelGene(c_gene_gspd, model)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_2 = ModelGene(c_gene_sctc, model)
-        model.add_mandatory_gene(gene_1)
-        model.add_accessory_gene(gene_2)
-
-        #     CoreHit(gene, model, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h20 = ModelHit(h20, gene_2, GeneStatus.ACCESSORY)
-        h40 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        v_h40 = ModelHit(h40, gene_1, GeneStatus.MANDATORY)
-        h50 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 50, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        v_h50 = ModelHit(h50, gene_2, GeneStatus.ACCESSORY)
-        hit_weights = HitWeight(**cfg.hit_weights())
-        c1 = Cluster([v_h10, v_h20], model, hit_weights)
-        c2 = Cluster([v_h40, v_h50], model, hit_weights)
-        r_c = RejectedCandidate(model, [c1, c2], ["The reasons to reject this candidate"])
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Rejected candidates:
-
-Cluster:
-- model = T2SS
-- replicon = replicon_1
-- hits = (h10, gspD, 10), (h20, sctC, 20)
-Cluster:
-- model = T2SS
-- replicon = replicon_1
-- hits = (h10, gspD, 40), (h20, sctC, 50)
-This candidate has been rejected because:
-\t- The reasons to reject this candidate
-============================================================
-"""
-
-        f_out = StringIO()
-        rejected_candidates_to_txt(model_fam_name, model_vers, [r_c], f_out)
-        self.maxDiff = None
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Rejected candidates
-"""
-        f_out = StringIO()
-        rejected_candidates_to_txt(model_fam_name, model_vers, [], f_out)
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-        # test with skipped replicons
-        rej_cand_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-#
-# WARNING: The replicon 'rep_1' has been SKIPPED. Cannot be solved before timeout.
-# WARNING: The replicon 'rep_2' has been SKIPPED. Cannot be solved before timeout.
-#
-# No Rejected candidates
-"""
-        f_out = StringIO()
-        rejected_candidates_to_txt(model_fam_name, model_vers, [], f_out, skipped_replicons=['rep_1', 'rep_2'])
-        self.maxDiff = None
-        self.assertMultiLineEqual(rej_cand_str, f_out.getvalue())
-
-
-    def test_loners_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-        model = Model("foo/T2SS", 10)
-
-        gene_name = "gspD"
-        cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        mg_gspd = ModelGene(cg_gspd, model, loner=True)
-
-        gene_name = "sctJ"
-        cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        mg_sctj = ModelGene(cg_sctj, model)
-
-        gene_name = "abc"
-        cg_abc = CoreGene(models_location, gene_name, profile_factory)
-        mg_abc = ModelGene(cg_abc, model)
-
-        model.add_mandatory_gene(mg_gspd)
-        model.add_accessory_gene(mg_sctj)
-        model.add_accessory_gene(mg_abc)
-
-        chit_abc = CoreHit(cg_abc, "hit_abc", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_sctj = CoreHit(cg_sctj, "hit_sctj", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_gspd1 = CoreHit(cg_gspd, "hit_gspd1", 803, "replicon_id", 20, 1.0, 2.0, 1.0, 1.0, 10, 20)
-        chit_gspd2 = CoreHit(cg_gspd, "hit_gspd2", 803, "replicon_id", 30, 1.0, 3.0, 1.0, 1.0, 10, 20)
-        mhit_abc = ModelHit(chit_abc, mg_abc, GeneStatus.ACCESSORY)
-        mhit_sctj = ModelHit(chit_sctj, mg_sctj, GeneStatus.ACCESSORY)
-        mhit_gspd1 = ModelHit(chit_gspd1, mg_gspd, GeneStatus.MANDATORY)
-        mhit_gspd2 = ModelHit(chit_gspd2, mg_gspd, GeneStatus.MANDATORY)
-        l_gspd1 = Loner(mhit_gspd1, counterpart=[mhit_gspd2])
-        system_1 = System(model,
-                          [Cluster([mhit_abc, mhit_sctj], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([l_gspd1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        loner_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Loners found:
-"""
-        loner_tsv += "\t".join(['replicon', 'model_fqn', 'function', 'gene_name', 'hit_id', 'hit_pos', 'hit_status',
-                                 'hit_seq_len', 'hit_i_eval', 'hit_score', 'hit_profile_cov',
-                                 'hit_seq_cov', 'hit_begin_match', 'hit_end_match'])
-        loner_tsv += "\n"
-        loner_tsv += "\t".join(['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd1', '20', 'mandatory', '803',
-                                 '1.000e+00', '2.000', '1.000', '1.000', '10', '20'])
-        loner_tsv += "\n"
-        loner_tsv += "\t".join(['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd2', '30', 'mandatory', '803',
-                                 '1.000e+00', '3.000', '1.000', '1.000', '10', '20'])
-        loner_tsv += "\n\n"
-
-        f_out = StringIO()
-        loners_to_tsv(model_fam_name, model_vers, [system_1], f_out)
-        self.assertMultiLineEqual(loner_tsv, f_out.getvalue())
-
-        # test No system found
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Loners found
-"""
-        f_out = StringIO()
-        loners_to_tsv(model_fam_name, model_vers, [], f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        # test No loners
-        loner_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Loners found
-"""
-        system_2 = System(model,
-                          [Cluster([mhit_abc, mhit_sctj], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        f_out = StringIO()
-        loners_to_tsv(model_fam_name, model_vers, [system_2], f_out)
-        self.assertMultiLineEqual(loner_tsv, f_out.getvalue())
-
-
-    def test_multisystem_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-        model = Model("foo/T2SS", 10)
-
-        gene_name = "gspD"
-        cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        mg_gspd = ModelGene(cg_gspd, model, multi_system=True)
-
-        gene_name = "sctJ"
-        cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        mg_sctj = ModelGene(cg_sctj, model)
-
-        gene_name = "abc"
-        cg_abc = CoreGene(models_location, gene_name, profile_factory)
-        mg_abc = ModelGene(cg_abc, model)
-
-        model.add_mandatory_gene(mg_gspd)
-        model.add_accessory_gene(mg_sctj)
-        model.add_accessory_gene(mg_abc)
-
-        chit_abc = CoreHit(cg_abc, "hit_abc", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_sctj = CoreHit(cg_sctj, "hit_sctj", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_gspd1 = CoreHit(cg_gspd, "hit_gspd1", 803, "replicon_id", 20, 1.0, 2.0, 1.0, 1.0, 10, 20)
-        chit_gspd2 = CoreHit(cg_gspd, "hit_gspd2", 803, "replicon_id", 30, 1.0, 3.0, 1.0, 1.0, 10, 20)
-        mhit_abc = ModelHit(chit_abc, mg_abc, GeneStatus.ACCESSORY)
-        mhit_sctj = ModelHit(chit_sctj, mg_sctj, GeneStatus.ACCESSORY)
-        mhit_gspd1 = ModelHit(chit_gspd1, mg_gspd, GeneStatus.MANDATORY)
-        mhit_gspd2 = ModelHit(chit_gspd2, mg_gspd, GeneStatus.MANDATORY)
-        l_gspd1 = MultiSystem(mhit_gspd1, counterpart=[mhit_gspd2])
-        system_1 = System(model,
-                          [Cluster([mhit_abc, mhit_sctj], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([l_gspd1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        multisystem_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Multisystems found:
-"""
-        multisystem_tsv += "\t".join(
-            ['replicon', 'model_fqn', 'function', 'gene_name', 'hit_id', 'hit_pos', 'hit_status',
-             'hit_seq_len', 'hit_i_eval', 'hit_score', 'hit_profile_cov',
-             'hit_seq_cov', 'hit_begin_match', 'hit_end_match'])
-        multisystem_tsv += "\n"
-        multisystem_tsv += "\t".join(
-            ['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd1', '20', 'mandatory', '803',
-             '1.000e+00', '2.000', '1.000', '1.000', '10', '20'])
-        multisystem_tsv += "\n"
-        multisystem_tsv += "\t".join(
-            ['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd2', '30', 'mandatory', '803',
-             '1.000e+00', '3.000', '1.000', '1.000', '10', '20'])
-        multisystem_tsv += "\n\n"
-
-        f_out = StringIO()
-        multisystems_to_tsv(model_fam_name, model_vers, [system_1], f_out)
-        self.assertMultiLineEqual(multisystem_tsv,
-                                  f_out.getvalue())
-
-        # test No system found
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Multisystems found
-"""
-        f_out = StringIO()
-        multisystems_to_tsv(model_fam_name, model_vers, [], f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        # test No multisystem found
-        system_2 = System(model,
-                          [Cluster([mhit_abc, mhit_sctj], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Multisystems found
-"""
-        f_out = StringIO()
-        multisystems_to_tsv(model_fam_name, model_vers, [system_2], f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-    def test_likely_systems_to_txt(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'unordered'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        # test if id is well incremented
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctc = ModelGene(c_gene_sctc, model)
-        model.add_neutral_gene(gene_sctc)
-        gene_name = "tadZ"
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model)
-        model.add_forbidden_gene(gene_tadz)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 804, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctc, "hit_3", 805, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctc, GeneStatus.NEUTRAL)
-        hit_4 = CoreHit(c_gene_tadz, "hit_4", 806, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_tadz, GeneStatus.FORBIDDEN)
-
-        system_1 = LikelySystem(model, [v_hit_1], [v_hit_2], [v_hit_3], [v_hit_4])
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        system_str = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Systems found:
-
-This replicon contains genetic materials needed for system foo/T2SS
-WARNING the quorum is reached but there is also some forbidden genes.
-
-system id = replicon_id_T2SS_1
-model = foo/T2SS
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 1), ('hit_3', 'sctC', 1), ('hit_4', 'tadZ', 1)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-
-neutral genes:
-\t- sctC: 1 (sctC)
-
-forbidden genes:
-\t- tadZ: 1 (tadZ)
-
-Use ordered replicon to have better prediction.
-
-"""
-
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_1])
-        likely_systems_to_txt(model_fam_name, model_vers, [system_1], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(system_str, f_out.getvalue())
-
-        f_out = StringIO()
-        likely_systems_to_txt(model_fam_name, model_vers, [], track_multi_systems_hit, f_out)
-        expected_out = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Likely Systems found
-"""
-        self.assertEqual(expected_out, f_out.getvalue())
-
-
-    def test_likely_systems_to_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'unordered'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        # test if id is well incremented
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctc = ModelGene(c_gene_sctc, model)
-        model.add_neutral_gene(gene_sctc)
-        gene_name = "tadZ"
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model)
-        model.add_forbidden_gene(gene_tadz)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 804, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctc, "hit_3", 805, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctc, GeneStatus.NEUTRAL)
-        hit_4 = CoreHit(c_gene_tadz, "hit_4", 806, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_tadz, GeneStatus.FORBIDDEN)
-
-        system_1 = LikelySystem(model, [v_hit_1], [v_hit_2], [v_hit_3], [v_hit_4])
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-        sol_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Likely Systems found:
-"""
-        sol_tsv += "\n"
-        sol_tsv += "# This replicon contains genetic materials needed for system foo/T2SS\n"
-        sol_tsv += "# WARNING the quorum is reached but there is also some forbidden genes."
-        sol_tsv += "\n"
-        sol_tsv += "\t".join(["replicon", "hit_id", "gene_name", "hit_pos", "model_fqn", "sys_id", "sys_wholeness",
-                              "hit_gene_ref", "hit_status", "hit_seq_len", "hit_i_eval", "hit_score",
-                              "hit_profile_cov", "hit_seq_cov", "hit_begin_match", "hit_end_match", "used_in"])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join(["replicon_id", "hit_1", "gspD", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                              "gspD", "mandatory", "803", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join(["replicon_id", "hit_2", "sctJ", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                              "sctJ", "accessory", "804", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join(["replicon_id", "hit_4", "tadZ", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                              "tadZ", "forbidden", "806", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join(["replicon_id", "hit_3", "sctC", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                              "sctC", "neutral", "805", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-
-        f_out = StringIO()
-        track_multi_systems_hit = HitSystemTracker([system_1])
-        likely_systems_to_tsv(model_fam_name, model_vers, [system_1], track_multi_systems_hit, f_out)
-        self.assertMultiLineEqual(sol_tsv, f_out.getvalue())
-
-        f_out = StringIO()
-        likely_systems_to_tsv(model_fam_name, model_vers, [], track_multi_systems_hit, f_out)
-        expected_out = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Likely Systems found
-"""
-        self.assertEqual(expected_out, f_out.getvalue())
-
-
-        def test_likely_systems_to_tsv(self):
-            args = argparse.Namespace()
-            args.sequence_db = self.find_data("base", "test_1.fasta")
-            args.db_type = 'unordered'
-            args.models_dir = self.find_data('models')
-            cfg = Config(MacsyDefaults(), args)
-
-            model_name = 'foo'
-            models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-            # we need to reset the ProfileFactory
-            # because it's a like a singleton
-            # so other tests are influenced by ProfileFactory and it's configuration
-            # for instance search_genes get profile without hmmer_exe
-            profile_factory = ProfileFactory(cfg)
-
-            model = Model("foo/T2SS", 10)
-            # test if id is well incremented
-            gene_name = "gspD"
-            c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-            gene_gspd = ModelGene(c_gene_gspd, model)
-            model.add_mandatory_gene(gene_gspd)
-            gene_name = "sctJ"
-            c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-            gene_sctj = ModelGene(c_gene_sctj, model)
-            model.add_accessory_gene(gene_sctj)
-            gene_name = "sctC"
-            c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-            gene_sctc = ModelGene(c_gene_sctc, model)
-            model.add_neutral_gene(gene_sctc)
-            gene_name = "tadZ"
-            c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-            gene_tadz = ModelGene(c_gene_tadz, model)
-            model.add_forbidden_gene(gene_tadz)
-
-            hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-            v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-            hit_2 = CoreHit(c_gene_sctj, "hit_2", 804, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-            v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-            hit_3 = CoreHit(c_gene_sctc, "hit_3", 805, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-            v_hit_3 = ModelHit(hit_3, gene_sctc, GeneStatus.NEUTRAL)
-            hit_4 = CoreHit(c_gene_tadz, "hit_4", 806, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-            v_hit_4 = ModelHit(hit_4, gene_tadz, GeneStatus.FORBIDDEN)
-
-            system_1 = LikelySystem(model, [v_hit_1], [v_hit_2], [v_hit_3], [v_hit_4])
-
-            model_fam_name = 'foo'
-            model_vers = '0.0b2'
-            sol_tsv = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-    # models : {model_fam_name}-{model_vers}
-    # {' '.join(sys.argv)}
-    # Likely Systems found:
-    """
-            sol_tsv += "\n"
-            sol_tsv += "# This replicon contains genetic materials needed for system foo/T2SS\n"
-            sol_tsv += "# WARNING the quorum is reached but there is also some forbidden genes."
-            sol_tsv += "\n"
-            sol_tsv += "\t".join(["replicon", "hit_id", "gene_name", "hit_pos", "model_fqn", "sys_id", "sys_wholeness",
-                                  "hit_gene_ref", "hit_status", "hit_seq_len", "hit_i_eval", "hit_score",
-                                  "hit_profile_cov", "hit_seq_cov", "hit_begin_match", "hit_end_match", "used_in"])
-            sol_tsv += "\n"
-            sol_tsv += '\t'.join(["replicon_id", "hit_1", "gspD", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                                  "gspD", "mandatory", "803", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-            sol_tsv += "\n"
-            sol_tsv += '\t'.join(["replicon_id", "hit_2", "sctJ", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                                  "sctJ", "accessory", "804", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-            sol_tsv += "\n"
-            sol_tsv += '\t'.join(["replicon_id", "hit_4", "tadZ", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                                  "tadZ", "forbidden", "806", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-            sol_tsv += "\n"
-            sol_tsv += '\t'.join(["replicon_id", "hit_3", "sctC", "1", "foo/T2SS", "replicon_id_T2SS_1", "1.000",
-                                  "sctC", "neutral", "805", "1.0", "1.000", "1.000", "1.000", "10", "20", ""])
-            sol_tsv += "\n"
-            sol_tsv += "\n"
-
-            f_out = StringIO()
-            track_multi_systems_hit = HitSystemTracker([system_1])
-            likely_systems_to_tsv(model_fam_name, model_vers, [system_1], track_multi_systems_hit, f_out)
-            self.assertMultiLineEqual(sol_tsv, f_out.getvalue())
-
-            f_out = StringIO()
-            likely_systems_to_tsv(model_fam_name, model_vers, [], track_multi_systems_hit, f_out)
-            expected_out = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-    # models : {model_fam_name}-{model_vers}
-    # {' '.join(sys.argv)}
-    # No Likely Systems found
-    """
-            self.assertEqual(expected_out, f_out.getvalue())
-
-
-    def test_unnlikely_systems_to_txt(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'unordered'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        # test if id is well incremented
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        gene_name = "sctJ"
-        c_gene_sctj = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_sctc = ModelGene(c_gene_sctc, model)
-        model.add_neutral_gene(gene_sctc)
-        gene_name = "tadZ"
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_tadz = ModelGene(c_gene_tadz, model)
-        model.add_forbidden_gene(gene_tadz)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 804, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctc, "hit_3", 805, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctc, GeneStatus.NEUTRAL)
-        hit_4 = CoreHit(c_gene_tadz, "hit_4", 806, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_tadz, GeneStatus.FORBIDDEN)
-        reason = "why it not a system"
-        system_1 = UnlikelySystem(model, [v_hit_1], [v_hit_2], [v_hit_3], [v_hit_4], reason)
-
-        model_fam_name = 'foo'
-        model_vers = '0.0b2'
-
-        exp_txt = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# Unlikely Systems found:
-
-This replicon probably not contains a system foo/T2SS:
-{reason}
-
-system id = replicon_id_T2SS_1
-model = foo/T2SS
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 1), ('hit_3', 'sctC', 1), ('hit_4', 'tadZ', 1)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-
-neutral genes:
-\t- sctC: 1 (sctC)
-
-forbidden genes:
-\t- tadZ: 1 (tadZ)
-
-Use ordered replicon to have better prediction.
-
-============================================================
-"""
-
-        f_out = StringIO()
-        unlikely_systems_to_txt(model_fam_name, model_vers, [system_1], f_out)
-        self.assertMultiLineEqual(exp_txt, f_out.getvalue())
-
-        f_out = StringIO()
-        unlikely_systems_to_txt(model_fam_name, model_vers, [], f_out)
-        expected_out = f"""# macsylib {macsylib.__version__} {macsylib.__commit__}
-# models : {model_fam_name}-{model_vers}
-# {' '.join(sys.argv)}
-# No Unlikely Systems found
-"""
-        self.assertEqual(expected_out, f_out.getvalue())
-
-
-    def test_loner_warning(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(models_location, 'gspD', profile_factory)
-        c_gene_sctj = CoreGene(models_location, 'sctJ', profile_factory)
-        c_gene_tadz = CoreGene(models_location, 'tadZ', profile_factory)
-
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        gene_tadz = ModelGene(c_gene_tadz, model, loner=True)
-
-        model.add_mandatory_gene(gene_gspd)
-        model.add_accessory_gene(gene_sctj)
-        model.add_accessory_gene(gene_tadz)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_tadz, "hit_3", 803, "replicon_id", 30, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        loner_1 = Loner(hit_3, gene_tadz, GeneStatus.ACCESSORY)
-        hit_4 = CoreHit(c_gene_gspd, "hit_4", 803, "replicon_id", 40, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_4 = ModelHit(hit_4, gene_gspd, GeneStatus.MANDATORY)
-        hit_5 = CoreHit(c_gene_sctj, "hit_5", 803, "replicon_id", 41, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mhit_5 = ModelHit(hit_5, gene_sctj, GeneStatus.ACCESSORY)
-
-        system_1 = System(model,
-                  [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-
-        system_2 = System(model,
-                          [Cluster([mhit_4, mhit_5], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        warnings = loner_warning([system_1, system_2])
-        self.assertListEqual(warnings,
-                             ["# WARNING Loner: there is only 1 occurrence(s) of loner 'tadZ' and 2 potential systems [replicon_id_T2SS_1, replicon_id_T2SS_2]"])
-
-        # The loner is also multisystem -> no warning
-        model = Model("foo/T2SS", 10)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        gene_tadz = ModelGene(c_gene_tadz, model, loner=True, multi_system=True)
-        model.add_mandatory_gene(gene_gspd)
-        model.add_accessory_gene(gene_sctj)
-        model.add_accessory_gene(gene_tadz)
-
-        loner_ms_1 = LonerMultiSystem(hit_3, gene_tadz, GeneStatus.ACCESSORY)
-        system_3 = System(model,
-                          [Cluster([v_hit_1, v_hit_2], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_ms_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-
-        system_4 = System(model,
-                          [Cluster([mhit_4, mhit_5], model, HitWeight(**cfg.hit_weights())),
-                           Cluster([loner_ms_1], model, HitWeight(**cfg.hit_weights()))],
-                          cfg.redundancy_penalty())
-        warnings = loner_warning([system_3, system_4])
-        self.assertListEqual(warnings, [])
-
-        # there is one loner and one system -> no warning
-        warnings = loner_warning([system_1])
-        self.assertListEqual(warnings, [])
--- macsylib.orig/tests/test_macsydata.py
+++ macsylib/tests/test_macsydata.py
@@ -161,495 +161,6 @@
         shutil.rmtree(unarch_pack_path)
         return arch_path
 
-    def test_find_all_installed_packages_w_models_dir(self):
-        fake_pack = 'fake_1'
-        self.create_fake_package(fake_pack, dest=self.models_dir[0])
-        reg = macsydata._find_all_installed_packages(models_dir=self.models_dir[0])
-        self.assertEqual([m.name for m in reg.models()], [fake_pack])
-
-
-    def test_find_all_installed_packages_wo_models_dir(self):
-        fake_pack = 'fake_1'
-        venv = os.environ.get('VIRTUAL_ENV')
-
-        os.environ['VIRTUAL_ENV'] = self.tmpdir + 'VENV'
-        try:
-            pack_name = 'macsylib'
-            common_path = os.path.join('share', pack_name, 'models')
-            models_dir = os.path.join(os.environ.get('VIRTUAL_ENV'), common_path)
-            os.makedirs(models_dir)
-            self.create_fake_package(fake_pack, dest=models_dir)
-
-            reg = macsydata._find_all_installed_packages()
-            self.assertEqual([m.name for m in reg.models()], [fake_pack])
-        finally:
-            if venv is None:
-                del os.environ['VIRTUAL_ENV']
-            else:
-                os.environ['VIRTUAL_ENV'] = venv
-
-    def test_find_all_installed_packages_wo_models_dir_w_other_package(self):
-        fake_pack = 'fake_2'
-        venv = os.environ.get('VIRTUAL_ENV')
-
-        os.environ['VIRTUAL_ENV'] = self.tmpdir + 'VENV'
-        try:
-            pack_name = 'macsyfinder'
-            common_path = os.path.join('share', pack_name, 'models')
-            models_dir = os.path.join(os.environ.get('VIRTUAL_ENV'), common_path)
-            os.makedirs(models_dir)
-            self.create_fake_package(fake_pack, dest=models_dir)
-
-            reg = macsydata._find_all_installed_packages(package_name='macsyfinder')
-            self.assertEqual([m.name for m in reg.models()], [fake_pack])
-        finally:
-            if venv is None:
-                del os.environ['VIRTUAL_ENV']
-            else:
-                os.environ['VIRTUAL_ENV'] = venv
-
-
-    def test_available(self):
-        list_pack = macsydata.RemoteModelIndex.list_packages
-        list_pack_vers = macsydata.RemoteModelIndex.list_package_vers
-        meta = macsydata.RemoteModelIndex.get_metadata
-        pack_name = 'fake_model'
-        pack_vers = '1.0'
-        pack_meta = {'short_desc': 'desc about fake_model'}
-        macsydata.RemoteModelIndex.list_packages = lambda x: [pack_name]
-        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack: [pack_vers]
-        macsydata.RemoteModelIndex.get_metadata = lambda x, pack, vers: pack_meta
-        self.create_fake_package('fake_model')
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_available(self.args)
-                get_pack = sys.stdout.getvalue().strip()
-            pack_name_vers = f"{pack_name} ({pack_vers})"
-            # use same formatting as in do_available
-            expected_pack = f"{pack_name_vers:26.25} - {pack_meta['short_desc']}"
-            self.assertEqual(get_pack, expected_pack)
-        finally:
-            macsydata.RemoteModelIndex.list_packages = list_pack
-            macsydata.RemoteModelIndex.list_package_vers = list_pack_vers
-            macsydata.RemoteModelIndex.get_metadata = meta
-
-        # test package with no version available
-        # no version = no tags
-        list_pack = macsydata.RemoteModelIndex.list_packages
-        list_pack_vers = macsydata.RemoteModelIndex.list_package_vers
-        meta = macsydata.RemoteModelIndex.get_metadata
-        pack_name = 'fake_model_no_vers'
-        pack_meta = {'short_desc': 'desc about fake_model'}
-        macsydata.RemoteModelIndex.list_packages = lambda x: [pack_name]
-        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack: []
-        macsydata.RemoteModelIndex.get_metadata = lambda x, pack, vers: pack_meta
-        self.create_fake_package('fake_model_no_vers')
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_available(self.args)
-                get_pack = sys.stdout.getvalue().strip()
-            self.assertEqual(get_pack, '')
-        finally:
-            macsydata.RemoteModelIndex.list_packages = list_pack
-            macsydata.RemoteModelIndex.list_package_vers = list_pack_vers
-            macsydata.RemoteModelIndex.get_metadata = meta
-
-
-    def test_info(self):
-        pack_name = "nimportnaoik"
-        self.args.model_package = pack_name
-        self.args.models_dir = None
-        with self.catch_log(log_name='macsylib'):
-            # macsylib.registry throw a warning if metadata is not found
-            # silenced it
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_info(self.args)
-                log_msg = log.get_value()
-        self.assertEqual(log_msg.strip(), f"Models '{pack_name}' not found locally.")
-
-        pack_name = "fake_pack"
-        self.args.package = pack_name
-        fake_pack_path = self.create_fake_package(pack_name)
-
-        def fake_find_installed_package(model_pack_name, models_dir=None, package_name='macsylib'):
-            return macsydata.ModelPackage(fake_pack_path)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = fake_find_installed_package
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_info(self.args)
-                msg = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        expected_info = """fake_pack (0.0b2)
-
-maintainer: auth_name <auth_name@mondomain.fr>
-
-this is a short description of the repos
-
-how to cite:
-\t- bla bla
-\t- link to publication
-\t- ligne 1
-\t  ligne 2
-\t  ligne 3 et bbbbb
-
-documentation
-\thttp://link/to/the/documentation
-
-This data are released under CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
-copyright: 2019, Institut Pasteur, CNRS"""
-        self.assertEqual(expected_info, msg)
-
-
-    def test_list(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0])
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, package_name='macsylib'):
-            return registry
-
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-
-        self.args.verbose = 1
-        self.args.outdated = False
-        self.args.uptodate = False
-        self.args.models_dir = None
-        self.args.long = False
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_list(self.args)
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-        expected_output = "fake_1-0.0b2\nfake_2-0.0b2"
-        self.assertEqual(packs,
-                         expected_output)
-
-
-    def test_list_long(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0])
-        model_dir = self.tmpdir
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, package_name='macsylib'):
-            return registry
-
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-
-        self.args.verbose = 1
-        self.args.outdated = False
-        self.args.uptodate = False
-        self.args.models_dir = None
-        self.args.long = True
-
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_list(self.args)
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-        expected_output  = f"""fake_1-0.0b2   ({os.path.join(model_dir, 'models', fake_packs[0])})
-fake_2-0.0b2   ({os.path.join(model_dir, 'models', fake_packs[1])})"""
-
-        self.assertEqual(packs,
-                         expected_output)
-
-
-    def test_list_outdated(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0], metadata=True)
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, package_name='macsylib'):
-            return registry
-
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-
-        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
-        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
-                                                                        'fake_2': ['0.0b2']}[name]
-        self.args.verbose = 1
-        self.args.outdated = True
-        self.args.uptodate = False
-        self.args.models_dir = None
-        self.args.long = False
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_list(self.args)
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
-
-        expected_output = 'fake_1-1.0 [0.0b2]'
-        self.assertEqual(packs,
-                         expected_output)
-
-
-    def test_list_uptodate(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0])
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, package_name='macsylib'):
-            return registry
-
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
-        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
-                                                                        'fake_2': ['0.0b2']}[name]
-        self.args.verbose = 1
-        self.args.outdated = False
-        self.args.uptodate = True
-        self.args.models_dir = None
-        self.args.long = False
-
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_list(self.args)
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
-        expected_output = 'fake_2-0.0b2'
-        self.assertEqual(packs, expected_output)
-
-
-    def test_list_verbose(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0])
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, package_name='macsylib'):
-            return registry
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
-        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
-                                                                        'fake_2': ['0.0b2']}[name]
-        os.unlink(os.path.join(self.models_dir[0], 'fake_1', 'metadata.yml'))
-        self.args.verbose = 2
-        self.args.outdated = False
-        self.args.uptodate = False
-        self.args.models_dir = None
-        self.args.long = False
-
-        try:
-            with self.catch_io(out=True):
-                with self.catch_log(log_name='macsydata') as log:
-                    macsydata.do_list(self.args)
-                    log_msg = log.get_value().strip()
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
-        self.assertEqual(packs, 'fake_2-0.0b2')
-        self.assertEqual(log_msg, f"[Errno 2] No such file or directory: '{self.models_dir[0]}/fake_1/metadata.yml'")
-
-
-    def test_freeze(self):
-        fake_packs = ('fake_1', 'fake_2')
-        for name in fake_packs:
-            self.create_fake_package(name, dest=self.models_dir[0])
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-        find_all_packages = macsydata._find_all_installed_packages
-        macsydata._find_all_installed_packages = lambda package_name: registry
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_freeze(self.args)
-                packs = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_all_installed_packages = find_all_packages
-        self.assertEqual(packs,
-                         "fake_1==0.0b2\nfake_2==0.0b2")
-
-
-    def test_cite(self):
-        model_pack_name = "nimportnaoik"
-        self.args.model_package = model_pack_name
-        self.args.models_dir = None
-        with self.catch_log(log_name='macsylib'):
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_cite(self.args)
-                log_msg = log.get_value()
-            self.assertEqual(log_msg.strip(), f"Models '{model_pack_name}' not found locally.")
-
-        pack_name = "fake_pack"
-        self.args.model_package = pack_name
-        fake_pack_path = self.create_fake_package(pack_name)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_pack_name, models_dir, package_name: macsydata.ModelPackage(fake_pack_path)
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_cite(self.args)
-                citation = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-        expected_citation = """To cite fake_pack:
-
-_ bla bla
-- link to publication
-- ligne 1
-  ligne 2
-  ligne 3 et bbbbb
-
-To cite MacSyLib:
-
-- Néron, Bertrand; Denise, Rémi; Coluzzi, Charles; Touchon, Marie; Rocha, Eduardo P.C.; Abby, Sophie S.
-  MacSyFinder v2: Improved modelling and search engine to identify molecular systems in genomes.
-  Peer Community Journal, Volume 3 (2023), article no. e28. doi : 10.24072/pcjournal.250.
-  https://peercommunityjournal.org/articles/10.24072/pcjournal.250/"""
-        self.assertEqual(expected_citation, citation)
-
-
-    def test_help(self):
-        pack_name = "nimportnaoik"
-        self.args.model_package = pack_name
-        self.args.models_dir = None
-        with self.catch_log(log_name='macsylib'):
-            # macsylib.registry throw a warning if metadata is not found
-            # silenced it
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_help(self.args)
-                log_msg = log.get_value()
-        self.assertEqual(log_msg.strip(), f"Models '{pack_name}' not found locally.")
-
-        model_pack_name = "fake_pack"
-        self.args.model_package = model_pack_name
-        fake_pack_path = self.create_fake_package(model_pack_name)
-
-        def fake_find_installed_package(model_pack_name, models_dir=None, package_name='macsylib'):
-            return macsydata.ModelPackage(fake_pack_path)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = fake_find_installed_package
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_help(self.args)
-                citation = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-        expected_citation = '# This a README'
-
-        self.assertEqual(expected_citation, citation)
-
-
-    def test_definition_all_def(self):
-        model_pack_name = 'fake_1'
-        self.args.model = [model_pack_name]
-        self.args.models_dir = None
-        fake_pack_path = self.create_fake_package(model_pack_name)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_pack_name, models_dir, package_name: macsylib.registries.ModelLocation(path=fake_pack_path)
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_show_definition(self.args)
-                stdout = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        expected_output = f"""<!-- fake_1/sub_fam_1/model_1 {fake_pack_path}/definitions/sub_fam_1/model_1.xml -->
-{self.definition_1}
-
-<!-- fake_1/sub_fam_2/model_2 {fake_pack_path}/definitions/sub_fam_2/model_2.xml -->
-{self.definition_2}"""
-        self.assertEqual(expected_output,
-                         stdout)
-
-
-    def test_definition_one_def(self):
-        pack_name = 'fake_1'
-        self.args.model = [pack_name, 'sub_fam_1/model_1', 'sub_fam_2/model_2']
-        self.args.models_dir = None
-        fake_pack_path = self.create_fake_package(pack_name)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_pack_name, models_dir, package_name: macsylib.registries.ModelLocation(path=fake_pack_path)
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_show_definition(self.args)
-                stdout = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        expected_output = f"""<!-- fake_1/sub_fam_1/model_1 {fake_pack_path}/definitions/sub_fam_1/model_1.xml -->
-{self.definition_1}
-
-<!-- fake_1/sub_fam_2/model_2 {fake_pack_path}/definitions/sub_fam_2/model_2.xml -->
-{self.definition_2}"""
-
-        self.assertEqual(expected_output,
-                         stdout)
-
-
-    def test_definition_models_dir(self):
-        pack_name = 'fake_1'
-        fake_pack_path = self.create_fake_package(pack_name, dest='model_dir')
-        self.args.model = [pack_name, 'sub_fam_1/model_1', 'sub_fam_2/model_2']
-        self.args.models_dir = os.path.dirname(fake_pack_path)
-
-        with self.catch_io(out=True):
-            macsydata.do_show_definition(self.args)
-            stdout = sys.stdout.getvalue().strip()
-
-        expected_output = f"""<!-- fake_1/sub_fam_1/model_1 {fake_pack_path}/definitions/sub_fam_1/model_1.xml -->
-{self.definition_1}
-
-<!-- fake_1/sub_fam_2/model_2 {fake_pack_path}/definitions/sub_fam_2/model_2.xml -->
-{self.definition_2}"""
-        self.maxDiff = None
-        self.assertEqual(expected_output,
-                         stdout)
-
-
-    def test_definition_bad_def(self):
-        pack_name = 'fake_1'
-        self.args.model = [pack_name, 'niportnaoik']
-        self.args.models_dir = None
-        fake_pack_path = self.create_fake_package(pack_name)
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_package_name, models_dir, package_name: macsylib.registries.ModelLocation(path=fake_pack_path)
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_show_definition(self.args)
-                log_msg = log.get_value().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        self.assertEqual(log_msg, "Model 'fake_1/niportnaoik' not found.")
-
-
     def test_definition_bad_pack(self):
         pack_name = 'nimportnaoik'
         self.args.model = [pack_name]
@@ -664,532 +175,6 @@
 
         self.assertEqual(log_msg, f"Model Package '{pack_name}' not found.")
 
-
-    def test_definition_bad_subfamily(self):
-        pack_name = 'fake_1'
-        self.args.model = ['/'.join([pack_name, 'niportnaoik'])]
-        self.args.models_dir = None
-        fake_pack_path = self.create_fake_package(pack_name)
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_package_name, models_dir, package_name: macsylib.registries.ModelLocation(path=fake_pack_path)
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_show_definition(self.args)
-                log_msg = log.get_value().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        self.assertEqual(log_msg,
-                         f"'niportnaoik' not found in package '{pack_name}'.")
-
-
-    def test_show_package(self):
-        pack_name = 'fake_1'
-        self.args.model = pack_name
-        self.args.models_dir = None
-        fake_pack_path = self.create_fake_package(pack_name, complex=True)
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = lambda model_pack_name, models_dir, package_name: macsylib.registries.ModelLocation(path=fake_pack_path)
-        try:
-            with self.catch_io(out=True):
-                macsydata.do_show_package(self.args)
-                stdout = sys.stdout.getvalue().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        expected_output = """fake_1
-    ├-sub_fam_1
-    │    ├-model_1
-    │    └-model_1_2
-    └-sub_fam_2
-         ├-model_2
-         └-model_2_2
-
-fake_1 (0.0b2) : 4 models"""
-
-        self.assertEqual(expected_output,
-                         stdout)
-
-
-    def test_show_package_bad_name(self):
-        pack_name = 'fake_1'
-        self.args.model = pack_name + '_KO'
-        self.create_fake_package(pack_name)
-        self.args.models_dir = self.models_dir[0]
-
-        with self.catch_log(log_name='macsylib'):
-            # macsylib.registry throw a warning if metadata is not found
-            # silenced it
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_show_package(self.args)
-                log_msg = log.get_value().strip()
-
-        self.assertEqual(log_msg, f"Model Package '{pack_name}_KO' not found.")
-
-
-    def test_check(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, vers=False)
-        self.args.path = path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.1'
-
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-
-        if lxml:
-            expected_msg = ""
-        else:
-            expected_msg = ("lxml is not installed grammar checking is basic. To deep checking install 'lxml' or "
-                            "install macsylib with target 'model': pip install macsylib[model]\n")
-        expected_msg += f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {os.path.join(self.tmpdir, pack_name)}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_20(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, vers=False)
-        self.args.path = path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.0'
-
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-
-        expected_msg = f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {os.path.join(self.tmpdir, pack_name)}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_warnings(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, readme=False, license=False)
-        self.args.path = path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.1'
-
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        if lxml:
-            expected_msg = ""
-        else:
-            expected_msg = "lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]\n"
-
-        expected_msg += """The model package 'fake_1' have not any LICENSE file. May be you have not right to use it.
-The model package 'fake_1' have not any README file.
-The field 'vers' is not required anymore in 'metadata.yml'.
-  It will be ignored and set by msl_data during installation phase according to the git tag.
-
-msl_data says: You're only giving me a partial QA payment?
-I'll take it this time, but I'm not happy.
-I'll be really happy, if you fix warnings above, before to publish these models."""
-
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_warnings_20(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, readme=False, license=False)
-        self.args.path = path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.0'
-
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-
-        expected_msg = """The model package 'fake_1' have not any LICENSE file. May be you have not right to use it.
-The model package 'fake_1' have not any README file.
-The field 'vers' is not required anymore in 'metadata.yml'.
-  It will be ignored and set by msl_data during installation phase according to the git tag.
-
-msl_data says: You're only giving me a partial QA payment?
-I'll take it this time, but I'm not happy.
-I'll be really happy, if you fix warnings above, before to publish these models."""
-
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_errors(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, profiles=False, definitions=False)
-        self.args.path = path
-        self.args.grammar = '2.1'
-        with self.catch_log(log_name='macsydata') as log:
-            with self.assertRaises(ValueError):
-                macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        if lxml:
-            expected_msg = ""
-        else:
-            expected_msg = ("lxml is not installed grammar checking is basic. To deep checking install 'lxml' or"
-                            " install macsylib with target 'model': pip install macsylib[model]\n")
-
-        expected_msg += """The model package 'fake_1' have no 'definitions' directory.
-The model package 'fake_1' have no 'profiles' directory.
-Please fix issues above, before publishing these models."""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_errors_20(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, profiles=False, definitions=False)
-        self.args.path = path
-        self.args.grammar = '2.1'
-        with self.catch_log(log_name='macsydata') as log:
-            with self.assertRaises(ValueError):
-                macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-
-        expected_msg = """The model package 'fake_1' have no 'definitions' directory.
-The model package 'fake_1' have no 'profiles' directory.
-Please fix issues above, before publishing these models."""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_errors_bad_syntax(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, definitions=False)
-        self.args.path = pack_path
-        self.args.grammar = '2.1'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_no_name.xml'), def_dir)
-        for name in ('sctJ', 'sctN'):
-            shutil.copyfile(self.find_data('models', 'foo', 'profiles', f'{name}.hmm'),
-                            os.path.join(pack_path, 'profiles', f"{name}.hmm")
-                            )
-        with self.catch_log(log_name='macsylib'):
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-        if lxml:
-            expected_msg = """gene_no_name is not valid: Element 'gene': The attribute 'name' is required but missing., line 7
-Please fix issues above, before publishing these models."""
-        else:
-            expected_msg = """lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]
-Invalid model definition 'fake_1/gene_no_name': gene without name
-Please fix issues above, before publishing these models."""
-
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_with_errors_bad_syntax_20(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, definitions=False)
-        self.args.path = pack_path
-        self.args.grammar = '2.0'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_no_name.xml'), def_dir)
-        for name in ('sctJ', 'sctN'):
-            shutil.copyfile(self.find_data('models', 'foo', 'profiles', f'{name}.hmm'),
-                            os.path.join(pack_path, 'profiles', f"{name}.hmm")
-                            )
-        with self.catch_log(log_name='macsylib'):
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-        expected_msg = """Invalid model definition 'fake_1/gene_no_name': gene without name
-Please fix issues above, before publishing these models."""
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_gene_twice(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name='msl_data'
-        self.args.grammar = '2.1'
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_twice.xml'), def_dir)
-        if lxml:
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-            expected_msg = """gene_twice is not valid: Element 'gene': Duplicate key-sequence ['flgB'] in unique identity-constraint 'UniqueGene'., line 9
-Please fix issues above, before publishing these models."""
-            self.assertEqual(expected_msg, log_msg)
-        else:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-            expected_msg = f"""lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]
-If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-            self.maxDiff = None
-            self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_gene_twice_20(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.0'
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_twice.xml'), def_dir)
-
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        expected_msg = f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-    def test_check_exchangeable_twice(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.1'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'exchangeable_twice.xml'), def_dir)
-        with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-        if lxml:
-            expected_msg = ""
-        else:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-            expected_msg = "lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]\n"
-
-        expected_msg += f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_exchangeable_twice_20(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.0'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'exchangeable_twice.xml'), def_dir)
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-
-        expected_msg = f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_gene_and_exchangeable(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.1'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_and_exchangeable.xml'), def_dir)
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        if lxml:
-            expected_msg = ""
-        else:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-            expected_msg = "lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]\n"
-
-        expected_msg += f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_gene_and_exchangeable_20(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name, vers=False, definitions=False,
-                                             gen_profiles=('flgB', 'flgC', 'fliE'))
-        self.args.path = pack_path
-        self.args.tool_name = 'msl_data'
-        self.args.grammar = '2.0'
-
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        shutil.copy(self.find_data('models', 'foo', 'definitions', 'gene_and_exchangeable.xml'), def_dir)
-        with self.catch_log(log_name='macsydata') as log:
-            macsydata.do_check(self.args)
-            log_msg = log.get_value().strip()
-        expected_msg = f"""If everyone were like you, I'd be out of business
-To push the models in organization:
-\tcd {pack_path}
-Transform the models into a git repository
-\tgit init .
-\tgit add .
-\tgit commit -m 'initial commit'
-add a remote repository to host the models
-for instance if you want to add the models to 'macsy-models'
-\tgit remote add origin https://github.com/macsy-models/
-\tgit tag -a <tag vers>  # check https://macsylib.readthedocs.io/en/latest/modeler_guide/publish_package.html#sharing-your-models
-\tgit push origin <tag vers>"""
-        self.maxDiff = None
-        self.assertEqual(expected_msg, log_msg)
-
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_bad_syntax_model_conf_lxml(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name)
-        self.args.path = pack_path
-        self.args.tool_name='msl_data'
-        self.args.grammar = '2.1'
-
-        shutil.copy(self.find_data('conf_files', 'model_conf_bad_value.xml'),
-                    os.path.join(pack_path, 'model_conf.xml'))
-        with self.catch_log(log_name='macsylib'):
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_check(self.args)
-                log_msg = log.get_value().strip()
-        expected_msg = f"""The model configuration file '{pack_path}/model_conf.xml' is not valid: Element 'itself': 'false' is not a valid value of the atomic type 'xs:float'., line 3
-Please fix issues above, before publishing these models."""
-        self.assertEqual(expected_msg, log_msg)
-
-
-    def test_check_bad_syntax_model_conf_no_lxml(self):
-        pack_name = 'fake_1'
-        pack_path = self.create_fake_package(pack_name)
-        self.args.path = pack_path
-        self.args.tool_name='msl_data'
-        self.args.grammar = '2.1'
-
-        shutil.copy(self.find_data('conf_files', 'model_conf_bad_value.xml'),
-                    os.path.join(pack_path, 'model_conf.xml'))
-        m_etree = macsydata.etree
-        macsydata.etree = None
-        try:
-            with self.catch_log(log_name='macsylib'):
-                with self.catch_log(log_name='macsydata') as log:
-                    with self.assertRaises(ValueError):
-                        macsydata.do_check(self.args)
-                    log_msg = log.get_value().strip()
-        finally:
-            macsydata.etree = m_etree
-        expected_msg = F"""lxml is not installed grammar checking is basic. To deep checking install 'lxml' or install macsylib with target 'model': pip install macsylib[model]
-The model configuration file '{pack_path}/model_conf.xml' is not valid: Element 'itself': 'false' is not a valid value of the atomic type 'xs:float'., line 3
-Please fix issues above, before publishing these models."""
-        self.maxDiff = None
-        print("")
-        self.assertEqual(expected_msg, log_msg)
-
-
-
     def test_download(self):
         def fake_download(_, pack_name, vers, dest=None):
             path = os.path.join(self.tmpdir, f"{pack_name}-{vers}.tar.gz")
@@ -1274,283 +259,6 @@
         expected_msg = "Downloading fake_1 1.0\ngithub limit error"
         self.assertEqual(log_msg, expected_msg)
 
-
-    def test_install_local(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '3.0'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata'):
-                macsydata.do_install(self.args)
-            expected_pack_path = os.path.join(self.models_dir[0], model_pack_name)
-            self.assertTrue(os.path.exists(expected_pack_path))
-            self.assertTrue(os.path.isdir(expected_pack_path))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'metadata.yml')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'README')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'definitions')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'profiles')))
-        finally:
-            del macsydata.Config.models_dir
-
-
-    def test_install_target(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '3.0'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_target = os.path.join(self.tmpdir, 'target')
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_target
-        self.args.no_clean = False
-
-        with self.catch_log(log_name='macsydata'):
-            macsydata.do_install(self.args)
-        expected_pack_path = os.path.join(macsydata_target, model_pack_name)
-        self.assertTrue(os.path.exists(expected_pack_path))
-        self.assertTrue(os.path.isdir(expected_pack_path))
-        self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'metadata.yml')))
-        self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'README')))
-        self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'definitions')))
-        self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'profiles')))
-
-
-    def test_install_bad_target(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '3.0'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_target = os.path.join(self.tmpdir, 'target')
-        open(macsydata_target, 'w').close()
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_target
-        self.args.no_clean = False
-
-        with self.assertRaises(RuntimeError) as ctx:
-            macsydata.do_install(self.args)
-        self.assertEqual(str(ctx.exception),
-                         f"'{macsydata_target}' already exist and is not a directory."
-                         )
-
-
-    def test_install_local_already_installed(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata'):
-                macsydata.do_install(self.args)
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_install(self.args)
-                msg_log = log.get_value().strip()
-            expected_log = f"""Requirement already satisfied: {model_pack_name}=={model_pack_vers} in {os.path.join(self.models_dir[0], model_pack_name)}.
-To force installation use option -f --force-reinstall."""
-            self.assertEqual(msg_log, expected_log)
-        finally:
-            del macsydata.Config.models_dir
-
-
-    def test_install_local_already_installed_force(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata'):
-                macsydata.do_install(self.args)
-
-            self.args.force = True
-            # remove README file to check if reinstall works
-            os.unlink(os.path.join(self.models_dir[0], model_pack_name, 'README'))
-
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_install(self.args)
-                msg_log = log.get_value().strip()
-            expected_log = f"""Extracting {model_pack_name} ({model_pack_vers}).
-Installing {model_pack_name} ({model_pack_vers}) in {self.models_dir[0]}
-Cleaning.
-The models {model_pack_name} ({model_pack_vers}) have been installed successfully."""
-            self.assertEqual(msg_log, expected_log)
-            self.assertTrue(os.path.exists(os.path.join(self.models_dir[0], model_pack_name, 'README')))
-        finally:
-            del macsydata.Config.models_dir
-
-
-    def test_install_installed_package_corrupted(self):
-        # there is no metadata file
-        # the package is not installable
-
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        unarch_pack_path = self.create_fake_package(model_pack_name, metadata=False, dest='tmp')
-        arch_path = f"{os.path.join(macsydata_tmp, model_pack_name)}-{model_pack_vers}.tar.gz"
-
-        # create a archive of the fake pack
-        with tarfile.open(arch_path, "w:gz") as arch:
-            arch.add(unarch_pack_path, arcname=model_pack_name)
-        shutil.rmtree(unarch_pack_path)
-
-        self.args.model_package = arch_path
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(MacsydataError):
-                    macsydata.do_install(self.args)
-                msg_log = log.get_value().strip()
-                expected_log = (f"Extracting {model_pack_name} ({model_pack_vers})."
-                                f"\nFailed to install '{model_pack_name}-{model_pack_vers}' : The model package has no 'metadata.yml' file."
-                                f"\nPlease contact the package maintainer. (local)")
-                self.assertEqual(expected_log, msg_log)
-        finally:
-            del macsydata.Config.models_dir
-
-
-    def test_install_remote(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        self.args.model_package = model_pack_name
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        # functions which do net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata'):
-                macsydata.do_install(self.args)
-            expected_pack_path = os.path.join(self.models_dir[0], model_pack_name)
-            self.assertTrue(os.path.exists(expected_pack_path))
-            self.assertTrue(os.path.isdir(expected_pack_path))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'metadata.yml')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'README')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'definitions')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'profiles')))
-        finally:
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
     def test_install_remote_spec_not_found(self):
         model_pack_name = 'fake_pack'
         model_pack_vers = '0.0b2'
@@ -1589,279 +297,6 @@
             macsydata.RemoteModelIndex.remote_exists = remote_exists
             macsydata.RemoteModelIndex.download = remote_download
 
-
-    def test_install_remote_already_in_local(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-
-        self.create_fake_package(model_pack_name, dest='models')
-
-        self.args.model_package = f"{model_pack_name}>{model_pack_vers}"
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = None
-        self.args.no_clean = False
-
-        # function which doing net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_install(self.args)
-                log_msg = log.get_value().strip()
-            self.assertEqual(log_msg,
-                             f"""Requirement already satisfied: {self.args.model_package} in {os.path.join(self.models_dir[0], model_pack_name)}.
-To force installation use option -f --force-reinstall.""")
-        finally:
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
-    def test_install_remote_already_in_local_force(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        self.create_fake_package(model_pack_name, dest='models')
-
-        self.args.model_package = f"{model_pack_name}>{model_pack_vers}"
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = True
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        # function which doing net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata'):
-                macsydata.do_install(self.args)
-            expected_pack_path = os.path.join(self.models_dir[0], model_pack_name)
-            self.assertTrue(os.path.exists(expected_pack_path))
-            self.assertTrue(os.path.isdir(expected_pack_path))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'metadata.yml')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'README')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'definitions')))
-            self.assertTrue(os.path.exists(os.path.join(expected_pack_path, 'profiles')))
-        finally:
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
-    def test_install_remote_lower_in_local(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '1.0'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-
-        self.create_fake_package(model_pack_name, dest='models')
-
-        self.args.model_package = f"{model_pack_name}=={model_pack_vers}"
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = None
-        self.args.no_clean = False
-        self.args.tool_name = 'msl_data'
-
-        # function which doing net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_install(self.args)
-                log_msg = log.get_value().strip()
-            self.assertEqual(log_msg,
-                             f"""{model_pack_name} (0.0b2) is already installed but {model_pack_vers} version is available.
-To install it please run '{self.args.tool_name} install --upgrade {model_pack_name}'""")
-        finally:
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
-    def test_install_remote_upper_in_local(self):
-        pack_name = 'fake_pack'
-        pack_vers = '0.0b1'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-
-        self.create_fake_package(pack_name, dest='models')
-
-        self.args.model_package = f"{pack_name}>{pack_vers}"
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = None
-        self.args.no_clean = False
-
-        # function which doing net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_install(self.args)
-                log_msg = log.get_value().strip()
-            self.assertEqual(log_msg,
-                             f"""{pack_name} (0.0b2) is already installed.
-To downgrade to 0.0b1 use option -f --force-reinstall.""")
-        finally:
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
-    @unittest.skipIf(os.getuid() == 0, 'Skip test if run as root')
-    def test_install_remote_permision_error(self):
-        model_pack_name = 'fake_pack'
-        model_pack_vers = '0.0b2'
-        macsydata_cache = os.path.join(self.tmpdir, 'cache')
-        os.mkdir(macsydata_cache)
-        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
-        os.mkdir(macsydata_tmp)
-        macsydata_dest = os.path.join(self.tmpdir, 'models')
-
-        os.chmod(self.models_dir[0], 0o111)
-
-        self.args.model_package = model_pack_name
-        self.args.cache = macsydata_cache
-        self.args.user = False
-        self.args.upgrade = False
-        self.args.force = False
-        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
-        self.args.target = macsydata_dest
-        self.args.no_clean = False
-
-        # functions which do net operations
-        # so we need to mock them
-        get_remote_available_versions = macsydata._get_remote_available_versions
-        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
-        remote_exists = macsydata.RemoteModelIndex.remote_exists
-        macsydata.RemoteModelIndex.remote_exists = lambda x: True
-        remote_download = macsydata.RemoteModelIndex.download
-        macsydata.RemoteModelIndex.download = self._fake_download
-        macsydata.Config.models_dir = lambda x: self.models_dir
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_install(self.args)
-                log_msg = log.get_value().strip()
-            self.maxDiff = None
-            self.assertEqual(log_msg,
-                             f"""{self.models_dir[0]} is not readable: [Errno 13] Permission denied: '{self.models_dir[0]}' : skip it.
-Downloading {model_pack_name} ({model_pack_vers}).
-Extracting {model_pack_name} ({model_pack_vers}).
-Installing {model_pack_name} ({model_pack_vers}) in {self.models_dir[0]}
-{self.models_dir[0]} is not writable: [Errno 13] Permission denied: '{os.path.join(self.models_dir[0], model_pack_name)}'
-Maybe you can use --user option to install in your HOME.""")
-        finally:
-            os.chmod(self.models_dir[0], 0o777)
-            del macsydata.Config.models_dir
-            macsydata._get_remote_available_versions = get_remote_available_versions
-            macsydata.RemoteModelIndex.remote_exists = remote_exists
-            macsydata.RemoteModelIndex.download = remote_download
-
-
-    def test_uninstall(self):
-        pack_name = 'fake_1'
-        path = self.create_fake_package(pack_name, dest=self.models_dir[0])
-        self.args.model_package = pack_name
-        self.args.models_dir = None
-
-        registry = ModelRegistry()
-        for model_loc in scan_models_dir(self.models_dir[0]):
-            registry.add(model_loc)
-
-        def fake_find_all_installed_package(models_dir=None, prog_name='macsylib'):
-            return registry
-
-        def fake_find_installed_package(model_pack_name, models_dir=None, package_name='macsylib'):
-            return registry[model_pack_name]
-
-        macsydata._find_all_installed_packages = fake_find_all_installed_package
-
-        find_local_package = macsydata._find_installed_package
-        macsydata._find_installed_package = fake_find_installed_package
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                macsydata.do_uninstall(self.args)
-                log_msg = log.get_value().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-
-        expected_msg = f"models '{pack_name}' in {path} uninstalled."
-        self.assertEqual(log_msg, expected_msg)
-        self.assertFalse(os.path.exists(path))
-
-        self.args.model_package = 'foo'
-        find_local_package = macsydata._find_installed_package
-
-        def fake_find_installed_package(model_pack_name, models_dir=None, package_name='macsylib'): return None
-
-        macsydata._find_installed_package = fake_find_installed_package
-        try:
-            with self.catch_log(log_name='macsydata') as log:
-                with self.assertRaises(ValueError):
-                    macsydata.do_uninstall(self.args)
-                log_msg = log.get_value().strip()
-        finally:
-            macsydata._find_installed_package = find_local_package
-        expected_msg = f"Models '{self.args.model_package}' not found locally."
-        self.assertEqual(log_msg, expected_msg)
-
-
     def test_search_in_pack_name(self):
         self.args.pattern = 'Foo'
         self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
--- macsylib.orig/tests/test_macsyprofile.py
+++ macsylib/tests/test_macsyprofile.py
@@ -140,12 +140,6 @@
         suffix = ".res_hmm_extract"
         self.assertEqual(macsyprofile.get_gene_name(path, suffix), expected_gene_name)
 
-
-    def test_getProfile_len(self):
-        path = self.find_data('models', 'functional', 'profiles', 'T1SS_abc.hmm')
-        self.assertEqual(macsyprofile.get_profile_len(path), 501)
-
-
     def test_LightHit(self):
         data = {'id': 'GCF_000006745_003720',
                 'replicon_name': 'GCF_000006745',
@@ -360,82 +354,6 @@
         hits = hmm_prof.parse()
         self.assertListEqual(expected_hits, hits)
 
-
-    def test_functional(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile.tsv')
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} {previous_run} "
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_pattern(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile_pattern.tsv')
-        # the argument do not need to be protected (we do not use shell)
-        # as on real command line so '*mpf' => *mpf
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} -p *mfp {previous_run} "
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_coverage(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile_coverage.tsv')
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} --coverage-profile 0.5 {previous_run} "
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_evalue(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile_evalue.tsv')
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} --i-evalue-sel 1e-3 {previous_run} "
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_best_score(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile_best_score.tsv')
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} --best-hits score {previous_run} "
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_no_hits(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        expected_result = self.find_data('results_macsyprofile_no_hits.tsv')
-        cmd = f"msl_profile -o {out} --index-dir {self.tmpdir} --i-evalue-sel 1e-10 --coverage-profile 2.0 {previous_run}"
-        macsyprofile.main(cmd.split()[1:], log_level='WARNING')
-        self.assertFileEqual(expected_result, out, comment='#')
-
-
-    def test_functional_out_exists(self):
-        out = os.path.join(self.tmpdir, 'test_macsyprofile')
-        open(out, 'w').close()
-        previous_run = self.find_data('functional_test_degenerated_systems')
-        cmd = f"msl_profile -o {self.tmpdir} --mute --best-hits score {previous_run} "
-
-        # we cannot test the log message here
-        # because the logger are init when main is called
-        # after that the context is established
-        # so when the wrapper is called the handler cannot be substituted by the fake
-        with self.catch_log('macsyprofile') as log:
-            with self.assertRaises(ValueError):
-                macsyprofile.main(cmd.split()[1:])
-            log_msg = log.get_value().strip()
-        self.assertEqual(log_msg,
-                         f"The file {self.tmpdir} already exists."
-                         " Remove it or specify a new output name --out or use --force option")
-
-
     def test_functional_no_previous_run(self):
         cmd = "msl_profile --mute nimportnaoik "
 
@@ -456,23 +374,3 @@
             log_msg = log.get_value().strip()
         self.assertEqual(log_msg,
                          "")
-
-
-    def test_functional_old_conf(self):
-        # old fashioned macsyfinder.conf
-        # models are not specified in the conf
-        old = self.find_data('conf_files', 'macsylib-old.conf')
-        shutil.copyfile(old, os.path.join(self.tmpdir, 'macsylib.conf'))
-
-        previous_run = self.tmpdir
-        cmd = f"msl_profile --index-dir {self.tmpdir} {previous_run}"
-        with self.catch_io(err=True):
-            with self.catch_log('macsyprofile') as log:
-                with self.assertRaises(ValueError):
-                    macsyprofile.main(cmd.split()[1:],
-                                      tool_name='my_tool',
-                                      log_level=logging.CRITICAL)
-                log_msg = log.get_value().strip()
-            self.assertEqual(log_msg,
-                             f"Cannot find models in conf file {self.tmpdir}."
-                             f" May be these results have been generated with an old version of my_tool.")
--- macsylib.orig/tests/test_metadata.py
+++ macsylib/tests/test_metadata.py
@@ -58,123 +58,9 @@
         self.assertIsNone(meta.vers)
         self.assertEqual(meta.license, '')
 
-
-    def test_load(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.maintainer, Maintainer(name='auth_name', email='auth_name@mondomain.fr'))
-        self.assertEqual(meta.short_desc, 'this is a short description of the repos')
-        self.assertEqual(meta.vers, '0.0b2')
-        self.assertEqual(meta.license, 'CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)')
-        self.assertEqual(meta.doc, 'http://link/to/the/documentation')
-        self.assertEqual(meta.cite, ['bla bla',
-                                                'link to publication',
-                                                'ligne 1\nligne 2\nligne 3 et bbbbb\n'])
-        self.assertEqual(meta.copyright_holder, 'Institut Pasteur, CNRS')
-        self.assertEqual(meta.copyright_date, '2019')
-
-
-    def test_load_copyright_range(self):
-        meta_path = self.find_data('pack_metadata', 'metadata_copyright_range.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.maintainer, Maintainer(name='auth_name', email='auth_name@mondomain.fr'))
-        self.assertEqual(meta.short_desc, 'this is a short description of the repos')
-        self.assertEqual(meta.vers, '0.0b2')
-        self.assertEqual(meta.license, 'CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)')
-        self.assertEqual(meta.doc, 'http://link/to/the/documentation')
-        self.assertEqual(meta.cite, ['bla bla',
-                                                'link to publication',
-                                                'ligne 1\nligne 2\nligne 3 et bbbbb\n'])
-        self.assertEqual(meta.copyright_holder, 'Institut Pasteur, CNRS')
-        self.assertEqual(meta.copyright_date, '2019-2024')
-
-    def test_load_bad_metadata(self):
-        meta_path = self.find_data('pack_metadata', 'bad_metadata.yml')
-        with self.assertRaises(ValueError) as ctx:
-            Metadata.load(meta_path)
-        self.assertEqual(str(ctx.exception),
-                         f"""
-- The metadata file '{meta_path}' is not valid: the element 'short_desc' is required.
-- The metadata file '{meta_path}' is not valid: the element 'maintainer' is required.""")
-
-
-    def test_maintainer(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.maintainer, Maintainer(name='auth_name', email='auth_name@mondomain.fr'))
-        new_auth = 'joe bar'
-        new_email = 'joe@domain.org'
-        meta.maintainer = Maintainer(new_auth, new_email)
-        self.assertEqual(meta.maintainer, Maintainer(name=new_auth, email=new_email))
-
-
-    def test_short_desc(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.short_desc, 'this is a short description of the repos')
-        new_short_desc = "This is a new short desc"
-        meta.short_desc = new_short_desc
-        self.assertEqual(meta.short_desc, new_short_desc)
-        with self.assertRaises(ValueError) as ctx:
-            meta.short_desc = ''
-        self.assertEqual(str(ctx.exception),
-                         "The field 'short_desc' is mandatory.")
-
-
-    def test_vers(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.vers, '0.0b2')
-        meta.vers = '0.0b3'
-        self.assertEqual(meta.vers, '0.0b3')
-
-
-    def test_cite(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.cite, ['bla bla', 'link to publication', 'ligne 1\nligne 2\nligne 3 et bbbbb\n'])
-        new_cite = ["citation_1", "citation_2"]
-        meta.cite = new_cite
-        self.assertEqual(meta.cite, new_cite)
-
-
-    def test_license(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.license, 'CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)')
-        new_license = "GPLv3"
-        meta.license = new_license
-        self.assertEqual(meta.license, new_license)
-
-
-    def test_copyright(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.copyright, '2019, Institut Pasteur, CNRS')
-        self.assertEqual(meta.copyright_date, '2019')
-        self.assertEqual(meta.copyright_holder, 'Institut Pasteur, CNRS')
-        meta.copyright_date = '2020-2024'
-        meta.copyright_holder = 'My institution'
-        self.assertEqual(meta.copyright, '2020-2024, My institution')
-
-        meta_path = self.find_data('pack_metadata', 'metadata_no_copyright.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.copyright, '')
-        self.assertEqual(meta.copyright_date, '')
-        self.assertEqual(meta.copyright_holder, '')
-
-
-    def test_doc(self):
-        meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
-        meta = Metadata.load(meta_path)
-        self.assertEqual(meta.doc, 'http://link/to/the/documentation')
-        meta.doc = 'new link'
-        self.assertEqual(meta.doc, 'new link')
-
-
     def test_save(self):
-        for yml_name in ('good_metadata.yml', 'metadata_no_vers.yml', 'metadata_no_license.yml',
-                         'metadata_no_doc.yml', 'metadata_no_copyright.yml'):
+        for yml_name in ('metadata_no_license.yml',
+                         ):
             with self.subTest(yml_name=yml_name):
                 meta_path = self.find_data('pack_metadata', yml_name)
                 meta = Metadata.load(meta_path)
--- macsylib.orig/tests/test_model_package.py
+++ macsylib/tests/test_model_package.py
@@ -73,11 +73,6 @@
                          f"{pack} does not seem to not be versioned.")
 
 
-    def test_init(self):
-        with self.assertRaises(TypeError):
-            model_package.AbstractModelIndex()
-
-
 class TestLocalModelIndex(MacsyTest):
 
     def test_init(self):
@@ -248,54 +243,6 @@
                          "HTTP Error 204: No Content")
 
     @patch('urllib.request.urlopen', side_effect=mocked_requests_get)
-    def test_get_metadata(self, mock_urlopen):
-        rem_exists = model_package.RemoteModelIndex.remote_exists
-        list_package_vers = model_package.RemoteModelIndex.list_package_vers
-        try:
-            vers = '0.0'
-            pack_name = 'foo'
-            model_package.RemoteModelIndex.remote_exists = lambda x: True
-            model_package.RemoteModelIndex.list_package_vers = lambda x, pack_name: [vers]
-            remote = model_package.RemoteModelIndex(org="get_metadata")
-            remote.cache = self.tmpdir
-            metadata = remote.get_metadata(pack_name)
-            self.assertDictEqual(metadata, {"maintainer": {"name": "moi"}})
-        finally:
-            model_package.RemoteModelIndex.remote_exists = rem_exists
-            model_package.RemoteModelIndex.list_package_vers = list_package_vers
-
-        #################################################
-        # The remote package is not versioned (tagged)  #
-        #################################################
-        try:
-            model_package.RemoteModelIndex.remote_exists = lambda x: True
-            model_package.RemoteModelIndex.list_package_vers = lambda x, pack_name: []
-            remote = model_package.RemoteModelIndex(org="get_metadata")
-            with self.assertRaises(MacsydataError) as ctx:
-                remote.get_metadata(pack_name)
-            self.assertEqual(str(ctx.exception),
-                             "No official version available for model 'foo'")
-        finally:
-            model_package.RemoteModelIndex.remote_exists = rem_exists
-            model_package.RemoteModelIndex.list_package_vers = list_package_vers
-
-        #####################################
-        # The pack version is not available #
-        #####################################
-        try:
-            model_package.RemoteModelIndex.remote_exists = lambda x: True
-            model_package.RemoteModelIndex.list_package_vers = lambda x, pack_name: ["12"]
-            remote = model_package.RemoteModelIndex(org="get_metadata")
-            with self.assertRaises(RuntimeError) as ctx:
-                remote.get_metadata(pack_name, vers="1.1")
-            self.assertEqual(str(ctx.exception),
-                             "The version '1.1' does not exists for model foo.")
-        finally:
-            model_package.RemoteModelIndex.remote_exists = rem_exists
-            model_package.RemoteModelIndex.list_package_vers = list_package_vers
-
-
-    @patch('urllib.request.urlopen', side_effect=mocked_requests_get)
     def test_list_packages(self, mock_urlopen):
         rem_exists = model_package.RemoteModelIndex.remote_exists
         try:
@@ -550,279 +497,6 @@
 
         return pack_path
 
-
-    def test_init(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        self.assertEqual(pack.path, fake_pack_path)
-        self.assertEqual(pack.readme, os.path.join(fake_pack_path, 'README'))
-        self.assertEqual(pack.name, 'fake_model')
-        self.assertEqual(pack.metadata_path, os.path.join(fake_pack_path, 'metadata.yml'))
-
-
-    def test_metadata(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        self.assertEqual(pack.metadata.maintainer, self.metadata.maintainer)
-        self.assertEqual(pack.metadata.short_desc, self.metadata.short_desc)
-        self.assertEqual(pack.metadata.license, self.metadata.license)
-        self.assertEqual(pack.metadata.copyright, self.metadata.copyright)
-        self.assertEqual(pack.metadata.doc, self.metadata.doc)
-        self.assertEqual(pack.metadata.cite, self.metadata.cite)
-
-    def test_find_readme(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        for ext in ('', '.rst', '.md'):
-            readme_path = os.path.join(pack.path, 'README' + ext)
-            os.rename(pack.readme, readme_path)
-            pack.readme = readme_path
-            self.assertEqual(pack._find_readme(), readme_path)
-        readme_path = os.path.join(pack.path, 'README.foo')
-        os.rename(pack.readme, readme_path)
-        self.assertIsNone(pack._find_readme())
-
-    def test_check_model_conf(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_model_conf()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-    def test_check_model_conf_no_conf(self):
-        fake_pack_path = self.create_fake_package('fake_model', conf=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_model_conf()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_model_conf_bad_conf_lxml(self):
-        model_name = 'fake_model'
-        fake_pack_path = self.create_fake_package(model_name, conf=False, bad_conf=True)
-        pack = model_package.ModelPackage(fake_pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_conf()
-        self.maxDiff = None
-
-        exp_errors = [f"The model configuration file '{fake_pack_path}/model_conf.xml' is not valid: "
-                      f"Element 'itself': 'FOO' is not a valid value of the atomic type 'xs:float'., line 3"]
-
-        self.assertListEqual(errors, exp_errors)
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_model_conf_bad_conf_no_lxml(self):
-        model_name = 'fake_model'
-        fake_pack_path = self.create_fake_package(model_name, conf=False, bad_conf=True)
-        pack = model_package.ModelPackage(fake_pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_conf()
-        self.maxDiff = None
-
-        mp_etree = model_package.etree
-        model_package.etree = None
-        try:
-            with self.catch_log(log_name='macsylib'):
-                errors, warnings = pack._check_model_conf()
-        finally:
-            model_package.etree = mp_etree
-
-        def_path = os.path.join(fake_pack_path, "model_conf.xml")
-        exp_errors = [f"The model configuration file '{def_path}' "
-                      "is not valid: could not convert string to float: 'FOO'"]
-        self.assertListEqual(errors, exp_errors)
-        self.assertListEqual(warnings, [])
-
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_grammar(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'all_features_model'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff =None
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_grammar_no_vers(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'model_no_vers'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff = None
-
-        self.assertListEqual(errors,
-                             [f"{df_name} is not valid: Element 'model': The attribute 'vers' is required but "
-                              "missing., line 1"])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_grammar_20(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'model_6'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar(grammar='2.1')
-        self.assertListEqual(errors,
-                             [])
-
-        self.assertListEqual(warnings,
-                             ['You ask to check grammar vers 2.1. '
-                              f'But in {df_name} you declare vers="2.0". Please update your model.'])
-
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar(grammar='2.0')
-        self.assertListEqual(errors,
-                             [])
-        self.assertListEqual(warnings,
-                             [])
-
-        mp_etree = model_package.etree
-        model_package.etree = None  # simultae no lxml
-        try:
-            with self.assertRaises(RuntimeError) as ctx:
-                errors, warnings = pack._check_model_grammar()
-        finally:
-            model_package.etree = mp_etree
-
-        self.assertEqual(str(ctx.exception),
-                         "To validate grammar >=2.1 you need to install `lxml` library.")
-        self.assertListEqual(errors,
-                             [])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_bad_vers(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False, vers=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'model_bad_vers'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                    def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack.check()
-        self.maxDiff = None
-        self.assertListEqual(errors,
-                             ["model_bad_vers is not valid: Element 'model', "
-                              "attribute 'vers': [facet 'pattern'] The value 'bad_vers' is not accepted by "
-                              "the pattern '\\d(.\\d){0,2}'., line 1"])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_unsupported_vers(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False, vers=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'model_unsupported_vers'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                    def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack.check()
-        self.maxDiff = None
-        self.assertListEqual(errors,
-                             [f"Unable to parse model definition '{model_name}/{df_name}' : The model definition {df_name}.xml has unsupported version: 3 . Supported versions are >=2, <3 . Please update your model."])
-        self.assertListEqual(warnings, ['You ask to check grammar vers 2.1. But in model_unsupported_vers you declare vers="3". Please update your model.'])
-
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_gene_no_name(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'gene_no_name'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff =None
-        self.assertListEqual(errors, ["gene_no_name is not valid: Element 'gene': "
-                                      "The attribute 'name' is required but missing., line 7"])
-        self.assertListEqual(warnings, [])
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_gene_twice(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'gene_twice'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff =None
-        self.assertListEqual(errors, ["gene_twice is not valid: Element 'gene': Duplicate key-sequence ['flgB'] "
-                                      "in unique identity-constraint 'UniqueGene'., line 9"])
-        self.assertListEqual(warnings, [])
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_exchangeable_twice(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'exchangeable_twice'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff =None
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-    @unittest.skipIf(not lxml, 'lxml is not installed')
-    def test_check_gene_and_exchangeable(self):
-        model_name = 'fake_model'
-        pack_path = self.create_fake_package(model_name, definitions=False)
-        def_dir = os.path.join(pack_path, 'definitions')
-        os.mkdir(def_dir)
-        df_name = 'gene_and_exchangeable'
-        shutil.copy(self.find_data('models', 'foo', 'definitions', f'{df_name}.xml'),
-                        def_dir)
-        pack = model_package.ModelPackage(pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_grammar()
-        self.maxDiff =None
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_structure(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
     def test_check_structure_bad_path(self):
         foobar = os.path.join(self.tmpdir, "foobar")
         pack = model_package.ModelPackage(foobar)
@@ -834,451 +508,3 @@
         errors, warnings = pack._check_structure()
         self.assertListEqual(errors, ["The model package 'foobar' is not a directory "])
         self.assertListEqual(warnings, [])
-
-    def test_check_structure_no_def(self):
-        fake_pack_path = self.create_fake_package('fake_model', definitions=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertListEqual(errors, ["The model package 'fake_model' have no 'definitions' directory."])
-        self.assertListEqual(warnings, [])
-
-        open(os.path.join(pack.path, 'definitions'), 'w').close()
-        errors, warnings = pack._check_structure()
-        self.assertListEqual(errors, [f"'{os.path.join(self.tmpdir, 'fake_model', 'definitions')}' is not a directory."])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_structure_no_profiles(self):
-        fake_pack_path = self.create_fake_package('fake_model', profiles=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertListEqual(errors, ["The model package 'fake_model' have no 'profiles' directory."])
-        self.assertListEqual(warnings, [])
-
-        open(os.path.join(pack.path, 'profiles'), 'w').close()
-        errors, warnings = pack._check_structure()
-        self.assertListEqual(errors, [f"'{os.path.join(self.tmpdir, 'fake_model', 'profiles')}' is not a directory."])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_structure_no_metadata(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertListEqual(errors, ["The model package 'fake_model' have no 'metadata.yml'."])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_structure_no_readme(self):
-        fake_pack_path = self.create_fake_package('fake_model', readme=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, ["The model package 'fake_model' have not any README file."])
-
-
-    def test_check_structure_no_license(self):
-        fake_pack_path = self.create_fake_package('fake_model', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, ["The model package 'fake_model' have not any LICENSE file. "
-                                    "May be you have not right to use it."])
-
-
-    def test_check_model_consistency(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_consistency()
-
-        self.assertEqual(warnings, [])
-        self.assertEqual(errors, [])
-
-
-    def test_check_model_consistency_extra_profile(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        open(os.path.join(fake_pack_path, 'profiles', 'extra_profile.hmm'), 'w').close()
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_consistency()
-
-        self.assertEqual(warnings, ['The extra_profile profiles are not referenced in any definitions.'])
-        self.assertEqual(errors, [])
-
-
-    def test_check_model_consistency_lack_one_profile(self):
-        fake_pack_path = self.create_fake_package('fake_model', skip_hmm=['flgB', 'fliE'])
-        pack = model_package.ModelPackage(fake_pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_consistency()
-
-        self.assertEqual(warnings, [])
-        self.assertSetEqual(set(errors),
-                            set(["'fake_model/flgB': No such profile",
-                                 "'fake_model/fliE': No such profile"])
-                            )
-
-
-    def test_check_model_consistency_bad_definitions(self):
-        fake_pack_path = self.create_fake_package('fake_model', bad_definitions=True)
-        pack = model_package.ModelPackage(fake_pack_path)
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_consistency()
-        self.assertEqual(warnings, [])
-        self.assertEqual(errors, ["fake_model/model_3: min_genes_required '1' must be greater or equal than "
-                                  "min_mandatory_genes_required '2'"])
-
-
-    @unittest.skipIf(lxml is None, 'lxml not installed')
-    def test_check_model_conf_unknown_elt_lxml(self):
-        pack_name = 'fake_model'
-        fake_pack_path = self.create_fake_package(pack_name, conf=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        shutil.copy(self.find_data('conf_files', 'model_conf_bad_element.xml'),
-                    os.path.join(fake_pack_path, 'model_conf.xml'))
-        with self.catch_log(log_name='macsylib'):
-            errors, warnings = pack._check_model_conf()
-        self.assertEqual(warnings, [])
-        self.assertEqual(errors, [
-            f"The model configuration file '{fake_pack_path}/model_conf.xml' is not valid: Element 'nimportnoik': "
-            f"This element is not expected., line 10"
-           ])
-
-
-    def test_check_model_conf_unknown_elt_no_lxml(self):
-        pack_name = 'fake_model'
-        fake_pack_path = self.create_fake_package(pack_name, conf=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        shutil.copy(self.find_data('conf_files', 'model_conf_bad_element.xml'),
-                    os.path.join(fake_pack_path, 'model_conf.xml'))
-        m_etree = model_package.etree
-        model_package.etree = None
-        try:
-            with self.catch_log(log_name='macsylib'):
-                errors, warnings = pack._check_model_conf()
-        finally:
-            model_package.etree = m_etree
-
-        self.assertEqual(warnings, [])
-        self.assertEqual(errors, [])
-
-
-    def test_check_no_readme_n_no_license(self):
-        fake_pack_path = self.create_fake_package('fake_model', readme=False, license=False, vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_structure()
-
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, ["The model package 'fake_model' have not any LICENSE file. "
-                                    "May be you have not right to use it.",
-                                    "The model package 'fake_model' have not any README file."])
-
-    def test_check_metadata(self):
-        fake_pack_path = self.create_fake_package('fake_model', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [])
-
-    def test_check_metadata_no_maintainer(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_maintainer.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertListEqual(errors, [f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                      f"the element 'maintainer' is required."])
-        self.assertListEqual(warnings, [])
-
-    def test_check_metadata_no_name(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_name.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertListEqual(errors, [f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                                "the element 'maintainer' must have fields 'name' and 'email'."])
-        self.assertListEqual(warnings, [])
-
-    def test_check_metadata_no_email(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_email.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertListEqual(errors, [f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                                "the element 'maintainer' must have fields 'name' and 'email'."])
-        self.assertListEqual(warnings, [])
-
-    def test_check_metadata_no_desc(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_desc.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                  f"the element 'short_desc' is required."])
-        self.assertEqual(warnings, [])
-
-
-    def test_check_metadata_no_vers(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_vers.yml')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [])
-
-    def test_check_metadata_with_vers(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, ["The field 'vers' is not required anymore in 'metadata.yml'."
-                                    "\n  It will be ignored and set by msl_data during installation phase according"
-                                    " to the git tag."])
-
-    def test_check_metadata_no_cite(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_cite.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [f"It's better if the field 'cite' is setup in '{fake_pack_path}/metadata.yml' file."])
-
-
-    def test_check_metadata_no_doc(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_doc.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [f"It's better if the field 'doc' is setup in '{fake_pack_path}/metadata.yml' file."])
-
-    def test_check_metadata_no_license(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_license.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [f"It's better if the field 'license' is setup in '{fake_pack_path}/metadata.yml' file."])
-
-    def test_check_metadata_no_copyright(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_copyright.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_metadata()
-        self.assertEqual(errors, [])
-        self.assertEqual(warnings, [f"It's better if the field 'copyright' is setup in '{fake_pack_path}/metadata.yml' file."])
-
-
-    def test_check(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='good_metadata.yml', vers=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack.check()
-        self.assertListEqual(warnings, [])
-        self.assertListEqual(errors, [])
-
-    def test_check_bad_metadata(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='bad_metadata.yml')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack.check()
-
-        self.assertListEqual(warnings, [])
-        self.assertListEqual(errors, [f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                      f"the element 'short_desc' is required.",
-                                      f"- The metadata file '{fake_pack_path}/metadata.yml' is not valid: "
-                                      f"the element 'maintainer' is required."])
-
-    def test_check_poor_quality_metadata(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_poor_quality.yml')
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack.check()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings,
-                             [f"It's better if the field 'cite' is setup in '{fake_pack_path}/metadata.yml' file.",
-                              f"It's better if the field 'doc' is setup in '{fake_pack_path}/metadata.yml' file.",
-                              f"It's better if the field 'license' is setup in '{fake_pack_path}/metadata.yml' file.",
-                              f"It's better if the field 'copyright' is setup in '{fake_pack_path}/metadata.yml' file."])
-
-    def test_check_several_profile_per_file(self):
-        fake_pack_path = self.create_fake_package('fake_model', profiles=False)
-        profiles_dir = os.path.join(fake_pack_path, 'profiles')
-        os.mkdir(profiles_dir)
-        shutil.copyfile(self.find_data('hmm', 'one_profile.hmm'), os.path.join(profiles_dir, 'one_profile.hmm'))
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings, [])
-
-        shutil.copyfile(self.find_data('hmm', 'several_profiles.hmm'), os.path.join(profiles_dir, 'several_profiles.hmm'))
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [
-            '\nThere are several profiles RM_Type_II__Type_II_REases___Type_II_REase01\n'
-            ' - RM_Type_II__Type_II_REases___Type_II_REase02\n'
-            f"in {os.path.join(self.tmpdir, 'fake_model', 'profiles', 'several_profiles')}.hmm:\n"
-            ' Split this file to have one profile per file.'
-        ])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_empty_profile(self):
-        fake_pack_path = self.create_fake_package('fake_model', profiles=False)
-        profiles_dir = os.path.join(fake_pack_path, 'profiles')
-        os.mkdir(profiles_dir)
-        fake_profile = os.path.join(profiles_dir, 'flgB.hmm')
-        open(fake_profile, 'w').close()
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [f"Profile {fake_profile} seems empty: Check this file."])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_old_profile(self):
-        fake_pack_path = self.create_fake_package('fake_model', profiles=False)
-        profiles_dir = os.path.join(fake_pack_path, 'profiles')
-        os.mkdir(profiles_dir)
-        old_profile = os.path.join(profiles_dir, 'old_profile.hmm')
-        shutil.copyfile(self.find_data('hmm', 'old_profile.hmm'), old_profile)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [f"The file {old_profile} does not seems to be HMMER 3 profile: "
-                                      f"check it or remove it."])
-        self.assertListEqual(warnings, [])
-
-
-    def test_check_dir_in_profile(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        profiles_dir = os.path.join(fake_pack_path, 'profiles')
-        dir_in_profiles = os.path.join(profiles_dir, 'nimportnaoik')
-        os.makedirs(dir_in_profiles)
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings,
-                             [f"found directory '{dir_in_profiles}' in profiles dir: subdirectories are not supported in profiles. "
-                              f"This directory will be IGNORED."])
-
-    def test_profile_with_bad_ext(self):
-        fake_pack_path = self.create_fake_package('fake_model')
-        profiles_dir = os.path.join(fake_pack_path, 'profiles')
-        bad_profile = os.path.join(profiles_dir, 'flgB.bad_ext')
-        open(bad_profile, 'w').close()
-        pack = model_package.ModelPackage(fake_pack_path)
-        errors, warnings = pack._check_profiles()
-        self.assertListEqual(errors, [])
-        self.assertListEqual(warnings,
-                             [f"The file '{bad_profile}' does not ends with '.hmm'. Skip it."])
-
-    def test_help(self):
-        fake_pack_path = self.create_fake_package('fake_model', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-
-        receive_help = pack.help()
-        self.assertEqual(receive_help, "# This a README\n")
-
-        os.unlink(os.path.join(fake_pack_path, 'README'))
-        pack = model_package.ModelPackage(fake_pack_path)
-        receive_help = pack.help()
-        self.assertEqual(receive_help, "No help available for package 'fake_model'.")
-
-
-    def test_info(self):
-        fake_pack_path = self.create_fake_package('fake_model', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-
-        info = pack.info()
-
-        expected_info = """
-fake_model (0.0b2)
-
-maintainer: auth_name <auth_name@mondomain.fr>
-
-this is a short description of the repos
-
-how to cite:
-\t- bla bla
-\t- link to publication
-\t- ligne 1
-\t  ligne 2
-\t  ligne 3 et bbbbb
-
-documentation
-\thttp://link/to/the/documentation
-
-This data are released under CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
-copyright: 2019, Institut Pasteur, CNRS
-"""
-        self.assertEqual(info, expected_info)
-
-    def test_info_no_citation(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_cite.yml', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-
-        info = pack.info()
-
-        expected_info = """
-fake_model (0.0b2)
-
-maintainer: auth_name <auth_name@mondomain.fr>
-
-this is a short description of the repos
-
-how to cite:
-\t- No citation available
-
-documentation
-\thttp://link/to/the/documentation
-
-This data are released under CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
-copyright: 2019, Institut Pasteur, CNRS
-"""
-        self.assertEqual(info, expected_info)
-
-    def test_info_no_doc(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_doc.yml', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-
-        info = pack.info()
-        expected_info = """
-fake_model (0.0b2)
-
-maintainer: auth_name <auth_name@mondomain.fr>
-
-this is a short description of the repos
-
-how to cite:
-\t- bla bla
-\t- link to publication
-\t- ligne 1
-\t  ligne 2
-\t  ligne 3 et bbbbb
-
-documentation
-\tNo documentation available
-
-This data are released under CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
-copyright: 2019, Institut Pasteur, CNRS
-"""
-        self.assertEqual(info, expected_info)
-
-
-    def test_info_no_license(self):
-        fake_pack_path = self.create_fake_package('fake_model', metadata='metadata_no_license.yml', license=False)
-        pack = model_package.ModelPackage(fake_pack_path)
-
-        info = pack.info()
-        expected_info = """
-fake_model (0.0b2)
-
-maintainer: auth_name <auth_name@mondomain.fr>
-
-this is a short description of the repos
-
-how to cite:
-\t- bla bla
-\t- link to publication
-\t- ligne 1
-\t  ligne 2
-\t  ligne 3 et bbbbb
-
-documentation
-\thttp://link/to/the/documentation
-
-This data are released under No license available
-copyright: 2019, Institut Pasteur, CNRS
-"""
-        self.assertEqual(info, expected_info)
--- macsylib.orig/tests/test_search_genes.py
+++ macsylib/tests/test_search_genes.py
@@ -43,132 +43,4 @@
 from tests import MacsyTest
 
 
-class TestSearchGenes(MacsyTest):
 
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_search_genes_')
-        self.tmp_dir = self._tmp_dir.name
-        macsylib.init_logger(name='macsylib')
-        macsylib.logger_set_level(level=30)
-
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_base.fa")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.log_level = 30
-        args.out_dir = os.path.join(self.tmp_dir, 'job_1')
-        args.res_search_dir = args.out_dir
-        args.no_cut_ga = True
-        args.index_dir = os.path.join(self.tmp_dir)
-        os.mkdir(args.out_dir)
-
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-
-        idx = Indexes(self.cfg)
-        idx.build()
-        self.profile_factory = ProfileFactory(self.cfg)
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-    def test_worker_cpu(self):
-        worker_meth = self.cfg.worker
-        from macsylib import search_genes
-        threads_available_ori = search_genes.threads_available
-        try:
-            self.cfg.worker = lambda: 5
-            worker, cpu = worker_cpu(10, self.cfg)
-            self.assertEqual(worker, 5)
-            self.assertEqual(cpu, 1)
-
-            self.cfg.worker = lambda: 11
-            worker, cpu = worker_cpu(5, self.cfg)
-            self.assertEqual(worker, 11)
-            self.assertEqual(cpu, 2)
-
-            self.cfg.worker = lambda: 0
-            search_genes.threads_available = lambda: 12
-            worker, cpu = worker_cpu(5, self.cfg)
-            self.assertEqual(worker, 12)
-            self.assertEqual(cpu, 2)
-
-        finally:
-            self.cfg.worker = worker_meth
-            search_genes.threads_available = threads_available_ori
-
-    def test_search_fail(self):
-        gene_name = "abc"
-        c_gene_abc = CoreGene(self.model_location, gene_name, self.profile_factory)
-        with self.assertRaises(AttributeError) as ctx:
-            search_genes([c_gene_abc], self.cfg)
-        self.assertEqual(str(ctx.exception),
-                         "'CoreGene' object has no attribute 'core_gene'")
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_search(self):
-        gene_name = "abc"
-        model_foo = Model("foo", 10)
-        model_bar = Model("bar", 10)
-        c_gene_abc = CoreGene(self.model_location, gene_name, self.profile_factory)
-        mg_abc_1 = ModelGene(c_gene_abc, model_foo)
-        mg_abc_2 = ModelGene(c_gene_abc, model_bar)
-        report = search_genes([mg_abc_1, mg_abc_2], self.cfg)
-        expected_hit = [CoreHit(c_gene_abc, "ESCO030p01_000260", 706, "ESCO030p01",
-                                26, float(1.000e-200), float(660.800), float(1.000), float(0.714), 160, 663
-                                )]
-        self.assertEqual(len(report), 1)
-        self.assertEqual(expected_hit[0], report[0].hits[0])
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_search_recover(self):
-        # first job searching using hmmsearch
-        gene_name = "abc"
-        model_foo = Model("foo", 10)
-        c_gene_abc = CoreGene(self.model_location, gene_name, self.profile_factory)
-        mg_abc_1 = ModelGene(c_gene_abc, model_foo)
-        report = search_genes([mg_abc_1], self.cfg)
-        expected_hit = [CoreHit(c_gene_abc, "ESCO030p01_000260", 706, "ESCO030p01",
-                                26, float(1.000e-200), float(660.800), float(1.000), float(0.714), 160, 663
-                                )]
-
-        # second job using recover
-        # disable hmmer to be sure that test use the recover inner function
-        self.cfg.hmmer = lambda: "hmmer_disable"
-        # and create a new dir for the second job
-        previous_job_path = self.cfg.working_dir()
-        self.cfg.previous_run = lambda: previous_job_path
-        self.cfg.out_dir = lambda: os.path.join(self.tmp_dir, 'job_2')
-        os.mkdir(self.cfg.out_dir())
-
-        # rerun with previous run
-        # but we have to reset the profile attached to the gene gene._profile._report
-        self.profile_factory = ProfileFactory(self.cfg)
-        report = search_genes([mg_abc_1], self.cfg)
-        self.assertEqual(len(report), 1)
-        self.assertEqual(expected_hit[0], report[0].hits[0])
-
-
-        # test ordered replicon
-        # the only thing that change is the name of the replicon
-        self.cfg._set_db_type('ordered_replicon')
-        self.profile_factory = ProfileFactory(self.cfg)
-        seq_name = os.path.basename(os.path.splitext(self.cfg.sequence_db())[0])
-        expected_hit[0].replicon_name = seq_name
-        report = search_genes([mg_abc_1], self.cfg)
-        self.assertEqual(len(report), 1)
-        self.assertEqual(expected_hit[0], report[0].hits[0])
-
-        # test ordered replicon
-        # there is no diff with ordered_replicon
-        self.cfg._set_db_type('unordered')
-        self.profile_factory = ProfileFactory(self.cfg)
-        seq_name = os.path.basename(os.path.splitext(self.cfg.sequence_db())[0])
-        expected_hit[0].replicon_name = seq_name
-        report = search_genes([mg_abc_1], self.cfg)
-        self.assertEqual(len(report), 1)
-        self.assertEqual(expected_hit[0], report[0].hits[0])
--- macsylib.orig/tests/test_search_systems.py
+++ macsylib/tests/test_search_systems.py
@@ -47,707 +47,3 @@
 from macsylib.hit import CoreHit
 
 from tests import MacsyTest
-
-
-class TestSearchSystems(MacsyTest):
-
-    def setUp(self):
-        self._tmp_dir = tempfile.TemporaryDirectory(prefix='test_msl_macsylib_')
-        self.tmp_dir = self._tmp_dir.name
-        self._reset_id()
-
-
-    def tearDown(self):
-        self._tmp_dir.cleanup()
-
-
-    def _reset_id(self):
-        """
-        reset System._id and RejectedCluster._id to get predictable ids
-        """
-        System._id = itertools.count(1)
-        RejectedCandidate._id = itertools.count(1)
-        AbstractUnordered._id = itertools.count(1)
-
-
-    def _fill_model_registry(self, config):
-        model_registry = ModelRegistry()
-
-        for model_dir in config.models_dir():
-            models_loc_available = scan_models_dir(model_dir,
-                                                   profile_suffix=config.profile_suffix(),
-                                                   relative_path=config.relative_path())
-            for model_loc in models_loc_available:
-                model_registry.add(model_loc)
-        return model_registry
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_search_systems_unordered(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'all']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-        systems, uncomplete_sys = search_systems(config, model_registry, def_to_detect, logger)
-        expected_sys_id = ['VICH001.B.00001.C001_T2SS_4', 'VICH001.B.00001.C001_MSH_3',
-                           'VICH001.B.00001.C001_T4P_5', 'VICH001.B.00001.C001_T4bP_6']
-        self.assertListEqual([s.id for s in systems], expected_sys_id)
-
-        expected_uncomplete_sys_id = ['VICH001.B.00001.C001_Archaeal-T4P_1', 'VICH001.B.00001.C001_ComM_2',
-                                      'VICH001.B.00001.C001_Tad_7']
-        self.assertListEqual([s.id for s in uncomplete_sys], expected_uncomplete_sys_id)
-
-
-    @unittest.skipIf(not shutil.which('hmmsearch'), 'hmmsearch not found in PATH')
-    def test_search_systems_ordered(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        # test ordered replicon
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'ordered_replicon'
-        args.models = ['set_1', 'all']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        systems, rejected_clst = search_systems(config, model_registry, def_to_detect, logger)
-        expected_sys_id = ['VICH001.B.00001.C001_MSH_1',
-                           'VICH001.B.00001.C001_T4P_13', 'VICH001.B.00001.C001_T4P_11', 'VICH001.B.00001.C001_T4P_9',
-                           'VICH001.B.00001.C001_T4P_10', 'VICH001.B.00001.C001_T4P_5', 'VICH001.B.00001.C001_T4P_4',
-                           'VICH001.B.00001.C001_T4bP_14', 'VICH001.B.00001.C001_T4P_12', 'VICH001.B.00001.C001_T4P_6',
-                           'VICH001.B.00001.C001_T4P_7', 'VICH001.B.00001.C001_T4P_8',
-                           'VICH001.B.00001.C001_T2SS_3', 'VICH001.B.00001.C001_T2SS_2']
-
-        self.assertListEqual([s.id for s in systems], expected_sys_id)
-
-        expected_scores = [10.5, 12.0, 9.5, 9.0, 8.5, 6.0, 5.0, 5.5, 10.5, 7.5, 7.0, 8.0, 8.06, 7.5]
-        self.assertListEqual([s.score for s in systems], expected_scores)
-        self.assertEqual(len(rejected_clst), 10)
-
-
-    def test_hits_but_no_systems(self):
-        # test hits but No Systems
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        # test ordered replicon
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'ordered_replicon'
-        args.models = ['set_1', 'Tad']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-        self._reset_id()
-        systems, rejected_clst = search_systems(config, model_registry, def_to_detect, logger)
-        self.assertEqual(systems, [])
-
-        # [rc.id, [hits.id], [reasons]]
-        expected_rejected_clst = [
-            ('VICH001.B.00001.C001_Tad_1',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412'],
-             ['The quorum of mandatory genes required (4) is not reached: 2', 'The quorum of genes required (6) is not reached: 2']),
-            ('VICH001.B.00001.C001_Tad_2',
-             ['VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833'],
-             ['The quorum of mandatory genes required (4) is not reached: 2', 'The quorum of genes required (6) is not reached: 2']),
-            ('VICH001.B.00001.C001_Tad_3',
-             ['VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307', 'VICH001.B.00001.C001_02308'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_4',
-             ['VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of mandatory genes required (4) is not reached: 2', 'The quorum of genes required (6) is not reached: 2']),
-            ('VICH001.B.00001.C001_Tad_5',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_6',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307',
-              'VICH001.B.00001.C001_02308'],
-             ['The quorum of genes required (6) is not reached: 4']),
-            ('VICH001.B.00001.C001_Tad_7',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_8',
-             ['VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833', 'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307',
-              'VICH001.B.00001.C001_02308'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_9',
-             ['VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833', 'VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_10',
-             ['VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307', 'VICH001.B.00001.C001_02308', 'VICH001.B.00001.C001_02599',
-              'VICH001.B.00001.C001_02600'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_11',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833',
-              'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307', 'VICH001.B.00001.C001_02308'],
-             ['The quorum of genes required (6) is not reached: 4']),
-            ('VICH001.B.00001.C001_Tad_12',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833',
-              'VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of genes required (6) is not reached: 4']),
-            ('VICH001.B.00001.C001_Tad_13',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307',
-              'VICH001.B.00001.C001_02308', 'VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of genes required (6) is not reached: 4']),
-            ('VICH001.B.00001.C001_Tad_14',
-             ['VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833', 'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307',
-              'VICH001.B.00001.C001_02308', 'VICH001.B.00001.C001_02599', 'VICH001.B.00001.C001_02600'],
-             ['The quorum of mandatory genes required (4) is not reached: 3', 'The quorum of genes required (6) is not reached: 3']),
-            ('VICH001.B.00001.C001_Tad_15',
-             ['VICH001.B.00001.C001_00409', 'VICH001.B.00001.C001_00412', 'VICH001.B.00001.C001_00829', 'VICH001.B.00001.C001_00833',
-              'VICH001.B.00001.C001_02306', 'VICH001.B.00001.C001_02307', 'VICH001.B.00001.C001_02308', 'VICH001.B.00001.C001_02599',
-              'VICH001.B.00001.C001_02600'],
-             ['The quorum of genes required (6) is not reached: 4'])
-        ]
-
-        results = [(rc.id, [h.id for h in rc.hits], rc.reasons) for rc in rejected_clst]
-        self.assertEqual(expected_rejected_clst, results)
-
-
-    def test_no_hits(self):
-        # test No hits
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        # test ordered replicon
-        seq_db = self.find_data('base', 'test_1.fasta')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'ordered_replicon'
-        args.models = ['set_1', 'ComM']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-        self._reset_id()
-        systems, rejected_clst = search_systems(config, model_registry, def_to_detect, logger)
-        self.assertEqual(systems, [])
-        self.assertEqual(rejected_clst, [])
-
-
-    def test_multisystems_out_sys(self):
-        # test multisystems
-        # multisytem hit are not in System (to small cluster)
-        # no system
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        # test ordered replicon
-        seq_db = self.find_data('base', 'test_12.fasta')
-        models_dir = self.find_data('models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'ordered_replicon'
-        args.models = ['functional', 'T12SS-multisystem']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-        self._reset_id()
-        systems, rejected_clst = search_systems(config, model_registry, def_to_detect, logger)
-
-        self.assertEqual(systems, [])
-        self.assertEqual([r.id for r in rejected_clst],
-                         ['test_12_T12SS-multisystem_1', 'test_12_T12SS-multisystem_2'])
-
-
-    def test_multisystems_in_sys(self):
-        # multisystem is in System, so it can play role for other cluster
-        # 2 systems found
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        # test ordered replicon
-        seq_db = self.find_data('base', 'test_13.fasta')
-        models_dir = self.find_data('models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'ordered_replicon'
-        args.models = ['functional', 'T12SS-multisystem']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-        self._reset_id()
-        systems, rejected_clst = search_systems(config, model_registry, def_to_detect, logger)
-        self.assertEqual({s.id for s in systems},
-                         {'test_13_T12SS-multisystem_3',
-                          'test_13_T12SS-multisystem_2',
-                          'test_13_T12SS-multisystem_1'})
-        self.assertEqual([r.id for r in rejected_clst],
-                         ['test_13_T12SS-multisystem_1'])
-
-
-    def test_search_in_unordered_replicon(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'MSH']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        models_def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        working_dir = config.working_dir()
-        config.save(path_or_buf=os.path.join(working_dir, config.cfg_name))
-
-        # build indexes
-        idx = Indexes(config)
-        idx.build(force=config.idx())
-
-        # create models
-        model_bank = ModelBank()
-        gene_bank = GeneBank()
-        profile_factory = ProfileFactory(config)
-
-        parser = DefinitionParser(config, model_bank, gene_bank, model_registry, profile_factory)
-        parser.parse(models_def_to_detect)
-
-        models_to_detect = [model_bank[model_loc.fqn] for model_loc in models_def_to_detect]
-
-        rep_name = 'VICH001.B.00001.C001'
-        mod_msh = models_to_detect[0]
-        ch_msha = CoreHit(mod_msh.get_gene('MSH_mshA').core_gene ,
-                          'VICH001.B.00001.C001_00416',
-                          178,
-                          rep_name,
-                          376,
-                          4.500e-36, 120.400, 0.948, 0.534,
-                          9, 103)
-        ch_mshe =  CoreHit(mod_msh.get_gene('MSH_mshE').core_gene ,
-                          'VICH001.B.00001.C001_00412',
-                          575,
-                          rep_name,
-                          372,
-                          4.800e-228,753.900,0.998,0.727,
-                          142, 559)
-        ch_mshg = CoreHit(mod_msh.get_gene('MSH_mshG').core_gene,
-                          'VICH001.B.00001.C001_02307',
-                          408,
-                          rep_name,
-                          2204,
-                          7.500e-76, 252.600, 0.994, 0.819,
-                          71, 404
-                          )
-        ch_mshl = CoreHit(mod_msh.get_gene('MSH_mshL').core_gene,
-                          'VICH001.B.00001.C001_02505',
-                          578,
-                          rep_name,
-                          2394,
-                          1.200e-22, 77.300, 0.886, 0.279,
-                          416, 576
-                          )
-        ch_mshm = CoreHit(mod_msh.get_gene('MSH_mshM').core_gene,
-                          'VICH001.B.00001.C001_00410',
-                          281,
-                          rep_name,
-                          370,
-                          1.800e-129, 428.000, 1.000, 0.940,
-                          1, 264
-                          )
-        ch_mshb = CoreHit(mod_msh.get_gene('MSH_mshB').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          196,
-                          rep_name,
-                          375,
-                          1.600e-35, 118.500,1.000, 0.388,
-                          18,93
-                          )
-        ch_mshc = CoreHit(mod_msh.get_gene('MSH_mshC').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          196,
-                          rep_name,
-                          375,
-                          5.300e-11, 40.100, 0.553, 0.214,
-                          18, 59
-                          )
-        ch_mshd = CoreHit(mod_msh.get_gene('MSH_mshD').core_gene,
-                          'VICH001.B.00001.C001_00416',
-                          178,
-                          rep_name,
-                          376,
-                          1.200e-07, 28.900, 0.518, 0.163,
-                          9, 37
-                          )
-
-        hits_by_replicon = {rep_name: [ch_msha, ch_mshe, ch_mshg, ch_mshl, ch_mshm, ch_mshb, ch_mshc, ch_mshd]}
-
-        likely_systems, unlikely_systems = search_in_unordered_replicon(hits_by_replicon, models_to_detect, logger)
-
-        self.assertEqual(len(likely_systems), 1)
-        self.assertEqual(likely_systems[0].id, 'VICH001.B.00001.C001_MSH_1')
-        self.assertListEqual(likely_systems[0].hits, [ch_mshm, ch_mshe, ch_mshb, ch_mshc, ch_msha, ch_mshd, ch_mshg, ch_mshl])
-        self.assertEqual(unlikely_systems, [])
-
-    def test_search_in_unordered_replicon_no_systems(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'MSH']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        models_def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        working_dir = config.working_dir()
-        config.save(path_or_buf=os.path.join(working_dir, config.cfg_name))
-
-        # build indexes
-        idx = Indexes(config)
-        idx.build(force=config.idx())
-
-        # create models
-        model_bank = ModelBank()
-        gene_bank = GeneBank()
-        profile_factory = ProfileFactory(config)
-
-        parser = DefinitionParser(config, model_bank, gene_bank, model_registry, profile_factory)
-        parser.parse(models_def_to_detect)
-
-        models_to_detect = [model_bank[model_loc.fqn] for model_loc in models_def_to_detect]
-
-        rep_name = 'VICH001.B.00001.C001'
-        mod_msh = models_to_detect[0]
-        ch_mshe =  CoreHit(mod_msh.get_gene('MSH_mshE').core_gene ,
-                          'VICH001.B.00001.C001_00412',
-                          575,
-                          rep_name,
-                          372,
-                          4.800e-228,753.900,0.998,0.727,
-                          142, 559)
-        ch_mshg = CoreHit(mod_msh.get_gene('MSH_mshG').core_gene,
-                          'VICH001.B.00001.C001_02307',
-                          408,
-                          rep_name,
-                          2204,
-                          7.500e-76, 252.600, 0.994, 0.819,
-                          71, 404
-                          )
-        ch_mshb = CoreHit(mod_msh.get_gene('MSH_mshB').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          196,
-                          rep_name,
-                          375,
-                          1.600e-35, 118.500,1.000, 0.388,
-                          18,93
-                          )
-        ch_mshc = CoreHit(mod_msh.get_gene('MSH_mshC').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          196,
-                          rep_name,
-                          375,
-                          5.300e-11, 40.100, 0.553, 0.214,
-                          18, 59
-                          )
-
-        hits_by_replicon = {rep_name: [ch_mshe, ch_mshg, ch_mshb, ch_mshc]}
-        likely_systems, unlikely_systems = search_in_unordered_replicon(hits_by_replicon, models_to_detect, logger)
-
-        self.assertEqual(len(unlikely_systems), 1)
-        self.assertEqual(unlikely_systems[0].id, 'VICH001.B.00001.C001_MSH_1')
-        self.assertListEqual(unlikely_systems[0].hits, [ch_mshe, ch_mshb, ch_mshc, ch_mshg])
-        self.assertListEqual(unlikely_systems[0].reasons, ['The quorum of mandatory genes required (3) is not reached: 2'])
-        self.assertEqual(likely_systems, [])
-
-    def test_search_in_unordered_replicon_no_hits(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'MSH']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        models_def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        working_dir = config.working_dir()
-        config.save(path_or_buf=os.path.join(working_dir, config.cfg_name))
-
-        # build indexes
-        idx = Indexes(config)
-        idx.build(force=config.idx())
-
-        # create models
-        model_bank = ModelBank()
-        gene_bank = GeneBank()
-        profile_factory = ProfileFactory(config)
-
-        parser = DefinitionParser(config, model_bank, gene_bank, model_registry, profile_factory)
-        parser.parse(models_def_to_detect)
-
-        models_to_detect = [model_bank[model_loc.fqn] for model_loc in models_def_to_detect]
-
-        hits_by_replicon = {'VICH001.B.00001.C001': []}
-        likely_systems, unlikely_systems = search_in_unordered_replicon(hits_by_replicon, models_to_detect, logger)
-        self.assertEqual(likely_systems, [])
-        self.assertEqual(unlikely_systems, [])
-
-
-    def test_search_in_ordered_replicon(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'MSH']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        models_def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        working_dir = config.working_dir()
-        config.save(path_or_buf=os.path.join(working_dir, config.cfg_name))
-
-        # build indexes
-        idx = Indexes(config)
-        idx.build(force=config.idx())
-
-        # create models
-        model_bank = ModelBank()
-        gene_bank = GeneBank()
-        profile_factory = ProfileFactory(config)
-
-        parser = DefinitionParser(config, model_bank, gene_bank, model_registry, profile_factory)
-        parser.parse(models_def_to_detect)
-
-        models_to_detect = [model_bank[model_loc.fqn] for model_loc in models_def_to_detect]
-
-        rep_name = 'VICH001.B.00001.C001'
-        mod_msh = models_to_detect[0]
-        ch_msha = CoreHit(mod_msh.get_gene('MSH_mshA').core_gene ,
-                          'VICH001.B.00001.C001_00416',
-                          178,
-                          rep_name,
-                          300,
-                          4.500e-36, 120.400, 0.948, 0.534,
-                          9, 103)
-        ch_mshe =  CoreHit(mod_msh.get_gene('MSH_mshE').core_gene ,
-                          'VICH001.B.00001.C001_00412',
-                          400,
-                          rep_name,
-                          372,
-                          4.800e-228,753.900,0.998,0.727,
-                          142, 559)
-        ch_mshg = CoreHit(mod_msh.get_gene('MSH_mshG').core_gene,
-                          'VICH001.B.00001.C001_02307',
-                          404,
-                          rep_name,
-                          2204,
-                          7.500e-76, 252.600, 0.994, 0.819,
-                          71, 404
-                          )
-        ch_mshl = CoreHit(mod_msh.get_gene('MSH_mshL').core_gene,
-                          'VICH001.B.00001.C001_02505',
-                          408,
-                          rep_name,
-                          2394,
-                          1.200e-22, 77.300, 0.886, 0.279,
-                          416, 576
-                          )
-        ch_mshm = CoreHit(mod_msh.get_gene('MSH_mshM').core_gene,
-                          'VICH001.B.00001.C001_00410',
-                          412,
-                          rep_name,
-                          370,
-                          1.800e-129, 428.000, 1.000, 0.940,
-                          1, 264
-                          )
-        ch_mshb = CoreHit(mod_msh.get_gene('MSH_mshB').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          100,
-                          rep_name,
-                          375,
-                          1.600e-35, 118.500,1.000, 0.388,
-                          18,93
-                          )
-        ch_mshc = CoreHit(mod_msh.get_gene('MSH_mshC').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          104,
-                          rep_name,
-                          375,
-                          5.300e-11, 40.100, 0.553, 0.214,
-                          18, 59
-                          )
-        ch_mshd = CoreHit(mod_msh.get_gene('MSH_mshD').core_gene,
-                          'VICH001.B.00001.C001_00416',
-                          108,
-                          rep_name,
-                          376,
-                          1.200e-07, 28.900, 0.518, 0.163,
-                          9, 37
-                          )
-
-        hits_by_replicon = {rep_name: [ch_msha, ch_mshe, ch_mshg, ch_mshl, ch_mshm, ch_mshb, ch_mshc, ch_mshd]}
-        systems, rej_cand = search_in_unordered_replicon(hits_by_replicon, models_to_detect, logger)
-
-        self.assertEqual(len(systems), 1)
-        self.assertEqual(systems[0].id, 'VICH001.B.00001.C001_MSH_1')
-        self.assertListEqual(systems[0].hits, [ch_msha, ch_mshm, ch_mshe, ch_mshb, ch_mshc, ch_mshd, ch_mshg, ch_mshl])
-        self.assertEqual(rej_cand, [])
-
-
-    def test_search_in_ordered_replicon_rej_cand(self):
-        logger = logging.getLogger('macsylib')
-        macsylib.logger_set_level(level='ERROR')
-        defaults = MacsyDefaults()
-
-        seq_db = self.find_data('base', 'VICH001.B.00001.C001.prt')
-        models_dir = self.find_data('data_set', 'models')
-        args = argparse.Namespace()
-        args.models_dir = models_dir
-        args.sequence_db = seq_db
-        args.db_type = 'unordered'
-        args.models = ['set_1', 'MSH']
-        args.worker = 4
-        args.out_dir = self.tmp_dir
-        args.index_dir = self.tmp_dir
-
-        config = Config(defaults, args)
-
-        model_registry = self._fill_model_registry(config)
-        models_def_to_detect, models_fam_name, models_version = get_def_to_detect(config.models(), model_registry)
-
-        working_dir = config.working_dir()
-        config.save(path_or_buf=os.path.join(working_dir, config.cfg_name))
-
-        # build indexes
-        idx = Indexes(config)
-        idx.build(force=config.idx())
-
-        # create models
-        model_bank = ModelBank()
-        gene_bank = GeneBank()
-        profile_factory = ProfileFactory(config)
-
-        parser = DefinitionParser(config, model_bank, gene_bank, model_registry, profile_factory)
-        parser.parse(models_def_to_detect)
-
-        models_to_detect = [model_bank[model_loc.fqn] for model_loc in models_def_to_detect]
-
-        rep_name = 'VICH001.B.00001.C001'
-        mod_msh = models_to_detect[0]
-
-        ch_mshe =  CoreHit(mod_msh.get_gene('MSH_mshE').core_gene ,
-                          'VICH001.B.00001.C001_00412',
-                          400,
-                          rep_name,
-                          372,
-                          4.800e-228,753.900,0.998,0.727,
-                          142, 559)
-        ch_mshg = CoreHit(mod_msh.get_gene('MSH_mshG').core_gene,
-                          'VICH001.B.00001.C001_02307',
-                          404,
-                          rep_name,
-                          2204,
-                          7.500e-76, 252.600, 0.994, 0.819,
-                          71, 404
-                          )
-        ch_mshb = CoreHit(mod_msh.get_gene('MSH_mshB').core_gene,
-                          'VICH001.B.00001.C001_00415',
-                          100,
-                          rep_name,
-                          375,
-                          1.600e-35, 118.500,1.000, 0.388,
-                          18,93
-                          )
-
-        hits_by_replicon = {rep_name: [ch_mshe, ch_mshg, ch_mshb]}
-        systems, rej_cand = search_in_unordered_replicon(hits_by_replicon, models_to_detect, logger)
-
-        self.assertEqual(len(rej_cand), 1)
-        self.assertEqual(rej_cand[0].id, 'VICH001.B.00001.C001_MSH_1')
-        self.assertListEqual(rej_cand[0].hits, [ch_mshe, ch_mshb, ch_mshg])
-        self.assertEqual(systems, [])
--- macsylib.orig/tests/test_serialization.py
+++ macsylib/tests/test_serialization.py
@@ -42,709 +42,3 @@
     TxtUnikelySystemSerializer, TsvSpecialHitSerializer, TsvRejectedCandidatesSerializer)
 
 from tests import MacsyTest
-
-
-class SerializationTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-
-        self.model_name = 'foo'
-        self.model_location = ModelLocation(path=os.path.join(args.models_dir, self.model_name))
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.hit_weights = HitWeight(**self.cfg.hit_weights())
-        # reset the uniq id number for AbstractUnordered
-        # to have predictable results for (Likely/Unlikely)Systems
-        System._id = itertools.count(1)
-        AbstractUnordered._id = itertools.count(1)
-
-    def test_SystemSerializer_str(self):
-        model_name = 'foo'
-        model_location = ModelLocation(path=os.path.join(self.cfg.models_dir()[0], model_name))
-        model_A = Model("foo/A", 10)
-        model_B = Model("foo/B", 10)
-
-        c_gene_sctn_flg = CoreGene(model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = ModelGene(c_gene_sctn_flg, model_B)
-        c_gene_sctj_flg = CoreGene(model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = ModelGene(c_gene_sctj_flg, model_B)
-        c_gene_flgB = CoreGene(model_location, "flgB", self.profile_factory)
-        c_gene_tadZ = CoreGene(model_location, "tadZ", self.profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model_B)
-
-        c_gene_sctn = CoreGene(model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model_A)
-        gene_sctn_hom = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_hom)
-
-        c_gene_sctj = CoreGene(model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model_A)
-        gene_sctj_an = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_an)
-
-        c_gene_gspd = CoreGene(model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model_A)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model_A)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        model_A.add_mandatory_gene(gene_sctn)
-        model_A.add_mandatory_gene(gene_sctj)
-        model_A.add_accessory_gene(gene_gspd)
-        model_A.add_forbidden_gene(gene_abc)
-
-        model_B.add_mandatory_gene(gene_sctn_flg)
-        model_B.add_mandatory_gene(gene_sctj_flg)
-        model_B.add_accessory_gene(gene_gspd)
-        model_B.add_accessory_gene(gene_tadZ)
-
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        h_sctj_flg = CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_tadZ = CoreHit(c_gene_tadZ, "hit_tadZ", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-
-        model_A._min_mandatory_genes_required = 2
-        model_A._min_genes_required = 2
-        c1 = Cluster([ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY),
-                      ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-                      ],
-                     model_A, self.hit_weights)
-
-        c2 = Cluster([ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY),
-                      ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)],
-                     model_A, self.hit_weights)
-
-        model_B._min_mandatory_genes_required = 1
-        model_B._min_genes_required = 2
-        c3 = Cluster([ModelHit(h_sctj_flg, gene_sctj_flg, GeneStatus.MANDATORY),
-                      ModelHit(h_tadZ, gene_tadZ, GeneStatus.ACCESSORY),
-                      ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)],
-                     model_B, self.hit_weights)
-
-        sys_A = System(model_A, [c1, c2], self.cfg.redundancy_penalty())
-        sys_A.id = "sys_id_A"
-        sys_B = System(model_B, [c3], self.cfg.redundancy_penalty())
-        sys_B.id = "sys_id_B"
-        hit_multi_sys_tracker = HitSystemTracker([sys_A, sys_B])
-        system_serializer = TxtSystemSerializer()
-
-        sys_str = f"""system id = {sys_A.id}
-model = foo/A
-replicon = replicon_id
-clusters = [('hit_sctj', 'sctJ', 1), ('hit_sctn', 'sctN', 1), ('hit_gspd', 'gspD', 1)], [('hit_sctj', 'sctJ', 1), ('hit_sctn', 'sctN', 1)]
-occ = 2
-wholeness = 1.000
-loci nb = 2
-score = 1.500
-
-mandatory genes:
-\t- sctN: 2 (sctN, sctN)
-\t- sctJ: 2 (sctJ, sctJ)
-
-accessory genes:
-\t- gspD: 1 (gspD [sys_id_B])
-
-neutral genes:
-"""
-        self.assertEqual(sys_str, system_serializer.serialize(sys_A, hit_multi_sys_tracker))
-
-
-    def test_SystemSerializer_tsv(self):
-        model = Model("foo/T2SS", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model, loner=True)
-        c_gene_sctn_flg = CoreGene(self.model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_flg)
-        model.add_accessory_gene(gene_sctn)
-
-        #CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                           pos      score
-        ch_gspd = CoreHit(c_gene_gspd, "h_gspd", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_gspd = ModelHit(ch_gspd, gene_ref=gene_gspd, gene_status=GeneStatus.MANDATORY)
-        ch_sctj = CoreHit(c_gene_sctj, "h_sctj", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 20, 30)
-        mh_sctj = ModelHit(ch_sctj, gene_ref=gene_sctj, gene_status=GeneStatus.ACCESSORY)
-
-        ch_sctn_flg = CoreHit(c_gene_sctn_flg, "h_sctn_flg", 803, "replicon_id", 40, 1.0, 1.0, 1.0, 1.0, 30, 40)
-        mh_sctn_flg = ModelHit(ch_sctn_flg, gene_ref=gene_sctn_flg, gene_status=GeneStatus.ACCESSORY)
-        ch_sctn = CoreHit(c_gene_sctn, "h_sctn", 803, "replicon_id", 80, 1.0, 1.0, 1.0, 1.0, 30, 40)
-        mh_sctn = Loner(ch_sctn, gene_ref=gene_sctn, gene_status=GeneStatus.ACCESSORY, counterpart=[mh_sctn_flg])
-
-        c1 = Cluster([mh_gspd, mh_sctj], model, self.hit_weights)
-        c2 = Cluster([mh_sctn], model, self.hit_weights)
-        sys_multi_loci = System(model, [c1, c2], self.cfg.redundancy_penalty())
-        # score                         1.5 .35 = 1.85
-        hit_multi_sys_tracker = HitSystemTracker([sys_multi_loci])
-        system_serializer = TsvSystemSerializer()
-
-        sys_tsv = "\t".join(["replicon_id", "h_gspd", "gspD", "10", "foo/T2SS", sys_multi_loci.id, "1", "1",
-                             "1.000", "1.850", "1", "gspD", "mandatory", "803",
-                             "1.0", "1.000", "1.000", "1.000", "10", "20", "", ""])
-        sys_tsv += "\n"
-        sys_tsv += "\t".join(["replicon_id", "h_sctj", "sctJ", "20", "foo/T2SS", sys_multi_loci.id, "1", "1",
-                              "1.000", "1.850", "1", "sctJ", "accessory", "803",
-                              "1.0", "1.000", "1.000", "1.000", "20", "30", "", ""])
-        sys_tsv += "\n"
-        sys_tsv += "\t".join(["replicon_id", "h_sctn", "sctN", "80", "foo/T2SS", sys_multi_loci.id, "1", "-1",
-                              "1.000", "1.850", "1", "sctN", "accessory", "803",
-                              "1.0", "1.000", "1.000", "1.000", "30", "40", "h_sctn_flg", ""])
-        sys_tsv += "\n"
-        self.maxDiff = None
-        self.assertEqual(sys_tsv, system_serializer.serialize(sys_multi_loci, hit_multi_sys_tracker))
-
-
-    def test_SolutionSerializer_tsv(self):
-        model_name = 'foo'
-        model_location = ModelLocation(path=os.path.join(self.cfg.models_dir()[0], model_name))
-
-        ###########
-        # Model B #
-        ###########
-        model_B = Model("foo/B", 10)
-        c_gene_sctn_flg = CoreGene(model_location, "sctN_FLG", self.profile_factory)
-        gene_sctn_flg = ModelGene(c_gene_sctn_flg, model_B)
-        c_gene_sctj_flg = CoreGene(model_location, "sctJ_FLG", self.profile_factory)
-        gene_sctj_flg = ModelGene(c_gene_sctj_flg, model_B)
-        c_gene_flgB = CoreGene(model_location, "flgB", self.profile_factory)
-        gene_flgB = ModelGene(c_gene_flgB, model_B)
-        c_gene_tadZ = CoreGene(model_location, "tadZ", self.profile_factory)
-        gene_tadZ = ModelGene(c_gene_tadZ, model_B)
-
-        model_B.add_mandatory_gene(gene_sctn_flg)
-        model_B.add_mandatory_gene(gene_sctj_flg)
-        model_B.add_accessory_gene(gene_flgB)
-        model_B.add_accessory_gene(gene_tadZ)
-
-        ###########
-        # Model A #
-        ###########
-        model_A = Model("foo/A", 10)
-        c_gene_sctn = CoreGene(model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model_A)
-        gene_sctn_hom = Exchangeable(c_gene_sctn_flg, gene_sctn)
-        gene_sctn.add_exchangeable(gene_sctn_hom)
-
-        c_gene_sctj = CoreGene(model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model_A)
-        gene_sctj_an = Exchangeable(c_gene_sctj_flg, gene_sctj)
-        gene_sctj.add_exchangeable(gene_sctj_an)
-
-        c_gene_gspd = CoreGene(model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model_A)
-        gene_gspd_an = Exchangeable(c_gene_flgB, gene_gspd)
-        gene_gspd.add_exchangeable(gene_gspd_an)
-
-        c_gene_abc = CoreGene(model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model_A, loner=True)
-        gene_abc_ho = Exchangeable(c_gene_tadZ, gene_abc)
-        gene_abc.add_exchangeable(gene_abc_ho)
-
-        model_A.add_mandatory_gene(gene_sctn)
-        model_A.add_mandatory_gene(gene_sctj)
-        model_A.add_accessory_gene(gene_gspd)
-        model_A.add_accessory_gene(gene_abc)
-
-        #       CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        #                                                           pos      score
-        h_sctj = CoreHit(c_gene_sctj, "hit_sctj", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctj = ModelHit(h_sctj, gene_sctj, GeneStatus.MANDATORY)
-        h_sctn = CoreHit(c_gene_sctn, "hit_sctn", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctn = ModelHit(h_sctn, gene_sctn, GeneStatus.MANDATORY)
-        h_gspd = CoreHit(c_gene_gspd, "hit_gspd", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_gspd = ModelHit(h_gspd, gene_gspd, GeneStatus.ACCESSORY)
-
-        h_sctj_flg = CoreHit(c_gene_sctj_flg, "hit_sctj_flg", 803, "replicon_id", 10, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_flgB = CoreHit(c_gene_flgB, "hit_flgB", 803, "replicon_id", 11, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc = CoreHit(c_gene_abc, "hit_abc", 803, "replicon_id", 20, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_abc2 = CoreHit(c_gene_abc, "hit_abc2", 803, "replicon_id", 50, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        h_tadZ = CoreHit(c_gene_tadZ, "hit_tadZ", 803, "replicon_id", 40, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        mh_sctj_flg = ModelHit(h_sctj_flg, gene_sctj_flg, GeneStatus.MANDATORY)
-        mh_flgB = ModelHit(h_flgB, gene_flgB, GeneStatus.ACCESSORY)
-        # mh_abc = ModelHit(h_abc, gene_abc, GeneStatus.ACCESSORY)
-        mh_abc2 = ModelHit(h_abc2, gene_abc, GeneStatus.ACCESSORY)
-        mh_tadZ = ModelHit(h_tadZ, gene_tadZ, GeneStatus.ACCESSORY)
-
-        model_A._min_mandatory_genes_required = 2
-        model_A._min_genes_required = 2
-        c1 = Cluster([mh_sctj, mh_sctn, mh_gspd], model_A, self.hit_weights)
-        c2 = Cluster([mh_sctj, mh_sctn], model_A, self.hit_weights)
-        c3 = Cluster([Loner(h_abc, gene_ref=gene_abc, gene_status=GeneStatus.ACCESSORY, counterpart=[mh_abc2])],
-                     model_A, self.hit_weights)
-
-        model_B._min_mandatory_genes_required = 1
-        model_B._min_genes_required = 2
-        c5 = Cluster([mh_sctj_flg, mh_tadZ, mh_flgB], model_B, self.hit_weights)
-
-        sys_A = System(model_A, [c1, c2, c3], self.cfg.redundancy_penalty())
-        # score =               2.5, 2 , 0.35 = 4.85 - (2 * 1.5) = 1.85
-
-        sys_A.id = "sys_id_A"
-        sys_B = System(model_B, [c5], self.cfg.redundancy_penalty())
-        # score =                2.0
-        sys_B.id = "sys_id_B"
-
-        sol = Solution([sys_A, sys_B])
-        sol_id = 12
-
-        hit_multi_sys_tracker = HitSystemTracker([sys_A, sys_B])
-        sol_serializer = TsvSolutionSerializer()
-
-        sol_tsv = '\t'.join([str(sol_id), 'replicon_id', 'hit_sctj', 'sctJ', '1', 'foo/A', 'sys_id_A',
-                            '2', '1', '1.000', '1.850', '2', 'sctJ', 'mandatory',
-                            '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_sctn', 'sctN', '2', 'foo/A', 'sys_id_A',
-                             '2', '1', '1.000', '1.850', '2', 'sctN', 'mandatory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_gspd', 'gspD', '3', 'foo/A', 'sys_id_A',
-                             '2', '1', '1.000', '1.850', '2', 'gspD', 'accessory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_sctj', 'sctJ', '1', 'foo/A', 'sys_id_A',
-                             '2', '2', '1.000', '1.850', '2', 'sctJ', 'mandatory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_sctn', 'sctN', '2', 'foo/A', 'sys_id_A',
-                             '2', '2', '1.000', '1.850', '2', 'sctN', 'mandatory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_abc', 'abc', '20', 'foo/A', 'sys_id_A',
-                             '2', '-1', '1.000', '1.850', '2', 'abc', 'accessory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', 'hit_abc2', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_sctj_flg', 'sctJ_FLG', '10', 'foo/B', 'sys_id_B',
-                             '1', '1', '0.750', '2.000', '1', 'sctJ_FLG', 'mandatory',
-                             '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_flgB', 'flgB', '11', 'foo/B', 'sys_id_B',
-                              '1', '1', '0.750', '2.000', '1', 'flgB', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += '\t'.join([str(sol_id), 'replicon_id', 'hit_tadZ', 'tadZ', '40', 'foo/B', 'sys_id_B',
-                              '1', '1', '0.750', '2.000', '1', 'tadZ', 'accessory',
-                              '803', '1.0', '1.000', '1.000', '1.000', '10', '20', '', ''])
-        sol_tsv += "\n"
-        sol_tsv += "\n"
-        ser = sol_serializer.serialize(sol, sol_id, hit_multi_sys_tracker)
-        self.maxDiff = None
-        self.assertEqual(ser, sol_tsv)
-
-
-    def test_LikelySystemSerializer_txt(self):
-        model = Model("foo/FOO", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        model.add_forbidden_gene(gene_abc)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        hit_4 = CoreHit(c_gene_abc, "hit_4", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_abc, GeneStatus.FORBIDDEN)
-
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [v_hit_4])
-        hit_multi_sys_tracker = HitSystemTracker([ls_1])
-        ser = TxtLikelySystemSerializer()
-
-        txt = ser.serialize(ls_1, hit_multi_sys_tracker)
-        expected_txt = """This replicon contains genetic materials needed for system foo/FOO
-WARNING the quorum is reached but there is also some forbidden genes.
-
-system id = replicon_id_FOO_1
-model = foo/FOO
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 2), ('hit_3', 'sctN', 3), ('hit_4', 'abc', 4)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-\t- sctN: 1 (sctN)
-
-neutral genes:
-
-forbidden genes:
-\t- abc: 1 (abc)
-
-Use ordered replicon to have better prediction.
-"""
-        self.assertEqual(txt, expected_txt)
-        ###########################
-        # Without forbidden genes #
-        ###########################
-
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [])
-
-        hit_multi_sys_tracker = HitSystemTracker([ls_1])
-        ser = TxtLikelySystemSerializer()
-
-        txt = ser.serialize(ls_1, hit_multi_sys_tracker)
-        expected_txt = """This replicon contains genetic materials needed for system foo/FOO
-
-
-system id = replicon_id_FOO_2
-model = foo/FOO
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 2), ('hit_3', 'sctN', 3)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-\t- sctN: 1 (sctN)
-
-neutral genes:
-
-forbidden genes:
-\t- abc: 0 ()
-
-Use ordered replicon to have better prediction.
-"""
-        self.assertEqual(txt, expected_txt)
-
-        ###############################
-        # With genes in other systems #
-        ###############################
-        model_bis = Model("foo/BAR", 10)
-        gene_sctj_bis = ModelGene(c_gene_sctj, model_bis)
-        model_bis.add_accessory_gene(gene_sctj_bis)
-        v_hit_bis = ModelHit(hit_2, gene_sctj_bis, GeneStatus.ACCESSORY)
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [])
-        ls_2 = LikelySystem(model_bis, [], [v_hit_bis], [], [])
-
-        hit_multi_sys_tracker = HitSystemTracker([ls_1, ls_2])
-        ser = TxtLikelySystemSerializer()
-
-        txt = ser.serialize(ls_1, hit_multi_sys_tracker)
-        expected_txt = """This replicon contains genetic materials needed for system foo/FOO
-
-
-system id = replicon_id_FOO_3
-model = foo/FOO
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 2), ('hit_3', 'sctN', 3)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ [replicon_id_BAR_4])
-\t- sctN: 1 (sctN)
-
-neutral genes:
-
-forbidden genes:
-\t- abc: 0 ()
-
-Use ordered replicon to have better prediction.
-"""
-        self.assertEqual(txt, expected_txt)
-
-
-    def test_LikelySystemSerializer_tsv(self):
-        model = Model("foo/FOO", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        model.add_forbidden_gene(gene_abc)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        hit_4 = CoreHit(c_gene_abc, "hit_4", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_abc, GeneStatus.FORBIDDEN)
-
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [v_hit_4])
-        hit_multi_sys_tracker = HitSystemTracker([ls_1])
-        ser = TsvLikelySystemSerializer()
-
-        tsv = ser.serialize(ls_1, hit_multi_sys_tracker)
-        expected_tsv = """# This replicon contains genetic materials needed for system foo/FOO
-# WARNING the quorum is reached but there is also some forbidden genes.
-"""
-        expected_tsv += ser.header + '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_1', 'gspD', '1', 'foo/FOO', ls_1.id, '1.000',
-                                   'gspD', 'mandatory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_2', 'sctJ', '2', 'foo/FOO', ls_1.id, '1.000',
-                                   'sctJ', 'accessory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_3', 'sctN', '3', 'foo/FOO', ls_1.id, '1.000',
-                                   'sctN', 'accessory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_4', 'abc', '4', 'foo/FOO', ls_1.id, '1.000',
-                                   'abc', 'forbidden', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        self.maxDiff = None
-        self.assertEqual(tsv, expected_tsv)
-
-        ###########################
-        # Without forbidden genes #
-        ###########################
-
-        ls_1 = LikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [])
-        hit_multi_sys_tracker = HitSystemTracker([ls_1])
-        ser = TsvLikelySystemSerializer()
-
-        tsv = ser.serialize(ls_1, hit_multi_sys_tracker)
-        expected_tsv = """# This replicon contains genetic materials needed for system foo/FOO"""
-        expected_tsv += '\n\n'
-        expected_tsv += ser.header + '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_1', 'gspD', '1', 'foo/FOO', ls_1.id, '1.000',
-                                   'gspD', 'mandatory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_2', 'sctJ', '2', 'foo/FOO', ls_1.id, '1.000',
-                                   'sctJ', 'accessory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_id', 'hit_3', 'sctN', '3', 'foo/FOO', ls_1.id, '1.000',
-                                   'sctN', 'accessory', '803', '1.0', '1.000', '1.000', '1.000', '10', '20', ''])
-        expected_tsv += '\n'
-        self.maxDiff = None
-        self.assertEqual(tsv, expected_tsv)
-
-
-    def test_UnlikelySystemSerializer_txt(self):
-        model = Model("foo/FOO", 10)
-        c_gene_gspd = CoreGene(self.model_location, "gspD", self.profile_factory)
-        gene_gspd = ModelGene(c_gene_gspd, model)
-        model.add_mandatory_gene(gene_gspd)
-        c_gene_sctj = CoreGene(self.model_location, "sctJ", self.profile_factory)
-        gene_sctj = ModelGene(c_gene_sctj, model)
-        model.add_accessory_gene(gene_sctj)
-        c_gene_sctn = CoreGene(self.model_location, "sctN", self.profile_factory)
-        gene_sctn = ModelGene(c_gene_sctn, model)
-        model.add_accessory_gene(gene_sctn)
-        c_gene_abc = CoreGene(self.model_location, "abc", self.profile_factory)
-        gene_abc = ModelGene(c_gene_abc, model)
-        model.add_forbidden_gene(gene_abc)
-
-        hit_1 = CoreHit(c_gene_gspd, "hit_1", 803, "replicon_id", 1, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_1 = ModelHit(hit_1, gene_gspd, GeneStatus.MANDATORY)
-        hit_2 = CoreHit(c_gene_sctj, "hit_2", 803, "replicon_id", 2, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_2 = ModelHit(hit_2, gene_sctj, GeneStatus.ACCESSORY)
-        hit_3 = CoreHit(c_gene_sctn, "hit_3", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_3 = ModelHit(hit_3, gene_sctn, GeneStatus.ACCESSORY)
-        hit_4 = CoreHit(c_gene_abc, "hit_4", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        v_hit_4 = ModelHit(hit_4, gene_abc, GeneStatus.FORBIDDEN)
-        ser = TxtUnikelySystemSerializer()
-
-        ls_1 = UnlikelySystem(model, [v_hit_1], [v_hit_2, v_hit_3], [], [v_hit_4], ["the reason why"])
-        txt = ser.serialize(ls_1)
-        expected_txt = """This replicon probably not contains a system foo/FOO:
-the reason why
-
-system id = replicon_id_FOO_1
-model = foo/FOO
-replicon = replicon_id
-hits = [('hit_1', 'gspD', 1), ('hit_2', 'sctJ', 2), ('hit_3', 'sctN', 3), ('hit_4', 'abc', 4)]
-wholeness = 1.000
-
-mandatory genes:
-\t- gspD: 1 (gspD)
-
-accessory genes:
-\t- sctJ: 1 (sctJ)
-\t- sctN: 1 (sctN)
-
-neutral genes:
-
-forbidden genes:
-\t- abc: 1 (abc)
-
-Use ordered replicon to have better prediction.
-"""
-        self.assertEqual(txt, expected_txt)
-
-
-    def test_SpecialHitSerializer_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        cfg = Config(MacsyDefaults(), args)
-
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        profile_factory = ProfileFactory(cfg)
-        model = Model("foo/T2SS", 10)
-
-        gene_name = "gspD"
-        cg_gspd = CoreGene(models_location, gene_name, profile_factory)
-        mg_gspd = ModelGene(cg_gspd, model, loner=True)
-
-        gene_name = "sctJ"
-        cg_sctj = CoreGene(models_location, gene_name, profile_factory)
-        mg_sctj = ModelGene(cg_sctj, model)
-
-        gene_name = "abc"
-        cg_abc = CoreGene(models_location, gene_name, profile_factory)
-        mg_abc = ModelGene(cg_abc, model)
-
-        model.add_mandatory_gene(mg_gspd)
-        model.add_accessory_gene(mg_sctj)
-        model.add_accessory_gene(mg_abc)
-
-        # chit_abc = CoreHit(cg_abc, "hit_abc", 803, "replicon_id", 3, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        # chit_sctj = CoreHit(cg_sctj, "hit_sctj", 803, "replicon_id", 4, 1.0, 1.0, 1.0, 1.0, 10, 20)
-        chit_gspd1 = CoreHit(cg_gspd, "hit_gspd1", 803, "replicon_id", 20, 1.0, 2.0, 1.0, 1.0, 10, 20)
-        chit_gspd2 = CoreHit(cg_gspd, "hit_gspd2", 803, "replicon_id", 30, 1.0, 3.0, 1.0, 1.0, 10, 20)
-        # mhit_abc = ModelHit(chit_abc, mg_abc, GeneStatus.ACCESSORY)
-        # mhit_sctj = ModelHit(chit_sctj, mg_sctj, GeneStatus.ACCESSORY)
-        mhit_gspd1 = ModelHit(chit_gspd1, mg_gspd, GeneStatus.MANDATORY)
-        mhit_gspd2 = ModelHit(chit_gspd2, mg_gspd, GeneStatus.MANDATORY)
-        l_gspd1 = Loner(mhit_gspd1, counterpart=[mhit_gspd2])
-        l_gspd2 = Loner(mhit_gspd2, counterpart=[mhit_gspd1])
-        ser = TsvSpecialHitSerializer()
-        txt = ser.serialize([l_gspd1, l_gspd2])
-
-        expected_txt = "\t".join(['replicon', 'model_fqn', 'function', 'gene_name', 'hit_id', 'hit_pos', 'hit_status',
-                                'hit_seq_len', 'hit_i_eval', 'hit_score', 'hit_profile_cov',
-                                'hit_seq_cov', 'hit_begin_match', 'hit_end_match'])
-        expected_txt += "\n"
-        expected_txt += "\t".join(['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd1', '20', 'mandatory', '803',
-                                '1.000e+00', '2.000', '1.000', '1.000', '10', '20'])
-        expected_txt += "\n"
-        expected_txt += "\t".join(['replicon_id', 'foo/T2SS', 'gspD', 'gspD', 'hit_gspd2', '30', 'mandatory', '803',
-                                '1.000e+00', '3.000', '1.000', '1.000', '10', '20'])
-        expected_txt += "\n"
-        self.maxDiff = None
-        self.assertEqual(txt, expected_txt)
-
-
-    def test_RejectedClusters_tsv(self):
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        args.res_search_dir = "blabla"
-
-        cfg = Config(MacsyDefaults(), args)
-        model_name = 'foo'
-        models_location = ModelLocation(path=os.path.join(args.models_dir, model_name))
-        profile_factory = ProfileFactory(cfg)
-
-        model = Model("foo/T2SS", 11)
-
-        gene_name = "gspD"
-        c_gene_gspd = CoreGene(models_location, gene_name, profile_factory)
-        gene_1 = ModelGene(c_gene_gspd, model)
-        gene_name = "sctC"
-        c_gene_sctc = CoreGene(models_location, gene_name, profile_factory)
-        gene_2 = ModelGene(c_gene_sctc, model)
-        gene_name = 'tadZ'
-        c_gene_tadz = CoreGene(models_location, gene_name, profile_factory)
-        gene_3 = ModelGene(c_gene_tadz, model)
-        gene_name = 'abc'
-        c_gene_abc = CoreGene(models_location, gene_name, profile_factory)
-        gene_4 = Exchangeable(c_gene_abc, gene_3)
-        gene_3.add_exchangeable(gene_4)
-
-        model.add_mandatory_gene(gene_1)
-        model.add_accessory_gene(gene_2)
-        model.add_accessory_gene(gene_3)
-
-        #     CoreHit(gene, hit_id, hit_seq_length, replicon_name, position, i_eval, score,
-        #         profile_coverage, sequence_coverage, begin_match, end_match
-        h10 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 10, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_10 = ModelHit(h10, gene_1, GeneStatus.MANDATORY)
-        h20 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 20, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh_20 = ModelHit(h20, gene_2, GeneStatus.ACCESSORY)
-        h40 = CoreHit(c_gene_gspd, "h10", 10, "replicon_1", 40, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_40 = ModelHit(h40, gene_1, GeneStatus.MANDATORY)
-        h50 = CoreHit(c_gene_sctc, "h20", 10, "replicon_1", 50, 1.0, 20.0, 1.0, 1.0, 10, 20)
-        mh_50 = ModelHit(h50, gene_2, GeneStatus.ACCESSORY)
-        h60 = CoreHit(c_gene_gspd, "h60", 10, "replicon_1", 60, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_60 = ModelHit(h60, gene_1, GeneStatus.MANDATORY)
-        h70 = CoreHit(c_gene_abc, "h70", 10, "replicon_1", 70, 1.0, 10.0, 1.0, 1.0, 10, 20)
-        mh_70 = ModelHit(h70, gene_4, GeneStatus.ACCESSORY)
-
-        hit_weights = HitWeight(**cfg.hit_weights())
-        c1 = Cluster([mh_10, mh_20], model, hit_weights)
-        c2 = Cluster([mh_40, mh_50], model, hit_weights)
-        c3 = Cluster([mh_60, mh_70], model, hit_weights)
-
-        RejectedCandidate._id = itertools.count(1)
-        r_c1 = RejectedCandidate(model, [c1, c2], ["The reasons to reject this candidate"])
-
-        r_c2 = RejectedCandidate(model, [c2, c3], ["reason One", "reason Two"])
-
-        ser = TsvRejectedCandidatesSerializer()
-        tsv = ser.serialize([r_c1, r_c2])
-
-        expected_tsv = '\t'.join(['candidate_id', 'replicon', 'model_fqn', 'cluster_id', 'hit_id', 'hit_pos', 'gene_name', 'function', 'reasons'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c1.id, 'h10', '10', 'gspD', 'gspD', 'The reasons to reject this candidate'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c1.id, 'h20', '20', 'sctC', 'sctC', 'The reasons to reject this candidate'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c2.id, 'h10', '40', 'gspD', 'gspD', 'The reasons to reject this candidate'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_1', 'replicon_1', 'foo/T2SS', c2.id, 'h20', '50', 'sctC', 'sctC', 'The reasons to reject this candidate'])
-        expected_tsv += '\n'
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_2', 'replicon_1', 'foo/T2SS', c2.id, 'h10', '40', 'gspD', 'gspD', 'reason One/reason Two'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_2', 'replicon_1', 'foo/T2SS', c2.id, 'h20', '50', 'sctC', 'sctC', 'reason One/reason Two'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_2', 'replicon_1', 'foo/T2SS', c3.id, 'h60', '60', 'gspD', 'gspD', 'reason One/reason Two'])
-        expected_tsv += '\n'
-        expected_tsv += '\t'.join(['replicon_1_T2SS_2', 'replicon_1', 'foo/T2SS', c3.id, 'h70', '70', 'abc', 'tadZ', 'reason One/reason Two'])
-        expected_tsv += '\n'
-        expected_tsv += '\n'
-
-        self.maxDiff = None
-        self.assertEqual(expected_tsv, tsv)
--- macsylib.orig/tests/test_solution.py
+++ macsylib/tests/test_solution.py
@@ -419,477 +419,3 @@
     systems['K'] = System(models['K'], [clusters['c10']], cfg.redundancy_penalty())  # 2 hits
     systems['K'].id = "replicon_id_K"
     return systems
-
-
-class SolutionTest(MacsyTest):
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.models, self.clusters = _build_clusters(self.cfg, self.profile_factory)
-        self.systems = _build_systems(self.models, self.clusters, self.cfg)
-
-
-    def test_gt(self):
-        s1 = Solution([self.systems[k] for k in 'AB'])   # 5 + 3     = 8 hits, 2 syst, 0.875, [2, 2, 3, 5, 5, 6, 7, 8]
-        s2 = Solution([self.systems[k] for k in 'HIJ'])  # 2 + 2 + 2 = 6 hits, 3 syst, 0.722, [2, 9, 7, 8, 8, 9]
-        s3 = Solution([self.systems[k] for k in 'DC'])   # 4 + 2     = 6 hits, 2 syst  0.900, [2, 9, 3, 6, 7, 8]
-        s4 = Solution([self.systems[k] for k in 'CF'])   # 4 + 1     = 5 hits, 2 syst, 0.900, [3, 6, 7, 8, 9]
-        s5 = Solution([self.systems[k] for k in 'EC'])   # 1 + 4     = 5 hits, 2 syst, 0.900, [3, 3, 6, 7, 8]
-        s6 = Solution([self.systems[k] for k in 'DB'])   # 2 + 3     = 5 hits, 2 syst, 0.875, [2, 9, 6, 7, 8]
-        self.assertGreater(s1, s2)  # s1 more hits than s2
-        self.assertGreater(s2, s3)  # s2 more systems than s3
-        self.assertGreater(s5, s6)  # s5 greater awholeness than s6
-        self.assertGreater(s4, s5)  # s4 "bigger positions than s5
-
-    def test_lt(self):
-        s1 = Solution([self.systems[k] for k in 'AB'])   # 5 + 3     = 8 hits, 2 syst, 0.875, [2, 2, 3, 5, 5, 6, 7, 8]
-        s2 = Solution([self.systems[k] for k in 'HIJ'])  # 2 + 2 + 2 = 6 hits, 3 syst, 0.722, [2, 9, 7, 8, 8, 9]
-        s3 = Solution([self.systems[k] for k in 'DC'])   # 4 + 2     = 6 hits, 2 syst  0.900, [2, 9, 3, 6, 7, 8]
-        s4 = Solution([self.systems[k] for k in 'CF'])   # 4 + 1     = 5 hits, 2 syst, 0.900, [3, 6, 7, 8, 9]
-        s5 = Solution([self.systems[k] for k in 'EC'])   # 1 + 4     = 5 hits, 2 syst, 0.900, [3, 3, 6, 7, 8]
-        s6 = Solution([self.systems[k] for k in 'DB'])   # 2 + 3     = 5 hits, 2 syst, 0.875, [2, 9, 6, 7, 8]
-        self.assertLess(s2, s1)  # s1 more hits than s2
-        self.assertLess(s3, s2)  # s2 more systems than s3
-        self.assertLess(s6, s5)  # s5 greater awholeness than s6
-        self.assertLess(s5, s4)  # s4 "bigger positions than s5
-
-
-    def test_sorting(self):
-        s1 = Solution([self.systems[k] for k in 'AB'])   # 5 + 3     = 8 hits, 2 syst, 0.875, [2, 2, 3, 5, 5, 6, 7, 8]
-        s2 = Solution([self.systems[k] for k in 'HIJ'])  # 2 + 2 + 2 = 6 hits, 3 syst, 0.722, [2, 9, 7, 8, 8, 9]
-        s3 = Solution([self.systems[k] for k in 'DC'])   # 4 + 2     = 6 hits, 2 syst  0.900, [2, 9, 3, 6, 7, 8]
-        s4 = Solution([self.systems[k] for k in 'CF'])   # 4 + 1     = 5 hits, 2 syst, 0.900, [3, 6, 7, 8, 9]
-        s5 = Solution([self.systems[k] for k in 'EC'])   # 1 + 4     = 5 hits, 2 syst, 0.900, [3, 3, 6, 7, 8]
-        s6 = Solution([self.systems[k] for k in 'DB'])   # 2 + 3     = 5 hits, 2 syst, 0.875, [2, 9, 6, 7, 8]
-
-        expected_order = [s6, s5, s4, s3, s2, s1]
-        shuffled_sol = expected_order[:]
-        random.shuffle(shuffled_sol)
-        sorted_sol = sorted(shuffled_sol)
-        self.assertEqual(expected_order, sorted_sol)
-
-    def test_systems(self):
-        s1 = Solution([self.systems[k] for k in 'CD'])
-        self.assertEqual([self.systems['D'], self.systems['C']],
-                         s1.systems)
-
-    def test_score(self):
-        s = Solution([self.systems[k] for k in 'CD'])
-        self.assertEqual(s.score, 4.5)
-
-        s = Solution([self.systems[k] for k in 'HIJ'])
-        self.assertEqual(s.score, 4.5)
-
-    def test_average_wholeness(self):
-        s = Solution([self.systems[k] for k in 'CD'])
-        self.assertEqual(s.average_wholeness, 0.9)
-
-        s = Solution([self.systems[k] for k in 'HIJ'])
-        self.assertEqual(s.average_wholeness, 0.7222222222222222)
-
-    def test_hits_number(self):
-        s = Solution([self.systems[k] for k in 'CD'])
-        self.assertEqual(s.hits_number, 6)
-
-        s = Solution([self.systems[k] for k in 'AB'])
-        self.assertEqual(s.hits_number, 8)
-
-
-    def test_hits_positions(self):
-        s = Solution([self.systems[k] for k in 'CD'])
-        self.assertEqual(s.hits_positions,
-                         [2, 9, 3, 6, 7, 8])
-
-        s = Solution([self.systems[k] for k in 'AB'])
-        self.assertEqual(s.hits_positions,
-                         [2, 2, 3, 5, 5, 6, 7, 8])
-
-    def test_iteration(self):
-        # be careful the systems are ordered in Solution
-        systems = [self.systems[k] for k in 'HIJ']
-        s = Solution(systems)
-        got = [syst for syst in s]
-        self.assertEqual(systems,
-                         got)
-
-
-class SolutionExplorerTest(MacsyTest):
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        # to turn on debugging
-        # uncomment the 3 following lines
-        # import macsylib
-        # macsylib.init_logger()
-        # macsylib.logger_set_level('DEBUG')
-
-        pass
-
-    def setUp(self) -> None:
-        args = argparse.Namespace()
-        args.sequence_db = self.find_data("base", "test_1.fasta")
-        args.db_type = 'gembase'
-        args.models_dir = self.find_data('models')
-        self.cfg = Config(MacsyDefaults(), args)
-        # we need to reset the ProfileFactory
-        # because it's a like a singleton
-        # so other tests are influenced by ProfileFactory and it's configuration
-        # for instance search_genes get profile without hmmer_exe
-        self.profile_factory = ProfileFactory(self.cfg)
-        self.models, self.clusters = _build_clusters(self.cfg, self.profile_factory)
-        self.systems = _build_systems(self.models, self.clusters, self.cfg)
-
-
-    def test_find_best_solution(self):
-        systems = [self.systems[k] for k in 'ABCD']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        # sorted_syst = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_A', 1.5), ('replicon_id_D', 1.5)]
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_A ['hit_sctj', 'hit_sctn', 'hit_gspd', 'hit_sctj', 'hit_sctn']
-        # replicon_id_D ['hit_abc', 'hit_sctn']
-        # C and D are compatible 4.5
-        # B and A are compatible 3.5
-        # B and D are compatible 3.5
-        # So the best Solution expected is C D 4.5
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'CD'])]
-        # The order of solutions are not relevant
-        # The order of systems in each solutions are not relevant
-        # transform list in set to compare them
-
-        self.assertEqual(score, 4.5)
-        self.assertEqual(best_sol, expected_sol)
-
-        systems = [self.systems[k] for k in 'ABC']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        # sorted_syst = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_A', 1.5)]
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_A ['hit_sctj', 'hit_sctn', 'hit_gspd', 'hit_sctj', 'hit_sctn']
-        # C is alone 3.0
-        # B and A are compatible 3.5
-        # So the best Solution expected is B and A
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'BA'])]
-        self.assertEqual(score, 3.5)
-        self.assertEqual(best_sol, expected_sol)
-
-        systems = [self.systems[k] for k in 'BCE']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        # sorted_syst = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_E', 0.5)]
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_E ['hit_gspd']
-        # C is alone 3.0
-        # B and E are compatible 2.5
-        # So the best Solution expected is C
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'C'])]
-        self.assertEqual(score, 3.0)
-        self.assertEqual(best_sol, expected_sol)
-
-        # systems = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_A', 1.5),
-        #            ('replicon_id_D', 1.5), ('replicon_id_E', 0.5)]
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_A ['hit_sctj', 'hit_sctn', 'hit_gspd', 'hit_sctj', 'hit_sctn']
-        # replicon_id_D ['hit_abc', 'hit_sctn']
-        # replicon_id_E ['hit_gspd']
-        # C and D are compatible 4.5
-        # B and A are compatible 3.5
-        # B and E are compatible 2.5
-        # D and E are compatible 2.0
-        systems = [self.systems[k] for k in 'ABCDE']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'CD'])]
-        self.assertEqual(score, 4.5)
-        self.assertEqual(best_sol, expected_sol)
-
-        # systems = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_A', 1.5),
-        #            ('replicon_id_D', 1.5), ('replicon_id_E', 0.5), ('replicon_id_F', 1.0)]
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_A ['hit_sctj', 'hit_sctn', 'hit_gspd', 'hit_sctj', 'hit_sctn']
-        # replicon_id_D ['hit_abc', 'hit_sctn']
-        # replicon_id_E ['hit_gspd']
-        # replicon_id_F ['hit_abc']
-        # C and D are compatible 4.5
-        # C and F are compatible 4.0
-        # B and A and F are compatible 4.5
-        # B and D and E are compatible 4.0
-        # B and E and F are compatible 3.5
-        # So the best Solution expected are C D / B A F
-        systems = [self.systems[k] for k in 'ABCDEF']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'BAF']),  # 3 + 5 + 1 = 9 hits
-                        Solution([self.systems[k] for k in 'CD'])]   # 4 + 2 = 7 hits
-
-        self.assertEqual(best_sol[0].score, 4.5)
-        self.assertEqual(best_sol[1].score, 4.5)
-        # test if the composition is right
-        self.assertEqual(best_sol, expected_sol)
-        # test if solution order is right
-
-        systems = [self.systems[k] for k in 'ABCDGH']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        # sorted_syst = [('replicon_id_C', 3.0), ('replicon_id_B', 2.0), ('replicon_id_A', 1.5), ('replicon_id_D', 1.5)
-        #                ('replicon_id_G', 3.0), ('replicon_id_H', 1.5)]
-        # replicon_id_A ['hit_sctj', 'hit_sctn', 'hit_gspd', 'hit_sctj', 'hit_sctn']
-        # replicon_id_B ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB']
-        # replicon_id_C ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_D ['hit_abc', 'hit_sctn']
-        # replicon_id_G ['hit_sctj_flg', 'hit_tadZ', 'hit_flgB', 'hit_gspd']
-        # replicon_id_H ['hit_abc', 'hit_sctn']
-        # C and D are compatible 4.5   wholeness = 0.8  + 1.0 = 1.8
-        # C and H are compatible 4.5               0.8  + 1.0 = 1.8
-        # G and D are compatible 4.5               0.8  + 1.0 = 1.8
-        # G and H are compatible 4.5               0.8  + 1.0 = 1.8
-        # B and A are compatible 3.5               0.75 + 1.0 = 1.75
-        # So the best Solution expected are C D / C H / G D / G H with score 4.5
-
-        best_sol, score = find_best_solutions(sorted_syst)
-        expected_sol = [Solution([self.systems[k] for k in 'CD']),  # 4 + 2 hits
-                        Solution([self.systems[k] for k in 'CH']),  # 4 + 2
-                        Solution([self.systems[k] for k in 'GD']),  # 4 + 2
-                        Solution([self.systems[k] for k in 'GH'])]  # 4 + 2
-        self.assertEqual(score, 4.5)
-        self.assertEqual(best_sol, expected_sol)
-
-        systems = [self.systems[k] for k in 'HJKI']
-        sorted_syst = sorted(systems, key=lambda s: (- s.score, s.id))
-        best_sol, score = find_best_solutions(sorted_syst)
-
-        # check if solution is ordered by wholeness average (3rd criterion)
-        # first criterion nb of hits
-        # second citerion nb of systems
-        # replicon_id_H ['hit_abc', 'hit_sctn']
-        # replicon_id_I ['hit_flgB', 'hit_tadZ']
-        # replicon_id_J ['hit_abc', 'hit_tadZ']
-        # replicon_id_K ['hit_flgB', 'hit_sctn']
-        #                                                             score  Nb hits  nb sys wholeness
-        expected_sol = [Solution([self.systems[k] for k in 'HI']),  # 1.5 + 1.5 = 3.0    4        2       1.0
-                        Solution([self.systems[k] for k in 'JK'])]  # 1.5 + 1.5 = 3.0    4        2       0.5
-        self.assertEqual(score, 3.0)
-        self.assertEqual(best_sol, expected_sol)
-
-
-    def test_combine_clusters(self):
-        combinations = combine_clusters([],
-                                       {},
-                                       multi_loci=False)
-        self.assertListEqual(combinations, [])
-        ##################################################
-        # with 3 regular clusters 0 loner 0 multisystyem
-        ##################################################
-        combinations = combine_clusters([self.clusters['c1'], self.clusters['c2'],  self.clusters['c3']],
-                                       {},
-                                       multi_loci=False)
-        self.assertEqual(combinations,
-                         [
-                             (self.clusters['c1'],),
-                             (self.clusters['c2'],),
-                             (self.clusters['c3'],)
-                         ])
-        # the same in multi loci
-        combinations = combine_clusters([self.clusters['c1'], self.clusters['c2'], self.clusters['c3']],
-                                        {},
-                                        multi_loci=True)
-        exp_combs = [
-                    (self.clusters['c1'],),
-                    (self.clusters['c2'],),
-                    (self.clusters['c3'],),
-                    (self.clusters['c1'], self.clusters['c2']),
-                    (self.clusters['c1'], self.clusters['c3']),
-                    (self.clusters['c2'], self.clusters['c3']),
-                    (self.clusters['c1'], self.clusters['c2'], self.clusters['c3'])
-                 ]
-        self.assertEqual(combinations, exp_combs)
-
-        ###########################################
-        # with 2 RC + 1 L not included in cluster
-        ###########################################
-        combinations = combine_clusters([self.clusters['c11'], self.clusters['c12']],
-                                        {},
-                                        multi_loci=False)
-        exp_combs = [
-                    (self.clusters['c11'],),
-                    (self.clusters['c12'],)
-                   ]
-        self.assertEqual(combinations, exp_combs)
-        # the same in multi loci
-        combinations = combine_clusters([self.clusters['c11'], self.clusters['c12']],
-                                       {},
-                                       multi_loci=True)
-        exp_combs = [
-                    (self.clusters['c11'],),
-                    (self.clusters['c12'],),
-                    (self.clusters['c11'], self.clusters['c12'])
-                   ]
-        self.assertEqual(combinations, exp_combs)
-
-        ##################################
-        # with 2 RC + 1 L already in RC 2
-        ##################################
-        # c11 = flgB, sctn_flg
-        # c12 = sctj_flg, sctn
-        # c13 = Loner sctn
-        combinations = combine_clusters([self.clusters['c11'], self.clusters['c12']],
-                                        {'sctN': self.clusters['c13']},
-                                        multi_loci=False)
-
-        exp_combs = [
-            (self.clusters['c11'],),
-            (self.clusters['c12'],),
-            (self.clusters['c11'], self.clusters['c13']),
-            (self.clusters['c13'],),
-        ]
-
-        self.assertEqual(combinations, exp_combs)
-
-        # the same in multi loci
-        combinations = combine_clusters([self.clusters['c11'], self.clusters['c12']],
-                                        {'sctN': self.clusters['c13']},
-                                        multi_loci=True)
-
-        exp_combs = [
-            (self.clusters['c11'],),
-            (self.clusters['c12'],),
-            (self.clusters['c11'], self.clusters['c12']),
-            (self.clusters['c11'], self.clusters['c13']),
-            (self.clusters['c13'],),
-        ]
-        self.assertEqual(combinations, exp_combs)
-
-        ###########################################
-        # with 2 RC  with one containing a MS     #
-        ###########################################
-        combinations = combine_clusters([self.clusters['c14'], self.clusters['c15']],
-                                        {'sctN': self.clusters['c16']},
-                                        multi_loci=True)
-        # c14 contains a MS
-        # c15 do not contains MS
-        # c16 is the artificial cluster with only sctn
-        exp_combs = [
-            (self.clusters['c14'],),
-            (self.clusters['c15'],),
-            (self.clusters['c14'], self.clusters['c15']),
-            (self.clusters['c15'], self.clusters['c16']),
-            (self.clusters['c16'],)]
-        self.assertEqual(combinations, exp_combs)
-
-        ###########################################
-        # with 2 RC + 2 L not included in cluster
-        ###########################################
-        combinations = combine_clusters([self.clusters['c17'], self.clusters['c18']],
-                                        {'sctn': self.clusters['c19'],
-                                         'tadZ': self.clusters['c20']
-                                         },
-                                        multi_loci=False)
-        exp_combs = [
-            (self.clusters['c17'],),
-            (self.clusters['c18'],),
-            (self.clusters['c17'], self.clusters['c19']),
-            (self.clusters['c18'], self.clusters['c19']),
-            (self.clusters['c19'],),
-            (self.clusters['c17'], self.clusters['c20']),
-            (self.clusters['c18'], self.clusters['c20']),
-            (self.clusters['c20'],),
-            (self.clusters['c17'], self.clusters['c19'], self.clusters['c20']),
-            (self.clusters['c18'], self.clusters['c19'], self.clusters['c20']),
-            (self.clusters['c19'], self.clusters['c20'])
-        ]
-
-        self.assertEqual(combinations, exp_combs)
-        # the same in multi loci
-        combinations = combine_clusters([self.clusters['c17'], self.clusters['c18']],
-                                        {'sctn': self.clusters['c19'],
-                                         'tadZ': self.clusters['c20']
-                                         },
-                                        multi_loci=True)
-        exp_combs = [
-            (self.clusters['c17'],),
-            (self.clusters['c18'],),
-            (self.clusters['c17'], self.clusters['c18']),
-            (self.clusters['c17'], self.clusters['c19']),
-            (self.clusters['c18'], self.clusters['c19']),
-            (self.clusters['c17'],self.clusters['c18'], self.clusters['c19']),
-            (self.clusters['c19'],),
-            (self.clusters['c17'], self.clusters['c20']),
-            (self.clusters['c18'], self.clusters['c20']),
-            (self.clusters['c17'],self.clusters['c18'], self.clusters['c20']),
-            (self.clusters['c20'],),
-            (self.clusters['c17'], self.clusters['c19'], self.clusters['c20']),
-            (self.clusters['c18'], self.clusters['c19'], self.clusters['c20']),
-            (self.clusters['c17'], self.clusters['c18'], self.clusters['c19'], self.clusters['c20']),
-            (self.clusters['c19'], self.clusters['c20'])
-        ]
-        # print("\n####################################################################")
-        # for comb in exp_combs:
-        #     print([c.id for c in comb])
-        # print("==============================")
-        # for comb in combinations:
-        #     print([c.id for c in comb])
-        self.assertEqual(combinations, exp_combs)
-
-
-    def test_combine_multisystems(self):
-        # key    id     hits
-        # c21    c47    sctj abc tadz
-        # c22    c48    sctn_flg gspd tadz
-        # c23    c49    Loner gspd
-        # c24    c50    MS gspd
-        # c25    c51    MS sctn
-        # c26    c52    MS sctj_flg
-
-        rejected_clst = RejectedCandidate(self.models['O'],
-                                         [self.clusters['c21']],
-                                         'fake_reason')
-        combinations = combine_multisystems(rejected_clst,
-                                            [self.clusters['c24'], self.clusters['c25'], self.clusters['c26']]
-                                            )
-        exp_combs = [
-            (self.clusters['c21'], self.clusters['c24']),
-            (self.clusters['c21'], self.clusters['c25']),
-            (self.clusters['c21'], self.clusters['c24'], self.clusters['c25'])
-            ]
-        self.assertEqual(combinations, exp_combs)
-
-        rejected_clst = RejectedCandidate(self.models['O'],
-                                         [self.clusters['c22']],
-                                         'fake_reason')
-        combinations = combine_multisystems([rejected_clst],
-                                            [self.clusters['c24'], self.clusters['c25'], self.clusters['c26']]
-                                            )
-        exp_combs = [
-            (self.clusters['c22'], self.clusters['c26'])
-            ]
-        self.assertEqual(combinations, exp_combs)
-
-        rejected_clst = RejectedCandidate(self.models['O'],
-                                         [self.clusters['c21'], self.clusters['c23']],
-                                         'fake_reason')
-        combinations = combine_multisystems([rejected_clst],
-                                            [self.clusters['c24'], self.clusters['c25'], self.clusters['c26']]
-                                            )
-        exp_combs = [
-            (self.clusters['c21'], self.clusters['c23'], self.clusters['c25'])
-            ]
-        self.assertEqual(combinations, exp_combs)
-        # print("\n####################################################################")
-        # for comb in exp_combs:
-        #     print([c.id for c in comb])
-        # print("==============================")
-        # for comb in combinations:
-        #     print([c.id for c in comb])
--- macsylib.orig/tests/test_utils.py
+++ macsylib/tests/test_utils.py
@@ -42,27 +42,6 @@
 
 class TestUtils(MacsyTest):
 
-    def test_list_models(self):
-        cmd_args = argparse.Namespace()
-        cmd_args.models_dir = self.find_data('fake_model_dir')
-        cmd_args.list_models = True
-        rcv_list_models = list_models(cmd_args)
-        exp_list_models = """set_1
-      /def_1_1
-      /def_1_2
-      /def_1_3
-      /def_1_4
-set_2
-      /level_1
-              /def_1_1
-              /def_1_2
-              /level_2
-                      /def_2_3
-                      /def_2_4
-"""
-        self.assertEqual(exp_list_models, rcv_list_models)
-
-
     @unittest.skipIf(platform.system() == 'Windows' or os.getuid() == 0, 'Skip test on Windows or if run as root')
     def test_list_models_no_permission(self):
         # on gitlab it is not allowed to change the permission of a directory
@@ -92,35 +71,6 @@
             os.chmod(cmd_args.models_dir, models_dir_perm)
             tmp_dir.cleanup()
 
-    def test_get_def_to_detect(self):
-        cmd_args = argparse.Namespace()
-        cmd_args.models_dir = self.find_data('fake_model_dir')
-        cmd_args.models = ('set_1', 'def_1_1', 'def_1_2', 'def_1_3')
-        registry = ModelRegistry()
-        models_location = scan_models_dir(cmd_args.models_dir)
-        for ml in models_location:
-            registry.add(ml)
-
-        # case where models are specified on command line
-        res, model_family, model_vers = get_def_to_detect(('set_1', ['def_1_1', 'def_1_2', 'def_1_3']), registry)
-        model_loc = registry['set_1']
-        self.assertEqual(model_family, 'set_1')
-        self.assertEqual(model_vers, '0.0b2')
-        exp = [model_loc.get_definition(name) for name in ('set_1/def_1_1', 'set_1/def_1_2', 'set_1/def_1_3')]
-        self.assertListEqual(res, exp)
-
-        # case we search all models
-        res, model_family, model_vers = get_def_to_detect(('set_1', ['all']), registry)
-        self.assertEqual(model_family, 'set_1')
-        self.assertEqual(model_vers, '0.0b2')
-        exp = model_loc.get_all_definitions()
-        self.assertListEqual(res, exp)
-
-        # case the models required does not exists
-        with self.assertRaises(ValueError):
-            get_def_to_detect(('set_1', ['FOO', 'BAR']), registry)
-
-
     def test_get_replicon_names_gembase(self):
         replicon_names = get_replicon_names(self.find_data('base', 'gembase.fasta'), 'gembase')
         self.assertListEqual(replicon_names,
