# Copyright 2009 by Peter Cock.  All rights reserved.
# This code is part of the Biopython distribution and governed by its
# license.  Please see the LICENSE file that should have been included
# as part of this package.
"""Unittests for the Seq objects."""

import array
import unittest
import warnings

from Bio import BiopythonWarning
from Bio import SeqIO
from Bio.Data.CodonTable import CodonTable
from Bio.Data.CodonTable import TranslationError
from Bio.Data.IUPACData import ambiguous_dna_values
from Bio.Data.IUPACData import ambiguous_rna_values
from Bio.Seq import _UndefinedSequenceData
from Bio.Seq import MutableSeq
from Bio.Seq import Seq
from Bio.Seq import translate
from Bio.Seq import UndefinedSequenceError
from Bio.SeqRecord import SeqRecord

try:
    import numpy as np
except ImportError:
    np = None

# This is just the standard table with less stop codons
# (replaced with coding for O as an artificial example)

# Turn black code style off
# fmt: off

special_table = CodonTable(forward_table={
    "TTT": "F", "TTC": "F", "TTA": "L", "TTG": "L",
    "TCT": "S", "TCC": "S", "TCA": "S", "TCG": "S",
    "TAT": "Y", "TAC": "Y", "TAA": "O",
    "TGT": "C", "TGC": "C", "TGA": "O", "TGG": "W",
    "CTT": "L", "CTC": "L", "CTA": "L", "CTG": "L",
    "CCT": "P", "CCC": "P", "CCA": "P", "CCG": "P",
    "CAT": "H", "CAC": "H", "CAA": "Q", "CAG": "Q",
    "CGT": "R", "CGC": "R", "CGA": "R", "CGG": "R",
    "ATT": "I", "ATC": "I", "ATA": "I", "ATG": "M",
    "ACT": "T", "ACC": "T", "ACA": "T", "ACG": "T",
    "AAT": "N", "AAC": "N", "AAA": "K", "AAG": "K",
    "AGT": "S", "AGC": "S", "AGA": "R", "AGG": "R",
    "GTT": "V", "GTC": "V", "GTA": "V", "GTG": "V",
    "GCT": "A", "GCC": "A", "GCA": "A", "GCG": "A",
    "GAT": "D", "GAC": "D", "GAA": "E", "GAG": "E",
    "GGT": "G", "GGC": "G", "GGA": "G", "GGG": "G"},
    start_codons=["TAA", "TAG", "TGA"],
    stop_codons=["TAG"],
)

Chilodonella_uncinata_table = CodonTable(forward_table={
    "TTT": "F", "TTC": "F", "TTA": "L", "TTG": "L",
    "TCT": "S", "TCC": "S", "TCA": "S", "TCG": "S",
    "TAT": "Y", "TAC": "Y",             "TAG": "Q",  # noqa: E241
    "TGT": "C", "TGC": "C", "TGA": "W", "TGG": "W",
    "CTT": "L", "CTC": "L", "CTA": "L", "CTG": "L",
    "CCT": "P", "CCC": "P", "CCA": "P", "CCG": "P",
    "CAT": "H", "CAC": "H", "CAA": "Q", "CAG": "Q",
    "CGT": "R", "CGC": "R", "CGA": "R", "CGG": "R",
    "ATT": "I", "ATC": "I", "ATA": "I", "ATG": "M",
    "ACT": "T", "ACC": "T", "ACA": "T", "ACG": "T",
    "AAT": "N", "AAC": "N", "AAA": "K", "AAG": "K",
    "AGT": "S", "AGC": "S", "AGA": "R", "AGG": "R",
    "GTT": "V", "GTC": "V", "GTA": "V", "GTG": "V",
    "GCT": "A", "GCC": "A", "GCA": "A", "GCG": "A",
    "GAT": "D", "GAC": "D", "GAA": "E", "GAG": "E",
    "GGT": "G", "GGC": "G", "GGA": "G", "GGG": "G"},
    start_codons=["ATG"],
    stop_codons=["TAA"],
)

# Turn black code style on
# fmt: on


class StringMethodTests(unittest.TestCase):
    _examples = [
        # These are length 9, a multiple of 3 for translation tests:
        Seq("ACGTGGGGT"),
        Seq("ACGUGGGGU"),
        Seq("GG"),
        Seq("A"),
    ]
    for seq in _examples[:]:
        _examples.append(MutableSeq(seq))
    _start_end_values = [0, 1, 2, 1000, -1, -2, -999, None]
    if np is not None:
        # test with numpy integers (np.int32, np.int64 etc.)
        _start_end_values.extend(np.array([3, 5]))

    def _test_method(self, method_name, start_end=False):
        """Check this method matches the plain string's method."""
        self.assertIsInstance(method_name, str)
        for example1 in self._examples:
            if not hasattr(example1, method_name):
                # e.g. MutableSeq does not support transcribe
                continue
            str1 = str(example1)

            for example2 in self._examples:
                if not hasattr(example2, method_name):
                    # e.g. MutableSeq does not support transcribe
                    continue
                str2 = str(example2)

                try:
                    i = getattr(example1, method_name)(str2)
                except ValueError:
                    i = ValueError
                try:
                    j = getattr(str1, method_name)(str2)
                except ValueError:
                    j = ValueError
                self.assertEqual(i, j, f"{example1!r}.{method_name}({str2!r})")
                try:
                    i = getattr(example1, method_name)(example2)
                except ValueError:
                    i = ValueError
                try:
                    j = getattr(str1, method_name)(str2)
                except ValueError:
                    j = ValueError
                self.assertEqual(i, j, f"{example1!r}.{method_name}({example2!r})")

                if start_end:
                    for start in self._start_end_values:
                        try:
                            i = getattr(example1, method_name)(str2, start)
                        except ValueError:
                            i = ValueError
                        try:
                            j = getattr(str1, method_name)(str2, start)
                        except ValueError:
                            j = ValueError
                        self.assertEqual(
                            i, j, f"{example1!r}.{method_name}({str2!r}, {start})"
                        )

                        for end in self._start_end_values:
                            try:
                                i = getattr(example1, method_name)(str2, start, end)
                            except ValueError:
                                i = ValueError
                            try:
                                j = getattr(str1, method_name)(str2, start, end)
                            except ValueError:
                                j = ValueError
                            self.assertEqual(
                                i,
                                j,
                                f"{example1!r}.{method_name}({str2!r}, {start}, {end})",
                            )

    def test_str_count(self):
        """Check matches the python string count method."""
        self._test_method("count", start_end=True)
        self.assertEqual(Seq("AC777GT").count("7"), 3)
        self.assertRaises(TypeError, Seq("AC777GT").count, 7)
        self.assertRaises(TypeError, Seq("AC777GT").count, None)

    def test_count_overlap(self):
        """Check count_overlap exception matches python string count method."""
        self.assertEqual(Seq("AC777GT").count("77"), 1)
        self.assertEqual(Seq("AC777GT").count_overlap("77"), 2)
        self.assertEqual(Seq("AC777GT").count_overlap("7"), 3)
        self.assertRaises(TypeError, Seq("AC777GT").count_overlap, 7)
        self.assertRaises(TypeError, Seq("AC777GT").count_overlap, None)

    def test_str_count_overlap_GG(self):
        """Check our count_overlap method using GG."""
        # Testing with self._examples
        expected = [
            3,
            3,
            1,
            0,  # Seq() Tests
            3,
            3,
            1,
            0,  # MutableSeq() Tests
        ]

        assert len(self._examples) == len(expected)

        for seq, exp in zip(self._examples, expected):
            # Using search term GG as a string
            self.assertEqual(seq.count_overlap("GG"), exp)
            self.assertEqual(seq.count_overlap("G" * 5), 0)
            # Using search term GG as a Seq
            self.assertEqual(seq.count_overlap(Seq("GG")), exp)
            self.assertEqual(seq.count_overlap(Seq("G" * 5)), 0)
            # Using search term GG as a MutableSeq
            self.assertEqual(seq.count_overlap(MutableSeq("GG")), exp)
            self.assertEqual(seq.count_overlap(MutableSeq("G" * 5)), 0)

    def test_count_overlap_start_end_GG(self):
        """Check our count_overlap method using GG with variable ends and starts."""
        # Testing Seq() and MutableSeq() with variable start and end arguments
        start_end_exp = [
            (1, 7, 3),
            (3, None, 3),
            (3, 6, 2),
            (4, 6, 1),
            (4, -1, 2),
            (-5, None, 2),
            (-5, 7, 2),
            (7, -5, 0),
            (-100, None, 3),
            (None, 100, 3),
            (-100, 1000, 3),
        ]

        testing_seq = "GTAGGGGAG"

        for start, end, exp in start_end_exp:
            self.assertEqual(Seq(testing_seq).count_overlap("GG", start, end), exp)
            self.assertEqual(
                MutableSeq(testing_seq).count_overlap("GG", start, end), exp
            )

        # Testing Seq() and MutableSeq() with a more heterogeneous sequenece
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("GG"), 5)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("GG"), 5)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("GG", 2, 8), 1)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("GG", 2, 8), 1)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("GG", -11, 6), 3)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("GG", -11, 6), 3)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("GG", 7, 2), 0)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("GG", 7, 2), 0)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("GG", -2, -10), 0)

    def test_str_count_overlap_NN(self):
        """Check our count_overlap method using NN."""
        # Testing with self._examples
        for seq in self._examples:
            # Using search term NN as a string
            self.assertEqual(seq.count_overlap("NN"), 0)
            self.assertEqual(seq.count_overlap("N" * 13), 0)
            # Using search term NN as a Seq
            self.assertEqual(seq.count_overlap(Seq("NN")), 0)
            self.assertEqual(seq.count_overlap(Seq("N" * 13)), 0)

    def test_count_overlap_start_end_NN(self):
        """Check our count_overlap method using NN with variable ends and starts."""
        # Testing Seq() and MutableSeq() with variable start and end arguments
        start_end_exp = [
            (1, 7, 0),
            (3, None, 0),
            (3, 6, 0),
            (4, 6, 0),
            (4, -1, 0),
            (-5, None, 0),
            (-5, 7, 0),
            (7, -5, 0),
            (-100, None, 0),
            (None, 100, 0),
            (-100, 1000, 0),
        ]

        testing_seq = "GTAGGGGAG"

        for start, end, exp in start_end_exp:
            self.assertEqual(Seq(testing_seq).count_overlap("NN", start, end), exp)
            self.assertEqual(
                MutableSeq(testing_seq).count_overlap("NN", start, end), exp
            )

        # Testing Seq() and MutableSeq() with a more heterogeneous sequenece
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("NN"), 0)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("NN"), 0)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("NN", 2, 8), 0)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("NN", 2, 8), 0)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("NN", -11, 6), 0)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("NN", -11, 6), 0)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("NN", 7, 2), 0)
        self.assertEqual(MutableSeq("GGGTGGTAGGG").count_overlap("NN", 7, 2), 0)
        self.assertEqual(Seq("GGGTGGTAGGG").count_overlap("NN", -10, -2), 0)

    def test_str_find(self):
        """Check matches the python string find method."""
        self._test_method("find", start_end=True)
        self.assertEqual(Seq("AC7GT").find("7"), 2)
        self.assertRaises(TypeError, Seq("AC7GT").find, 7)
        self.assertRaises(TypeError, Seq("ACGT").find, None)

    def test_str_rfind(self):
        """Check matches the python string rfind method."""
        self._test_method("rfind", start_end=True)
        self.assertEqual(Seq("AC7GT").rfind("7"), 2)
        self.assertRaises(TypeError, Seq("AC7GT").rfind, 7)
        self.assertRaises(TypeError, Seq("ACGT").rfind, None)

    def test_str_index(self):
        """Check matches the python string index method."""
        self._test_method("index", start_end=True)
        self.assertEqual(Seq("AC7GT").index("7"), 2)
        self.assertRaises(TypeError, Seq("AC7GT").index, 7)
        self.assertRaises(TypeError, Seq("ACGT").index, None)
        self.assertEqual(MutableSeq("AC7GT").index("7"), 2)
        self.assertRaises(TypeError, MutableSeq("AC7GT").index, 7)
        self.assertRaises(TypeError, MutableSeq("ACGT").index, None)

    def test_str_rindex(self):
        """Check matches the python string rindex method."""
        self._test_method("rindex", start_end=True)
        self.assertEqual(Seq("AC7GT").rindex("7"), 2)
        self.assertRaises(TypeError, Seq("AC7GT").rindex, 7)
        self.assertRaises(TypeError, Seq("ACGT").rindex, None)
        self.assertEqual(MutableSeq("AC7GT").rindex("7"), 2)
        self.assertRaises(TypeError, MutableSeq("AC7GT").rindex, 7)
        self.assertRaises(TypeError, MutableSeq("ACGT").rindex, None)

    def test_str_startswith(self):
        """Check matches the python string startswith method."""
        self._test_method("startswith", start_end=True)
        self.assertTrue("ABCDE".startswith(("ABE", "OBE", "ABC")))
        self.assertRaises(TypeError, Seq("ACGT").startswith, None)
        self.assertRaises(TypeError, MutableSeq("ACGT").startswith, None)

        # Now check with a tuple of sub sequences
        for example1 in self._examples:
            subs = tuple(
                example1[start : start + 2] for start in range(0, len(example1) - 2, 3)
            )
            subs_str = tuple(str(s) for s in subs)

            self.assertEqual(
                str(example1).startswith(subs_str), example1.startswith(subs)
            )
            self.assertEqual(
                str(example1).startswith(subs_str), example1.startswith(subs_str)
            )  # strings!
            self.assertEqual(
                str(example1).startswith(subs_str, 3), example1.startswith(subs, 3)
            )
            self.assertEqual(
                str(example1).startswith(subs_str, 2, 6),
                example1.startswith(subs, 2, 6),
            )

    def test_str_endswith(self):
        """Check matches the python string endswith method."""
        self._test_method("endswith", start_end=True)
        self.assertTrue("ABCDE".endswith(("ABE", "OBE", "CDE")))
        self.assertRaises(TypeError, Seq("ACGT").endswith, None)

        # Now check with a tuple of sub sequences
        for example1 in self._examples:
            subs = tuple(
                example1[start : start + 2] for start in range(0, len(example1) - 2, 3)
            )
            subs_str = tuple(str(s) for s in subs)

            self.assertEqual(str(example1).endswith(subs_str), example1.endswith(subs))
            self.assertEqual(
                str(example1).startswith(subs_str), example1.startswith(subs_str)
            )  # strings!
            self.assertEqual(
                str(example1).endswith(subs_str, 3), example1.endswith(subs, 3)
            )
            self.assertEqual(
                str(example1).endswith(subs_str, 2, 6), example1.endswith(subs, 2, 6)
            )

    def test_str_strip(self):
        """Check matches the python string strip method."""
        self._test_method("strip")
        s = Seq(" ACGT ")
        m = MutableSeq(" ACGT ")
        self.assertEqual(s.strip(), "ACGT")
        self.assertRaises(TypeError, s.strip, 7)
        self.assertEqual(s, " ACGT ")
        self.assertEqual(m.strip(), "ACGT")
        self.assertRaises(TypeError, m.strip, 7)
        self.assertEqual(m, " ACGT ")
        self.assertEqual(m.strip(inplace=True), "ACGT")
        self.assertEqual(m, "ACGT")
        with self.assertRaises(TypeError) as cm:
            s.strip("ACGT", inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")

    def test_str_lstrip(self):
        """Check matches the python string lstrip method."""
        self._test_method("lstrip")
        s = Seq(" ACGT ")
        m = MutableSeq(" ACGT ")
        self.assertEqual(s.lstrip(), "ACGT ")
        self.assertRaises(TypeError, s.lstrip, 7)
        self.assertEqual(s, " ACGT ")
        self.assertEqual(m.lstrip(), "ACGT ")
        self.assertRaises(TypeError, m.lstrip, 7)
        self.assertEqual(m, " ACGT ")
        self.assertEqual(m.lstrip(inplace=True), "ACGT ")
        self.assertEqual(m, "ACGT ")
        with self.assertRaises(TypeError) as cm:
            s.lstrip("ACGT", inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")

    def test_str_removeprefix(self):
        """Check matches the python string removeprefix method."""
        self.assertRaises(TypeError, Seq("ACGT").removeprefix, 7)
        self.assertRaises(TypeError, Seq("ACGT").removeprefix, 7.0)
        self.assertRaises(TypeError, Seq("ACGT").removeprefix, None)
        self.assertRaises(
            UndefinedSequenceError, Seq(data=None, length=1000).removeprefix, 7.0
        )
        self.assertRaises(
            UndefinedSequenceError, Seq(data=None, length=1000).removeprefix, "A"
        )

    def test_str_removesuffix(self):
        """Check matches the python string removesuffix method."""
        self.assertRaises(TypeError, Seq("ACGT").removesuffix, 7)
        self.assertRaises(TypeError, Seq("ACGT").removesuffix, 7.0)
        self.assertRaises(TypeError, Seq("ACGT").removesuffix, None)
        self.assertRaises(
            UndefinedSequenceError, Seq(data=None, length=1000).removesuffix, 7.0
        )
        self.assertRaises(
            UndefinedSequenceError, Seq(data=None, length=1000).removesuffix, "A"
        )

    def test_str_rstrip(self):
        """Check matches the python string rstrip method."""
        self._test_method("rstrip")
        s = Seq(" ACGT ")
        m = MutableSeq(" ACGT ")
        self.assertEqual(s.rstrip(), " ACGT")
        self.assertRaises(TypeError, s.rstrip, 7)
        self.assertEqual(s, " ACGT ")
        self.assertEqual(m.rstrip(), " ACGT")
        self.assertRaises(TypeError, m.rstrip, 7)
        self.assertEqual(m, " ACGT ")
        self.assertEqual(m.rstrip(inplace=True), " ACGT")
        self.assertEqual(m, " ACGT")
        with self.assertRaises(TypeError) as cm:
            s.rstrip("ACGT", inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")

    def test_str_split(self):
        """Check matches the python string split method."""
        self._test_method("split")
        self.assertEqual(Seq("AC7GT").split("7"), "AC7GT".split("7"))
        self.assertRaises(TypeError, Seq("AC7GT").split, 7)
        self.assertEqual(MutableSeq("AC7GT").split("7"), "AC7GT".split("7"))
        self.assertRaises(TypeError, MutableSeq("AC7GT").split, 7)

    def test_str_rsplit(self):
        """Check matches the python string rsplit method."""
        self._test_method("rsplit")
        self.assertEqual(Seq("AC7GT").rsplit("7"), "AC7GT".rsplit("7"))
        self.assertRaises(TypeError, Seq("AC7GT").rsplit, 7)
        self.assertEqual(MutableSeq("AC7GT").rsplit("7"), "AC7GT".rsplit("7"))
        self.assertRaises(TypeError, MutableSeq("AC7GT").rsplit, 7)

    def test_str_length(self):
        """Check matches the python string __len__ method."""
        for example1 in self._examples:
            str1 = str(example1)
            self.assertEqual(len(example1), len(str1))

    def test_str_upper(self):
        """Check matches the python string upper method."""
        for example1 in self._examples:
            str1 = str(example1)
            example1 = example1.upper()
            self.assertEqual(example1, str1.upper())
        with self.assertRaises(TypeError) as cm:
            Seq("abcd").upper(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")

    def test_str_lower(self):
        """Check matches the python string lower method."""
        for example1 in self._examples:
            str1 = str(example1)
            example1 = example1.lower()
            self.assertEqual(example1, str1.lower())
        with self.assertRaises(TypeError) as cm:
            Seq("ABCD").lower(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")

    def test_str_isupper(self):
        """Check matches the python string isupper method."""
        for example1 in self._examples:
            str1 = str(example1)
            if isinstance(example1, _UndefinedSequenceData):
                with self.assertRaises(UndefinedSequenceError):
                    example1.isupper()
            else:
                example1 = example1.isupper()
            self.assertEqual(example1, str1.isupper())

    def test_str_islower(self):
        """Check matches the python string islower method."""
        for example1 in self._examples:
            str1 = str(example1)
            if isinstance(example1, _UndefinedSequenceData):
                with self.assertRaises(UndefinedSequenceError):
                    example1.islower()
            else:
                example1 = example1.islower()
            self.assertEqual(example1, str1.islower())

    def test_str_replace(self):
        """Check matches the python string replace method."""
        s = Seq("AAGTACGT")
        m = MutableSeq("AAGTACGT")
        t = s.replace("AC", "XYZ")
        self.assertEqual(s, "AAGTACGT")
        self.assertEqual(t, "AAGTXYZGT")
        self.assertRaises(TypeError, s.replace, "AC", "XYZ", True)
        t = m.replace("AC", "XYZ")
        self.assertEqual(m, "AAGTACGT")
        self.assertEqual(t, "AAGTXYZGT")
        t = m.replace("AC", "XYZ", inplace=True)
        self.assertEqual(m, "AAGTXYZGT")
        self.assertEqual(t, "AAGTXYZGT")
        u = Seq(None, length=20)
        t = u.replace("AT", "CG")
        self.assertEqual(repr(t), "Seq(None, length=20)")
        with self.assertRaises(UndefinedSequenceError) as cm:
            u.replace("AT", "ACGT")  # unequal length
        self.assertEqual(str(cm.exception), "Sequence content is undefined")
        records = SeqIO.parse("TwoBit/sequence.littleendian.2bit", "twobit")
        v = records["seq6"].seq  # ACGTacgtNNNNnn, lazy-loaded
        s = Seq("xyzACGTacgtNNNNnnXYZ")
        t = s.replace(v, "KLM")
        self.assertEqual(t, "xyzKLMXYZ")
        s = Seq("xyzKLMabcd")
        t = s.replace("KLM", v)
        self.assertEqual(t, "xyzACGTacgtNNNNnnabcd")

    def test_str_encode(self):
        """Check matches the python string encode method."""
        for example1 in self._examples:
            str1 = str(example1)
            self.assertEqual(bytes(example1), str1.encode("ascii"))

    def test_str_hash(self):
        for example1 in self._examples:
            if isinstance(example1, MutableSeq):
                continue
            with warnings.catch_warnings():
                # Silence change in behaviour warning
                warnings.simplefilter("ignore", BiopythonWarning)
                self.assertEqual(
                    hash(str(example1)),
                    hash(example1),
                    "Hash mismatch, %r for %r vs %r for %r"
                    % (hash(str(example1)), id(example1), hash(example1), example1),
                )

    def test_str_comparison(self):
        for example1 in self._examples:
            for example2 in self._examples:
                with warnings.catch_warnings():
                    self.assertEqual(
                        str(example1) == str(example2),
                        example1 == example2,
                        f"Checking {example1!r} == {example2!r}",
                    )
                    self.assertEqual(
                        str(example1) != str(example2),
                        example1 != example2,
                        f"Checking {example1!r} != {example2!r}",
                    )
                    self.assertEqual(
                        str(example1) < str(example2),
                        example1 < example2,
                        f"Checking {example1!r} < {example2!r}",
                    )
                    self.assertEqual(
                        str(example1) <= str(example2),
                        example1 <= example2,
                        f"Checking {example1!r} <= {example2!r}",
                    )
                    self.assertEqual(
                        str(example1) > str(example2),
                        example1 > example2,
                        f"Checking {example1!r} > {example2!r}",
                    )
                    self.assertEqual(
                        str(example1) >= str(example2),
                        example1 >= example2,
                        f"Checking {example1!r} >= {example2!r}",
                    )

    def test_str_getitem(self):
        """Check slicing and indexing works like a string."""
        for example1 in self._examples:
            str1 = str(example1)
            for i in self._start_end_values:
                if i is not None and abs(i) < len(example1):
                    self.assertEqual(example1[i], str1[i])
                self.assertEqual(example1[:i], str1[:i])
                self.assertEqual(example1[i:], str1[i:])
                for j in self._start_end_values:
                    self.assertEqual(example1[i:j], str1[i:j])
                    for step in range(-3, 4):
                        if step == 0:
                            with self.assertRaises(ValueError) as cm:
                                example1[i:j:step]
                            self.assertEqual(
                                str(cm.exception), "slice step cannot be zero"
                            )
                        else:
                            self.assertEqual(example1[i:j:step], str1[i:j:step])
        u = Seq(None, length=0)
        self.assertEqual(u, "")

    def test_search(self):
        """Check the search method of Seq objects."""
        s = Seq("ACGTACGT")
        matches = s.search(["CGT", Seq("CG"), b"ACGT", bytearray(b"GTA")])
        self.assertEqual(next(matches), (0, "ACGT"))
        self.assertEqual(next(matches), (1, "CGT"))
        self.assertEqual(next(matches), (1, "CG"))
        self.assertEqual(next(matches), (2, "GTA"))
        self.assertEqual(next(matches), (4, "ACGT"))
        self.assertEqual(next(matches), (5, "CGT"))
        self.assertEqual(next(matches), (5, "CG"))
        self.assertRaises(StopIteration, next, matches)
        s = MutableSeq("ACGTACGT")
        matches = s.search(["CGT", Seq("CG"), b"ACGT", bytearray(b"GTA")])
        self.assertEqual(next(matches), (0, "ACGT"))
        self.assertEqual(next(matches), (1, "CGT"))
        self.assertEqual(next(matches), (1, "CG"))
        self.assertEqual(next(matches), (2, "GTA"))
        self.assertEqual(next(matches), (4, "ACGT"))
        self.assertEqual(next(matches), (5, "CGT"))
        self.assertEqual(next(matches), (5, "CG"))
        self.assertRaises(StopIteration, next, matches)

    def test_search_final_position(self):
        """Check search includes the final valid starting position."""
        substrings = ("E", Seq("E"), MutableSeq("E"), b"E", bytearray(b"E"))
        empty_substrings = ("", Seq(""), MutableSeq(""), b"", bytearray(b""))
        for sequence_type in (Seq, MutableSeq):
            sequence = sequence_type("ABCDE")
            for substring in substrings:
                with self.subTest(
                    sequence_type=sequence_type, substring_type=type(substring)
                ):
                    self.assertEqual(list(sequence.search([substring])), [(4, "E")])

            self.assertEqual(
                list(sequence.search(["E", "DE", "CDE", "ABCDE"])),
                [(0, "ABCDE"), (2, "CDE"), (3, "DE"), (4, "E")],
            )
            self.assertEqual(list(sequence_type("A").search(["A"])), [(0, "A")])
            self.assertEqual(list(sequence_type("").search(["A"])), [])
            self.assertEqual(list(sequence.search([])), [])

            for substring in empty_substrings:
                with self.subTest(
                    sequence_type=sequence_type,
                    empty_substring_type=type(substring),
                ):
                    self.assertEqual(
                        list(sequence.search([substring])),
                        [(index, "") for index in range(len(sequence) + 1)],
                    )
                    self.assertEqual(
                        list(sequence_type("").search([substring])), [(0, "")]
                    )

    def test_MutableSeq_setitem(self):
        """Check setting sequence contents of a MutableSeq object."""
        m = MutableSeq("ABCD")
        m[1] = "X"
        self.assertEqual(m, "AXCD")
        m[1:3] = MutableSeq("XY")
        self.assertEqual(m, "AXYD")
        m[1:3] = Seq("KL")
        self.assertEqual(m, "AKLD")
        m[1:3] = Seq("bc")
        self.assertEqual(m, "AbcD")
        with self.assertRaises(TypeError) as cm:
            m[1:3] = 9
        self.assertEqual(str(cm.exception), "received unexpected type 'int'")

    def test_MutableSeq_extend(self):
        """Check extending a MutableSeq object."""
        m = MutableSeq("ABCD")
        m.extend(MutableSeq("xyz"))
        self.assertEqual(m, "ABCDxyz")
        m.extend(Seq("KLM"))
        self.assertEqual(m, "ABCDxyzKLM")
        m.extend("PQRST")
        self.assertEqual(m, "ABCDxyzKLMPQRST")
        with self.assertRaises(TypeError) as cm:
            m.extend(5)
        self.assertEqual(str(cm.exception), "expected a string, Seq or MutableSeq")

    def test_tomutable(self):
        """Check creating a MutableSeq object."""
        for example1 in self._examples:
            mut = MutableSeq(example1)
            self.assertIsInstance(mut, MutableSeq)
            self.assertEqual(mut, example1)

    def test_toseq(self):
        """Check creating a Seq object."""
        for example1 in self._examples:
            seq = Seq(example1)
            self.assertIsInstance(seq, Seq)
            self.assertEqual(seq, example1)

    def test_the_complement(self):
        """Check obj.complement() method."""
        mapping = ""
        for example1 in self._examples:
            if isinstance(example1, MutableSeq):
                continue
            if "u" in example1 or "U" in example1:
                comp = example1.complement_rna()
            else:
                comp = example1.complement()
            str1 = str(example1)
            if "U" in str1 or "u" in str1:
                mapping = str.maketrans("ACGUacgu", "UGCAugca")
            else:
                # Default to DNA, e.g. complement("A") -> "T" not "U"
                mapping = str.maketrans("ACGTacgt", "TGCAtgca")
            self.assertEqual(str1.translate(mapping), comp)
        with self.assertRaises(TypeError) as cm:
            Seq("ACGT").complement(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        with self.assertRaises(TypeError) as cm:
            Seq("ACGT").complement_rna(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        self.assertEqual(
            repr(Seq(None, length=20).complement()), "Seq(None, length=20)"
        )
        self.assertEqual(
            repr(Seq(None, length=20).complement_rna()), "Seq(None, length=20)"
        )

    def test_the_reverse_complement(self):
        """Check obj.reverse_complement() method."""
        mapping = ""
        for example1 in self._examples:
            if isinstance(example1, MutableSeq):
                continue
            if "u" in example1 or "U" in example1:
                comp = example1.reverse_complement_rna()
            else:
                comp = example1.reverse_complement()
            str1 = str(example1)
            if "U" in str1 or "u" in str1:
                mapping = str.maketrans("ACGUacgu", "UGCAugca")
            else:
                # Defaults to DNA, so reverse_complement("A") --> "T" not "U"
                mapping = str.maketrans("ACGTacgt", "TGCAtgca")
            self.assertEqual(str1.translate(mapping)[::-1], comp)
        with self.assertRaises(TypeError) as cm:
            Seq("ACGT").reverse_complement(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        with self.assertRaises(TypeError) as cm:
            Seq("ACGT").reverse_complement_rna(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        self.assertEqual(
            repr(Seq(None, length=20).reverse_complement()), "Seq(None, length=20)"
        )
        self.assertEqual(
            repr(Seq(None, length=20).reverse_complement_rna()), "Seq(None, length=20)"
        )

    def test_the_transcription(self):
        """Check obj.transcribe() method."""
        mapping = ""
        for example1 in self._examples:
            if isinstance(example1, MutableSeq):
                continue
            tran = example1.transcribe()
            str1 = str(example1)
            if len(str1) % 3 != 0:
                # TODO - Check for or silence the expected warning?
                continue
            self.assertEqual(str1.replace("T", "U").replace("t", "u"), tran)
        with self.assertRaises(TypeError) as cm:
            Seq("ACGT").transcribe(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        self.assertEqual(
            repr(Seq(None, length=20).transcribe()), "Seq(None, length=20)"
        )

    def test_the_back_transcription(self):
        """Check obj.back_transcribe() method."""
        mapping = ""
        for example1 in self._examples:
            if isinstance(example1, MutableSeq):
                continue
            tran = example1.back_transcribe()
            str1 = str(example1)
            self.assertEqual(str1.replace("U", "T").replace("u", "t"), tran)
        with self.assertRaises(TypeError) as cm:
            Seq("ACGU").back_transcribe(inplace=True)
        self.assertEqual(str(cm.exception), "Sequence is immutable")
        self.assertEqual(
            repr(Seq(None, length=20).back_transcribe()), "Seq(None, length=20)"
        )

    def test_the_translate(self):
        """Check obj.translate() method."""
        mapping = ""
        for example1 in self._examples:
            if len(example1) % 3 != 0:
                # TODO - Check for or silence the expected warning?
                continue
            tran = example1.translate()
            # Try with positional vs named argument:
            self.assertEqual(example1.translate(11), example1.translate(table=11))

            # TODO - check the actual translation, and all the optional args
        with self.assertRaises(ValueError):
            Seq("ABCD").translate("XYZ")
        with self.assertWarns(BiopythonWarning) as cm:
            Seq(None, length=20).translate()
        self.assertEqual(
            str(cm.warning),
            "Partial codon, len(sequence) not a multiple of three. This may become an error in future.",
        )

    def test_the_translation_of_stops(self):
        """Check obj.translate() method with stop codons."""
        misc_stops = "TAATAGTGAAGAAGG"
        nuc = Seq(misc_stops)
        self.assertEqual("***RR", nuc.translate())
        self.assertEqual("***RR", nuc.translate(1))
        self.assertEqual("***RR", nuc.translate("SGC0"))
        self.assertEqual("**W**", nuc.translate(table=2))
        self.assertEqual("**WRR", nuc.translate(table="Yeast Mitochondrial"))
        self.assertEqual("**WSS", nuc.translate(table=5))
        self.assertEqual("**WSS", nuc.translate(table=9))
        self.assertEqual("**CRR", nuc.translate(table="Euplotid Nuclear"))
        self.assertEqual("***RR", nuc.translate(table=11))
        self.assertEqual("***RR", nuc.translate(table="11"))
        self.assertEqual("***RR", nuc.translate(table="Bacterial"))
        self.assertEqual("**GRR", nuc.translate(table=25))
        self.assertEqual("", nuc.translate(to_stop=True))
        self.assertEqual("O*ORR", nuc.translate(table=special_table))
        self.assertEqual("*QWRR", nuc.translate(table=Chilodonella_uncinata_table))
        nuc = MutableSeq(misc_stops)
        self.assertEqual("***RR", nuc.translate())
        self.assertEqual("***RR", nuc.translate(1))
        self.assertEqual("***RR", nuc.translate("SGC0"))
        self.assertEqual("**W**", nuc.translate(table=2))
        self.assertEqual("**WRR", nuc.translate(table="Yeast Mitochondrial"))
        self.assertEqual("**WSS", nuc.translate(table=5))
        self.assertEqual("**WSS", nuc.translate(table=9))
        self.assertEqual("**CRR", nuc.translate(table="Euplotid Nuclear"))
        self.assertEqual("***RR", nuc.translate(table=11))
        self.assertEqual("***RR", nuc.translate(table="11"))
        self.assertEqual("***RR", nuc.translate(table="Bacterial"))
        self.assertEqual("**GRR", nuc.translate(table=25))
        self.assertEqual("", nuc.translate(to_stop=True))
        self.assertEqual("O*ORR", nuc.translate(table=special_table))
        self.assertEqual("*QWRR", nuc.translate(table=Chilodonella_uncinata_table))
        # These test the Bio.Seq.translate() function - move these?:
        self.assertEqual(
            "*QWRR", translate(str(nuc), table=Chilodonella_uncinata_table)
        )
        self.assertEqual("O*ORR", translate(str(nuc), table=special_table))
        self.assertEqual("", translate(str(nuc), to_stop=True))
        self.assertEqual("***RR", translate(str(nuc), table="Bacterial"))
        self.assertEqual("***RR", translate(str(nuc), table="11"))
        self.assertEqual("***RR", translate(str(nuc), table=11))
        self.assertEqual("**W**", translate(str(nuc), table=2))
        self.assertEqual(Seq("TAT").translate(), "Y")
        self.assertEqual(Seq("TAR").translate(), "*")
        self.assertEqual(Seq("TAN").translate(), "X")
        self.assertEqual(Seq("NNN").translate(), "X")
        self.assertEqual(Seq("TAt").translate(), "Y")
        self.assertEqual(Seq("TaR").translate(), "*")
        self.assertEqual(Seq("TaN").translate(), "X")
        self.assertEqual(Seq("nnN").translate(), "X")
        self.assertEqual(Seq("tat").translate(), "Y")
        self.assertEqual(Seq("tar").translate(), "*")
        self.assertEqual(Seq("tan").translate(), "X")
        self.assertEqual(Seq("nnn").translate(), "X")

    def test_module_translate_gap(self):
        """Check Bio.Seq.translate() handles gaps consistently."""
        for gap in ("-", "+", "."):
            nucleotide = f"ATG{gap * 3}TAA"
            protein = f"M{gap}*"
            with self.subTest(gap=gap):
                self.assertEqual(translate(nucleotide, gap=gap), protein)
                for sequence_type in (Seq, MutableSeq):
                    result = translate(sequence_type(nucleotide), gap=gap)
                    self.assertEqual(result, Seq(protein))
                    self.assertIsInstance(result, Seq)

        nucleotide = "ATG---TAA"
        for sequence_type in (str, Seq, MutableSeq):
            for kwargs in ({}, {"gap": None}):
                with (
                    self.subTest(sequence_type=sequence_type, kwargs=kwargs),
                    self.assertRaises(TranslationError),
                ):
                    translate(sequence_type(nucleotide), **kwargs)

        self.assertEqual(Seq(nucleotide).translate(), Seq("M-*"))
        self.assertEqual(MutableSeq(nucleotide).translate(), MutableSeq("M-*"))

    def test_the_translation_of_invalid_codons(self):
        """Check obj.translate() method with invalid codons."""
        for codon in ["TA?", "N-N", "AC_", "Ac_"]:
            msg = f"Translating {codon} should fail"
            nuc = Seq(codon)
            with self.assertRaises(TranslationError, msg=msg):
                nuc.translate()
            nuc = MutableSeq(codon)
            with self.assertRaises(TranslationError, msg=msg):
                nuc.translate()

    def test_the_translation_of_ambig_codons(self):
        """Check obj.translate() method with ambiguous codons."""
        for ambig_values in [ambiguous_dna_values, ambiguous_rna_values]:
            ambig = set(ambig_values.keys())
            ambig.remove("X")
            for c1 in ambig:
                for c2 in ambig:
                    for c3 in ambig:
                        values = {
                            str(Seq(a + b + c).translate())
                            for a in ambig_values[c1]
                            for b in ambig_values[c2]
                            for c in ambig_values[c3]
                        }
                        t = Seq(c1 + c2 + c3).translate()
                        if t == "*":
                            self.assertEqual(values, set("*"))
                        elif t == "X":
                            self.assertGreater(
                                len(values),
                                1,
                                "translate('%s') = '%s' not '%s'"
                                % (c1 + c2 + c3, t, ",".join(values)),
                            )
                        elif t == "Z":
                            self.assertEqual(values, set("EQ"))
                        elif t == "B":
                            self.assertEqual(values, set("DN"))
                        elif t == "J":
                            self.assertEqual(values, set("LI"))
                        else:
                            self.assertEqual(values, set(t))
                        # TODO - Use the Bio.Data.IUPACData module for the
                        # ambiguous protein mappings?

    def test_Seq_init_error(self):
        """Check Seq __init__ raises the appropriate exceptions."""
        self.assertRaises(TypeError, Seq, ("A", "C", "G", "T"))
        self.assertRaises(TypeError, Seq, ["A", "C", "G", "T"])
        self.assertRaises(TypeError, Seq, 1)
        self.assertRaises(TypeError, Seq, 1.0)
        self.assertRaises(ValueError, Seq, None)

    def test_MutableSeq_init_error(self):
        """Check MutableSeq __init__ raises the appropriate exceptions."""
        self.assertRaises(TypeError, MutableSeq, ("A", "C", "G", "T"))
        self.assertRaises(TypeError, MutableSeq, ["A", "C", "G", "T"])
        self.assertRaises(TypeError, MutableSeq, 1)
        self.assertRaises(TypeError, MutableSeq, 1.0)
        self.assertRaises(TypeError, MutableSeq, array.array("i", [1, 2, 3, 4]))

    def test_join_Seq_TypeError(self):
        """Checks that a TypeError is thrown for all non-iterable types."""
        # No iterable types which contain non-accepted types either.

        spacer = Seq("NNNNN")
        self.assertRaises(TypeError, spacer.join, 5)
        self.assertRaises(TypeError, spacer.join, SeqRecord(Seq("ATG")))
        self.assertRaises(TypeError, spacer.join, ["ATG", "ATG", 5, "ATG"])

    def test_join_MutableSeq_TypeError_iter(self):
        """Checks that a TypeError is thrown for all non-iterable types."""
        # No iterable types which contain non-accepted types either.

        spacer = MutableSeq("MMMMM")
        self.assertRaises(TypeError, spacer.join, 5)
        self.assertRaises(TypeError, spacer.join, ["ATG", "ATG", 5, "ATG"])

    def test_join_Seq(self):
        """Checks if Seq join correctly concatenates sequence with the spacer."""
        spacer = Seq("NNNNN")
        self.assertEqual("N" * 15, spacer.join([Seq("NNNNN"), Seq("NNNNN")]))

        spacer1 = Seq("")
        spacers = [spacer1, Seq("NNNNN"), Seq("GGG")]
        example_strings = ["ATG", "ATG", "ATG", "ATG"]
        example_strings_seqs = ["ATG", "ATG", Seq("ATG"), "ATG"]

        # strings with empty spacer
        str_concatenated = spacer1.join(example_strings)

        self.assertEqual(str_concatenated, "".join(example_strings))

        for spacer in spacers:
            seq_concatenated = spacer.join(example_strings_seqs)
            self.assertEqual(seq_concatenated, str(spacer).join(example_strings))
            # Now try single sequence arguments, should join the letters
            for target in example_strings + example_strings_seqs:
                self.assertEqual(
                    str(spacer).join(str(target)), str(spacer.join(target))
                )

    def test_join_MutableSeq_mixed(self):
        """Check MutableSeq objects can be joined."""
        spacer = MutableSeq("NNNNN")
        self.assertEqual(
            "N" * 15, spacer.join([MutableSeq("NNNNN"), MutableSeq("NNNNN")])
        )
        self.assertRaises(TypeError, spacer.join([Seq("NNNNN"), MutableSeq("NNNNN")]))

    def test_join_Seq_with_file(self):
        """Checks if Seq join correctly concatenates sequence from a file with the spacer."""
        filename = "Fasta/f003.fa"
        seqlist = [record.seq for record in SeqIO.parse(filename, "fasta")]
        seqlist_as_strings = [str(_) for _ in seqlist]

        spacer = Seq("NNNNN")
        spacer1 = Seq("")
        # seq objects with spacer
        seq_concatenated = spacer.join(seqlist)
        # seq objects with empty spacer
        seq_concatenated1 = spacer1.join(seqlist)

        ref_data = ref_data1 = ""
        ref_data = str(spacer).join(seqlist_as_strings)
        ref_data1 = str(spacer1).join(seqlist_as_strings)

        self.assertEqual(seq_concatenated, ref_data)
        self.assertEqual(seq_concatenated1, ref_data1)
        with self.assertRaises(TypeError):
            spacer.join(SeqIO.parse(filename, "fasta"))

    def test_join_MutableSeq(self):
        """Checks if MutableSeq join correctly concatenates sequence with the spacer."""
        # Only expect it to take Seq objects and/or strings in an iterable!

        spacer1 = MutableSeq("")
        spacers = [spacer1, MutableSeq("NNNNN"), MutableSeq("GGG")]
        example_strings = ["ATG", "ATG", "ATG", "ATG"]
        example_strings_seqs = ["ATG", "ATG", Seq("ATG"), "ATG"]

        # strings with empty spacer
        str_concatenated = spacer1.join(example_strings)

        self.assertEqual(str_concatenated, "".join(example_strings))

        for spacer in spacers:
            seq_concatenated = spacer.join(example_strings_seqs)
            self.assertEqual(seq_concatenated, str(spacer).join(example_strings))

    def test_join_MutableSeq_with_file(self):
        """Checks if MutableSeq join correctly concatenates sequence from a file with the spacer."""
        filename = "Fasta/f003.fa"
        seqlist = [record.seq for record in SeqIO.parse(filename, "fasta")]
        seqlist_as_strings = [str(_) for _ in seqlist]

        spacer = MutableSeq("NNNNN")
        spacer1 = MutableSeq("")
        # seq objects with spacer
        seq_concatenated = spacer.join(seqlist)
        # seq objects with empty spacer
        seq_concatenated1 = spacer1.join(seqlist)

        ref_data = ref_data1 = ""
        ref_data = str(spacer).join(seqlist_as_strings)
        ref_data1 = str(spacer1).join(seqlist_as_strings)

        self.assertEqual(seq_concatenated, ref_data)
        self.assertEqual(seq_concatenated1, ref_data1)
        with self.assertRaises(TypeError):
            spacer.join(SeqIO.parse(filename, "fasta"))

    def test_equality(self):
        """Test equality when mixing types."""
        self.assertEqual(Seq("6"), "6")
        self.assertNotEqual(Seq("6"), 6)
        self.assertEqual(Seq(""), "")
        self.assertNotEqual(Seq(""), None)
        self.assertEqual(Seq("None"), "None")
        self.assertNotEqual(Seq("None"), None)

        self.assertEqual(MutableSeq("6"), "6")
        self.assertNotEqual(MutableSeq("6"), 6)
        self.assertEqual(MutableSeq(""), "")
        self.assertNotEqual(MutableSeq(""), None)
        self.assertEqual(MutableSeq("None"), "None")
        self.assertNotEqual(MutableSeq("None"), None)

    # TODO - Addition...


class FileBasedTests(unittest.TestCase):
    """Test Seq objects created from files by SeqIO."""

    def test_unknown_seq(self):
        """Test if feature extraction works properly for unknown sequences."""
        rec = SeqIO.read("GenBank/NT_019265.gb", "genbank")
        self.assertIsInstance(rec.seq, Seq)
        self.assertRaises(UndefinedSequenceError, bytes, rec.seq)

        feature = rec.features[1]
        seq = feature.extract(rec.seq)
        self.assertIsInstance(seq, Seq)
        self.assertEqual(len(seq), len(feature))
        self.assertRaises(UndefinedSequenceError, bytes, seq)


class ComparisonTests(unittest.TestCase):
    """Test comparisons of Seq and MutableSeq."""

    def test_eq(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertEqual(seq1[2:4], seq2[3:5], msg=msg)
                self.assertEqual(seq1[2:4], "AT", msg=msg)
                self.assertEqual(seq2[3:5], "AT", msg=msg)
                self.assertEqual(seq1[2:4], b"AT", msg=msg)
                self.assertEqual(seq2[3:5], b"AT", msg=msg)
                self.assertEqual(seq1[2:4], Seq("AT"), msg=msg)
                self.assertEqual(seq2[3:5], Seq("AT"), msg=msg)
                self.assertEqual(seq1[2:4], MutableSeq("AT"), msg=msg)
                self.assertEqual(seq2[3:5], MutableSeq("AT"), msg=msg)
                self.assertEqual(seq2[3:5], seq1[2:4], msg=msg)
                self.assertEqual("AT", seq1[2:4], msg=msg)
                self.assertEqual("AT", seq2[3:5], msg=msg)
                self.assertEqual(b"AT", seq1[2:4], msg=msg)
                self.assertEqual(b"AT", seq2[3:5], msg=msg)
                self.assertEqual(Seq("AT"), seq1[2:4], msg=msg)
                self.assertEqual(Seq("AT"), seq2[3:5], msg=msg)
                self.assertEqual(MutableSeq("AT"), seq1[2:4], msg=msg)
                self.assertEqual(MutableSeq("AT"), seq2[3:5], msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 == Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 == Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 == Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 == Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, len(seq1)) == seq1
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, len(seq2)) == seq2
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, 10) == seq1
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, 10) == seq2

    def test_ne(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertNotEqual(seq1, seq2, msg=msg)
                self.assertNotEqual(seq1, "AT", msg=msg)
                self.assertNotEqual(seq2, "AT", msg=msg)
                self.assertNotEqual(seq1, b"AT", msg=msg)
                self.assertNotEqual(seq2, b"AT", msg=msg)
                self.assertNotEqual(seq1, Seq("AT"), msg=msg)
                self.assertNotEqual(seq2, Seq("AT"), msg=msg)
                self.assertNotEqual(seq1, MutableSeq("AT"), msg=msg)
                self.assertNotEqual(seq2, MutableSeq("AT"), msg=msg)
                self.assertNotEqual(seq1[2:4], "CG", msg=msg)
                self.assertNotEqual(seq2[3:5], "CG", msg=msg)
                self.assertNotEqual(seq1[2:4], b"CG", msg=msg)
                self.assertNotEqual(seq2[3:5], b"CG", msg=msg)
                self.assertNotEqual(seq1[2:4], Seq("CG"), msg=msg)
                self.assertNotEqual(seq2[3:5], Seq("CG"), msg=msg)
                self.assertNotEqual(seq1[2:4], MutableSeq("CG"), msg=msg)
                self.assertNotEqual(seq2[3:5], MutableSeq("CG"), msg=msg)
                self.assertNotEqual(seq2, seq1, msg=msg)
                self.assertNotEqual("AT", seq1, msg=msg)
                self.assertNotEqual("AT", seq2, msg=msg)
                self.assertNotEqual(b"AT", seq1, msg=msg)
                self.assertNotEqual(b"AT", seq2, msg=msg)
                self.assertNotEqual(Seq("AT"), seq1, msg=msg)
                self.assertNotEqual(Seq("AT"), seq2, msg=msg)
                self.assertNotEqual(MutableSeq("AT"), seq1, msg=msg)
                self.assertNotEqual(MutableSeq("AT"), seq2, msg=msg)
                self.assertNotEqual("CG", seq1[2:4], msg=msg)
                self.assertNotEqual("CG", seq2[3:5], msg=msg)
                self.assertNotEqual(b"CG", seq1[2:4], msg=msg)
                self.assertNotEqual(b"CG", seq2[3:5], msg=msg)
                self.assertNotEqual(Seq("CG"), seq1[2:4], msg=msg)
                self.assertNotEqual(Seq("CG"), seq2[3:5], msg=msg)
                self.assertNotEqual(MutableSeq("CG"), seq1[2:4], msg=msg)
                self.assertNotEqual(MutableSeq("CG"), seq2[3:5], msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 != Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 != Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 != Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 != Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, len(seq1)) != seq1
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, len(seq2)) != seq2
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, 10) != seq1
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    Seq(None, 10) != seq2

    def test_lt(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertLess(seq1, seq2, msg=msg)
                self.assertLess("AA", seq1, msg=msg)
                self.assertLess(seq1, "TT", msg=msg)
                self.assertLess("AA", seq2, msg=msg)
                self.assertLess(seq2, "TTT", msg=msg)
                self.assertLess(b"AA", seq1, msg=msg)
                self.assertLess(seq1, b"TT", msg=msg)
                self.assertLess(b"AA", seq2, msg=msg)
                self.assertLess(seq2, b"TTT", msg=msg)
                self.assertLess(Seq("AA"), seq1, msg=msg)
                self.assertLess(seq1, Seq("TT"), msg=msg)
                self.assertLess(Seq("AA"), seq2, msg=msg)
                self.assertLess(seq2, Seq("TTT"), msg=msg)
                self.assertLess(MutableSeq("AA"), seq1, msg=msg)
                self.assertLess(seq1, MutableSeq("TT"), msg=msg)
                self.assertLess(MutableSeq("AA"), seq2, msg=msg)
                self.assertLess(seq2, MutableSeq("TTT"), msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 < Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 < Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 < Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 < Seq(None, 10)
                self.assertLess("AA", seq1[2:4], msg=msg)
                self.assertLess("AA", seq2[3:5], msg=msg)
                self.assertLess(b"AA", seq1[2:4], msg=msg)
                self.assertLess(b"AA", seq2[3:5], msg=msg)
                self.assertLess(seq2[3:5], seq1[2:6], msg=msg)
                self.assertLess(Seq("AA"), seq1[2:4], msg=msg)
                self.assertLess(Seq("AA"), seq2[3:5], msg=msg)
                self.assertLess(MutableSeq("AA"), seq1[2:4], msg=msg)
                self.assertLess(MutableSeq("AA"), seq2[3:5], msg=msg)
                self.assertLess(seq1[2:4], "TT", msg=msg)
                self.assertLess(seq2[3:5], "TT", msg=msg)
                self.assertLess(seq1[2:4], b"TT", msg=msg)
                self.assertLess(seq2[3:5], b"TT", msg=msg)
                self.assertLess(seq1[2:4], Seq("TT"), msg=msg)
                self.assertLess(seq2[3:5], Seq("TT"), msg=msg)
                self.assertLess(seq1[2:4], MutableSeq("TT"), msg=msg)
                self.assertLess(seq2[3:5], MutableSeq("TT"), msg=msg)

    def test_le(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertLessEqual(seq1, seq2, msg=msg)
                self.assertLessEqual(seq1, "TT", msg=msg)
                self.assertLessEqual("TT", seq2, msg=msg)
                self.assertLessEqual(seq1, b"TT", msg=msg)
                self.assertLessEqual("TT", seq2, msg=msg)
                self.assertLessEqual(seq1, Seq("TT"), msg=msg)
                self.assertLessEqual("TT", seq2, msg=msg)
                self.assertLessEqual(seq1, MutableSeq("TT"), msg=msg)
                self.assertLessEqual(MutableSeq("TT"), seq2, msg=msg)
                self.assertLessEqual("AA", seq1, msg=msg)
                self.assertLessEqual("AA", seq2, msg=msg)
                self.assertLessEqual(b"AA", seq1, msg=msg)
                self.assertLessEqual(b"AA", seq2, msg=msg)
                self.assertLessEqual(Seq("AA"), seq1, msg=msg)
                self.assertLessEqual(Seq("AA"), seq2, msg=msg)
                self.assertLessEqual(MutableSeq("AA"), seq1, msg=msg)
                self.assertLessEqual(MutableSeq("AA"), seq2, msg=msg)
                self.assertLessEqual("GC", seq1, msg=msg)
                self.assertLessEqual("GC", seq2, msg=msg)
                self.assertLessEqual(b"GC", seq1, msg=msg)
                self.assertLessEqual(b"GC", seq2, msg=msg)
                self.assertLessEqual(Seq("GC"), seq1, msg=msg)
                self.assertLessEqual(Seq("GC"), seq2, msg=msg)
                self.assertLessEqual(MutableSeq("GC"), seq1, msg=msg)
                self.assertLessEqual(MutableSeq("GC"), seq2, msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 <= Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 <= Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 <= Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 <= Seq(None, 10)
                self.assertLessEqual("AA", seq1[2:4], msg=msg)
                self.assertLessEqual("AA", seq2[3:5], msg=msg)
                self.assertLessEqual(b"AA", seq1[2:4], msg=msg)
                self.assertLessEqual(b"AA", seq2[3:5], msg=msg)
                self.assertLessEqual(seq1[2:4], seq2[3:5], msg=msg)
                self.assertLessEqual(Seq("AA"), seq1[2:4], msg=msg)
                self.assertLessEqual(Seq("AA"), seq2[3:5], msg=msg)
                self.assertLessEqual(MutableSeq("AA"), seq1[2:4], msg=msg)
                self.assertLessEqual(MutableSeq("AA"), seq2[3:5], msg=msg)
                self.assertLessEqual(seq1[2:4], "TT", msg=msg)
                self.assertLessEqual(seq2[3:5], "TT", msg=msg)
                self.assertLessEqual(seq1[2:4], b"TT", msg=msg)
                self.assertLessEqual(seq2[3:5], b"TT", msg=msg)
                self.assertLessEqual(seq1[2:4], seq2[3:5], msg=msg)
                self.assertLessEqual(seq1[2:4], Seq("TT"), msg=msg)
                self.assertLessEqual(seq2[3:5], Seq("TT"), msg=msg)
                self.assertLessEqual(seq1[2:4], MutableSeq("TT"), msg=msg)
                self.assertLessEqual(seq2[3:5], MutableSeq("TT"), msg=msg)

    def test_gt(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertGreater(seq2, seq1, msg=msg)
                self.assertGreater("TT", seq1, msg=msg)
                self.assertGreater(seq2, "TT", msg=msg)
                self.assertGreater(b"TT", seq1, msg=msg)
                self.assertGreater(seq2, b"TT", msg=msg)
                self.assertGreater(Seq("TT"), seq1, msg=msg)
                self.assertGreater(seq2, Seq("TT"), msg=msg)
                self.assertGreater(MutableSeq("TT"), seq1, msg=msg)
                self.assertGreater(seq2, MutableSeq("TT"), msg=msg)
                self.assertGreater(seq1, "AA", msg=msg)
                self.assertGreater(seq2, "AA", msg=msg)
                self.assertGreater(seq1, b"AA", msg=msg)
                self.assertGreater(seq2, b"AA", msg=msg)
                self.assertGreater(seq1, Seq("AA"), msg=msg)
                self.assertGreater(seq2, Seq("AA"), msg=msg)
                self.assertGreater(seq1, MutableSeq("AA"), msg=msg)
                self.assertGreater(seq2, MutableSeq("AA"), msg=msg)
                self.assertGreater(seq1, "GC", msg=msg)
                self.assertGreater(seq2, "GC", msg=msg)
                self.assertGreater(seq1, b"GC", msg=msg)
                self.assertGreater(seq2, b"GC", msg=msg)
                self.assertGreater(seq1, Seq("GC"), msg=msg)
                self.assertGreater(seq2, Seq("GC"), msg=msg)
                self.assertGreater(seq1, MutableSeq("GC"), msg=msg)
                self.assertGreater(seq2, MutableSeq("GC"), msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 > Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 > Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 > Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 > Seq(None, 10)
                self.assertGreater(seq1[2:4], "AA", msg=msg)
                self.assertGreater(seq2[3:5], "AA", msg=msg)
                self.assertGreater(seq1[2:4], b"AA", msg=msg)
                self.assertGreater(seq2[3:5], b"AA", msg=msg)
                self.assertGreater(seq1[2:6], seq2[3:5], msg=msg)
                self.assertGreater(seq1[2:4], Seq("AA"), msg=msg)
                self.assertGreater(seq2[3:5], Seq("AA"), msg=msg)
                self.assertGreater(seq1[2:4], MutableSeq("AA"), msg=msg)
                self.assertGreater(seq2[3:5], MutableSeq("AA"), msg=msg)
                self.assertGreater("TT", seq1[2:4], msg=msg)
                self.assertGreater("TT", seq2[3:5], msg=msg)
                self.assertGreater(b"TT", seq1[2:4], msg=msg)
                self.assertGreater(b"TT", seq2[3:5], msg=msg)
                self.assertGreater(Seq("TT"), seq1[2:4], msg=msg)
                self.assertGreater(Seq("TT"), seq2[3:5], msg=msg)
                self.assertGreater(MutableSeq("TT"), seq1[2:4], msg=msg)
                self.assertGreater(MutableSeq("TT"), seq2[3:5], msg=msg)

    def test_ge(self):
        s1 = "GCATGTATGT"
        s2 = "TTGATCAGTT"
        for seq1 in (Seq(s1), MutableSeq(s1)):
            for seq2 in (Seq(s2), MutableSeq(s2)):
                msg = f"{type(seq1)} vs {type(seq2)}"
                self.assertGreaterEqual(seq2, seq1, msg=msg)
                self.assertGreaterEqual("TT", seq1, msg=msg)
                self.assertGreaterEqual(seq2, "TT", msg=msg)
                self.assertGreaterEqual(b"TT", seq1, msg=msg)
                self.assertGreaterEqual(seq2, b"TT", msg=msg)
                self.assertGreaterEqual(Seq("TT"), seq1, msg=msg)
                self.assertGreaterEqual(seq2, Seq("TT"), msg=msg)
                self.assertGreaterEqual(MutableSeq("TT"), seq1, msg=msg)
                self.assertGreaterEqual(seq2, MutableSeq("TT"), msg=msg)
                self.assertGreaterEqual(seq1, "AA", msg=msg)
                self.assertGreaterEqual(seq2, "AA", msg=msg)
                self.assertGreaterEqual(seq1, b"AA", msg=msg)
                self.assertGreaterEqual(seq2, b"AA", msg=msg)
                self.assertGreaterEqual(seq1, Seq("AA"), msg=msg)
                self.assertGreaterEqual(seq2, Seq("AA"), msg=msg)
                self.assertGreaterEqual(seq1, MutableSeq("AA"), msg=msg)
                self.assertGreaterEqual(seq2, MutableSeq("AA"), msg=msg)
                self.assertGreaterEqual(seq1, "GC", msg=msg)
                self.assertGreaterEqual(seq2, "GC", msg=msg)
                self.assertGreaterEqual(seq1, b"GC", msg=msg)
                self.assertGreaterEqual(seq2, b"GC", msg=msg)
                self.assertGreaterEqual(seq1, Seq("GC"), msg=msg)
                self.assertGreaterEqual(seq2, Seq("GC"), msg=msg)
                self.assertGreaterEqual(seq1, MutableSeq("GC"), msg=msg)
                self.assertGreaterEqual(seq2, MutableSeq("GC"), msg=msg)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 >= Seq(None, len(seq1))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 >= Seq(None, len(seq2))
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq1 >= Seq(None, 10)
                with self.assertRaises(UndefinedSequenceError, msg=msg):
                    seq2 >= Seq(None, 10)
                self.assertGreaterEqual(seq1[2:4], "AA", msg=msg)
                self.assertGreaterEqual(seq2[3:5], "AA", msg=msg)
                self.assertGreaterEqual(seq1[2:4], b"AA", msg=msg)
                self.assertGreaterEqual(seq2[3:5], b"AA", msg=msg)
                self.assertGreaterEqual(seq1[2:4], seq2[3:5], msg=msg)
                self.assertGreaterEqual(seq1[2:4], Seq("AA"), msg=msg)
                self.assertGreaterEqual(seq2[3:5], Seq("AA"), msg=msg)
                self.assertGreaterEqual(seq1[2:4], MutableSeq("AA"), msg=msg)
                self.assertGreaterEqual(seq2[3:5], MutableSeq("AA"), msg=msg)
                self.assertGreaterEqual("TT", seq1[2:4], msg=msg)
                self.assertGreaterEqual("TT", seq2[3:5], msg=msg)
                self.assertGreaterEqual(b"TT", seq1[2:4], msg=msg)
                self.assertGreaterEqual(b"TT", seq2[3:5], msg=msg)
                self.assertGreaterEqual(seq1[2:4], seq2[3:5], msg=msg)
                self.assertGreaterEqual(Seq("TT"), seq1[2:4], msg=msg)
                self.assertGreaterEqual(Seq("TT"), seq2[3:5], msg=msg)
                self.assertGreaterEqual(MutableSeq("TT"), seq1[2:4], msg=msg)
                self.assertGreaterEqual(MutableSeq("TT"), seq2[3:5], msg=msg)


class PartialSequenceTests(unittest.TestCase):
    """Test Seq objects with partially defined sequences."""

    def test_init(self):
        seq = Seq({5: "ACGT"}, length=20)
        self.assertEqual(repr(seq), "Seq({5: 'ACGT'}, length=20)")
        with self.assertRaises(ValueError) as cm:
            Seq({5: "ACGT"}, length=-10)
        self.assertEqual(str(cm.exception), "length must not be negative.")
        with self.assertRaises(ValueError) as cm:
            Seq({5: 1.5}, length=10)
        self.assertEqual(str(cm.exception), "Expected bytes-like objects or strings")
        with self.assertRaises(ValueError) as cm:
            Seq({5: "PQRST", 8: "KLM"}, length=10)
        self.assertEqual(str(cm.exception), "Sequence data are overlapping.")
        with self.assertRaises(ValueError) as cm:
            Seq({5: "PQRST"}, length=8)
        self.assertEqual(
            str(cm.exception), "Provided sequence data extend beyond sequence length."
        )

    def test_repr(self):
        seq = Seq({5: "ACGT", 14: "GGC"}, length=20)
        self.assertEqual(repr(seq), "Seq({5: 'ACGT', 14: 'GGC'}, length=20)")
        seq = Seq({5: "ACGT" * 25, 140: "GGC"}, length=143)
        self.assertEqual(
            repr(seq),
            "Seq({5: 'ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC...CGT', 140: 'GGC'}, length=143)",
        )
        seq = Seq({5: "ACGT" * 25, 140: "GGC"}, length=150)
        self.assertEqual(
            repr(seq),
            "Seq({5: 'ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC...CGT', 140: 'GGC'}, length=150)",
        )
        seq = Seq({5: "ACGT" * 25, 140: "acgt" * 20}, length=250)
        self.assertEqual(
            repr(seq),
            "Seq({5: 'ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC...CGT', 140: 'acgtacgtacgtacgtacgtacgtacgtacgtacgtacgtacgtacgtacgtac...cgt'}, length=250)",
        )

    def test_getitem(self):
        #           1    1    2
        # 0    5    0    5    0
        # ?????ABCD?????EFG???
        seq = Seq({5: "ABCD", 14: "EFG"}, length=20)
        self.assertEqual(repr(seq), "Seq({5: 'ABCD', 14: 'EFG'}, length=20)")
        # index
        with self.assertRaises(UndefinedSequenceError) as cm:
            seq[0]
        self.assertEqual(str(cm.exception), "Sequence at position 0 is undefined")
        with self.assertRaises(UndefinedSequenceError) as cm:
            seq[1]
        self.assertEqual(str(cm.exception), "Sequence at position 1 is undefined")
        self.assertEqual(seq[5], "A")
        self.assertEqual(seq[6], "B")
        self.assertEqual(seq[7], "C")
        self.assertEqual(seq[8], "D")
        with self.assertRaises(UndefinedSequenceError) as cm:
            seq[10]
        self.assertEqual(str(cm.exception), "Sequence at position 10 is undefined")
        self.assertEqual(seq[14], "E")
        self.assertEqual(seq[15], "F")
        self.assertEqual(seq[16], "G")
        with self.assertRaises(UndefinedSequenceError) as cm:
            seq[17]
        self.assertEqual(str(cm.exception), "Sequence at position 17 is undefined")
        with self.assertRaises(IndexError) as cm:
            seq[30]
        self.assertEqual(str(cm.exception), "sequence index out of range")
        # step = 0
        with self.assertRaises(ValueError) as cm:
            s = seq[::0]
        self.assertEqual(str(cm.exception), "slice step cannot be zero")
        # step = 1, stop = +inf
        s = seq[:]  # ?????ABCD?????EFG???
        self.assertEqual(repr(s), "Seq({5: 'ABCD', 14: 'EFG'}, length=20)")
        s = seq[0:]  # ?????ABCD?????EFG???
        self.assertEqual(repr(s), "Seq({5: 'ABCD', 14: 'EFG'}, length=20)")
        s = seq[1:]  # ????ABCD?????EFG???
        self.assertEqual(repr(s), "Seq({4: 'ABCD', 13: 'EFG'}, length=19)")
        s = seq[4:]  # ?ABCD?????EFG???
        self.assertEqual(repr(s), "Seq({1: 'ABCD', 10: 'EFG'}, length=16)")
        s = seq[5:]  # ABCD?????EFG???
        self.assertEqual(repr(s), "Seq({0: 'ABCD', 9: 'EFG'}, length=15)")
        s = seq[6:]  # BCD?????EFG???
        self.assertEqual(repr(s), "Seq({0: 'BCD', 8: 'EFG'}, length=14)")
        s = seq[7:]  # CD?????EFG???
        self.assertEqual(repr(s), "Seq({0: 'CD', 7: 'EFG'}, length=13)")
        s = seq[8:]  # D?????EFG???
        self.assertEqual(repr(s), "Seq({0: 'D', 6: 'EFG'}, length=12)")
        s = seq[9:]  # ?????EFG???
        self.assertEqual(repr(s), "Seq({5: 'EFG'}, length=11)")
        s = seq[10:]  # ????EFG???
        self.assertEqual(repr(s), "Seq({4: 'EFG'}, length=10)")
        s = seq[13:]  # ?EFG???
        self.assertEqual(repr(s), "Seq({1: 'EFG'}, length=7)")
        s = seq[14:]  # EFG???
        self.assertEqual(repr(s), "Seq({0: 'EFG'}, length=6)")
        s = seq[15:]  # FG???
        self.assertEqual(repr(s), "Seq({0: 'FG'}, length=5)")
        s = seq[16:]  # G???
        self.assertEqual(repr(s), "Seq({0: 'G'}, length=4)")
        s = seq[17:]  # ???
        self.assertEqual(repr(s), "Seq(None, length=3)")
        s = seq[18:]  # ??
        self.assertEqual(repr(s), "Seq(None, length=2)")
        s = seq[19:]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[20:]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # step = 1, stop = 9
        s = seq[:9]  # ?????ABCD
        self.assertEqual(repr(s), "Seq({5: 'ABCD'}, length=9)")
        s = seq[0:9]  # ?????ABCD
        self.assertEqual(repr(s), "Seq({5: 'ABCD'}, length=9)")
        s = seq[1:9]  # ????ABCD
        self.assertEqual(repr(s), "Seq({4: 'ABCD'}, length=8)")
        s = seq[4:9]  # ?ABCD
        self.assertEqual(repr(s), "Seq({1: 'ABCD'}, length=5)")
        s = seq[5:9]  # ABCD
        self.assertEqual(s._data, b"ABCD")
        s = seq[6:9]  # BCD
        self.assertEqual(s._data, b"BCD")
        s = seq[7:9]  # CD
        self.assertEqual(s._data, b"CD")
        s = seq[8:9]  # D
        self.assertEqual(s._data, b"D")
        s = seq[9:9]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        s = seq[10:9]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # step = 2, stop = +inf
        s = seq[::2]  # ???BD??EG?
        self.assertEqual(repr(s), "Seq({3: 'BD', 7: 'EG'}, length=10)")
        s = seq[0::2]  # ???BD??EG?
        self.assertEqual(repr(s), "Seq({3: 'BD', 7: 'EG'}, length=10)")
        s = seq[1::2]  # ??AC???F??
        self.assertEqual(repr(s), "Seq({2: 'AC', 7: 'F'}, length=10)")
        s = seq[4::2]  # ?BD??EG?
        self.assertEqual(repr(s), "Seq({1: 'BD', 5: 'EG'}, length=8)")
        s = seq[5::2]  # AC???F??
        self.assertEqual(repr(s), "Seq({0: 'AC', 5: 'F'}, length=8)")
        s = seq[6::2]  # BD??EG?
        self.assertEqual(repr(s), "Seq({0: 'BD', 4: 'EG'}, length=7)")
        s = seq[7::2]  # C???F??
        self.assertEqual(repr(s), "Seq({0: 'C', 4: 'F'}, length=7)")
        s = seq[8::2]  # D??EG?
        self.assertEqual(repr(s), "Seq({0: 'D', 3: 'EG'}, length=6)")
        s = seq[9::2]  # ???F??
        self.assertEqual(repr(s), "Seq({3: 'F'}, length=6)")
        s = seq[10::2]  # ??EG?
        self.assertEqual(repr(s), "Seq({2: 'EG'}, length=5)")
        s = seq[13::2]  # ?F??
        self.assertEqual(repr(s), "Seq({1: 'F'}, length=4)")
        s = seq[14::2]  # EG?
        self.assertEqual(repr(s), "Seq({0: 'EG'}, length=3)")
        s = seq[15::2]  # F??
        self.assertEqual(repr(s), "Seq({0: 'F'}, length=3)")
        s = seq[16::2]  # G?
        self.assertEqual(repr(s), "Seq({0: 'G'}, length=2)")
        s = seq[17::2]  # ??
        self.assertEqual(repr(s), "Seq(None, length=2)")
        s = seq[18::2]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[19::2]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[20::2]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # step = -1, start = None
        s = seq[::-1]  # ???GFE?????DCBA?????
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DCBA'}, length=20)")
        s = seq[:0:-1]  # ???GFE?????DCBA????
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DCBA'}, length=19)")
        s = seq[:1:-1]  # ???GFE?????DCBA???
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DCBA'}, length=18)")
        s = seq[:4:-1]  # ???GFE?????DCBA
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DCBA'}, length=15)")
        s = seq[:5:-1]  # ???GFE?????DCB
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DCB'}, length=14)")
        s = seq[:6:-1]  # ???GFE?????DC
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'DC'}, length=13)")
        s = seq[:7:-1]  # ???GFE?????D
        self.assertEqual(repr(s), "Seq({3: 'GFE', 11: 'D'}, length=12)")
        s = seq[:8:-1]  # ???GFE?????
        self.assertEqual(repr(s), "Seq({3: 'GFE'}, length=11)")
        s = seq[:9:-1]  # ???GFE????
        self.assertEqual(repr(s), "Seq({3: 'GFE'}, length=10)")
        s = seq[:10:-1]  # ???GFE???
        self.assertEqual(repr(s), "Seq({3: 'GFE'}, length=9)")
        s = seq[:13:-1]  # ???GFE
        self.assertEqual(repr(s), "Seq({3: 'GFE'}, length=6)")
        s = seq[:14:-1]  # ???GF
        self.assertEqual(repr(s), "Seq({3: 'GF'}, length=5)")
        s = seq[:15:-1]  # ???G
        self.assertEqual(repr(s), "Seq({3: 'G'}, length=4)")
        s = seq[:16:-1]  # ???
        self.assertEqual(repr(s), "Seq(None, length=3)")
        s = seq[:17:-1]  # ??
        self.assertEqual(repr(s), "Seq(None, length=2)")
        s = seq[:18:-1]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[:19:-1]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        s = seq[:20:-1]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # step = -1, stop = 9
        s = seq[9::-1]  # ?DCBA?????
        self.assertEqual(repr(s), "Seq({1: 'DCBA'}, length=10)")
        s = seq[9:0:-1]  # ?DCBA????
        self.assertEqual(repr(s), "Seq({1: 'DCBA'}, length=9)")
        s = seq[9:1:-1]  # ?DCBA???
        self.assertEqual(repr(s), "Seq({1: 'DCBA'}, length=8)")
        s = seq[9:4:-1]  # ?DCBA
        self.assertEqual(repr(s), "Seq({1: 'DCBA'}, length=5)")
        s = seq[9:5:-1]  # ?DCB
        self.assertEqual(repr(s), "Seq({1: 'DCB'}, length=4)")
        s = seq[9:6:-1]  # ?DC
        self.assertEqual(repr(s), "Seq({1: 'DC'}, length=3)")
        s = seq[9:7:-1]  # ?D
        self.assertEqual(repr(s), "Seq({1: 'D'}, length=2)")
        s = seq[9:8:-1]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[9:9:-1]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        s = seq[9:10:-1]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # step = -2, stop = None
        s = seq[::-2]  # ??F???CA??
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'CA'}, length=10)")
        s = seq[:0:-2]  # ??F???CA??
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'CA'}, length=10)")
        s = seq[:1:-2]  # ??F???CA?
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'CA'}, length=9)")
        s = seq[:4:-2]  # ??F???CA
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'CA'}, length=8)")
        s = seq[:5:-2]  # ??F???C
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'C'}, length=7)")
        s = seq[:6:-2]  # ??F???C
        self.assertEqual(repr(s), "Seq({2: 'F', 6: 'C'}, length=7)")
        s = seq[:7:-2]  # ??F???
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=6)")
        s = seq[:8:-2]  # ??F???
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=6)")
        s = seq[:9:-2]  # ??F??
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=5)")
        s = seq[:10:-2]  # ??F??
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=5)")
        s = seq[:13:-2]  # ??F
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=3)")
        s = seq[:14:-2]  # ??F
        self.assertEqual(repr(s), "Seq({2: 'F'}, length=3)")
        s = seq[:15:-2]  # ??
        self.assertEqual(repr(s), "Seq(None, length=2)")
        s = seq[:16:-2]  # ??
        self.assertEqual(repr(s), "Seq(None, length=2)")
        s = seq[:17:-2]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[:18:-2]  # ?
        self.assertEqual(repr(s), "Seq(None, length=1)")
        s = seq[:19:-2]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        s = seq[:20:-2]  # empty sequence
        self.assertEqual(repr(s), "Seq('')")
        # test merging segments
        seq = Seq({5: "ABCD", 11: "EFGH"}, length=20)
        s = seq[5::2]
        self.assertEqual(repr(s), "Seq({0: 'AC', 3: 'EG'}, length=8)")
        s = seq[5::3]
        self.assertEqual(repr(s), "Seq({0: 'ADEH'}, length=5)")
        s = seq[5::4]
        self.assertEqual(repr(s), "Seq({0: 'A', 2: 'G'}, length=4)")
        s = seq[5::5]
        self.assertEqual(repr(s), "Seq({0: 'A'}, length=3)")
        s = seq[4:]
        self.assertEqual(repr(s), "Seq({1: 'ABCD', 7: 'EFGH'}, length=16)")
        s = seq[4::2]
        self.assertEqual(repr(s), "Seq({1: 'BD', 4: 'FH'}, length=8)")
        s = seq[4::3]
        self.assertEqual(repr(s), "Seq({1: 'C', 3: 'G'}, length=6)")
        s = seq[4::4]
        self.assertEqual(repr(s), "Seq({1: 'DF'}, length=4)")
        # test length 0
        self.assertEqual(Seq({}, length=0), "")

    def test_addition(self):
        s1 = Seq("ABCD")
        s2 = Seq("EFG")
        u1 = Seq(None, length=7)
        u2 = Seq(None, length=9)
        p1 = Seq({3: "KLM", 11: "XYZ"}, length=17)
        p2 = Seq({0: "PQRST", 8: "HIJ"}, length=13)
        records = SeqIO.parse("TwoBit/sequence.littleendian.2bit", "twobit")
        t = records["seq6"].seq  # ACGTacgtNNNNnn, lazy-loaded
        self.assertEqual(s1 + s1, Seq("ABCDABCD"))
        self.assertEqual(s1 + s2, Seq("ABCDEFG"))
        self.assertEqual(repr(s1 + u1), "Seq({0: 'ABCD'}, length=11)")
        self.assertEqual(repr(s1 + u2), "Seq({0: 'ABCD'}, length=13)")
        self.assertEqual(
            repr(s1 + p1), "Seq({0: 'ABCD', 7: 'KLM', 15: 'XYZ'}, length=21)"
        )
        self.assertEqual(repr(s1 + p2), "Seq({0: 'ABCDPQRST', 12: 'HIJ'}, length=17)")
        self.assertEqual(s1 + t, Seq("ABCDACGTacgtNNNNnn"))
        self.assertEqual(s2 + s1, Seq("EFGABCD"))
        self.assertEqual(s2 + s2, Seq("EFGEFG"))
        self.assertEqual(repr(s2 + u1), "Seq({0: 'EFG'}, length=10)")
        self.assertEqual(repr(s2 + u2), "Seq({0: 'EFG'}, length=12)")
        self.assertEqual(
            repr(s2 + p1), "Seq({0: 'EFG', 6: 'KLM', 14: 'XYZ'}, length=20)"
        )
        self.assertEqual(repr(s2 + p2), "Seq({0: 'EFGPQRST', 11: 'HIJ'}, length=16)")
        self.assertEqual(s2 + t, Seq("EFGACGTacgtNNNNnn"))
        self.assertEqual(repr(u1 + s1), "Seq({7: 'ABCD'}, length=11)")
        self.assertEqual(repr(u1 + s2), "Seq({7: 'EFG'}, length=10)")
        self.assertEqual(repr(u1 + u1), "Seq(None, length=14)")
        self.assertEqual(repr(u1 + u2), "Seq(None, length=16)")
        self.assertEqual(repr(u1 + p1), "Seq({10: 'KLM', 18: 'XYZ'}, length=24)")
        self.assertEqual(repr(u1 + p2), "Seq({7: 'PQRST', 15: 'HIJ'}, length=20)")
        self.assertEqual(repr(u1 + t), "Seq({7: 'ACGTacgtNNNNnn'}, length=21)")
        self.assertEqual(repr(u2 + s1), "Seq({9: 'ABCD'}, length=13)")
        self.assertEqual(repr(u2 + s2), "Seq({9: 'EFG'}, length=12)")
        self.assertEqual(repr(u2 + u1), "Seq(None, length=16)")
        self.assertEqual(repr(u2 + u2), "Seq(None, length=18)")
        self.assertEqual(repr(u2 + p1), "Seq({12: 'KLM', 20: 'XYZ'}, length=26)")
        self.assertEqual(repr(u2 + p2), "Seq({9: 'PQRST', 17: 'HIJ'}, length=22)")
        self.assertEqual(repr(u2 + t), "Seq({9: 'ACGTacgtNNNNnn'}, length=23)")
        self.assertEqual(
            repr(p1 + s1), "Seq({3: 'KLM', 11: 'XYZ', 17: 'ABCD'}, length=21)"
        )
        self.assertEqual(
            repr(p1 + s2), "Seq({3: 'KLM', 11: 'XYZ', 17: 'EFG'}, length=20)"
        )
        self.assertEqual(repr(p1 + u1), "Seq({3: 'KLM', 11: 'XYZ'}, length=24)")
        self.assertEqual(repr(p1 + u2), "Seq({3: 'KLM', 11: 'XYZ'}, length=26)")
        self.assertEqual(
            repr(p1 + p1), "Seq({3: 'KLM', 11: 'XYZ', 20: 'KLM', 28: 'XYZ'}, length=34)"
        )
        self.assertEqual(
            repr(p1 + p2),
            "Seq({3: 'KLM', 11: 'XYZ', 17: 'PQRST', 25: 'HIJ'}, length=30)",
        )
        self.assertEqual(
            repr(p1 + t), "Seq({3: 'KLM', 11: 'XYZ', 17: 'ACGTacgtNNNNnn'}, length=31)"
        )
        self.assertEqual(
            repr(p2 + s1), "Seq({0: 'PQRST', 8: 'HIJ', 13: 'ABCD'}, length=17)"
        )
        self.assertEqual(
            repr(p2 + s2), "Seq({0: 'PQRST', 8: 'HIJ', 13: 'EFG'}, length=16)"
        )
        self.assertEqual(repr(p2 + u1), "Seq({0: 'PQRST', 8: 'HIJ'}, length=20)")
        self.assertEqual(repr(p2 + u2), "Seq({0: 'PQRST', 8: 'HIJ'}, length=22)")
        self.assertEqual(
            repr(p2 + p1),
            "Seq({0: 'PQRST', 8: 'HIJ', 16: 'KLM', 24: 'XYZ'}, length=30)",
        )
        self.assertEqual(
            repr(p2 + p2),
            "Seq({0: 'PQRST', 8: 'HIJ', 13: 'PQRST', 21: 'HIJ'}, length=26)",
        )
        self.assertEqual(
            repr(p2 + t), "Seq({0: 'PQRST', 8: 'HIJ', 13: 'ACGTacgtNNNNnn'}, length=27)"
        )
        self.assertEqual(t + s1, Seq("ACGTacgtNNNNnnABCD"))
        self.assertEqual(t + s2, Seq("ACGTacgtNNNNnnEFG"))
        self.assertEqual(repr(t + u1), "Seq({0: 'ACGTacgtNNNNnn'}, length=21)")
        self.assertEqual(repr(t + u2), "Seq({0: 'ACGTacgtNNNNnn'}, length=23)")
        self.assertEqual(
            repr(t + p1), "Seq({0: 'ACGTacgtNNNNnn', 17: 'KLM', 25: 'XYZ'}, length=31)"
        )
        self.assertEqual(
            repr(t + p2), "Seq({0: 'ACGTacgtNNNNnnPQRST', 22: 'HIJ'}, length=27)"
        )
        self.assertEqual(t + t, Seq("ACGTacgtNNNNnnACGTacgtNNNNnn"))
        p1 = Seq({3: "KLM", 11: "XYZ"}, length=14)
        p2 = Seq({0: "PQRST", 8: "HIJ"}, length=11)
        self.assertEqual(
            repr(p1 + p2), "Seq({3: 'KLM', 11: 'XYZPQRST', 22: 'HIJ'}, length=25)"
        )
        self.assertEqual(
            repr(p2 + p1),
            "Seq({0: 'PQRST', 8: 'HIJ', 14: 'KLM', 22: 'XYZ'}, length=25)",
        )
        self.assertEqual(repr(p1 + s1), "Seq({3: 'KLM', 11: 'XYZABCD'}, length=18)")
        self.assertEqual(repr(p1 + s2), "Seq({3: 'KLM', 11: 'XYZEFG'}, length=17)")

    def test_multiplication(self):
        p1 = Seq({3: "KLM", 11: "XYZ"}, length=17)
        p2 = Seq({0: "PQRST", 8: "HIJ"}, length=11)
        self.assertEqual(
            repr(3 * p1),
            "Seq({3: 'KLM', 11: 'XYZ', 20: 'KLM', 28: 'XYZ', 37: 'KLM', 45: 'XYZ'}, length=51)",
        )
        self.assertEqual(
            repr(3 * p2),
            "Seq({0: 'PQRST', 8: 'HIJPQRST', 19: 'HIJPQRST', 30: 'HIJ'}, length=33)",
        )

    def test_lower_upper(self):
        u = Seq({3: "KLM", 11: "XYZ"}, length=17)
        l = Seq({0: "pqrst", 8: "hij"}, length=13)  # noqa: E741
        m = Seq({5: "ABCD", 10: "efgh"}, length=20)
        self.assertEqual(repr(u.upper()), "Seq({3: 'KLM', 11: 'XYZ'}, length=17)")
        self.assertEqual(repr(u.lower()), "Seq({3: 'klm', 11: 'xyz'}, length=17)")
        self.assertEqual(repr(l.upper()), "Seq({0: 'PQRST', 8: 'HIJ'}, length=13)")
        self.assertEqual(repr(l.lower()), "Seq({0: 'pqrst', 8: 'hij'}, length=13)")
        self.assertEqual(repr(m.upper()), "Seq({5: 'ABCD', 10: 'EFGH'}, length=20)")
        self.assertEqual(repr(m.lower()), "Seq({5: 'abcd', 10: 'efgh'}, length=20)")

    def test_complement(self):
        s = Seq({3: "AACC", 11: "CGT"}, length=20)
        u = Seq({3: "AACC", 11: "CGU"}, length=20)
        self.assertEqual(repr(s.complement()), "Seq({3: 'TTGG', 11: 'GCA'}, length=20)")
        self.assertEqual(repr(u.complement()), "Seq({3: 'TTGG', 11: 'GCA'}, length=20)")
        self.assertEqual(
            repr(s.reverse_complement()), "Seq({6: 'ACG', 13: 'GGTT'}, length=20)"
        )
        self.assertEqual(
            repr(u.reverse_complement()),
            "Seq({6: 'ACG', 13: 'GGTT'}, length=20)",
        )
        self.assertEqual(
            repr(s.complement_rna()), "Seq({3: 'UUGG', 11: 'GCA'}, length=20)"
        )
        self.assertEqual(
            repr(u.complement_rna()), "Seq({3: 'UUGG', 11: 'GCA'}, length=20)"
        )
        self.assertEqual(
            repr(s.reverse_complement_rna()), "Seq({6: 'ACG', 13: 'GGUU'}, length=20)"
        )
        self.assertEqual(
            repr(u.reverse_complement_rna()), "Seq({6: 'ACG', 13: 'GGUU'}, length=20)"
        )

    def test_replace(self):
        s = Seq({3: "AACC", 11: "CGT"}, length=20)
        self.assertEqual(
            repr(s.replace("A", "X")), "Seq({3: 'XXCC', 11: 'CGT'}, length=20)"
        )
        self.assertEqual(
            repr(s.replace("CC", "YY")), "Seq({3: 'AAYY', 11: 'CGT'}, length=20)"
        )
        self.assertRaises(UndefinedSequenceError, s.replace, "A", "XX")

    def test_transcribe(self):
        s = Seq({3: "acgt", 11: "ACGT"}, length=20)
        u = s.transcribe()
        self.assertEqual(repr(u), "Seq({3: 'acgu', 11: 'ACGU'}, length=20)")
        s = u.back_transcribe()
        self.assertEqual(repr(s), "Seq({3: 'acgt', 11: 'ACGT'}, length=20)")


if __name__ == "__main__":
    runner = unittest.TextTestRunner(verbosity=2)
    unittest.main(testRunner=runner)
