# Copyright 2006-2014 by Peter Cock.  All rights reserved.
# Revisions copyright 2011 Brandon Invergo. 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.
"""Tests for Bio.Align.mauve module."""
import os
import unittest

from io import StringIO

from Bio.Seq import Seq, MutableSeq
from Bio import SeqIO
from Bio import Align


try:
    import numpy as np
except ImportError:
    from Bio import MissingPythonDependencyError

    raise MissingPythonDependencyError(
        "Install numpy if you want to use Bio.Align.mauve."
    ) from None


class TestCombinedFile(unittest.TestCase):
    # Generate the output file combined.xmfa by running
    # progressiveMauve combined.fa --output=combined.xmfa

    filename = "combined.fa"
    path = os.path.join("Mauve", filename)
    records = SeqIO.parse(path, "fasta")
    sequences = {str(index): record.seq for index, record in enumerate(records)}
    del filename
    del path
    del records

    def test_parse(self):
        path = os.path.join("Mauve", "combined.xmfa")
        with open(path) as stream:
            alignments = Align.parse(stream, "mauve")
            self.check_alignments(alignments)
            alignments.rewind()
            self.check_alignments(alignments)
        with Align.parse(path, "mauve") as alignments:
            self.check_alignments(alignments)
        with self.assertRaises(AttributeError):
            alignments._stream
        with Align.parse(path, "mauve") as alignments:
            pass
        with self.assertRaises(AttributeError):
            alignments._stream

    def check_alignments(self, alignments):
        saved_alignments = []
        metadata = alignments.metadata
        self.assertEqual(len(metadata), 3)
        self.assertEqual(metadata["FormatVersion"], "Mauve1")
        self.assertEqual(metadata["File"], "combined.fa")
        self.assertEqual(metadata["BackboneFile"], "combined.xmfa.bbcols")
        identifiers = alignments.identifiers
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 3)
        self.assertEqual(len(alignment.sequences), 3)
        self.assertEqual(alignment.sequences[0].id, "0")
        self.assertEqual(
            repr(alignment.sequences[0].seq),
            "Seq({1: 'AAAAGGAAAGTACGGCCCGGCCACTCCGGGTGTGTGCTAGGAGGGCTT'}, length=49)",
        )
        sequence = self.sequences[alignment.sequences[0].id]
        start = len(sequence) - alignment.coordinates[0, 0]
        end = len(sequence) - alignment.coordinates[0, -1]
        self.assertEqual(start, 1)
        self.assertEqual(end, 49)
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment.sequences[1].id, "1")
        self.assertEqual(alignment.sequences[1].seq, "")
        start = alignment.coordinates[1, 0]
        end = alignment.coordinates[1, -1]
        self.assertEqual(start, 0)
        self.assertEqual(end, 0)
        self.assertEqual(alignment.sequences[2].id, "2")
        self.assertEqual(
            repr(alignment.sequences[2].seq),
            "Seq({1: 'AAGCCCTGCGCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT'}, length=48)",
        )
        start = alignment.coordinates[2, 0]
        end = alignment.coordinates[2, -1]
        self.assertEqual(start, 1)
        self.assertEqual(end, 48)
        sequence = self.sequences[alignment.sequences[2].id][start:end]
        self.assertEqual(alignment.sequences[2].seq[start:end], sequence)
        self.assertEqual(
            alignment[0], "AAGCCCTCCTAGCACACACCCGGAGTGG-CCGGGCCGTACTTTCCTTTT"
        )
        self.assertEqual(
            alignment[1], "-------------------------------------------------"
        )
        self.assertEqual(
            alignment[2], "AAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT"
        )
        self.assertTrue(
            np.array_equal(
                alignment.coordinates,
                np.array(
                    [
                        [49, 40, 38, 21, 21, 1],
                        [0, 0, 0, 0, 0, 0],
                        [1, 10, 10, 27, 28, 48],
                    ]
                ),
            )
        )
        self.assertEqual(
            str(alignment),
            """\
0                49 AAGCCCTCCTAGCACACACCCGGAGTGG-CCGGGCCGTACTTTCCTTTT  1
1                 0 -------------------------------------------------  0
2                 1 AAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT 48
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 1:2-49 - combined.fa
AAGCCCTCCTAGCACACACCCGGAGTGG-CCGGGCCGTACTTTCCTTTT
> 2:0-0 + combined.fa
-------------------------------------------------
> 3:2-48 + combined.fa
AAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT
=
""",
        )
        self.assertTrue(
            np.array_equal(
                np.array(alignment, "U"),
                # fmt: off
np.array([['A', 'A', 'G', 'C', 'C', 'C', 'T', 'C', 'C', 'T', 'A', 'G', 'C',
           'A', 'C', 'A', 'C', 'A', 'C', 'C', 'C', 'G', 'G', 'A', 'G', 'T',
           'G', 'G', '-', 'C', 'C', 'G', 'G', 'G', 'C', 'C', 'G', 'T', 'A',
           'C', 'T', 'T', 'T', 'C', 'C', 'T', 'T', 'T', 'T'],
          ['-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-',
           '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-',
           '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-',
           '-', '-', '-', '-', '-', '-', '-', '-', '-', '-'],
          ['A', 'A', 'G', 'C', 'C', 'C', 'T', 'G', 'C', '-', '-', 'G', 'C',
           'G', 'C', 'T', 'C', 'A', 'G', 'C', 'C', 'G', 'G', 'A', 'G', 'T',
           'G', 'T', 'C', 'C', 'C', 'G', 'G', 'G', 'C', 'C', 'C', 'T', 'G',
           'C', 'T', 'T', 'T', 'C', 'C', 'T', 'T', 'T', 'T']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 1)
        self.assertEqual(len(alignment.sequences), 1)
        self.assertEqual(alignment.sequences[0].id, "0")
        self.assertEqual(alignment.sequences[0].seq, "G")
        sequence = self.sequences[alignment.sequences[0].id]
        start = alignment.coordinates[0, 0]
        end = alignment.coordinates[0, -1]
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment[0], "G")
        self.assertTrue(np.array_equal(alignment.coordinates, np.array([[0, 1]])))
        self.assertEqual(
            str(alignment),
            """\
0                 0 G 1
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 1:1-1 + combined.fa
G
=
""",
        )
        self.assertTrue(
            np.array_equal(np.array(alignment, "U"), np.array([["G"]], dtype="U"))
        )
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 1)
        self.assertEqual(len(alignment.sequences), 1)
        self.assertEqual(alignment.sequences[0].id, "0")
        self.assertEqual(repr(alignment.sequences[0].seq), "Seq({49: 'A'}, length=50)")
        sequence = self.sequences[alignment.sequences[0].id]
        start = alignment.coordinates[0, 0]
        end = alignment.coordinates[0, -1]
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment[0], "A")
        self.assertTrue(np.array_equal(alignment.coordinates, np.array([[49, 50]])))
        self.assertEqual(
            str(alignment),
            """\
0                49 A 50
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 1:50-50 + combined.fa
A
=
""",
        )
        self.assertTrue(
            np.array_equal(np.array(alignment, "U"), np.array([["A"]], dtype="U"))
        )
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 1)
        self.assertEqual(len(alignment.sequences), 1)
        self.assertEqual(alignment.sequences[0].id, "1")
        self.assertEqual(
            alignment.sequences[0].seq, "GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT"
        )
        sequence = self.sequences[alignment.sequences[0].id]
        start = alignment.coordinates[0, 0]
        end = alignment.coordinates[0, -1]
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment[0], "GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT")
        self.assertTrue(np.array_equal(alignment.coordinates, np.array([[0, 41]])))
        self.assertEqual(
            str(alignment),
            """\
1                 0 GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT 41
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 2:1-41 + combined.fa
GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT
=
""",
        )
        self.assertTrue(
            np.array_equal(
                np.array(alignment, "U"),
                # fmt: off
np.array([['G', 'A', 'A', 'G', 'A', 'G', 'G', 'A', 'A', 'A', 'A', 'G', 'T',
           'A', 'G', 'A', 'T', 'C', 'C', 'C', 'T', 'G', 'G', 'C', 'G', 'T',
           'C', 'C', 'G', 'G', 'A', 'G', 'C', 'T', 'G', 'G', 'G', 'A', 'C',
           'G', 'T']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 1)
        self.assertEqual(len(alignment.sequences), 1)
        self.assertEqual(alignment.sequences[0].id, "2")
        self.assertEqual(alignment.sequences[0].seq, "C")
        sequence = self.sequences[alignment.sequences[0].id]
        start = alignment.coordinates[0, 0]
        end = alignment.coordinates[0, -1]
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment[0], "C")
        self.assertTrue(np.array_equal(alignment.coordinates, np.array([[0, 1]])))
        self.assertEqual(
            str(alignment),
            """\
2                 0 C 1
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 3:1-1 + combined.fa
C
=
""",
        )
        self.assertTrue(
            np.array_equal(np.array(alignment, "U"), np.array([["C"]], dtype="U"))
        )
        alignment = next(alignments)
        saved_alignments.append(alignment)
        self.assertEqual(len(alignment), 1)
        self.assertEqual(len(alignment.sequences), 1)
        self.assertEqual(alignment.sequences[0].id, "2")
        self.assertEqual(repr(alignment.sequences[0].seq), "Seq({48: 'C'}, length=49)")
        sequence = self.sequences[alignment.sequences[0].id]
        start = alignment.coordinates[0, 0]
        end = alignment.coordinates[0, -1]
        self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
        self.assertEqual(alignment[0], "C")
        self.assertTrue(np.array_equal(alignment.coordinates, np.array([[48, 49]])))
        self.assertEqual(
            str(alignment),
            """\
2                48 C 49
""",
        )
        self.assertEqual(
            alignment.format("mauve", metadata, identifiers),
            """\
> 3:49-49 + combined.fa
C
=
""",
        )
        self.assertTrue(
            np.array_equal(np.array(alignment, "U"), np.array([["C"]], dtype="U"))
        )
        self.assertRaises(StopIteration, next, alignments)
        # As each nucleotide in each sequence is stored exactly once in an XMFA
        # file, we can reconstitute the full sequences:
        self.assertEqual(len(saved_alignments), 6)
        maxindex = -1
        for alignment in saved_alignments:
            for record in alignment.sequences:
                index = int(record.id)
                if index > maxindex:
                    maxindex = index
        n = maxindex + 1
        self.assertEqual(n, 3)
        lengths = [0] * n
        for alignment in saved_alignments:
            for record in alignment.sequences:
                index = int(record.id)
                length = len(record.seq)
                if length > lengths[index]:
                    lengths[index] = length
        self.assertEqual(lengths[0], 50)
        self.assertEqual(lengths[1], 41)
        self.assertEqual(lengths[2], 49)
        sequences = [None] * 3
        for index, length in enumerate(lengths):
            sequences[index] = MutableSeq("N" * length)
        # Now fill up the sequences:
        for alignment in saved_alignments:
            for row, record in zip(alignment.coordinates, alignment.sequences):
                index = int(record.id)
                start = row[0]
                end = row[-1]
                if start > end:
                    start, end = end, start
                sequences[index][start:end] = record.seq[start:end]
        # Confirm that the fully defined sequences agree with the Fasta file:
        for index, sequence in enumerate(sequences):
            sequences[index] = Seq(sequence)
            key = str(index)
            self.assertEqual(sequences[index], self.sequences[key])
        # Make sure we can replace the partially defined sequences by these
        # fully defined sequences, and get the same alignment:
        alignment = saved_alignments[0]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(
                alignment[0], "AAGCCCTCCTAGCACACACCCGGAGTGG-CCGGGCCGTACTTTCCTTTT"
            )
            self.assertEqual(
                alignment[1], "-------------------------------------------------"
            )
            self.assertEqual(
                alignment[2], "AAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT"
            )
        alignment = saved_alignments[1]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(alignment[0], "G")
        alignment = saved_alignments[2]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(alignment[0], "A")
        alignment = saved_alignments[3]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(alignment[0], "GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT")
        alignment = saved_alignments[4]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(alignment[0], "C")
        alignment = saved_alignments[5]
        for record in alignment.sequences:
            index = int(record.id)
            record.seq = sequences[index]
            self.assertEqual(alignment[0], "C")

    def test_write_read(self):
        path = os.path.join("Mauve", "combined.xmfa")
        with open(path) as stream:
            data = stream.read()

        stream = StringIO()
        stream.write(data)
        stream.seek(0)
        alignments = Align.parse(stream, "mauve")
        output = StringIO()
        n = Align.write(alignments, output, "mauve")
        self.assertEqual(n, 6)
        output.seek(0)
        self.assertEqual(output.read(), data)


class TestSeparateFiles(unittest.TestCase):
    # Generate the output file separate.xmfa by running
    # progressiveMauve --solid-seeds equCab1.fa canFam2.fa mm9.fa --output=separate.xmfa

    sequences = {}
    for species in ("equCab1", "canFam2", "mm9"):
        filename = f"{species}.fa"
        path = os.path.join("Mauve", filename)
        record = SeqIO.read(path, "fasta")
        sequences[filename] = record.seq
        del filename
        del path
        del record

    def test_parse(self):
        path = os.path.join("Mauve", "separate.xmfa")
        saved_alignments = []
        with open(path) as stream:
            alignments = Align.parse(stream, "mauve")
            metadata = alignments.metadata
            self.assertEqual(len(metadata), 2)
            self.assertEqual(metadata["FormatVersion"], "Mauve1")
            self.assertEqual(metadata["BackboneFile"], "separate.xmfa.bbcols")
            identifiers = alignments.identifiers
            alignment = next(alignments)
            saved_alignments.append(alignment)
            self.assertEqual(len(alignment), 3)
            self.assertEqual(len(alignment.sequences), 3)
            self.assertEqual(alignment.sequences[0].id, "equCab1.fa")
            self.assertEqual(
                alignment.sequences[0].seq,
                Seq("GAAAAGGAAAGTACGGCCCGGCCACTCCGGGTGTGTGCTAGGAGGGCTTA"),
            )
            start = alignment.coordinates[0, 0]
            end = alignment.coordinates[0, -1]
            self.assertEqual(start, 50)
            self.assertEqual(end, 0)
            self.assertEqual(alignment.sequences[1].id, "canFam2.fa")
            self.assertEqual(
                alignment.sequences[1].seq,
                Seq("CAAGCCCTGCGCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTTC"),
            )
            start = alignment.coordinates[1, 0]
            end = alignment.coordinates[1, -1]
            sequence = self.sequences[alignment.sequences[1].id]
            self.assertEqual(start, 0)
            self.assertEqual(end, 49)
            self.assertEqual(alignment.sequences[1].seq[start:end], sequence[start:end])
            self.assertEqual(alignment.sequences[2].id, "mm9.fa")

            sequence = alignment.sequences[2].seq
            start = len(sequence) - alignment.coordinates[2, 0]
            end = len(sequence) - alignment.coordinates[2, -1]
            self.assertEqual(start, 0)
            self.assertEqual(end, 19)
            sequence = self.sequences[alignment.sequences[2].id][start:end]
            self.assertEqual(alignment.sequences[2].seq[start:end], sequence)
            self.assertEqual(
                alignment[0], "TAAGCCCTCCTAGCACACACCCGGAGTGGCC-GGGCCGTAC-TTTCCTTTTC"
            )
            self.assertEqual(
                alignment[1], "CAAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGC-TTTCCTTTTC"
            )
            self.assertEqual(
                alignment[2], "---------------------------------GGATCTACTTTTCCTCTTC"
            )
            self.assertEqual(
                str(alignment),
                """\
equCab1.f        50 TAAGCCCTCCTAGCACACACCCGGAGTGGCC-GGGCCGTAC-TTTCCTTTTC  0
canFam2.f         0 CAAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGC-TTTCCTTTTC 49
mm9.fa           19 ---------------------------------GGATCTACTTTTCCTCTTC  0
""",
            )
            self.assertTrue(
                np.array_equal(
                    alignment.coordinates,
                    # fmt: off
                    np.array([[50, 40, 38, 19, 19, 18, 10, 10,  0],
                              [ 0, 10, 10, 29, 30, 31, 39, 39, 49],
                              [19, 19, 19, 19, 19, 19, 11, 10,  0]]),
                    # fmt: on
                )
            )
            self.assertEqual(
                alignment.format("mauve", metadata, identifiers),
                """\
> 1:1-50 - equCab1.fa
TAAGCCCTCCTAGCACACACCCGGAGTGGCC-GGGCCGTAC-TTTCCTTTTC
> 2:1-49 + canFam2.fa
CAAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGC-TTTCCTTTTC
> 3:1-19 - mm9.fa
---------------------------------GGATCTACTTTTCCTCTTC
=
""",
            )
            self.assertTrue(
                np.array_equal(
                    np.array(alignment, "U"),
                    # fmt: off
np.array([['T', 'A', 'A', 'G', 'C', 'C', 'C', 'T', 'C', 'C', 'T', 'A', 'G',
           'C', 'A', 'C', 'A', 'C', 'A', 'C', 'C', 'C', 'G', 'G', 'A', 'G',
           'T', 'G', 'G', 'C', 'C', '-', 'G', 'G', 'G', 'C', 'C', 'G', 'T',
           'A', 'C', '-', 'T', 'T', 'T', 'C', 'C', 'T', 'T', 'T', 'T', 'C'],
          ['C', 'A', 'A', 'G', 'C', 'C', 'C', 'T', 'G', 'C', '-', '-', 'G',
           'C', 'G', 'C', 'T', 'C', 'A', 'G', 'C', 'C', 'G', 'G', 'A', 'G',
           'T', 'G', 'T', 'C', 'C', 'C', 'G', 'G', 'G', 'C', 'C', 'C', 'T',
           'G', 'C', '-', 'T', 'T', 'T', 'C', 'C', 'T', 'T', 'T', 'T', 'C'],
          ['-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-',
           '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-',
           '-', '-', '-', '-', '-', '-', '-', 'G', 'G', 'A', 'T', 'C', 'T',
           'A', 'C', 'T', 'T', 'T', 'T', 'C', 'C', 'T', 'C', 'T', 'T', 'C']],
         dtype='U')
                    # fmt: on
                )
            )
            alignment = next(alignments)
            saved_alignments.append(alignment)
            self.assertEqual(len(alignment), 1)
            self.assertEqual(len(alignment.sequences), 1)
            self.assertEqual(alignment.sequences[0].id, "mm9.fa")
            self.assertEqual(
                repr(alignment.sequences[0].seq),
                "Seq({19: 'CTGGCGTCCGGAGCTGGGACGT'}, length=41)",
            )
            sequence = self.sequences[alignment.sequences[0].id]
            start = alignment.coordinates[0, 0]
            end = alignment.coordinates[0, -1]
            self.assertEqual(alignment.sequences[0].seq[start:end], sequence[start:end])
            self.assertEqual(alignment[0], "CTGGCGTCCGGAGCTGGGACGT")
            self.assertTrue(np.array_equal(alignment.coordinates, np.array([[19, 41]])))
            self.assertEqual(
                str(alignment),
                """\
mm9.fa           19 CTGGCGTCCGGAGCTGGGACGT 41
""",
            )
            self.assertEqual(
                alignment.format("mauve", metadata, identifiers),
                """\
> 3:20-41 + mm9.fa
CTGGCGTCCGGAGCTGGGACGT
=
""",
            )
            self.assertTrue(
                np.array_equal(
                    np.array(alignment, "U"),
                    # fmt: off
np.array([['C', 'T', 'G', 'G', 'C', 'G', 'T', 'C', 'C', 'G', 'G',
           'A', 'G', 'C', 'T', 'G', 'G', 'G', 'A', 'C', 'G', 'T']], dtype='U')
                    # fmt: on
                )
            )
            self.assertRaises(StopIteration, next, alignments)
        # As each nucleotide in each sequence is stored exactly once in an XMFA
        # file, we can reconstitute the full sequences:
        self.assertEqual(len(saved_alignments), 2)
        filenames = []
        for alignment in saved_alignments:
            for record in alignment.sequences:
                filename = record.id
                filenames.append(filename)
        filenames = set(filenames)
        n = len(filenames)
        self.assertEqual(n, 3)
        lengths = {filename: 0 for filename in filenames}
        for alignment in saved_alignments:
            for record in alignment.sequences:
                filename = record.id
                length = len(record.seq)
                if length > lengths[filename]:
                    lengths[filename] = length
        self.assertEqual(lengths["equCab1.fa"], 50)
        self.assertEqual(lengths["canFam2.fa"], 49)
        self.assertEqual(lengths["mm9.fa"], 41)
        sequences = {}
        for filename, length in lengths.items():
            sequences[filename] = MutableSeq("N" * length)
        # Now fill up the sequences:
        for alignment in saved_alignments:
            for row, record in zip(alignment.coordinates, alignment.sequences):
                filename = record.id
                start = row[0]
                end = row[-1]
                if start > end:
                    start, end = end, start
                sequences[filename][start:end] = record.seq[start:end]
        # Confirm that the fully defined sequences agree with the Fasta file:
        for filename, sequence in sequences.items():
            sequences[filename] = Seq(sequence)
            self.assertEqual(sequences[filename], self.sequences[filename])
        # Make sure we can replace the partially defined sequences by these
        # fully defined sequences, and get the same alignment:
        alignment = saved_alignments[0]
        for record in alignment.sequences:
            filename = record.id
            record.seq = sequences[filename]
            self.assertEqual(
                alignment[0], "TAAGCCCTCCTAGCACACACCCGGAGTGGCC-GGGCCGTAC-TTTCCTTTTC"
            )
            self.assertEqual(
                alignment[1], "CAAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGC-TTTCCTTTTC"
            )
            self.assertEqual(
                alignment[2], "---------------------------------GGATCTACTTTTCCTCTTC"
            )
        alignment = saved_alignments[1]
        for record in alignment.sequences:
            filename = record.id
            record.seq = sequences[filename]
            self.assertEqual(alignment[0], "CTGGCGTCCGGAGCTGGGACGT")

    def test_write_read(self):
        path = os.path.join("Mauve", "separate.xmfa")
        with open(path) as stream:
            data = stream.read()

        stream = StringIO()
        stream.write(data)
        stream.seek(0)
        alignments = Align.parse(stream, "mauve")
        output = StringIO()
        n = Align.write(alignments, output, "mauve")
        self.assertEqual(n, 2)
        output.seek(0)
        self.assertEqual(output.read(), data)


class TestMauveBasic(unittest.TestCase):
    def test_empty(self):
        stream = StringIO()
        with self.assertRaisesRegex(ValueError, "Empty file."):
            Align.parse(stream, "mauve")


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