diff --git a/PanACoTA/subcommands/annotate.py b/PanACoTA/subcommands/annotate.py
index b406a88f23fa2f9d4cbe8b9a2c08da1455f4d28c..c3381d9c57af8fa5b212f20bb8fac77d89ec65e6 100755
--- a/PanACoTA/subcommands/annotate.py
+++ b/PanACoTA/subcommands/annotate.py
@@ -605,7 +605,7 @@ def check_args(parser, args):
     if args.cutn != 5 and args.from_info:
         parser.error("If you provide a list of genomes with their calculated L90 and number of "
                      "contigs, PanACoTA will use the given sequences as is. It will not cut "
-                     "them. So, you cannot use both --cutN and --info")
+                     "them. So, you cannot use both --cutn and --info.")
     if args.l90 != 100 and args.from_info:
         parser.error("If you provide a list of genomes with their calculated L90 and number of "
                      "contigs, PanACoTA will use this information, and not re-calculate it. "
@@ -642,10 +642,6 @@ def check_args(parser, args):
         print(colored(thresholds_message(args.l90, args.nbcont), "yellow"))
         if args.from_info:
             print(colored(nosplit_message(), "yellow"))
-            if not args.prodigal_only:
-                print(colored("\t-> Check that your genomes have unique headers, where headers "
-                              "are the 20 first characters of first word of current "
-                              "header", "yellow"))
     print()
 
     return args
diff --git a/test/test_functional/test_annote-parser.py b/test/test_functional/test_annote-parser.py
index dafe447136c220517ad5868714761ffeb7155eb3..b0d21955ab3f094b18524e270dc5388d0785b499 100755
--- a/test/test_functional/test_annote-parser.py
+++ b/test/test_functional/test_annote-parser.py
@@ -8,7 +8,7 @@ import pytest
 import argparse
 import time
 
-from genomeAPCAT.subcommands import annote as annot
+from PanACoTA.subcommands import annotate as annot
 
 
 def test_parser_noarg(capsys):
@@ -21,11 +21,12 @@ def test_parser_noarg(capsys):
     with pytest.raises(SystemExit):
         annot.parse(parser, "".split())
     _, err = capsys.readouterr()
-    assert "-d DB_PATH -r RES_PATH [-n NAME] [-Q] [--l90 L90]" in err
-    assert "[--nbcont NBCONT] [--cutN CUTN] [--date DATE] [--tmp TMPDIR]" in err
-    assert "[--prok PROKKADIR] [-F] [--threads THREADS] [-v] [-q] [-h]" in err
-    assert "list_file" in err
-    assert "the following arguments are required: list_file, -d, -r" in err
+    assert "[-d DB_PATH] -r RES_PATH [-l LIST_FILE] [-n NAME] [-Q]" in err
+    assert "[--info FROM_INFO] [--prodigal] [--l90 L90] [--nbcont NBCONT]" in err
+    assert "[--cutn CUTN] [--date DATE] [--tmp TMPDIR]" in err
+    assert "[--annot_dir ANNOTDIR] [-F] [--small] [--threads THREADS] [-v]" in err
+    assert "[-q] [-h]" in err
+    assert "the following arguments are required: -r" in err
 
 
 def test_parser_noname(capsys):
@@ -36,7 +37,7 @@ def test_parser_noname(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "listfile -d dbpath -r respath".split())
+        annot.parse(parser, "-r respath".split())
     _, err = capsys.readouterr()
     assert ("You must specify your genomes dataset name in 4 characters with "
             "'-n name' option (type -h for more information). Or, if you do not want "
@@ -44,30 +45,30 @@ def test_parser_noname(capsys):
             "option '-Q") in err
 
 
-def test_parser_wrongname(capsys):
-    """
-    Test that when the script is called with a genome name with more than 4 characters,
-    it returns an error message
-    """
-    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
-    annot.build_parser(parser)
-    with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n genome".split())
-    _, err = capsys.readouterr()
-    assert ("The genome name must contain 4 characters. For example, this name can "
-            "correspond to the 2 first letters of genus, and 2 first letters of "
-            "species, e.g. ESCO for Escherichia Coli.") in err
+# def test_parser_wrongname(capsys):
+#     """
+#     Test that when the script is called with a genome name with more than 4 characters,
+#     it returns an error message
+#     """
+#     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+#     annot.build_parser(parser)
+#     with pytest.raises(SystemExit):
+#         annot.parse(parser, "list_file -d dbpath -r respath -n genome".split())
+#     _, err = capsys.readouterr()
+#     assert ("The genome name must contain 4 characters. For example, this name can "
+#             "correspond to the 2 first letters of genus, and 2 first letters of "
+#             "species, e.g. ESCO for Escherichia Coli.") in err
 
 
 def test_parser_negative_cont(capsys):
     """
-    Test that when the script is called with a limit of contig number higher than 9999,
+    Test that when the script is called with a limit of contig number <0,
     it returns an error message
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --nbcont -5".split())
+        annot.parse(parser, "-d dbpath -r respath -n g123 --nbcont -5".split())
     _, err = capsys.readouterr()
     assert "The maximum number of contigs allowed must be a positive number." in err
 
@@ -80,7 +81,7 @@ def test_parser_high_cont(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --nbcont 10005".split())
+        annot.parse(parser, "-Q -r respath -n g123 --nbcont 10005".split())
     _, err = capsys.readouterr()
     assert "We do not support genomes with more than 9999 contigs." in err
 
@@ -93,7 +94,7 @@ def test_parser_wrong_cont(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --nbcont 10.5".split())
+        annot.parse(parser, "-Q -r respath -n g123 --nbcont 10.5".split())
     _, err = capsys.readouterr()
     assert "argument --nbcont: invalid int value: 10.5" in err
 
@@ -106,7 +107,7 @@ def test_parser_wrongl90(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --l90 l90".split())
+        annot.parse(parser, "-n TOTO -r respath -n g123 --l90 l90".split())
     _, err = capsys.readouterr()
     assert "argument --l90: invalid int value: 'l90'" in err
 
@@ -119,9 +120,9 @@ def test_parser_wrong_cut(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --cutN 10.5".split())
+        annot.parse(parser, "-Q -d dbpath -r respath -n g123 --cutn 10.5".split())
     _, err = capsys.readouterr()
-    assert "argument --cutN: invalid int value: '10.5'" in err
+    assert "argument --cutn: invalid int value: '10.5'" in err
 
 
 def test_parser_wrong_thread(capsys):
@@ -132,9 +133,9 @@ def test_parser_wrong_thread(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --threads 10.5".split())
+        annot.parse(parser, "-Q -d dbpath -r respath -n g123 --threads 10.5".split())
     _, err = capsys.readouterr()
-    assert "argument --threads: invalid int value: '10.5'" in err
+    assert "argument --threads threads: invalid int value: 10.5" in err
 
 
 def test_parser_wrong_date(capsys):
@@ -145,7 +146,7 @@ def test_parser_wrong_date(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 --date 417".split())
+        annot.parse(parser, "-Q -d dbpath -r respath -n g123 --date 417".split())
     _, err = capsys.readouterr()
     assert ("The date must contain 4 characters. Usually, it contains 4 digits, "
             "corresponding to the month (2 digits) and year (2 digits).") in err
@@ -158,10 +159,10 @@ def test_parser_q_and_v(capsys):
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 -q -v".split())
+        annot.parse(parser, "-d dbpath -r respath -n g123 -q -v".split())
     _, err = capsys.readouterr()
-    assert (("Choose between a verbose output (-v) or quiet output (-q)."
-             " You cannot have both...")) in err
+    assert ("Choose between a verbose output (-v) or a quiet output (-q). "
+            "You cannot have both.") in err
 
 
 def test_parser_default():
@@ -171,8 +172,8 @@ def test_parser_default():
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
-    options = annot.parse(parser, "list_file -d dbpath -r respath -n g123".split())
-    assert options.list_file == "list_file"
+    options = annot.parse(parser, "-r respath -n g123 -l list_genomes -d dbpath".split())
+    assert options.list_file == "list_genomes"
     assert options.db_path == "dbpath"
     assert options.res_path == "respath"
     assert options.name == "g123"
@@ -183,6 +184,9 @@ def test_parser_default():
     assert options.date == time.strftime("%m%y")
     assert not options.force
     assert not options.qc_only
+    assert not options.from_info
+    assert not options.prodigal_only
+    assert not options.small
 
 
 def test_parser_values():
@@ -191,8 +195,9 @@ def test_parser_values():
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
-    options = annot.parse(parser, ("list_file -d dbpath -r respath -n g123 --l90 2 "
-                                   "--nbcont 10 --cutN 0 --threads 8 --date toto").split())
+    options = annot.parse(parser, ("-l list_file -d dbpath -r respath -n g123 --l90 2 "
+                                   "--nbcont 10 --cutn 0 --threads 2 --date toto "
+                                   "--prodigal -F").split())
     assert options.list_file == "list_file"
     assert options.db_path == "dbpath"
     assert options.res_path == "respath"
@@ -200,56 +205,187 @@ def test_parser_values():
     assert options.l90 == 2
     assert options.nbcont == 10
     assert options.cutn == 0
-    assert options.threads == 8
+    assert options.threads == 2
     assert options.date == "toto"
-    assert not options.force
+    assert options.force
     assert not options.qc_only
+    assert not options.from_info
+    assert options.prodigal_only
+    assert not options.small
 
 
-def test_parser_force():
+def test_parser_wrongforce(capsys):
     """
-    Test that when run with '-F' option, force is initialized to "--force".
+    Test that when run with '-F' option + a value, it returns an error message.
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
-    options = annot.parse(parser, "list_file -d dbpath -r respath -n g123 -F".split())
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-d dbpath -r respath -n g123 -F 10".split())
+    _, err = capsys.readouterr()
+    assert "unrecognized arguments: 10" in err
+
+
+def test_parser_qc():
+    """
+    Test that when run with '-Q' option (for QC only) and no name given for the genome, it
+    is set to "NONE"
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    options = annot.parse(parser, "-l list_file -d dbpath -r respath -Q".split())
     assert options.list_file == "list_file"
     assert options.db_path == "dbpath"
     assert options.res_path == "respath"
-    assert options.name == "g123"
+    assert options.name == "NONE"
     assert options.l90 == 100
     assert options.nbcont == 999
     assert options.cutn == 5
     assert options.threads == 1
     assert options.date == time.strftime("%m%y")
-    assert options.force
-    assert not options.qc_only
+    assert not options.force
+    assert options.qc_only
 
 
-def test_parser_wrongforce(capsys):
+def test_parser_prokka_small(capsys):
     """
-    Test that when run with '-F' option + a value, it returns an error message.
+    Test that when run with --small without --prodigal, error message
+    (--small only available with --prodigal)
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
     with pytest.raises(SystemExit):
-        annot.parse(parser, "list_file -d dbpath -r respath -n g123 -F 10".split())
+        annot.parse(parser, "-l list_file -d dbpath -r respath -Q --small".split())
     _, err = capsys.readouterr()
-    assert "unrecognized arguments: 10" in err
+    assert ("You cannot use --small option with prokka. Either use prodigal, "
+            "or remove this option.") in err
 
 
-def test_parser_qc():
+def test_parser_info_cutn(capsys):
     """
-    Test that when run with '-Q' option (for QC only) and no name given for the genome, it
-    is set to "NONE"
+    Test that when run with --info and --cutn x : error message
+    If we run from info file, will not touch the sequences.
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-l list_file -d dbpath -r respath -n name "
+                            "--info infofile --cutn 10".split())
+    _, err = capsys.readouterr()
+    assert ("If you provide a list of genomes with their calculated L90 and number of contigs, "
+            "PanACoTA will use the given sequences as is. It will not cut them. So, you cannot "
+            "use both --cutn and --info.") in err
+
+
+def test_parser_info_l90(capsys):
+    """
+    Test that when run with --info and --l90 x : error message
+    If we run from info file, will not touch the sequences.
     """
     parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
     annot.build_parser(parser)
-    options = annot.parse(parser, "list_file -d dbpath -r respath -Q".split())
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-l list_file -d dbpath -r respath -n name "
+                            "--info infofile --l90 20".split())
+    _, err = capsys.readouterr()
+    assert ("If you provide a list of genomes with their calculated L90 and number of contigs, "
+            "PanACoTA will use this information, and not re-calculate it. So, you cannot use "
+            "both --info and --l90") in err
+
+def test_parser_info_nbcont(capsys):
+    """
+    Test that when run with --info and --nbcont x : error message
+    If we run from info file, will not touch the sequences.
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-l list_file -d dbpath -r respath -n name "
+                            "--info infofile --nbcont 20".split())
+    _, err = capsys.readouterr()
+    assert ("If you provide a list of genomes with their calculated L90 and number of contigs, "
+            "PanACoTA will use this information, and not re-calculate it. So, you cannot use "
+            "both --info and --nbcont") in err
+
+
+def test_parser_noinfo_nolist(capsys):
+    """
+    Test that when run without --info nor -l : error message
+    Must provide one of them
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-d dbpath -r respath -n name --nbcont 20".split())
+    _, err = capsys.readouterr()
+    assert ("You must provide a list of genomes to annotate. Either raw genomes "
+            "(see -l option), or genomes with quality information (see --info option).") in err
+
+
+def test_parser_noinfo_nodbpath(capsys):
+    """
+    Test that when run without --info nor -d : error message
+    Needs a path to genomes to annotate!
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-r respath -n name --nbcont 20 -l listgenomes".split())
+    _, err = capsys.readouterr()
+    assert ("You must provide a path to your database genome sequences (-d <db_path>). "
+            "If you already have a LSTINFO file, it contains this db_path. Use it "
+            "with --info <lstinfo file> option.") in err
+
+
+def test_parser_info_dbpath(capsys):
+    """
+    Test that when run with both --info and -d : error message
+    Must know which genomes to annotate between the 2
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    with pytest.raises(SystemExit):
+        annot.parse(parser, "-r respath -n name --info file -d dbpath".split())
+    _, err = capsys.readouterr()
+    assert ("If you run from your LSTINFO file, this one already contains the path "
+            "of genomes to annotate. Remove -d <db_path> option.") in err
+
+
+def test_parser_filter(capsys):
+    """
+    Test that warnings are written (when will split l90 and/or nbcont)
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    options = annot.parse(parser, "-l list_file -d dbpath -r respath -Q --l90 10".split())
     assert options.list_file == "list_file"
     assert options.db_path == "dbpath"
     assert options.res_path == "respath"
     assert options.name == "NONE"
+    assert options.l90 == 10
+    assert options.nbcont == 999
+    assert options.cutn == 5
+    assert options.threads == 1
+    assert options.date == time.strftime("%m%y")
+    assert not options.force
+    assert options.qc_only
+    stdout, _ = capsys.readouterr()
+    print(stdout)
+    assert (" !! Your genomes will be filtered, and only the ones with 'L90' <= 10 and 'number of contigs' < 999 will be kept. If you want to change those thresholds, use '--l90' and '--nbcont' options.") in stdout
+
+
+def test_parser_nosplit(capsys):
+    """
+    Test that warnings are written (when will split l90 and/or nbcont)
+    """
+    parser = argparse.ArgumentParser(description="Annotate all genomes", add_help=False)
+    annot.build_parser(parser)
+    options = annot.parse(parser, "--info infofile -r respath -Q".split())
+    assert not options.list_file
+    assert not options.db_path
+    assert options.from_info == "infofile"
+    assert options.res_path == "respath"
+    assert options.name == "NONE"
     assert options.l90 == 100
     assert options.nbcont == 999
     assert options.cutn == 5
@@ -257,3 +393,7 @@ def test_parser_qc():
     assert options.date == time.strftime("%m%y")
     assert not options.force
     assert options.qc_only
+    stdout, _ = capsys.readouterr()
+    print(stdout)
+    assert (" !! Your sequences will be used as is by PanACoTA. Be sure you already split your sequences at each row of X 'N' if needed.") in stdout
+    assert ("PanACoTA will use the values (L90, nbcont) given in your info file. It will ignore the genomes for which those values are incorrect. It will also ignore genomes with more than 999 contigs.")