tests.test_distance

Complexity

Total Complexity

115

Size/Duplication

Total Lines	3017
Duplicated Lines	0 %

Importance

Changes

0

100 Methods

Rating	Name	Duplication	Size	Complexity
A	HammingTestCases.test_hamming()	0	23	1
A	DiceTestCases.test_sim_dice()	0	25	1
A	OverlapTestCases.test_dist_overlap()	0	25	1
A	TanimotoTestCases.test_tanimoto_coeff()	0	25	1
A	HammingTestCases.test_dist_hamming()	0	23	1
B	LevenshteinTestCases.test_levenshtein()	0	87	1
A	HammingTestCases.test_sim_hamming()	0	23	1
A	LevenshteinTestCases.test_sim_levenshtein()	0	13	1
A	DiceTestCases.test_dist_dice()	0	25	1
A	JaccardTestCases.test_sim_jaccard()	0	25	1
A	LevenshteinTestCases.test_dist_damerau()	0	33	1
A	TverskyIndexTestCases.test_sim_tversky()	0	47	1
A	OverlapTestCases.test_sim_overlap()	0	25	1
A	TanimotoTestCases.test_tanimoto()	0	30	1
A	TverskyIndexTestCases.test_dist_tversky()	0	48	1
A	LevenshteinTestCases.test_damerau_levenshtein()	0	23	1
A	LevenshteinTestCases.test_dist_levenshtein()	0	13	1
A	JaccardTestCases.test_dist_jaccard()	0	25	1
A	LevenshteinTestCases.test_sim_damerau()	0	33	1
B	MinkowskiTestCases.test_minkowski()	0	47	1
A	ManhattanTestCases.test_manhattan()	0	25	1
A	MinkowskiTestCases.test_sim_minkowski()	0	25	1
A	ManhattanTestCases.test_dist_manhattan()	0	25	1
A	ManhattanTestCases.test_sim_manhattan()	0	25	1
A	MinkowskiTestCases.test_dist_minkowski()	0	25	1
A	EuclideanTestCases.test_sim_euclidean()	0	30	1
A	ChebyshevTestCases.test_dist_chebyshev()	0	25	1
A	ChebyshevTestCases.test_chebyshev()	0	25	1
A	EuclideanTestCases.test_dist_euclidean()	0	30	1
A	CosineSimilarityTestCases.test_dist_cosine()	0	30	1
A	ChebyshevTestCases.test_sim_chebyshev()	0	25	1
A	EuclideanTestCases.test_euclidean()	0	25	1
A	CosineSimilarityTestCases.test_sim_cosine()	0	29	1
A	TypoTestCases.test_dist_typo()	0	19	1
A	Sift4TestCases.test_sift4_common()	0	48	1
A	CompressionTestCases.test_sim_compression()	0	24	1
A	BagTestCases.test_dist_bag()	0	13	1
A	PrefixTestCases.test_dist_prefix()	0	30	1
B	Sift4TestCases.test_sim_sift4()	0	54	1
A	LcsstrTestCases.test_lcsstr()	0	44	1
A	LengthTestCases.test_dist_ident()	0	13	1
A	SuffixTestCases.test_dist_suffix()	0	30	1
A	CompressionTestCases.test_dist_compression()	0	25	1
A	LcsseqTestCases.test_dist_lcsseq()	0	34	1
A	JaroWinklerTestCases.test_sim_strcmp95()	0	31	1
A	LcsstrTestCases.test_sim_lcsstr()	0	34	1
A	CompressionTestCases.test_sim_compression_arith()	0	22	1
A	BaystatTestCases.test_sim_baystat()	0	26	1
A	BagTestCases.test_sim_bag()	0	13	1
B	SynonameTestCases.test_synoname()	0	117	1
A	MongeElkanTestCases.test_dist_monge_elkan()	0	18	1
A	SuffixTestCases.test_sim_suffix()	0	30	1
A	SmithWatermanTestCases.test_smith_waterman()	0	16	1
A	EudexTestCases.test_dist_eudex()	0	20	1
A	SynonameTestCases.test_synoname_strip_punct()	0	6	1
A	EditexTestCases.test_editex_local()	0	15	1
A	EditexTestCases.test_editex()	0	15	1
A	GotohTestCases.test_gotoh_nialls()	0	14	3
A	LengthTestCases.test_sim_ident()	0	13	1
A	BaystatTestCases.test_dist_baystat()	0	21	1
A	SynonameTestCases.test_synoname_word_approximation()	0	20	1
A	GotohTestCases.test_gotoh()	0	31	1
A	SimDistTestCases.test_sim()	0	5	1
A	TypoTestCases.test_sim_typo()	0	21	1
A	MLIPNSTestCases.test_dist_mlipns()	0	13	1
A	IndelTestCases.test_dist_indel()	0	14	1
A	MatrixSimTestCases.test_sim_matrix()	0	22	1
B	EudexTestCases.test_eudex_hamming()	0	40	5
A	MongeElkanTestCases.test_sim_monge_elkan()	0	19	1
B	Sift4TestCases.test_dist_sift4()	0	54	1
A	BagTestCases.test_bag()	0	13	1
A	IdentityTestCases.test_dist_ident()	0	9	1
A	LcsseqTestCases.test_sim_lcsseq()	0	34	1
A	Sift4TestCases.test_sift4_simplest()	0	42	1
A	LcsseqTestCases.test_lcsseq()	0	34	1
B	RatcliffObershelpTestCases.test_sim_ratcliff_obershelp()	0	47	5
A	MraTestCases.test_mra_compare()	0	17	1
A	EditexTestCases.test_sim_editex()	0	10	1
B	JaroWinklerTestCases.test_sim_jaro_winkler()	0	50	1
A	NeedlemanWunschTestCases.test_needleman_wunsch_nialls()	0	7	2
A	SimDistTestCases.test_dist()	0	5	1
A	SmithWatermanTestCases.test_smith_waterman_nialls()	0	6	2
A	MLIPNSTestCases.test_sim_mlipns()	0	13	1
A	EditexTestCases.test_dist_editex()	0	10	1
A	JaroWinklerTestCases.test_dist_strcmp95()	0	12	1
A	PrefixTestCases.test_sim_prefix()	0	30	1
A	CompressionTestCases.test_dist_compression_rle()	0	15	1
A	TypoTestCases.test_typo()	0	21	1
A	RatcliffObershelpTestCases.test_dist_ratcliff_obershelp()	0	28	1
A	MraTestCases.test_dist_mra()	0	17	1
A	MraTestCases.test_sim_mra()	0	17	1
A	IdentityTestCases.test_sim_ident()	0	9	1
A	LcsstrTestCases.test_dist_lcsstr()	0	34	1
A	CompressionTestCases.test_dist_compression_arith()	0	22	1
A	EudexTestCases.test_sim_eudex()	0	20	1
A	IndelTestCases.test_sim_indel()	0	14	1
A	JaroWinklerTestCases.test_dist_jaro_winkler()	0	36	1
A	CompressionTestCases.test_lzma()	0	12	2
A	NeedlemanWunschTestCases.test_needleman_wunsch()	0	17	1
A	CompressionTestCases.test_sim_compression_rle()	0	14	1

# -*- coding: utf-8 -*-

# Copyright 2014-2018 by Christopher C. Little.
# This file is part of Abydos.
#
# Abydos is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Abydos is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Abydos. If not, see <http://www.gnu.org/licenses/>.

"""abydos.tests.test_distance.

This module contains unit tests for abydos.distance
"""

from __future__ import division, unicode_literals

import math
import os
import pkgutil
import sys
import unittest
from difflib import SequenceMatcher

from abydos.compression import ac_train
from abydos.distance import _synoname_strip_punct, bag, chebyshev, \
    damerau_levenshtein, dist, dist_bag, dist_baystat, dist_chebyshev, \
    dist_compression, dist_cosine, dist_damerau, dist_dice, dist_editex, \
    dist_euclidean, dist_eudex, dist_hamming, dist_ident, dist_indel, \
    dist_jaccard, dist_jaro_winkler, dist_lcsseq, dist_lcsstr, dist_length, \
    dist_levenshtein, dist_manhattan, dist_minkowski, dist_mlipns, \
    dist_monge_elkan, dist_mra, dist_overlap, dist_prefix, \
    dist_ratcliff_obershelp, dist_sift4, dist_strcmp95, dist_suffix, \
    dist_tversky, dist_typo, editex, euclidean, eudex_hamming, gotoh, \
    hamming, lcsseq, lcsstr, levenshtein, manhattan, minkowski, mra_compare, \
    needleman_wunsch, sift4_common, sift4_simplest, sim, sim_bag, \
    sim_baystat, sim_chebyshev, sim_compression, sim_cosine, sim_damerau, \
    sim_dice, sim_editex, sim_euclidean, sim_eudex, sim_hamming, sim_ident, \
    sim_indel, sim_jaccard, sim_jaro_winkler, sim_lcsseq, sim_lcsstr, \
    sim_length, sim_levenshtein, sim_manhattan, sim_matrix, sim_minkowski, \
    sim_mlipns, sim_monge_elkan, sim_mra, sim_overlap, sim_prefix, \
    sim_ratcliff_obershelp, sim_sift4, sim_strcmp95, sim_suffix, \
    sim_tanimoto, sim_tversky, sim_typo, smith_waterman, synoname, \
    synoname_word_approximation, tanimoto, typo
from abydos.qgram import QGrams

from six.moves import range

TESTDIR = os.path.dirname(__file__)

NIALL = ('Niall', 'Neal', 'Neil', 'Njall', 'Njáll', 'Nigel', 'Neel', 'Nele',
         'Nigelli', 'Nel', 'Kneale', 'Uí Néill', 'O\'Neill', 'MacNeil',
         'MacNele', 'Niall Noígíallach')

COLIN = ('Colin', 'Collin', 'Cullen', 'Cuilen', 'Cailean', 'MacCailean',
         'Cuilén', 'Colle', 'Calum', 'Callum', 'Colinn', 'Colon', 'Colynn',
         'Col', 'Cole', 'Nicolas', 'Nicholas', 'Cailean Mór Caimbeul')


class LevenshteinTestCases(unittest.TestCase):
    """Test Levenshtein functions.

    abydos.distance.levenshtein, .dist_levenshtein,
    .sim_levenshtein, .damerau, .dist_damerau, & .sim_damerau
    """

    def test_levenshtein(self):
        """Test abydos.distance.levenshtein."""
        self.assertEqual(levenshtein('', ''), 0)

        # http://oldfashionedsoftware.com/tag/levenshtein-distance/
        self.assertEqual(levenshtein('a', ''), 1)
        self.assertEqual(levenshtein('', 'a'), 1)
        self.assertEqual(levenshtein('abc', ''), 3)
        self.assertEqual(levenshtein('', 'abc'), 3)
        self.assertEqual(levenshtein('', ''), 0)
        self.assertEqual(levenshtein('a', 'a'), 0)
        self.assertEqual(levenshtein('abc', 'abc'), 0)
        self.assertEqual(levenshtein('', 'a'), 1)
        self.assertEqual(levenshtein('a', 'ab'), 1)
        self.assertEqual(levenshtein('b', 'ab'), 1)
        self.assertEqual(levenshtein('ac', 'abc'), 1)
        self.assertEqual(levenshtein('abcdefg', 'xabxcdxxefxgx'), 6)
        self.assertEqual(levenshtein('a', ''), 1)
        self.assertEqual(levenshtein('ab', 'a'), 1)
        self.assertEqual(levenshtein('ab', 'b'), 1)
        self.assertEqual(levenshtein('abc', 'ac'), 1)
        self.assertEqual(levenshtein('xabxcdxxefxgx', 'abcdefg'), 6)
        self.assertEqual(levenshtein('a', 'b'), 1)
        self.assertEqual(levenshtein('ab', 'ac'), 1)
        self.assertEqual(levenshtein('ac', 'bc'), 1)
        self.assertEqual(levenshtein('abc', 'axc'), 1)
        self.assertEqual(levenshtein('xabxcdxxefxgx', '1ab2cd34ef5g6'), 6)
        self.assertEqual(levenshtein('example', 'samples'), 3)
        self.assertEqual(levenshtein('sturgeon', 'urgently'), 6)
        self.assertEqual(levenshtein('levenshtein', 'frankenstein'), 6)
        self.assertEqual(levenshtein('distance', 'difference'), 5)
        self.assertEqual(levenshtein('java was neat', 'scala is great'), 7)

        # https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
        self.assertEqual(levenshtein('CA', 'ABC', 'dam'), 2)
        self.assertEqual(levenshtein('CA', 'ABC', 'osa'), 3)

        # test cost of insert
        self.assertEqual(levenshtein('', 'b', 'lev', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(levenshtein('', 'b', 'osa', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(levenshtein('', 'b', 'dam', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(levenshtein('a', 'ab', 'lev', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(levenshtein('a', 'ab', 'osa', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(levenshtein('a', 'ab', 'dam', cost=(5, 7, 10, 10)), 5)

        # test cost of delete
        self.assertEqual(levenshtein('b', '', 'lev', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(levenshtein('b', '', 'osa', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(levenshtein('b', '', 'dam', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(levenshtein('ab', 'a', 'lev', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(levenshtein('ab', 'a', 'osa', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(levenshtein('ab', 'a', 'dam', cost=(5, 7, 10, 10)), 7)

        # test cost of substitute
        self.assertEqual(levenshtein('a', 'b', 'lev', cost=(10, 10, 5, 10)), 5)
        self.assertEqual(levenshtein('a', 'b', 'osa', cost=(10, 10, 5, 10)), 5)
        self.assertEqual(levenshtein('a', 'b', 'dam', cost=(10, 10, 5, 10)), 5)
        self.assertEqual(levenshtein('ac', 'bc', 'lev',
                                     cost=(10, 10, 5, 10)), 5)
        self.assertEqual(levenshtein('ac', 'bc', 'osa',
                                     cost=(10, 10, 5, 10)), 5)
        self.assertEqual(levenshtein('ac', 'bc', 'dam',
                                     cost=(10, 10, 5, 10)), 5)

        # test cost of transpose
        self.assertEqual(levenshtein('ab', 'ba', 'lev',
                                     cost=(10, 10, 10, 5)), 20)
        self.assertEqual(levenshtein('ab', 'ba', 'osa',
                                     cost=(10, 10, 10, 5)), 5)
        self.assertEqual(levenshtein('ab', 'ba', 'dam',
                                     cost=(5, 5, 10, 5)), 5)
        self.assertEqual(levenshtein('abc', 'bac', 'lev',
                                     cost=(10, 10, 10, 5)), 20)
        self.assertEqual(levenshtein('abc', 'bac', 'osa',
                                     cost=(10, 10, 10, 5)), 5)
        self.assertEqual(levenshtein('abc', 'bac', 'dam',
                                     cost=(5, 5, 10, 5)), 5)
        self.assertEqual(levenshtein('cab', 'cba', 'lev',
                                     cost=(10, 10, 10, 5)), 20)
        self.assertEqual(levenshtein('cab', 'cba', 'osa',
                                     cost=(10, 10, 10, 5)), 5)
        self.assertEqual(levenshtein('cab', 'cba', 'dam',
                                     cost=(5, 5, 10, 5)), 5)

        # test exception
        self.assertRaises(ValueError, levenshtein, 'ab', 'ba', 'dam',
                          cost=(10, 10, 10, 5))

    def test_dist_levenshtein(self):
        """Test abydos.distance.dist_levenshtein."""
        self.assertEqual(dist_levenshtein('', ''), 0)

        self.assertEqual(dist_levenshtein('a', 'a'), 0)
        self.assertEqual(dist_levenshtein('ab', 'ab'), 0)
        self.assertEqual(dist_levenshtein('', 'a'), 1)
        self.assertEqual(dist_levenshtein('', 'ab'), 1)
        self.assertEqual(dist_levenshtein('a', 'c'), 1)

        self.assertAlmostEqual(dist_levenshtein('abc', 'ac'), 1/3)
        self.assertAlmostEqual(dist_levenshtein('abbc', 'ac'), 1/2)
        self.assertAlmostEqual(dist_levenshtein('abbc', 'abc'), 1/4)

    def test_sim_levenshtein(self):
        """Test abydos.distance.sim_levenshtein."""
        self.assertEqual(sim_levenshtein('', ''), 1)

        self.assertEqual(sim_levenshtein('a', 'a'), 1)
        self.assertEqual(sim_levenshtein('ab', 'ab'), 1)
        self.assertEqual(sim_levenshtein('', 'a'), 0)
        self.assertEqual(sim_levenshtein('', 'ab'), 0)
        self.assertEqual(sim_levenshtein('a', 'c'), 0)

        self.assertAlmostEqual(sim_levenshtein('abc', 'ac'), 2/3)
        self.assertAlmostEqual(sim_levenshtein('abbc', 'ac'), 1/2)
        self.assertAlmostEqual(sim_levenshtein('abbc', 'abc'), 3/4)

    def test_damerau_levenshtein(self):
        """Test abydos.distance.damerau_levenshtein."""
        self.assertEqual(damerau_levenshtein('', ''), 0)
        self.assertEqual(damerau_levenshtein('CA', 'CA'), 0)
        self.assertEqual(damerau_levenshtein('CA', 'ABC'), 2)
        self.assertEqual(damerau_levenshtein('', 'b', cost=(5, 7, 10, 10)), 5)
        self.assertEqual(damerau_levenshtein('a', 'ab', cost=(5, 7, 10, 10)),
                         5)
        self.assertEqual(damerau_levenshtein('b', '', cost=(5, 7, 10, 10)), 7)
        self.assertEqual(damerau_levenshtein('ab', 'a', cost=(5, 7, 10, 10)),
                         7)
        self.assertEqual(damerau_levenshtein('a', 'b', cost=(10, 10, 5, 10)),
                         5)
        self.assertEqual(damerau_levenshtein('ac', 'bc',
                                             cost=(10, 10, 5, 10)), 5)
        self.assertEqual(damerau_levenshtein('ab', 'ba',
                                             cost=(5, 5, 10, 5)), 5)
        self.assertEqual(damerau_levenshtein('abc', 'bac',
                                             cost=(5, 5, 10, 5)), 5)
        self.assertEqual(damerau_levenshtein('cab', 'cba',
                                             cost=(5, 5, 10, 5)), 5)
        self.assertRaises(ValueError, damerau_levenshtein, 'ab', 'ba',
                          cost=(10, 10, 10, 5))

    def test_dist_damerau(self):
        """Test abydos.distance.dist_damerau."""
        self.assertEqual(dist_damerau('', ''), 0)

        self.assertEqual(dist_damerau('a', 'a'), 0)
        self.assertEqual(dist_damerau('ab', 'ab'), 0)
        self.assertEqual(dist_damerau('', 'a'), 1)
        self.assertEqual(dist_damerau('', 'ab'), 1)
        self.assertEqual(dist_damerau('a', 'c'), 1)

        self.assertAlmostEqual(dist_damerau('abc', 'ac'), 1/3)
        self.assertAlmostEqual(dist_damerau('abbc', 'ac'), 1/2)
        self.assertAlmostEqual(dist_damerau('abbc', 'abc'), 1/4)

        self.assertAlmostEqual(dist_damerau('CA', 'ABC'), 2/3)
        self.assertAlmostEqual(dist_damerau('', 'b', cost=(5, 7, 10, 10)), 1)
        self.assertAlmostEqual(dist_damerau('a', 'ab',
                                            cost=(5, 7, 10, 10)), 1/2)
        self.assertAlmostEqual(dist_damerau('b', '', cost=(5, 7, 10, 10)), 1)
        self.assertAlmostEqual(dist_damerau('ab', 'a',
                                            cost=(5, 7, 10, 10)), 1/2)
        self.assertAlmostEqual(dist_damerau('a', 'b',
                                            cost=(10, 10, 5, 10)), 1/2)
        self.assertAlmostEqual(dist_damerau('ac', 'bc',
                                            cost=(10, 10, 5, 10)), 1/4)
        self.assertAlmostEqual(dist_damerau('ab', 'ba',
                                            cost=(5, 5, 10, 5)), 1/2)
        self.assertAlmostEqual(dist_damerau('abc', 'bac',
                                            cost=(5, 5, 10, 5)), 1/3)
        self.assertAlmostEqual(dist_damerau('cab', 'cba',
                                            cost=(5, 5, 10, 5)), 1/3)
        self.assertRaises(ValueError, dist_damerau, 'ab', 'ba',
                          cost=(10, 10, 10, 5))

    def test_sim_damerau(self):
        """Test abydos.distance.sim_damerau."""
        self.assertEqual(sim_damerau('', ''), 1)

        self.assertEqual(sim_damerau('a', 'a'), 1)
        self.assertEqual(sim_damerau('ab', 'ab'), 1)
        self.assertEqual(sim_damerau('', 'a'), 0)
        self.assertEqual(sim_damerau('', 'ab'), 0)
        self.assertEqual(sim_damerau('a', 'c'), 0)

        self.assertAlmostEqual(sim_damerau('abc', 'ac'), 2/3)
        self.assertAlmostEqual(sim_damerau('abbc', 'ac'), 1/2)
        self.assertAlmostEqual(sim_damerau('abbc', 'abc'), 3/4)

        self.assertAlmostEqual(sim_damerau('CA', 'ABC'), 1/3)
        self.assertAlmostEqual(sim_damerau('', 'b', cost=(5, 7, 10, 10)), 0)
        self.assertAlmostEqual(sim_damerau('a', 'ab', cost=(5, 7, 10, 10)),
                               1/2)
        self.assertAlmostEqual(sim_damerau('b', '', cost=(5, 7, 10, 10)), 0)
        self.assertAlmostEqual(sim_damerau('ab', 'a', cost=(5, 7, 10, 10)),
                               1/2)
        self.assertAlmostEqual(sim_damerau('a', 'b', cost=(10, 10, 5, 10)),
                               1/2)
        self.assertAlmostEqual(sim_damerau('ac', 'bc',
                                           cost=(10, 10, 5, 10)), 3/4)
        self.assertAlmostEqual(sim_damerau('ab', 'ba',
                                           cost=(5, 5, 10, 5)), 1/2)
        self.assertAlmostEqual(sim_damerau('abc', 'bac',
                                           cost=(5, 5, 10, 5)), 2/3)
        self.assertAlmostEqual(sim_damerau('cab', 'cba',
                                           cost=(5, 5, 10, 5)), 2/3)
        self.assertRaises(ValueError, sim_damerau, 'ab', 'ba',
                          cost=(10, 10, 10, 5))


class HammingTestCases(unittest.TestCase):
    """Test Hamming functions.

    abydos.distance.hamming, .dist_hamming, & .sim_hamming
    """

    def test_hamming(self):
        """Test abydos.distance.hamming."""
        self.assertEqual(hamming('', ''), 0)
        self.assertEqual(hamming('', '', False), 0)

        self.assertEqual(hamming('a', ''), 1)
        self.assertEqual(hamming('a', 'a'), 0)
        self.assertEqual(hamming('a', 'a', False), 0)
        self.assertEqual(hamming('a', 'b'), 1)
        self.assertEqual(hamming('a', 'b', False), 1)
        self.assertEqual(hamming('abc', 'cba'), 2)
        self.assertEqual(hamming('abc', 'cba', False), 2)
        self.assertEqual(hamming('abc', ''), 3)
        self.assertEqual(hamming('bb', 'cbab'), 3)

        # test exception
        self.assertRaises(ValueError, hamming, 'ab', 'a', False)

        # https://en.wikipedia.org/wiki/Hamming_distance
        self.assertEqual(hamming('karolin', 'kathrin'), 3)
        self.assertEqual(hamming('karolin', 'kerstin'), 3)
        self.assertEqual(hamming('1011101', '1001001'), 2)
        self.assertEqual(hamming('2173896', '2233796'), 3)

    def test_dist_hamming(self):
        """Test abydos.distance.dist_hamming."""
        self.assertEqual(dist_hamming('', ''), 0)
        self.assertEqual(dist_hamming('', '', False), 0)

        self.assertEqual(dist_hamming('a', ''), 1)
        self.assertEqual(dist_hamming('a', 'a'), 0)
        self.assertEqual(dist_hamming('a', 'a', False), 0)
        self.assertEqual(dist_hamming('a', 'b'), 1)
        self.assertEqual(dist_hamming('a', 'b', False), 1)
        self.assertAlmostEqual(dist_hamming('abc', 'cba'), 2/3)
        self.assertAlmostEqual(dist_hamming('abc', 'cba', False), 2/3)
        self.assertEqual(dist_hamming('abc', ''), 1)
        self.assertAlmostEqual(dist_hamming('bb', 'cbab'), 3/4)

        # test exception
        self.assertRaises(ValueError, dist_hamming, 'ab', 'a', False)

        # https://en.wikipedia.org/wiki/Hamming_distance
        self.assertAlmostEqual(dist_hamming('karolin', 'kathrin'), 3/7)
        self.assertAlmostEqual(dist_hamming('karolin', 'kerstin'), 3/7)
        self.assertAlmostEqual(dist_hamming('1011101', '1001001'), 2/7)
        self.assertAlmostEqual(dist_hamming('2173896', '2233796'), 3/7)

    def test_sim_hamming(self):
        """Test abydos.distance.sim_hamming."""
        self.assertEqual(sim_hamming('', ''), 1)
        self.assertEqual(sim_hamming('', '', False), 1)

        self.assertEqual(sim_hamming('a', ''), 0)
        self.assertEqual(sim_hamming('a', 'a'), 1)
        self.assertEqual(sim_hamming('a', 'a', False), 1)
        self.assertEqual(sim_hamming('a', 'b'), 0)
        self.assertEqual(sim_hamming('a', 'b', False), 0)
        self.assertAlmostEqual(sim_hamming('abc', 'cba'), 1/3)
        self.assertAlmostEqual(sim_hamming('abc', 'cba', False), 1/3)
        self.assertEqual(sim_hamming('abc', ''), 0)
        self.assertAlmostEqual(sim_hamming('bb', 'cbab'), 1/4)

        # test exception
        self.assertRaises(ValueError, sim_hamming, 'ab', 'a', False)

        # https://en.wikipedia.org/wiki/Hamming_distance
        self.assertAlmostEqual(sim_hamming('karolin', 'kathrin'), 4/7)
        self.assertAlmostEqual(sim_hamming('karolin', 'kerstin'), 4/7)
        self.assertAlmostEqual(sim_hamming('1011101', '1001001'), 5/7)
        self.assertAlmostEqual(sim_hamming('2173896', '2233796'), 4/7)


NONQ_FROM = 'The quick brown fox jumped over the lazy dog.'
NONQ_TO = 'That brown dog jumped over the fox.'


class TverskyIndexTestCases(unittest.TestCase):
    """Test Tversky functions.

    abydos.distance.sim_tversky & .dist_tversky
    """

    def test_sim_tversky(self):
        """Test abydos.distance.sim_tversky."""
        self.assertEqual(sim_tversky('', ''), 1)
        self.assertEqual(sim_tversky('nelson', ''), 0)
        self.assertEqual(sim_tversky('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_tversky('nelson', 'neilsen'), 4/11)

        self.assertEqual(sim_tversky('', '', 2), 1)
        self.assertEqual(sim_tversky('nelson', '', 2), 0)
        self.assertEqual(sim_tversky('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_tversky('nelson', 'neilsen', 2), 4/11)

        # test valid alpha & beta
        self.assertRaises(ValueError, sim_tversky, 'abcd', 'dcba', 2, -1, -1)
        self.assertRaises(ValueError, sim_tversky, 'abcd', 'dcba', 2, -1, 0)
        self.assertRaises(ValueError, sim_tversky, 'abcd', 'dcba', 2, 0, -1)

        # test empty QGrams
        self.assertAlmostEqual(sim_tversky('nelson', 'neilsen', 7), 0.0)

        # test unequal alpha & beta
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 2, 1), 3/11)
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 1, 2), 3/10)
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 2, 2), 3/13)

        # test bias parameter
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 1, 1, 0.5),
                               7/11)
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 2, 1, 0.5), 7/9)
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 1, 2, 0.5),
                               7/15)
        self.assertAlmostEqual(sim_tversky('niall', 'neal', 2, 2, 2, 0.5),
                               7/11)

        # supplied q-gram tests
        self.assertEqual(sim_tversky(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_tversky(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_tversky(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_tversky(QGrams('nelson'),
                                           QGrams('neilsen')), 4/11)

        # non-q-gram tests
        self.assertEqual(sim_tversky('', '', 0), 1)
        self.assertEqual(sim_tversky('the quick', '', 0), 0)
        self.assertEqual(sim_tversky('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_tversky(NONQ_FROM, NONQ_TO, 0), 1/3)
        self.assertAlmostEqual(sim_tversky(NONQ_TO, NONQ_FROM, 0), 1/3)

    def test_dist_tversky(self):
        """Test abydos.distance.dist_tversky."""
        self.assertEqual(dist_tversky('', ''), 0)
        self.assertEqual(dist_tversky('nelson', ''), 1)
        self.assertEqual(dist_tversky('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_tversky('nelson', 'neilsen'), 7/11)

        self.assertEqual(dist_tversky('', '', 2), 0)
        self.assertEqual(dist_tversky('nelson', '', 2), 1)
        self.assertEqual(dist_tversky('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_tversky('nelson', 'neilsen', 2), 7/11)

        # test valid alpha & beta
        self.assertRaises(ValueError, dist_tversky, 'abcd', 'dcba', 2, -1, -1)
        self.assertRaises(ValueError, dist_tversky, 'abcd', 'dcba', 2, -1, 0)
        self.assertRaises(ValueError, dist_tversky, 'abcd', 'dcba', 2, 0, -1)

        # test empty QGrams
        self.assertAlmostEqual(dist_tversky('nelson', 'neilsen', 7), 1.0)

        # test unequal alpha & beta
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 2, 1), 8/11)
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 1, 2), 7/10)
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 2, 2), 10/13)

        # test bias parameter
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 1, 1, 0.5),
                               4/11)
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 2, 1, 0.5),
                               2/9)
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 1, 2, 0.5),
                               8/15)
        self.assertAlmostEqual(dist_tversky('niall', 'neal', 2, 2, 2, 0.5),
                               4/11)

        # supplied q-gram tests
        self.assertEqual(dist_tversky(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_tversky(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_tversky(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_tversky(QGrams('nelson'),
                                            QGrams('neilsen')), 7/11)

        # non-q-gram tests
        self.assertEqual(dist_tversky('', '', 0), 0)
        self.assertEqual(dist_tversky('the quick', '', 0), 1)
        self.assertEqual(dist_tversky('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_tversky(NONQ_FROM, NONQ_TO, 0), 2/3)
        self.assertAlmostEqual(dist_tversky(NONQ_TO, NONQ_FROM, 0), 2/3)


class DiceTestCases(unittest.TestCase):
    """Test Dice functions.

    abydos.distance.sim_dice & .dist_dice
    """

    def test_sim_dice(self):
        """Test abydos.distance.sim_dice."""
        self.assertEqual(sim_dice('', ''), 1)
        self.assertEqual(sim_dice('nelson', ''), 0)
        self.assertEqual(sim_dice('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_dice('nelson', 'neilsen'), 8/15)

        self.assertEqual(sim_dice('', '', 2), 1)
        self.assertEqual(sim_dice('nelson', '', 2), 0)
        self.assertEqual(sim_dice('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_dice('nelson', 'neilsen', 2), 8/15)

        # supplied q-gram tests
        self.assertEqual(sim_dice(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_dice(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_dice(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_dice(QGrams('nelson'), QGrams('neilsen')),
                               8/15)

        # non-q-gram tests
        self.assertEqual(sim_dice('', '', 0), 1)
        self.assertEqual(sim_dice('the quick', '', 0), 0)
        self.assertEqual(sim_dice('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_dice(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(sim_dice(NONQ_TO, NONQ_FROM, 0), 1/2)

    def test_dist_dice(self):
        """Test abydos.distance.dist_dice."""
        self.assertEqual(dist_dice('', ''), 0)
        self.assertEqual(dist_dice('nelson', ''), 1)
        self.assertEqual(dist_dice('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_dice('nelson', 'neilsen'), 7/15)

        self.assertEqual(dist_dice('', '', 2), 0)
        self.assertEqual(dist_dice('nelson', '', 2), 1)
        self.assertEqual(dist_dice('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_dice('nelson', 'neilsen', 2), 7/15)

        # supplied q-gram tests
        self.assertEqual(dist_dice(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_dice(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_dice(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_dice(QGrams('nelson'), QGrams('neilsen')),
                               7/15)

        # non-q-gram tests
        self.assertEqual(dist_dice('', '', 0), 0)
        self.assertEqual(dist_dice('the quick', '', 0), 1)
        self.assertEqual(dist_dice('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_dice(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(dist_dice(NONQ_TO, NONQ_FROM, 0), 1/2)


class JaccardTestCases(unittest.TestCase):
    """Test Jaccard functions.

    abydos.distance.sim_jaccard & .dist_jaccard
    """

    def test_sim_jaccard(self):
        """Test abydos.distance.sim_jaccard."""
        self.assertEqual(sim_jaccard('', ''), 1)
        self.assertEqual(sim_jaccard('nelson', ''), 0)
        self.assertEqual(sim_jaccard('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_jaccard('nelson', 'neilsen'), 4/11)

        self.assertEqual(sim_jaccard('', '', 2), 1)
        self.assertEqual(sim_jaccard('nelson', '', 2), 0)
        self.assertEqual(sim_jaccard('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_jaccard('nelson', 'neilsen', 2), 4/11)

        # supplied q-gram tests
        self.assertEqual(sim_jaccard(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_jaccard(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_jaccard(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_jaccard(QGrams('nelson'),
                                           QGrams('neilsen')), 4/11)

        # non-q-gram tests
        self.assertEqual(sim_jaccard('', '', 0), 1)
        self.assertEqual(sim_jaccard('the quick', '', 0), 0)
        self.assertEqual(sim_jaccard('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_jaccard(NONQ_FROM, NONQ_TO, 0), 1/3)
        self.assertAlmostEqual(sim_jaccard(NONQ_TO, NONQ_FROM, 0), 1/3)

    def test_dist_jaccard(self):
        """Test abydos.distance.dist_jaccard."""
        self.assertEqual(dist_jaccard('', ''), 0)
        self.assertEqual(dist_jaccard('nelson', ''), 1)
        self.assertEqual(dist_jaccard('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_jaccard('nelson', 'neilsen'), 7/11)

        self.assertEqual(dist_jaccard('', '', 2), 0)
        self.assertEqual(dist_jaccard('nelson', '', 2), 1)
        self.assertEqual(dist_jaccard('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_jaccard('nelson', 'neilsen', 2), 7/11)

        # supplied q-gram tests
        self.assertEqual(dist_jaccard(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_jaccard(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_jaccard(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_jaccard(QGrams('nelson'),
                                            QGrams('neilsen')), 7/11)

        # non-q-gram tests
        self.assertEqual(dist_jaccard('', '', 0), 0)
        self.assertEqual(dist_jaccard('the quick', '', 0), 1)
        self.assertEqual(dist_jaccard('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_jaccard(NONQ_FROM, NONQ_TO, 0), 2/3)
        self.assertAlmostEqual(dist_jaccard(NONQ_TO, NONQ_FROM, 0), 2/3)


class OverlapTestCases(unittest.TestCase):
    """Test overlap functions.

    abydos.distance.sim_overlap & .dist_overlap
    """

    def test_sim_overlap(self):
        """Test abydos.distance.sim_overlap."""
        self.assertEqual(sim_overlap('', ''), 1)
        self.assertEqual(sim_overlap('nelson', ''), 0)
        self.assertEqual(sim_overlap('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_overlap('nelson', 'neilsen'), 4/7)

        self.assertEqual(sim_overlap('', '', 2), 1)
        self.assertEqual(sim_overlap('nelson', '', 2), 0)
        self.assertEqual(sim_overlap('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_overlap('nelson', 'neilsen', 2), 4/7)

        # supplied q-gram tests
        self.assertEqual(sim_overlap(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_overlap(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_overlap(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_overlap(QGrams('nelson'),
                                           QGrams('neilsen')), 4/7)

        # non-q-gram tests
        self.assertEqual(sim_overlap('', '', 0), 1)
        self.assertEqual(sim_overlap('the quick', '', 0), 0)
        self.assertEqual(sim_overlap('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_overlap(NONQ_FROM, NONQ_TO, 0), 4/7)
        self.assertAlmostEqual(sim_overlap(NONQ_TO, NONQ_FROM, 0), 4/7)

    def test_dist_overlap(self):
        """Test abydos.distance.dist_overlap."""
        self.assertEqual(dist_overlap('', ''), 0)
        self.assertEqual(dist_overlap('nelson', ''), 1)
        self.assertEqual(dist_overlap('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_overlap('nelson', 'neilsen'), 3/7)

        self.assertEqual(dist_overlap('', '', 2), 0)
        self.assertEqual(dist_overlap('nelson', '', 2), 1)
        self.assertEqual(dist_overlap('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_overlap('nelson', 'neilsen', 2), 3/7)

        # supplied q-gram tests
        self.assertEqual(dist_overlap(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_overlap(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_overlap(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_overlap(QGrams('nelson'),
                                            QGrams('neilsen')), 3/7)

        # non-q-gram tests
        self.assertEqual(dist_overlap('', '', 0), 0)
        self.assertEqual(dist_overlap('the quick', '', 0), 1)
        self.assertEqual(dist_overlap('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_overlap(NONQ_FROM, NONQ_TO, 0), 3/7)
        self.assertAlmostEqual(dist_overlap(NONQ_TO, NONQ_FROM, 0), 3/7)


class TanimotoTestCases(unittest.TestCase):
    """Test Tanimoto functions.

    abydos.distance.sim_tanimoto & .tanimoto
    """

    def test_tanimoto_coeff(self):
        """Test abydos.distance.sim_tanimoto."""
        self.assertEqual(sim_tanimoto('', ''), 1)
        self.assertEqual(sim_tanimoto('nelson', ''), 0)
        self.assertEqual(sim_tanimoto('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_tanimoto('nelson', 'neilsen'), 4/11)

        self.assertEqual(sim_tanimoto('', '', 2), 1)
        self.assertEqual(sim_tanimoto('nelson', '', 2), 0)
        self.assertEqual(sim_tanimoto('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_tanimoto('nelson', 'neilsen', 2), 4/11)

        # supplied q-gram tests
        self.assertEqual(sim_tanimoto(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_tanimoto(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_tanimoto(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_tanimoto(QGrams('nelson'),
                                            QGrams('neilsen')), 4/11)

        # non-q-gram tests
        self.assertEqual(sim_tanimoto('', '', 0), 1)
        self.assertEqual(sim_tanimoto('the quick', '', 0), 0)
        self.assertEqual(sim_tanimoto('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_tanimoto(NONQ_FROM, NONQ_TO, 0), 1/3)
        self.assertAlmostEqual(sim_tanimoto(NONQ_TO, NONQ_FROM, 0), 1/3)

    def test_tanimoto(self):
        """Test abydos.distance.tanimoto."""
        self.assertEqual(tanimoto('', ''), 0)
        self.assertEqual(tanimoto('nelson', ''), float('-inf'))
        self.assertEqual(tanimoto('', 'neilsen'), float('-inf'))
        self.assertAlmostEqual(tanimoto('nelson', 'neilsen'),
                               math.log(4/11, 2))

        self.assertEqual(tanimoto('', '', 2), 0)
        self.assertEqual(tanimoto('nelson', '', 2), float('-inf'))
        self.assertEqual(tanimoto('', 'neilsen', 2), float('-inf'))
        self.assertAlmostEqual(tanimoto('nelson', 'neilsen', 2),
                               math.log(4/11, 2))

        # supplied q-gram tests
        self.assertEqual(tanimoto(QGrams(''), QGrams('')), 0)
        self.assertEqual(tanimoto(QGrams('nelson'), QGrams('')), float('-inf'))
        self.assertEqual(tanimoto(QGrams(''), QGrams('neilsen')),
                         float('-inf'))
        self.assertAlmostEqual(tanimoto(QGrams('nelson'), QGrams('neilsen')),
                               math.log(4/11, 2))

        # non-q-gram tests
        self.assertEqual(tanimoto('', '', 0), 0)
        self.assertEqual(tanimoto('the quick', '', 0), float('-inf'))
        self.assertEqual(tanimoto('', 'the quick', 0), float('-inf'))
        self.assertAlmostEqual(tanimoto(NONQ_FROM, NONQ_TO, 0),
                               math.log(1/3, 2))
        self.assertAlmostEqual(tanimoto(NONQ_TO, NONQ_FROM, 0),
                               math.log(1/3, 2))


class MinkowskiTestCases(unittest.TestCase):
    """Test Minkowski functions.

    abydos.distance.minkowski, sim_minkowski & .dist_minkowski
    """

    def test_minkowski(self):
        """Test abydos.distance.minkowski."""
        self.assertEqual(minkowski('', ''), 0)
        self.assertEqual(minkowski('nelson', ''), 7)
        self.assertEqual(minkowski('', 'neilsen'), 8)
        self.assertAlmostEqual(minkowski('nelson', 'neilsen'), 7)

        self.assertEqual(minkowski('', '', 2), 0)
        self.assertEqual(minkowski('nelson', '', 2), 7)
        self.assertEqual(minkowski('', 'neilsen', 2), 8)
        self.assertAlmostEqual(minkowski('nelson', 'neilsen', 2), 7)

        # supplied q-gram tests
        self.assertEqual(minkowski(QGrams(''), QGrams('')), 0)
        self.assertEqual(minkowski(QGrams('nelson'), QGrams('')), 7)
        self.assertEqual(minkowski(QGrams(''), QGrams('neilsen')), 8)
        self.assertAlmostEqual(minkowski(QGrams('nelson'),
                                         QGrams('neilsen')), 7)

        # non-q-gram tests
        self.assertEqual(minkowski('', '', 0), 0)
        self.assertEqual(minkowski('the quick', '', 0), 2)
        self.assertEqual(minkowski('', 'the quick', 0), 2)
        self.assertAlmostEqual(minkowski(NONQ_FROM, NONQ_TO, 0), 8)
        self.assertAlmostEqual(minkowski(NONQ_TO, NONQ_FROM, 0), 8)

        # test l_0 "norm"
        self.assertEqual(minkowski('', '', 1, 0), 0)
        self.assertEqual(minkowski('a', '', 1, 0), 1)
        self.assertEqual(minkowski('a', 'b', 1, 0), 2)
        self.assertEqual(minkowski('ab', 'b', 1, 0), 1)
        self.assertEqual(minkowski('aab', 'b', 1, 0), 1)
        self.assertEqual(minkowski('', '', 1, 0, True), 0)
        self.assertEqual(minkowski('a', '', 1, 0, True), 1)
        self.assertEqual(minkowski('a', 'b', 1, 0, True), 1)
        self.assertEqual(minkowski('ab', 'b', 1, 0, True), 1/2)
        self.assertEqual(minkowski('aab', 'b', 1, 0, True), 1/2)
        self.assertEqual(minkowski('aaab', 'b', 1, 0, True), 1/2)
        self.assertEqual(minkowski('aaab', 'ab', 1, 0, True), 1/2)

        # test with alphabet
        self.assertEqual(minkowski('ab', 'b', 1, alphabet=26), 1)
        self.assertEqual(minkowski('ab', 'b', 1, normalize=True, alphabet=26),
                         1/26)
        self.assertEqual(minkowski('ab', 'b', 1, normalize=True,
                                   alphabet='abcdefghijklmnopqrstuvwxyz'),
                         1/26)

    def test_sim_minkowski(self):
        """Test abydos.distance.sim_minkowski."""
        self.assertEqual(sim_minkowski('', ''), 1)
        self.assertEqual(sim_minkowski('nelson', ''), 0)
        self.assertEqual(sim_minkowski('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_minkowski('nelson', 'neilsen'), 8/15)

        self.assertEqual(sim_minkowski('', '', 2), 1)
        self.assertEqual(sim_minkowski('nelson', '', 2), 0)
        self.assertEqual(sim_minkowski('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_minkowski('nelson', 'neilsen', 2), 8/15)

        # supplied q-gram tests
        self.assertEqual(sim_minkowski(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_minkowski(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_minkowski(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_minkowski(QGrams('nelson'),
                                             QGrams('neilsen')), 8/15)

        # non-q-gram tests
        self.assertEqual(sim_minkowski('', '', 0), 1)
        self.assertEqual(sim_minkowski('the quick', '', 0), 0)
        self.assertEqual(sim_minkowski('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_minkowski(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(sim_minkowski(NONQ_TO, NONQ_FROM, 0), 1/2)

    def test_dist_minkowski(self):
        """Test abydos.distance.dist_minkowski."""
        self.assertEqual(dist_minkowski('', ''), 0)
        self.assertEqual(dist_minkowski('nelson', ''), 1)
        self.assertEqual(dist_minkowski('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_minkowski('nelson', 'neilsen'), 7/15)

        self.assertEqual(dist_minkowski('', '', 2), 0)
        self.assertEqual(dist_minkowski('nelson', '', 2), 1)
        self.assertEqual(dist_minkowski('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_minkowski('nelson', 'neilsen', 2), 7/15)

        # supplied q-gram tests
        self.assertEqual(dist_minkowski(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_minkowski(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_minkowski(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_minkowski(QGrams('nelson'),
                                              QGrams('neilsen')), 7/15)

        # non-q-gram tests
        self.assertEqual(dist_minkowski('', '', 0), 0)
        self.assertEqual(dist_minkowski('the quick', '', 0), 1)
        self.assertEqual(dist_minkowski('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_minkowski(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(dist_minkowski(NONQ_TO, NONQ_FROM, 0), 1/2)


class ManhattanTestCases(unittest.TestCase):
    """Test Manhattan functions.

    abydos.distance.manhattan, sim_manhattan & .dist_manhattan
    """

    def test_manhattan(self):
        """Test abydos.distance.manhattan."""
        self.assertEqual(manhattan('', ''), 0)
        self.assertEqual(manhattan('nelson', ''), 7)
        self.assertEqual(manhattan('', 'neilsen'), 8)
        self.assertAlmostEqual(manhattan('nelson', 'neilsen'), 7)

        self.assertEqual(manhattan('', '', 2), 0)
        self.assertEqual(manhattan('nelson', '', 2), 7)
        self.assertEqual(manhattan('', 'neilsen', 2), 8)
        self.assertAlmostEqual(manhattan('nelson', 'neilsen', 2), 7)

        # supplied q-gram tests
        self.assertEqual(manhattan(QGrams(''), QGrams('')), 0)
        self.assertEqual(manhattan(QGrams('nelson'), QGrams('')), 7)
        self.assertEqual(manhattan(QGrams(''), QGrams('neilsen')), 8)
        self.assertAlmostEqual(manhattan(QGrams('nelson'),
                                         QGrams('neilsen')), 7)

        # non-q-gram tests
        self.assertEqual(manhattan('', '', 0), 0)
        self.assertEqual(manhattan('the quick', '', 0), 2)
        self.assertEqual(manhattan('', 'the quick', 0), 2)
        self.assertAlmostEqual(manhattan(NONQ_FROM, NONQ_TO, 0), 8)
        self.assertAlmostEqual(manhattan(NONQ_TO, NONQ_FROM, 0), 8)

    def test_sim_manhattan(self):
        """Test abydos.distance.sim_manhattan."""
        self.assertEqual(sim_manhattan('', ''), 1)
        self.assertEqual(sim_manhattan('nelson', ''), 0)
        self.assertEqual(sim_manhattan('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_manhattan('nelson', 'neilsen'), 8/15)

        self.assertEqual(sim_manhattan('', '', 2), 1)
        self.assertEqual(sim_manhattan('nelson', '', 2), 0)
        self.assertEqual(sim_manhattan('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_manhattan('nelson', 'neilsen', 2), 8/15)

        # supplied q-gram tests
        self.assertEqual(sim_manhattan(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_manhattan(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_manhattan(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_manhattan(QGrams('nelson'),
                                             QGrams('neilsen')), 8/15)

        # non-q-gram tests
        self.assertEqual(sim_manhattan('', '', 0), 1)
        self.assertEqual(sim_manhattan('the quick', '', 0), 0)
        self.assertEqual(sim_manhattan('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_manhattan(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(sim_manhattan(NONQ_TO, NONQ_FROM, 0), 1/2)

    def test_dist_manhattan(self):
        """Test abydos.distance.dist_manhattan."""
        self.assertEqual(dist_manhattan('', ''), 0)
        self.assertEqual(dist_manhattan('nelson', ''), 1)
        self.assertEqual(dist_manhattan('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_manhattan('nelson', 'neilsen'), 7/15)

        self.assertEqual(dist_manhattan('', '', 2), 0)
        self.assertEqual(dist_manhattan('nelson', '', 2), 1)
        self.assertEqual(dist_manhattan('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_manhattan('nelson', 'neilsen', 2), 7/15)

        # supplied q-gram tests
        self.assertEqual(dist_manhattan(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_manhattan(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_manhattan(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_manhattan(QGrams('nelson'),
                                              QGrams('neilsen')), 7/15)

        # non-q-gram tests
        self.assertEqual(dist_manhattan('', '', 0), 0)
        self.assertEqual(dist_manhattan('the quick', '', 0), 1)
        self.assertEqual(dist_manhattan('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_manhattan(NONQ_FROM, NONQ_TO, 0), 1/2)
        self.assertAlmostEqual(dist_manhattan(NONQ_TO, NONQ_FROM, 0), 1/2)


class EuclideanTestCases(unittest.TestCase):
    """Test Euclidean functions.

    abydos.distance.euclidean, sim_euclidean & .dist_euclidean
    """

    def test_euclidean(self):
        """Test abydos.distance.euclidean."""
        self.assertEqual(euclidean('', ''), 0)
        self.assertEqual(euclidean('nelson', ''), 7**0.5)
        self.assertEqual(euclidean('', 'neilsen'), 8**0.5)
        self.assertAlmostEqual(euclidean('nelson', 'neilsen'), 7**0.5)

        self.assertEqual(euclidean('', '', 2), 0)
        self.assertEqual(euclidean('nelson', '', 2), 7**0.5)
        self.assertEqual(euclidean('', 'neilsen', 2), 8**0.5)
        self.assertAlmostEqual(euclidean('nelson', 'neilsen', 2), 7**0.5)

        # supplied q-gram tests
        self.assertEqual(euclidean(QGrams(''), QGrams('')), 0)
        self.assertEqual(euclidean(QGrams('nelson'), QGrams('')), 7**0.5)
        self.assertEqual(euclidean(QGrams(''), QGrams('neilsen')), 8**0.5)
        self.assertAlmostEqual(euclidean(QGrams('nelson'),
                                         QGrams('neilsen')), 7**0.5)

        # non-q-gram tests
        self.assertEqual(euclidean('', '', 0), 0)
        self.assertEqual(euclidean('the quick', '', 0), 2**0.5)
        self.assertEqual(euclidean('', 'the quick', 0), 2**0.5)
        self.assertAlmostEqual(euclidean(NONQ_FROM, NONQ_TO, 0), 8**0.5)
        self.assertAlmostEqual(euclidean(NONQ_TO, NONQ_FROM, 0), 8**0.5)

    def test_sim_euclidean(self):
        """Test abydos.distance.sim_euclidean."""
        self.assertEqual(sim_euclidean('', ''), 1)
        self.assertEqual(sim_euclidean('nelson', ''), 0)
        self.assertEqual(sim_euclidean('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_euclidean('nelson', 'neilsen'),
                               1-7**0.5/23**0.5)

        self.assertEqual(sim_euclidean('', '', 2), 1)
        self.assertEqual(sim_euclidean('nelson', '', 2), 0)
        self.assertEqual(sim_euclidean('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_euclidean('nelson', 'neilsen', 2),
                               1-7**0.5/23**0.5)

        # supplied q-gram tests
        self.assertEqual(sim_euclidean(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_euclidean(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_euclidean(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_euclidean(QGrams('nelson'),
                                             QGrams('neilsen')),
                               1-7**0.5/23**0.5)

        # non-q-gram tests
        self.assertEqual(sim_euclidean('', '', 0), 1)
        self.assertEqual(sim_euclidean('the quick', '', 0), 0)
        self.assertEqual(sim_euclidean('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_euclidean(NONQ_FROM, NONQ_TO, 0),
                               1-8**0.5/24**0.5)
        self.assertAlmostEqual(sim_euclidean(NONQ_TO, NONQ_FROM, 0),
                               1-8**0.5/24**0.5)

    def test_dist_euclidean(self):
        """Test abydos.distance.dist_euclidean."""
        self.assertEqual(dist_euclidean('', ''), 0)
        self.assertEqual(dist_euclidean('nelson', ''), 1)
        self.assertEqual(dist_euclidean('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_euclidean('nelson', 'neilsen'),
                               7**0.5 / 23**0.5)

        self.assertEqual(dist_euclidean('', '', 2), 0)
        self.assertEqual(dist_euclidean('nelson', '', 2), 1)
        self.assertEqual(dist_euclidean('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_euclidean('nelson', 'neilsen', 2),
                               7**0.5 / 23**0.5)

        # supplied q-gram tests
        self.assertEqual(dist_euclidean(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_euclidean(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_euclidean(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_euclidean(QGrams('nelson'),
                                              QGrams('neilsen')),
                               7**0.5 / 23**0.5)

        # non-q-gram tests
        self.assertEqual(dist_euclidean('', '', 0), 0)
        self.assertEqual(dist_euclidean('the quick', '', 0), 1)
        self.assertEqual(dist_euclidean('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_euclidean(NONQ_FROM, NONQ_TO, 0),
                               8**0.5/24**0.5)
        self.assertAlmostEqual(dist_euclidean(NONQ_TO, NONQ_FROM, 0),
                               8**0.5/24**0.5)


class ChebyshevTestCases(unittest.TestCase):
    """Test Chebyshev functions.

    abydos.distance.chebyshev, sim_chebyshev & .dist_chebyshev
    """

    def test_chebyshev(self):
        """Test abydos.distance.chebyshev."""
        self.assertEqual(chebyshev('', ''), 0)
        self.assertEqual(chebyshev('nelson', ''), 1)
        self.assertEqual(chebyshev('', 'neilsen'), 1)
        self.assertEqual(chebyshev('nelson', 'neilsen'), 1)

        self.assertEqual(chebyshev('', '', 2), 0)
        self.assertEqual(chebyshev('nelson', '', 2), 1)
        self.assertEqual(chebyshev('', 'neilsen', 2), 1)
        self.assertAlmostEqual(chebyshev('nelson', 'neilsen', 2), 1)

        # supplied q-gram tests
        self.assertEqual(chebyshev(QGrams(''), QGrams('')), 0)
        self.assertEqual(chebyshev(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(chebyshev(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(chebyshev(QGrams('nelson'),
                                         QGrams('neilsen')), 1)

        # non-q-gram tests
        self.assertEqual(chebyshev('', '', 0), 0)
        self.assertEqual(chebyshev('the quick', '', 0), 1)
        self.assertEqual(chebyshev('', 'the quick', 0), 1)
        self.assertAlmostEqual(chebyshev(NONQ_FROM, NONQ_TO, 0), 1)
        self.assertAlmostEqual(chebyshev(NONQ_TO, NONQ_FROM, 0), 1)

    def test_sim_chebyshev(self):
        """Test abydos.distance.sim_chebyshev."""
        self.assertEqual(sim_chebyshev('', ''), 1)
        self.assertEqual(sim_chebyshev('nelson', ''), 0)
        self.assertEqual(sim_chebyshev('', 'neilsen'), 0)
        self.assertEqual(sim_chebyshev('nelson', 'neilsen'), 0)

        self.assertEqual(sim_chebyshev('', '', 2), 1)
        self.assertEqual(sim_chebyshev('nelson', '', 2), 0)
        self.assertEqual(sim_chebyshev('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_chebyshev('nelson', 'neilsen', 2), 0)

        # supplied q-gram tests
        self.assertEqual(sim_chebyshev(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_chebyshev(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_chebyshev(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_chebyshev(QGrams('nelson'),
                                             QGrams('neilsen')), 0)

        # non-q-gram tests
        self.assertEqual(sim_chebyshev('', '', 0), 1)
        self.assertEqual(sim_chebyshev('the quick', '', 0), 0)
        self.assertEqual(sim_chebyshev('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_chebyshev(NONQ_FROM, NONQ_TO, 0), 0)
        self.assertAlmostEqual(sim_chebyshev(NONQ_TO, NONQ_FROM, 0), 0)

    def test_dist_chebyshev(self):
        """Test abydos.distance.dist_chebyshev."""
        self.assertEqual(dist_chebyshev('', ''), 0)
        self.assertEqual(dist_chebyshev('nelson', ''), 1)
        self.assertEqual(dist_chebyshev('', 'neilsen'), 1)
        self.assertEqual(dist_chebyshev('nelson', 'neilsen'), 1)

        self.assertEqual(dist_chebyshev('', '', 2), 0)
        self.assertEqual(dist_chebyshev('nelson', '', 2), 1)
        self.assertEqual(dist_chebyshev('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_chebyshev('nelson', 'neilsen', 2), 1)

        # supplied q-gram tests
        self.assertEqual(dist_chebyshev(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_chebyshev(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_chebyshev(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_chebyshev(QGrams('nelson'),
                                              QGrams('neilsen')), 1)

        # non-q-gram tests
        self.assertEqual(dist_chebyshev('', '', 0), 0)
        self.assertEqual(dist_chebyshev('the quick', '', 0), 1)
        self.assertEqual(dist_chebyshev('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_chebyshev(NONQ_FROM, NONQ_TO, 0), 1)
        self.assertAlmostEqual(dist_chebyshev(NONQ_TO, NONQ_FROM, 0), 1)


class CosineSimilarityTestCases(unittest.TestCase):
    """Test cosine similarity functions.

    abydos.distance.sim_cosine & .dist_cosine
    """

    def test_sim_cosine(self):
        """Test abydos.distance.sim_cosine."""
        self.assertEqual(sim_cosine('', ''), 1)
        self.assertEqual(sim_cosine('nelson', ''), 0)
        self.assertEqual(sim_cosine('', 'neilsen'), 0)
        self.assertAlmostEqual(sim_cosine('nelson', 'neilsen'),
                               4/math.sqrt(7*8))

        self.assertEqual(sim_cosine('', '', 2), 1)
        self.assertEqual(sim_cosine('nelson', '', 2), 0)
        self.assertEqual(sim_cosine('', 'neilsen', 2), 0)
        self.assertAlmostEqual(sim_cosine('nelson', 'neilsen', 2),
                               4/math.sqrt(7*8))

        # supplied q-gram tests
        self.assertEqual(sim_cosine(QGrams(''), QGrams('')), 1)
        self.assertEqual(sim_cosine(QGrams('nelson'), QGrams('')), 0)
        self.assertEqual(sim_cosine(QGrams(''), QGrams('neilsen')), 0)
        self.assertAlmostEqual(sim_cosine(QGrams('nelson'), QGrams('neilsen')),
                               4/math.sqrt(7*8))

        # non-q-gram tests
        self.assertEqual(sim_cosine('', '', 0), 1)
        self.assertEqual(sim_cosine('the quick', '', 0), 0)
        self.assertEqual(sim_cosine('', 'the quick', 0), 0)
        self.assertAlmostEqual(sim_cosine(NONQ_FROM, NONQ_TO, 0),
                               4/math.sqrt(9*7))
        self.assertAlmostEqual(sim_cosine(NONQ_TO, NONQ_FROM, 0),
                               4/math.sqrt(9*7))

    def test_dist_cosine(self):
        """Test abydos.distance.dist_cosine."""
        self.assertEqual(dist_cosine('', ''), 0)
        self.assertEqual(dist_cosine('nelson', ''), 1)
        self.assertEqual(dist_cosine('', 'neilsen'), 1)
        self.assertAlmostEqual(dist_cosine('nelson', 'neilsen'),
                               1-(4/math.sqrt(7*8)))

        self.assertEqual(dist_cosine('', '', 2), 0)
        self.assertEqual(dist_cosine('nelson', '', 2), 1)
        self.assertEqual(dist_cosine('', 'neilsen', 2), 1)
        self.assertAlmostEqual(dist_cosine('nelson', 'neilsen', 2),
                               1-(4/math.sqrt(7*8)))

        # supplied q-gram tests
        self.assertEqual(dist_cosine(QGrams(''), QGrams('')), 0)
        self.assertEqual(dist_cosine(QGrams('nelson'), QGrams('')), 1)
        self.assertEqual(dist_cosine(QGrams(''), QGrams('neilsen')), 1)
        self.assertAlmostEqual(dist_cosine(QGrams('nelson'),
                                           QGrams('neilsen')),
                               1-(4/math.sqrt(7*8)))

        # non-q-gram tests
        self.assertEqual(dist_cosine('', '', 0), 0)
        self.assertEqual(dist_cosine('the quick', '', 0), 1)
        self.assertEqual(dist_cosine('', 'the quick', 0), 1)
        self.assertAlmostEqual(dist_cosine(NONQ_FROM, NONQ_TO, 0),
                               1-4/math.sqrt(9*7))
        self.assertAlmostEqual(dist_cosine(NONQ_TO, NONQ_FROM, 0),
                               1-4/math.sqrt(9*7))


class JaroWinklerTestCases(unittest.TestCase):
    """Test Jaro(-Winkler) functions.

    abydos.distance.sim_strcmp95, .dist_strcmp95, .sim_jaro_winkler, &
    .dist_jaro_winkler
    """

    def test_sim_strcmp95(self):
        """Test abydos.distance.sim_strcmp95."""
        self.assertEqual(sim_strcmp95('', ''), 1)
        self.assertEqual(sim_strcmp95('MARTHA', ''), 0)
        self.assertEqual(sim_strcmp95('', 'MARTHA'), 0)
        self.assertEqual(sim_strcmp95('MARTHA', 'MARTHA'), 1)

        self.assertAlmostEqual(sim_strcmp95('MARTHA', 'MARHTA'), 0.96111111)
        self.assertAlmostEqual(sim_strcmp95('DWAYNE', 'DUANE'), 0.873)
        self.assertAlmostEqual(sim_strcmp95('DIXON', 'DICKSONX'), 0.839333333)

        self.assertAlmostEqual(sim_strcmp95('ABCD', 'EFGH'), 0.0)

        # long_strings = True
        self.assertAlmostEqual(sim_strcmp95('DIXON', 'DICKSONX', True),
                               0.85393939)
        self.assertAlmostEqual(sim_strcmp95('DWAYNE', 'DUANE', True),
                               0.89609090)
        self.assertAlmostEqual(sim_strcmp95('MARTHA', 'MARHTA', True),
                               0.97083333)

        # cover case where we don't boost, etc.
        self.assertAlmostEqual(sim_strcmp95('A', 'ABCDEFGHIJK'), 69/99)
        self.assertAlmostEqual(sim_strcmp95('A', 'ABCDEFGHIJK', True), 69 / 99)
        self.assertAlmostEqual(sim_strcmp95('d', 'abcdefgh'), 0.708333333)
        self.assertAlmostEqual(sim_strcmp95('d', 'abcdefgh', True),
                               0.708333333)
        self.assertAlmostEqual(sim_strcmp95('1', 'abc1efgh', True),
                               0.708333333)
        self.assertAlmostEqual(sim_strcmp95('12hundredths', '12hundred', True),
                               0.916666667)

    def test_dist_strcmp95(self):
        """Test abydos.distance.dist_strcmp95."""
        self.assertEqual(dist_strcmp95('', ''), 0)
        self.assertEqual(dist_strcmp95('MARTHA', ''), 1)
        self.assertEqual(dist_strcmp95('', 'MARTHA'), 1)
        self.assertEqual(dist_strcmp95('MARTHA', 'MARTHA'), 0)

        self.assertAlmostEqual(dist_strcmp95('MARTHA', 'MARHTA'), 0.03888888)
        self.assertAlmostEqual(dist_strcmp95('DWAYNE', 'DUANE'), 0.127)
        self.assertAlmostEqual(dist_strcmp95('DIXON', 'DICKSONX'), 0.160666666)

        self.assertAlmostEqual(dist_strcmp95('ABCD', 'EFGH'), 1.0)

    def test_sim_jaro_winkler(self):
        """Test abydos.distance.sim_jaro_winkler."""
        self.assertEqual(sim_jaro_winkler('', '', mode='jaro'), 1)
        self.assertEqual(sim_jaro_winkler('', '', mode='winkler'), 1)
        self.assertEqual(sim_jaro_winkler('MARTHA', '', mode='jaro'), 0)
        self.assertEqual(sim_jaro_winkler('MARTHA', '', mode='winkler'), 0)
        self.assertEqual(sim_jaro_winkler('', 'MARHTA', mode='jaro'), 0)
        self.assertEqual(sim_jaro_winkler('', 'MARHTA', mode='winkler'), 0)
        self.assertEqual(sim_jaro_winkler('MARTHA', 'MARTHA', mode='jaro'), 1)
        self.assertEqual(sim_jaro_winkler('MARTHA', 'MARTHA', mode='winkler'),
                         1)

        # https://en.wikipedia.org/wiki/Jaro-Winkler_distance
        self.assertAlmostEqual(sim_jaro_winkler('MARTHA', 'MARHTA',
                                                mode='jaro'), 0.94444444)
        self.assertAlmostEqual(sim_jaro_winkler('MARTHA', 'MARHTA',
                                                mode='winkler'), 0.96111111)
        self.assertAlmostEqual(sim_jaro_winkler('DWAYNE', 'DUANE',
                                                mode='jaro'), 0.82222222)
        self.assertAlmostEqual(sim_jaro_winkler('DWAYNE', 'DUANE',
                                                mode='winkler'), 0.84)
        self.assertAlmostEqual(sim_jaro_winkler('DIXON', 'DICKSONX',
                                                mode='jaro'), 0.76666666)
        self.assertAlmostEqual(sim_jaro_winkler('DIXON', 'DICKSONX',
                                                mode='winkler'), 0.81333333)

        self.assertRaises(ValueError, sim_jaro_winkler, 'abcd', 'dcba',
                          boost_threshold=2)
        self.assertRaises(ValueError, sim_jaro_winkler, 'abcd', 'dcba',
                          boost_threshold=-1)
        self.assertRaises(ValueError, sim_jaro_winkler, 'abcd', 'dcba',
                          scaling_factor=0.3)
        self.assertRaises(ValueError, sim_jaro_winkler, 'abcd', 'dcba',
                          scaling_factor=-1)

        self.assertAlmostEqual(sim_jaro_winkler('ABCD', 'EFGH'), 0.0)

        # long_strings = True (applies only to Jaro-Winkler, not Jaro)
        self.assertEqual(sim_jaro_winkler('ABCD', 'EFGH', long_strings=True),
                         sim_jaro_winkler('ABCD', 'EFGH'))
        self.assertEqual(sim_jaro_winkler('DIXON', 'DICKSONX', mode='jaro',
                                          long_strings=True),
                         sim_jaro_winkler('DIXON', 'DICKSONX',
                                          mode='jaro'))
        self.assertAlmostEqual(sim_jaro_winkler('DIXON', 'DICKSONX',
                                                mode='winkler',
                                                long_strings=True), 0.83030303)
        self.assertAlmostEqual(sim_jaro_winkler('MARTHA', 'MARHTA',
                                                mode='winkler',
                                                long_strings=True), 0.97083333)

    def test_dist_jaro_winkler(self):
        """Test abydos.distance.dist_jaro_winkler."""
        self.assertEqual(dist_jaro_winkler('', '', mode='jaro'), 0)
        self.assertEqual(dist_jaro_winkler('', '', mode='winkler'), 0)
        self.assertEqual(dist_jaro_winkler('MARTHA', '', mode='jaro'), 1)
        self.assertEqual(dist_jaro_winkler('MARTHA', '', mode='winkler'), 1)
        self.assertEqual(dist_jaro_winkler('', 'MARHTA', mode='jaro'), 1)
        self.assertEqual(dist_jaro_winkler('', 'MARHTA', mode='winkler'), 1)
        self.assertEqual(dist_jaro_winkler('MARTHA', 'MARTHA', mode='jaro'), 0)
        self.assertEqual(dist_jaro_winkler('MARTHA', 'MARTHA', mode='winkler'),
                         0)

        # https://en.wikipedia.org/wiki/Jaro-Winkler_distance
        self.assertAlmostEqual(dist_jaro_winkler('MARTHA', 'MARHTA',
                                                 mode='jaro'), 0.05555555)
        self.assertAlmostEqual(dist_jaro_winkler('MARTHA', 'MARHTA',
                                                 mode='winkler'), 0.03888888)
        self.assertAlmostEqual(dist_jaro_winkler('DWAYNE', 'DUANE',
                                                 mode='jaro'), 0.17777777)
        self.assertAlmostEqual(dist_jaro_winkler('DWAYNE', 'DUANE',
                                                 mode='winkler'), 0.16)
        self.assertAlmostEqual(dist_jaro_winkler('DIXON', 'DICKSONX',
                                                 mode='jaro'), 0.23333333)
        self.assertAlmostEqual(dist_jaro_winkler('DIXON', 'DICKSONX',
                                                 mode='winkler'), 0.18666666)

        self.assertRaises(ValueError, dist_jaro_winkler, 'abcd', 'dcba',
                          boost_threshold=2)
        self.assertRaises(ValueError, dist_jaro_winkler, 'abcd', 'dcba',
                          boost_threshold=-1)
        self.assertRaises(ValueError, dist_jaro_winkler, 'abcd', 'dcba',
                          scaling_factor=0.3)
        self.assertRaises(ValueError, dist_jaro_winkler, 'abcd', 'dcba',
                          scaling_factor=-1)

        self.assertAlmostEqual(dist_jaro_winkler('ABCD', 'EFGH'), 1.0)


class LcsseqTestCases(unittest.TestCase):
    """Test LCSseq functions.

    abydos.distance.lcsseq, .sim_lcsseq, & .dist_lcsseq
    """

    def test_lcsseq(self):
        """Test abydos.distance.lcsseq."""
        self.assertEqual(lcsseq('', ''), '')
        self.assertEqual(lcsseq('A', ''), '')
        self.assertEqual(lcsseq('', 'A'), '')
        self.assertEqual(lcsseq('A', 'A'), 'A')
        self.assertEqual(lcsseq('ABCD', ''), '')
        self.assertEqual(lcsseq('', 'ABCD'), '')
        self.assertEqual(lcsseq('ABCD', 'ABCD'), 'ABCD')
        self.assertEqual(lcsseq('ABCD', 'BC'), 'BC')
        self.assertEqual(lcsseq('ABCD', 'AD'), 'AD')
        self.assertEqual(lcsseq('ABCD', 'AC'), 'AC')
        self.assertEqual(lcsseq('AB', 'CD'), '')
        self.assertEqual(lcsseq('ABC', 'BCD'), 'BC')

        self.assertEqual(lcsseq('DIXON', 'DICKSONX'), 'DION')

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertEqual(lcsseq('AGCAT', 'GAC'), 'AC')
        self.assertEqual(lcsseq('XMJYAUZ', 'MZJAWXU'), 'MJAU')

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertEqual(lcsseq('hell', 'hello'), 'hell')
        self.assertEqual(lcsseq('hello', 'hell'), 'hell')
        self.assertEqual(lcsseq('ell', 'hell'), 'ell')
        self.assertEqual(lcsseq('hell', 'ell'), 'ell')
        self.assertEqual(lcsseq('faxbcd', 'abdef'), 'abd')

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertEqual(lcsseq('hello world', 'world war 2'), 'world')
        self.assertEqual(lcsseq('foo bar', 'bar foo'), 'foo')
        self.assertEqual(lcsseq('aaa', 'aa'), 'aa')
        self.assertEqual(lcsseq('cc', 'bbbbcccccc'), 'cc')
        self.assertEqual(lcsseq('ccc', 'bcbb'), 'c')

    def test_sim_lcsseq(self):
        """Test abydos.distance.sim_lcsseq."""
        self.assertEqual(sim_lcsseq('', ''), 1)
        self.assertEqual(sim_lcsseq('A', ''), 0)
        self.assertEqual(sim_lcsseq('', 'A'), 0)
        self.assertEqual(sim_lcsseq('A', 'A'), 1)
        self.assertEqual(sim_lcsseq('ABCD', ''), 0)
        self.assertEqual(sim_lcsseq('', 'ABCD'), 0)
        self.assertEqual(sim_lcsseq('ABCD', 'ABCD'), 1)
        self.assertAlmostEqual(sim_lcsseq('ABCD', 'BC'), 2/4)
        self.assertAlmostEqual(sim_lcsseq('ABCD', 'AD'), 2/4)
        self.assertAlmostEqual(sim_lcsseq('ABCD', 'AC'), 2/4)
        self.assertAlmostEqual(sim_lcsseq('AB', 'CD'), 0)
        self.assertAlmostEqual(sim_lcsseq('ABC', 'BCD'), 2/3)

        self.assertAlmostEqual(sim_lcsseq('DIXON', 'DICKSONX'), 4/8)

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertAlmostEqual(sim_lcsseq('AGCAT', 'GAC'), 2/5)
        self.assertAlmostEqual(sim_lcsseq('XMJYAUZ', 'MZJAWXU'), 4/7)

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertAlmostEqual(sim_lcsseq('hell', 'hello'), 4/5)
        self.assertAlmostEqual(sim_lcsseq('hello', 'hell'), 4/5)
        self.assertAlmostEqual(sim_lcsseq('ell', 'hell'), 3/4)
        self.assertAlmostEqual(sim_lcsseq('hell', 'ell'), 3/4)
        self.assertAlmostEqual(sim_lcsseq('faxbcd', 'abdef'), 3/6)

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertAlmostEqual(sim_lcsseq('hello world', 'world war 2'), 5/11)
        self.assertAlmostEqual(sim_lcsseq('foo bar', 'bar foo'), 3/7)
        self.assertAlmostEqual(sim_lcsseq('aaa', 'aa'), 2/3)
        self.assertAlmostEqual(sim_lcsseq('cc', 'bbbbcccccc'), 2/10)
        self.assertAlmostEqual(sim_lcsseq('ccc', 'bcbb'), 1/4)

    def test_dist_lcsseq(self):
        """Test abydos.distance.dist_lcsseq."""
        self.assertEqual(dist_lcsseq('', ''), 0)
        self.assertEqual(dist_lcsseq('A', ''), 1)
        self.assertEqual(dist_lcsseq('', 'A'), 1)
        self.assertEqual(dist_lcsseq('A', 'A'), 0)
        self.assertEqual(dist_lcsseq('ABCD', ''), 1)
        self.assertEqual(dist_lcsseq('', 'ABCD'), 1)
        self.assertEqual(dist_lcsseq('ABCD', 'ABCD'), 0)
        self.assertAlmostEqual(dist_lcsseq('ABCD', 'BC'), 2/4)
        self.assertAlmostEqual(dist_lcsseq('ABCD', 'AD'), 2/4)
        self.assertAlmostEqual(dist_lcsseq('ABCD', 'AC'), 2/4)
        self.assertAlmostEqual(dist_lcsseq('AB', 'CD'), 1)
        self.assertAlmostEqual(dist_lcsseq('ABC', 'BCD'), 1/3)

        self.assertAlmostEqual(dist_lcsseq('DIXON', 'DICKSONX'), 4/8)

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertAlmostEqual(dist_lcsseq('AGCAT', 'GAC'), 3/5)
        self.assertAlmostEqual(dist_lcsseq('XMJYAUZ', 'MZJAWXU'), 3/7)

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertAlmostEqual(dist_lcsseq('hell', 'hello'), 1/5)
        self.assertAlmostEqual(dist_lcsseq('hello', 'hell'), 1/5)
        self.assertAlmostEqual(dist_lcsseq('ell', 'hell'), 1/4)
        self.assertAlmostEqual(dist_lcsseq('hell', 'ell'), 1/4)
        self.assertAlmostEqual(dist_lcsseq('faxbcd', 'abdef'), 3/6)

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertAlmostEqual(dist_lcsseq('hello world', 'world war 2'), 6/11)
        self.assertAlmostEqual(dist_lcsseq('foo bar', 'bar foo'), 4/7)
        self.assertAlmostEqual(dist_lcsseq('aaa', 'aa'), 1/3)
        self.assertAlmostEqual(dist_lcsseq('cc', 'bbbbcccccc'), 8/10)
        self.assertAlmostEqual(dist_lcsseq('ccc', 'bcbb'), 3/4)


class LcsstrTestCases(unittest.TestCase):
    """Test LCSstr functions.

    abydos.distance.lcsstr, .sim_lcsstr, & .dist_lcsstr
    """

    def test_lcsstr(self):
        """Test abydos.distance.lcsstr."""
        self.assertEqual(lcsstr('', ''), '')
        self.assertEqual(lcsstr('A', ''), '')
        self.assertEqual(lcsstr('', 'A'), '')
        self.assertEqual(lcsstr('A', 'A'), 'A')
        self.assertEqual(lcsstr('ABCD', ''), '')
        self.assertEqual(lcsstr('', 'ABCD'), '')
        self.assertEqual(lcsstr('ABCD', 'ABCD'), 'ABCD')
        self.assertEqual(lcsstr('ABCD', 'BC'), 'BC')
        self.assertEqual(lcsstr('ABCD', 'AD'), 'A')
        self.assertEqual(lcsstr('ABCD', 'AC'), 'A')
        self.assertEqual(lcsstr('AB', 'CD'), '')
        self.assertEqual(lcsstr('ABC', 'BCD'), 'BC')

        self.assertEqual(lcsstr('DIXON', 'DICKSONX'), 'DI')

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertEqual(lcsstr('AGCAT', 'GAC'), 'A')
        self.assertEqual(lcsstr('XMJYAUZ', 'MZJAWXU'), 'X')

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertEqual(lcsstr('hell', 'hello'), 'hell')
        self.assertEqual(lcsstr('hello', 'hell'), 'hell')
        self.assertEqual(lcsstr('ell', 'hell'), 'ell')
        self.assertEqual(lcsstr('hell', 'ell'), 'ell')
        self.assertEqual(lcsstr('faxbcd', 'abdef'), 'f')

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertEqual(lcsstr('hello world', 'world war 2'), 'world')
        self.assertEqual(lcsstr('foo bar', 'bar foo'), 'foo')
        self.assertEqual(lcsstr('aaa', 'aa'), 'aa')
        self.assertEqual(lcsstr('cc', 'bbbbcccccc'), 'cc')
        self.assertEqual(lcsstr('ccc', 'bcbb'), 'c')

        # http://www.maplesoft.com/support/help/Maple/view.aspx?path=StringTools/LongestCommonSubString
        self.assertEqual(lcsstr('abax', 'bax'), 'bax')
        self.assertEqual(lcsstr('tsaxbaxyz', 'axcaxy'), 'axy')
        self.assertEqual(lcsstr('abcde', 'uvabxycde'), 'cde')
        self.assertEqual(lcsstr('abc', 'xyz'), '')
        self.assertEqual(lcsstr('TAAGGTCGGCGCGCACGCTGGCGAGTATGGTGCGGAGGCCCTGGA\
GAGGTGAGGCTCCCTCCCCTGCTCCGACCCGGGCTCCTCGCCCGCCCGGACCCAC', 'AAGCGCCGCGCAGTCTGGG\
CTCCGCACACTTCTGGTCCAGTCCGACTGAGAAGGAACCACCATGGTGCTGTCTCCCGCTGACAAGACCAACATCAAG\
ACTGCCTGGGAAAAGATCGGCAGCCACGGTGGCGAGTATGGCGCCGAGGCCGT'), 'TGGCGAGTATGG')

    def test_sim_lcsstr(self):
        """Test abydos.distance.sim_lcsstr."""
        self.assertEqual(sim_lcsstr('', ''), 1)
        self.assertEqual(sim_lcsstr('A', ''), 0)
        self.assertEqual(sim_lcsstr('', 'A'), 0)
        self.assertEqual(sim_lcsstr('A', 'A'), 1)
        self.assertEqual(sim_lcsstr('ABCD', ''), 0)
        self.assertEqual(sim_lcsstr('', 'ABCD'), 0)
        self.assertEqual(sim_lcsstr('ABCD', 'ABCD'), 1)
        self.assertAlmostEqual(sim_lcsstr('ABCD', 'BC'), 2/4)
        self.assertAlmostEqual(sim_lcsstr('ABCD', 'AD'), 1/4)
        self.assertAlmostEqual(sim_lcsstr('ABCD', 'AC'), 1/4)
        self.assertAlmostEqual(sim_lcsstr('AB', 'CD'), 0)
        self.assertAlmostEqual(sim_lcsstr('ABC', 'BCD'), 2/3)

        self.assertAlmostEqual(sim_lcsstr('DIXON', 'DICKSONX'), 2/8)

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertAlmostEqual(sim_lcsstr('AGCAT', 'GAC'), 1/5)
        self.assertAlmostEqual(sim_lcsstr('XMJYAUZ', 'MZJAWXU'), 1/7)

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertAlmostEqual(sim_lcsstr('hell', 'hello'), 4/5)
        self.assertAlmostEqual(sim_lcsstr('hello', 'hell'), 4/5)
        self.assertAlmostEqual(sim_lcsstr('ell', 'hell'), 3/4)
        self.assertAlmostEqual(sim_lcsstr('hell', 'ell'), 3/4)
        self.assertAlmostEqual(sim_lcsstr('faxbcd', 'abdef'), 1/6)

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertAlmostEqual(sim_lcsstr('hello world', 'world war 2'), 5/11)
        self.assertAlmostEqual(sim_lcsstr('foo bar', 'bar foo'), 3/7)
        self.assertAlmostEqual(sim_lcsstr('aaa', 'aa'), 2/3)
        self.assertAlmostEqual(sim_lcsstr('cc', 'bbbbcccccc'), 2/10)
        self.assertAlmostEqual(sim_lcsstr('ccc', 'bcbb'), 1/4)

    def test_dist_lcsstr(self):
        """Test abydos.distance.dist_lcsstr."""
        self.assertEqual(dist_lcsstr('', ''), 0)
        self.assertEqual(dist_lcsstr('A', ''), 1)
        self.assertEqual(dist_lcsstr('', 'A'), 1)
        self.assertEqual(dist_lcsstr('A', 'A'), 0)
        self.assertEqual(dist_lcsstr('ABCD', ''), 1)
        self.assertEqual(dist_lcsstr('', 'ABCD'), 1)
        self.assertEqual(dist_lcsstr('ABCD', 'ABCD'), 0)
        self.assertAlmostEqual(dist_lcsstr('ABCD', 'BC'), 2/4)
        self.assertAlmostEqual(dist_lcsstr('ABCD', 'AD'), 3/4)
        self.assertAlmostEqual(dist_lcsstr('ABCD', 'AC'), 3/4)
        self.assertAlmostEqual(dist_lcsstr('AB', 'CD'), 1)
        self.assertAlmostEqual(dist_lcsstr('ABC', 'BCD'), 1/3)

        self.assertAlmostEqual(dist_lcsstr('DIXON', 'DICKSONX'), 6/8)

        # https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
        self.assertAlmostEqual(dist_lcsstr('AGCAT', 'GAC'), 4/5)
        self.assertAlmostEqual(dist_lcsstr('XMJYAUZ', 'MZJAWXU'), 6/7)

        # https://github.com/jwmerrill/factor/blob/master/basis/lcs/lcs-tests.factor
        self.assertAlmostEqual(dist_lcsstr('hell', 'hello'), 1/5)
        self.assertAlmostEqual(dist_lcsstr('hello', 'hell'), 1/5)
        self.assertAlmostEqual(dist_lcsstr('ell', 'hell'), 1/4)
        self.assertAlmostEqual(dist_lcsstr('hell', 'ell'), 1/4)
        self.assertAlmostEqual(dist_lcsstr('faxbcd', 'abdef'), 5/6)

        # http://www.unesco.org/culture/languages-atlas/assets/_core/php/qcubed_unit_tests.php
        self.assertAlmostEqual(dist_lcsstr('hello world', 'world war 2'), 6/11)
        self.assertAlmostEqual(dist_lcsstr('foo bar', 'bar foo'), 4/7)
        self.assertAlmostEqual(dist_lcsstr('aaa', 'aa'), 1/3)
        self.assertAlmostEqual(dist_lcsstr('cc', 'bbbbcccccc'), 8/10)
        self.assertAlmostEqual(dist_lcsstr('ccc', 'bcbb'), 3/4)


class RatcliffObershelpTestCases(unittest.TestCase):
    """Test Ratcliff-Obserhelp functions.

    abydos.distance.sim_ratcliff_obershelp, &
    abydos.distance.dist_ratcliff_obershelp
    """

    def test_sim_ratcliff_obershelp(self):
        """Test abydos.distance.sim_ratcliff_obershelp."""
        # https://github.com/rockymadden/stringmetric/blob/master/core/src/test/scala/com/rockymadden/stringmetric/similarity/RatcliffObershelpMetricSpec.scala
        self.assertEqual(sim_ratcliff_obershelp('', ''), 1)
        self.assertEqual(sim_ratcliff_obershelp('abc', ''), 0)
        self.assertEqual(sim_ratcliff_obershelp('', 'xyz'), 0)
        self.assertEqual(sim_ratcliff_obershelp('abc', 'abc'), 1)
        self.assertEqual(sim_ratcliff_obershelp('123', '123'), 1)
        self.assertEqual(sim_ratcliff_obershelp('abc', 'xyz'), 0)
        self.assertEqual(sim_ratcliff_obershelp('123', '456'), 0)
        self.assertAlmostEqual(sim_ratcliff_obershelp('aleksander',
                                                      'alexandre'),
                               0.7368421052631579)
        self.assertAlmostEqual(sim_ratcliff_obershelp('alexandre',
                                                      'aleksander'),
                               0.7368421052631579)
        self.assertAlmostEqual(sim_ratcliff_obershelp('pennsylvania',
                                                      'pencilvaneya'),
                               0.6666666666666666)
        self.assertAlmostEqual(sim_ratcliff_obershelp('pencilvaneya',
                                                      'pennsylvania'),
                               0.6666666666666666)
        self.assertAlmostEqual(sim_ratcliff_obershelp('abcefglmn', 'abefglmo'),
                               0.8235294117647058)
        self.assertAlmostEqual(sim_ratcliff_obershelp('abefglmo', 'abcefglmn'),
                               0.8235294117647058)

        with open(TESTDIR+'/corpora/variantNames.csv') as cav_testset:
            next(cav_testset)
            for line in cav_testset:
                line = line.strip().split(',')
                word1, word2 = line[0], line[4]
                self.assertAlmostEqual(sim_ratcliff_obershelp(word1, word2),
                                       SequenceMatcher(None, word1,
                                                       word2).ratio())

        with open(TESTDIR+'/corpora/wikipediaCommonMisspellings.csv') as missp:
            next(missp)
            for line in missp:
                line = line.strip().upper()
                line = ''.join([_ for _ in line.strip() if _ in
                                tuple('ABCDEFGHIJKLMNOPQRSTUVWXYZ,')])
                word1, word2 = line.split(',')
                # print(word1, word2e)
                self.assertAlmostEqual(sim_ratcliff_obershelp(word1, word2),
                                       SequenceMatcher(None, word1,
                                                       word2).ratio())

    def test_dist_ratcliff_obershelp(self):
        """Test abydos.distance.dist_ratcliff_obershelp."""
        # https://github.com/rockymadden/stringmetric/blob/master/core/src/test/scala/com/rockymadden/stringmetric/similarity/RatcliffObershelpMetricSpec.scala
        self.assertEqual(dist_ratcliff_obershelp('', ''), 0)
        self.assertEqual(dist_ratcliff_obershelp('abc', ''), 1)
        self.assertEqual(dist_ratcliff_obershelp('', 'xyz'), 1)
        self.assertEqual(dist_ratcliff_obershelp('abc', 'abc'), 0)
        self.assertEqual(dist_ratcliff_obershelp('123', '123'), 0)
        self.assertEqual(dist_ratcliff_obershelp('abc', 'xyz'), 1)
        self.assertEqual(dist_ratcliff_obershelp('123', '456'), 1)
        self.assertAlmostEqual(dist_ratcliff_obershelp('aleksander',
                                                       'alexandre'),
                               0.2631578947368421)
        self.assertAlmostEqual(dist_ratcliff_obershelp('alexandre',
                                                       'aleksander'),
                               0.2631578947368421)
        self.assertAlmostEqual(dist_ratcliff_obershelp('pennsylvania',
                                                       'pencilvaneya'),
                               0.3333333333333333)
        self.assertAlmostEqual(dist_ratcliff_obershelp('pencilvaneya',
                                                       'pennsylvania'),
                               0.3333333333333333)
        self.assertAlmostEqual(dist_ratcliff_obershelp('abcefglmn',
                                                       'abefglmo'),
                               0.1764705882352941)
        self.assertAlmostEqual(dist_ratcliff_obershelp('abefglmo',
                                                       'abcefglmn'),
                               0.1764705882352941)


class MraTestCases(unittest.TestCase):
    """Test MRA functions.

    abydos.distance.mra_compare, .sim_mra & .dist_mra
    """

    def test_mra_compare(self):
        """Test abydos.distance.mra_compare."""
        self.assertEqual(mra_compare('', ''), 6)
        self.assertEqual(mra_compare('a', 'a'), 6)
        self.assertEqual(mra_compare('abcdefg', 'abcdefg'), 6)
        self.assertEqual(mra_compare('abcdefg', ''), 0)
        self.assertEqual(mra_compare('', 'abcdefg'), 0)

        # https://en.wikipedia.org/wiki/Match_rating_approach
        self.assertEqual(mra_compare('Byrne', 'Boern'), 5)
        self.assertEqual(mra_compare('Smith', 'Smyth'), 5)
        self.assertEqual(mra_compare('Catherine', 'Kathryn'), 4)

        self.assertEqual(mra_compare('ab', 'abcdefgh'), 0)
        self.assertEqual(mra_compare('ab', 'ac'), 5)
        self.assertEqual(mra_compare('abcdefik', 'abcdefgh'), 3)
        self.assertEqual(mra_compare('xyz', 'abc'), 0)

    def test_sim_mra(self):
        """Test abydos.distance.sim_mra."""
        self.assertEqual(sim_mra('', ''), 1)
        self.assertEqual(sim_mra('a', 'a'), 1)
        self.assertEqual(sim_mra('abcdefg', 'abcdefg'), 1)
        self.assertEqual(sim_mra('abcdefg', ''), 0)
        self.assertEqual(sim_mra('', 'abcdefg'), 0)

        # https://en.wikipedia.org/wiki/Match_rating_approach
        self.assertEqual(sim_mra('Byrne', 'Boern'), 5/6)
        self.assertEqual(sim_mra('Smith', 'Smyth'), 5/6)
        self.assertEqual(sim_mra('Catherine', 'Kathryn'), 4/6)

        self.assertEqual(sim_mra('ab', 'abcdefgh'), 0)
        self.assertEqual(sim_mra('ab', 'ac'), 5/6)
        self.assertEqual(sim_mra('abcdefik', 'abcdefgh'), 3/6)
        self.assertEqual(sim_mra('xyz', 'abc'), 0)

    def test_dist_mra(self):
        """Test abydos.distance.dist_mra."""
        self.assertEqual(dist_mra('', ''), 0)
        self.assertEqual(dist_mra('a', 'a'), 0)
        self.assertEqual(dist_mra('abcdefg', 'abcdefg'), 0)
        self.assertEqual(dist_mra('abcdefg', ''), 1)
        self.assertEqual(dist_mra('', 'abcdefg'), 1)

        # https://en.wikipedia.org/wiki/Match_rating_approach
        self.assertAlmostEqual(dist_mra('Byrne', 'Boern'), 1/6)
        self.assertAlmostEqual(dist_mra('Smith', 'Smyth'), 1/6)
        self.assertAlmostEqual(dist_mra('Catherine', 'Kathryn'), 2/6)

        self.assertEqual(dist_mra('ab', 'abcdefgh'), 1)
        self.assertAlmostEqual(dist_mra('ab', 'ac'), 1/6)
        self.assertAlmostEqual(dist_mra('abcdefik', 'abcdefgh'), 3/6)
        self.assertEqual(dist_mra('xyz', 'abc'), 1)


class CompressionTestCases(unittest.TestCase):
    """Test compression distance functions.

    abydos.distance.dist_compression & .sim_compression
    """

    arith_dict = ac_train(' '.join(NIALL))

    def test_dist_compression(self):
        """Test abydos.distance.dist_compression."""
        self.assertEqual(dist_compression('', ''), 0)
        self.assertEqual(dist_compression('', '', 'bzip2'), 0)
        self.assertEqual(dist_compression('', '', 'zlib'), 0)
        self.assertEqual(dist_compression('', '', 'arith'), 0)
        self.assertEqual(dist_compression('', '', 'arith', self.arith_dict), 0)
        self.assertEqual(dist_compression('', '', 'rle'), 0)
        self.assertEqual(dist_compression('', '', 'bwtrle'), 0)

        self.assertGreater(dist_compression('a', ''), 0)
        self.assertGreater(dist_compression('a', '', 'bzip2'), 0)
        self.assertGreater(dist_compression('a', '', 'zlib'), 0)
        self.assertGreater(dist_compression('a', '', 'arith'), 0)
        self.assertGreater(dist_compression('a', '', 'arith', self.arith_dict),
                           0)
        self.assertGreater(dist_compression('a', '', 'rle'), 0)
        self.assertGreater(dist_compression('a', '', 'bwtrle'), 0)

        self.assertGreater(dist_compression('abcdefg', 'fg'), 0)
        self.assertGreater(dist_compression('abcdefg', 'fg', 'bzip2'), 0)
        self.assertGreater(dist_compression('abcdefg', 'fg', 'zlib'), 0)
        self.assertGreater(dist_compression('abcdefg', 'fg', 'arith'), 0)
        self.assertGreater(dist_compression('abcdefg', 'fg', 'rle'), 0)
        self.assertGreater(dist_compression('abcdefg', 'fg', 'bwtrle'), 0)

    def test_dist_compression_arith(self):
        """Test abydos.distance.dist_compression (arithmetric compression)."""
        self.assertAlmostEqual(dist_compression('Niall', 'Neil', 'arith',
                                                self.arith_dict),
                               0.608695652173913)
        self.assertAlmostEqual(dist_compression('Neil', 'Niall', 'arith',
                                                self.arith_dict),
                               0.608695652173913)
        self.assertAlmostEqual(dist_compression('Niall', 'Neil', 'arith'),
                               0.6875)
        self.assertAlmostEqual(dist_compression('Neil', 'Niall', 'arith'),
                               0.6875)
        self.assertAlmostEqual(dist_compression('Njáll', 'Njall', 'arith',
                                                self.arith_dict),
                               0.714285714285714)
        self.assertAlmostEqual(dist_compression('Njall', 'Njáll', 'arith',
                                                self.arith_dict),
                               0.714285714285714)
        self.assertAlmostEqual(dist_compression('Njáll', 'Njall', 'arith'),
                               0.75)
        self.assertAlmostEqual(dist_compression('Njall', 'Njáll', 'arith'),
                               0.75)

    def test_dist_compression_rle(self):
        """Test abydos.distance.dist_compression (RLE & BWT+RLE)."""
        self.assertAlmostEqual(dist_compression('abc', 'abc', 'rle'), 0)
        self.assertAlmostEqual(dist_compression('abc', 'def', 'rle'), 1)

        self.assertAlmostEqual(dist_compression('abc', 'abc', 'bwtrle'), 0)
        self.assertAlmostEqual(dist_compression('abc', 'def', 'bwtrle'), 0.75)

        self.assertAlmostEqual(dist_compression('aaa', 'bbaaa', 'rle'), 0.5)
        self.assertAlmostEqual(dist_compression('abb', 'bbba', 'rle'), 1/3)
        self.assertAlmostEqual(dist_compression('banana', 'banane', 'bwtrle'),
                               0.57142857142)
        self.assertAlmostEqual(dist_compression('bananas', 'bananen',
                                                'bwtrle'),
                               0.5)

    def test_sim_compression(self):
        """Test abydos.distance.sim_compression."""
        self.assertEqual(sim_compression('', ''), 1)
        self.assertEqual(sim_compression('', '', 'bzip2'), 1)
        self.assertEqual(sim_compression('', '', 'zlib'), 1)
        self.assertEqual(sim_compression('', '', 'arith'), 1)
        self.assertEqual(sim_compression('', '', 'arith', self.arith_dict), 1)
        self.assertEqual(sim_compression('', '', 'rle'), 1)
        self.assertEqual(sim_compression('', '', 'bwtrle'), 1)

        self.assertLess(sim_compression('a', ''), 1)
        self.assertLess(sim_compression('a', '', 'bzip2'), 1)
        self.assertLess(sim_compression('a', '', 'zlib'), 1)
        self.assertLess(sim_compression('a', '', 'arith'), 1)
        self.assertLess(sim_compression('a', '', 'arith', self.arith_dict), 1)
        self.assertLess(sim_compression('a', '', 'rle'), 1)
        self.assertLess(sim_compression('a', '', 'bwtrle'), 1)

        self.assertLess(sim_compression('abcdefg', 'fg'), 1)
        self.assertLess(sim_compression('abcdefg', 'fg', 'bzip2'), 1)
        self.assertLess(sim_compression('abcdefg', 'fg', 'zlib'), 1)
        self.assertLess(sim_compression('abcdefg', 'fg', 'arith'), 1)
        self.assertLess(sim_compression('abcdefg', 'fg', 'rle'), 1)
        self.assertLess(sim_compression('abcdefg', 'fg', 'bwtrle'), 1)

    def test_sim_compression_arith(self):
        """Test abydos.distance.sim_compression (arithmetric compression)."""
        self.assertAlmostEqual(sim_compression('Niall', 'Neil', 'arith',
                                               self.arith_dict),
                               0.3913043478260869)
        self.assertAlmostEqual(sim_compression('Neil', 'Niall', 'arith',
                                               self.arith_dict),
                               0.3913043478260869)
        self.assertAlmostEqual(sim_compression('Niall', 'Neil', 'arith'),
                               0.3125)
        self.assertAlmostEqual(sim_compression('Neil', 'Niall', 'arith'),
                               0.3125)
        self.assertAlmostEqual(sim_compression('Njáll', 'Njall', 'arith',
                                               self.arith_dict),
                               0.285714285714285)
        self.assertAlmostEqual(sim_compression('Njall', 'Njáll', 'arith',
                                               self.arith_dict),
                               0.285714285714285)
        self.assertAlmostEqual(sim_compression('Njáll', 'Njall', 'arith'),
                               0.25)
        self.assertAlmostEqual(sim_compression('Njall', 'Njáll', 'arith'),
                               0.25)

    def test_sim_compression_rle(self):
        """Test abydos.distance.sim_compression (RLE & BWT+RLE)."""
        self.assertAlmostEqual(sim_compression('abc', 'abc', 'rle'), 1)
        self.assertAlmostEqual(sim_compression('abc', 'def', 'rle'), 0)

        self.assertAlmostEqual(sim_compression('abc', 'abc', 'bwtrle'), 1)
        self.assertAlmostEqual(sim_compression('abc', 'def', 'bwtrle'), 0.25)

        self.assertAlmostEqual(sim_compression('aaa', 'bbaaa', 'rle'), 0.5)
        self.assertAlmostEqual(sim_compression('abb', 'bbba', 'rle'), 2/3)
        self.assertAlmostEqual(sim_compression('banana', 'banane', 'bwtrle'),
                               0.42857142857)
        self.assertAlmostEqual(sim_compression('bananas', 'bananen', 'bwtrle'),
                               0.5)

    def test_lzma(self):
        """Test LZMA-related sim/dist functions."""
        if bool(pkgutil.find_loader('lzma')):
            self.assertEqual(dist_compression('', '', 'lzma'), 0)
            self.assertGreater(dist_compression('a', '', 'lzma'), 0)
            self.assertGreater(dist_compression('abcdefg', 'fg', 'lzma'), 0)
            self.assertEqual(sim_compression('', '', 'lzma'), 1)
            self.assertLess(sim_compression('a', '', 'lzma'), 1)
            self.assertLess(sim_compression('abcdefg', 'fg', 'lzma'), 1)
            del sys.modules['lzma']

        self.assertRaises(ValueError, dist_compression, 'a', '', 'lzma')


class MongeElkanTestCases(unittest.TestCase):
    """Test Monge-Elkan functions.

    abydos.distance.sim_monge_elkan & .dist_monge_elkan
    """

    def test_sim_monge_elkan(self):
        """Test abydos.distance.sim_monge_elkan."""
        self.assertEqual(sim_monge_elkan('', ''), 1)
        self.assertEqual(sim_monge_elkan('', 'a'), 0)
        self.assertEqual(sim_monge_elkan('a', 'a'), 1)

        self.assertEqual(sim_monge_elkan('Niall', 'Neal'), 3/4)
        self.assertEqual(sim_monge_elkan('Niall', 'Njall'), 5/6)
        self.assertEqual(sim_monge_elkan('Niall', 'Niel'), 3/4)
        self.assertEqual(sim_monge_elkan('Niall', 'Nigel'), 3/4)

        self.assertEqual(sim_monge_elkan('Niall', 'Neal', symmetric=True),
                         31/40)
        self.assertEqual(sim_monge_elkan('Niall', 'Njall', symmetric=True),
                         5/6)
        self.assertEqual(sim_monge_elkan('Niall', 'Niel', symmetric=True),
                         31/40)
        self.assertAlmostEqual(sim_monge_elkan('Niall', 'Nigel',
                                               symmetric=True), 17/24)

    def test_dist_monge_elkan(self):
        """Test abydos.distance.dist_monge_elkan."""
        self.assertEqual(dist_monge_elkan('', ''), 0)
        self.assertEqual(dist_monge_elkan('', 'a'), 1)

        self.assertEqual(dist_monge_elkan('Niall', 'Neal'), 1/4)
        self.assertAlmostEqual(dist_monge_elkan('Niall', 'Njall'), 1/6)
        self.assertEqual(dist_monge_elkan('Niall', 'Niel'), 1/4)
        self.assertEqual(dist_monge_elkan('Niall', 'Nigel'), 1/4)

        self.assertAlmostEqual(dist_monge_elkan('Niall', 'Neal',
                                                symmetric=True), 9/40)
        self.assertAlmostEqual(dist_monge_elkan('Niall', 'Njall',
                                                symmetric=True), 1/6)
        self.assertAlmostEqual(dist_monge_elkan('Niall', 'Niel',
                                                symmetric=True), 9/40)
        self.assertAlmostEqual(dist_monge_elkan('Niall', 'Nigel',
                                                symmetric=True), 7/24)


class IdentityTestCases(unittest.TestCase):
    """Test identity similarity functions.

    abydos.distance.sim_ident & .dist_ident
    """

    def test_sim_ident(self):
        """Test abydos.distance.sim_ident."""
        self.assertEqual(sim_ident('', ''), 1)
        self.assertEqual(sim_ident('', 'a'), 0)
        self.assertEqual(sim_ident('a', ''), 0)
        self.assertEqual(sim_ident('a', 'a'), 1)
        self.assertEqual(sim_ident('abcd', 'abcd'), 1)
        self.assertEqual(sim_ident('abcd', 'dcba'), 0)
        self.assertEqual(sim_ident('abc', 'cba'), 0)

    def test_dist_ident(self):
        """Test abydos.distance.dist_ident."""
        self.assertEqual(dist_ident('', ''), 0)
        self.assertEqual(dist_ident('', 'a'), 1)
        self.assertEqual(dist_ident('a', ''), 1)
        self.assertEqual(dist_ident('a', 'a'), 0)
        self.assertEqual(dist_ident('abcd', 'abcd'), 0)
        self.assertEqual(dist_ident('abcd', 'dcba'), 1)
        self.assertEqual(dist_ident('abc', 'cba'), 1)


def _sim_wikipedia(src, tar):
    """Return a similarity score for two DNA base pairs.

    Values copied from:
    https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm
    """
    nw_matrix = {('A', 'A'): 10, ('G', 'G'): 7, ('C', 'C'): 9, ('T', 'T'): 8,
                 ('A', 'G'): -1, ('A', 'C'): -3, ('A', 'T'): -4,
                 ('G', 'C'): -5, ('G', 'T'): -3, ('C', 'T'): 0}
    return sim_matrix(src, tar, nw_matrix, symmetric=True, alphabet='CGAT')


def _sim_nw(src, tar):
    """Return 1 if src is tar, otherwise -1."""
    return 2*float(src is tar)-1


class MatrixSimTestCases(unittest.TestCase):
    """Test matrix similarity functions.

    abydos.distance.sim_matrix
    """

    def test_sim_matrix(self):
        """Test abydos.distance.sim_matrix."""
        self.assertEqual(sim_matrix('', ''), 1)
        self.assertEqual(sim_matrix('', 'a'), 0)
        self.assertEqual(sim_matrix('a', ''), 0)
        self.assertEqual(sim_matrix('a', 'a'), 1)
        self.assertEqual(sim_matrix('abcd', 'abcd'), 1)
        self.assertEqual(sim_matrix('abcd', 'dcba'), 0)
        self.assertEqual(sim_matrix('abc', 'cba'), 0)

        # https://en.wikipedia.org/wiki/Needleman–Wunsch_algorithm
        self.assertEqual(_sim_wikipedia('A', 'C'), -3)
        self.assertEqual(_sim_wikipedia('G', 'G'), 7)
        self.assertEqual(_sim_wikipedia('A', 'A'), 10)
        self.assertEqual(_sim_wikipedia('T', 'A'), -4)
        self.assertEqual(_sim_wikipedia('T', 'C'), 0)
        self.assertEqual(_sim_wikipedia('A', 'G'), -1)
        self.assertEqual(_sim_wikipedia('C', 'T'), 0)

        self.assertRaises(ValueError, sim_matrix, 'abc', 'cba', alphabet='ab')
        self.assertRaises(ValueError, sim_matrix, 'abc', 'ba', alphabet='ab')
        self.assertRaises(ValueError, sim_matrix, 'ab', 'cba', alphabet='ab')


class NeedlemanWunschTestCases(unittest.TestCase):
    """Test Needleman-Wunsch functions.

    abydos.distance.needleman_wunsch
    """

    def test_needleman_wunsch(self):
        """Test abydos.distance.needleman_wunsch."""
        self.assertEqual(needleman_wunsch('', ''), 0)

        # https://en.wikipedia.org/wiki/Needleman–Wunsch_algorithm
        self.assertEqual(needleman_wunsch('GATTACA', 'GCATGCU',
                                          1, _sim_nw), 0)
        self.assertEqual(needleman_wunsch('AGACTAGTTAC', 'CGAGACGT',
                                          5, _sim_wikipedia), 16)

        # checked against http://ds9a.nl/nwunsch/ (mismatch=1, gap=5, skew=5)
        self.assertEqual(needleman_wunsch('CGATATCAG', 'TGACGSTGC',
                                          5, _sim_nw), -5)
        self.assertEqual(needleman_wunsch('AGACTAGTTAC', 'TGACGSTGC',
                                          5, _sim_nw), -7)
        self.assertEqual(needleman_wunsch('AGACTAGTTAC', 'CGAGACGT',
                                          5, _sim_nw), -15)

    def test_needleman_wunsch_nialls(self):
        """Test abydos.distance.needleman_wunsch (Nialls set)."""
        # checked against http://ds9a.nl/nwunsch/ (mismatch=1, gap=2, skew=2)
        nw_vals = (5, 0, -2, 3, 1, 1, -2, -2, -1, -3, -3, -5, -3, -7, -7, -19)
        for i in range(len(NIALL)):
            self.assertEqual(needleman_wunsch(NIALL[0], NIALL[i], 2,
                                              _sim_nw), nw_vals[i])


class SmithWatermanTestCases(unittest.TestCase):
    """Test Smith-Waterman functions.

    abydos.distance.smith_waterman
    """

    def test_smith_waterman(self):
        """Test abydos.distance.smith_waterman."""
        self.assertEqual(smith_waterman('', ''), 0)

        # https://en.wikipedia.org/wiki/Needleman–Wunsch_algorithm
        self.assertEqual(smith_waterman('GATTACA', 'GCATGCU',
                                        1, _sim_nw), 0)
        self.assertEqual(smith_waterman('AGACTAGTTAC', 'CGAGACGT',
                                        5, _sim_wikipedia), 26)

        self.assertEqual(smith_waterman('CGATATCAG', 'TGACGSTGC',
                                        5, _sim_nw), 0)
        self.assertEqual(smith_waterman('AGACTAGTTAC', 'TGACGSTGC',
                                        5, _sim_nw), 1)
        self.assertEqual(smith_waterman('AGACTAGTTAC', 'CGAGACGT',
                                        5, _sim_nw), 0)

    def test_smith_waterman_nialls(self):
        """Test abydos.distance.smith_waterman (Nialls set)."""
        sw_vals = (5, 1, 1, 3, 2, 1, 1, 0, 0, 1, 1, 2, 2, 1, 0, 0)
        for i in range(len(NIALL)):
            self.assertEqual(smith_waterman(NIALL[0], NIALL[i], 2,
                                            _sim_nw), sw_vals[i])


class GotohTestCases(unittest.TestCase):
    """Test Gotoh functions.

    abydos.distance.gotoh
    """

    def test_gotoh(self):
        """Test abydos.distance.needleman_wunsch_affine."""
        self.assertEqual(gotoh('', ''), 0)

        # https://en.wikipedia.org/wiki/Needleman–Wunsch_algorithm
        self.assertEqual(gotoh('GATTACA', 'GCATGCU', 1, 1, _sim_nw), 0)
        self.assertGreaterEqual(gotoh('GATTACA', 'GCATGCU', 1, 0.5, _sim_nw),
                                needleman_wunsch('GATTACA', 'GCATGCU', 1,
                                                 _sim_nw))
        self.assertEqual(gotoh('AGACTAGTTAC', 'CGAGACGT', 5, 5,
                               _sim_wikipedia), 16)
        self.assertGreaterEqual(gotoh('AGACTAGTTAC', 'CGAGACGT', 5, 2,
                                      _sim_wikipedia),
                                needleman_wunsch('AGACTAGTTAC', 'CGAGACGT', 5,
                                                 _sim_wikipedia))

        # checked against http://ds9a.nl/nwunsch/ (mismatch=1, gap=5, skew=5)
        self.assertEqual(gotoh('CGATATCAG', 'TGACGSTGC', 5, 5, _sim_nw), -5)
        self.assertGreaterEqual(gotoh('CGATATCAG', 'TGACGSTGC', 5, 2, _sim_nw),
                                needleman_wunsch('CGATATCAG', 'TGACGSTGC', 5,
                                                 _sim_nw))
        self.assertEqual(gotoh('AGACTAGTTAC', 'TGACGSTGC', 5, 5, _sim_nw), -7)
        self.assertGreaterEqual(gotoh('AGACTAGTTAC', 'TGACGSTGC', 5, 2,
                                      _sim_nw),
                                needleman_wunsch('AGACTAGTTAC', 'TGACGSTGC', 5,
                                                 _sim_nw))
        self.assertEqual(gotoh('AGACTAGTTAC', 'CGAGACGT', 5, 5, _sim_nw), -15)
        self.assertGreaterEqual(gotoh('AGACTAGTTAC', 'CGAGACGT', 5, 2,
                                      _sim_nw),
                                needleman_wunsch('AGACTAGTTAC', 'CGAGACGT', 5,
                                                 _sim_nw))

    def test_gotoh_nialls(self):
        """Test abydos.distance.gotoh (Nialls set)."""
        # checked against http://ds9a.nl/nwunsch/ (mismatch=1, gap=2, skew=2)
        nw_vals = (5, 0, -2, 3, 1, 1, -2, -2, -1, -3, -3, -5, -3, -7, -7, -19)
        for i in range(len(NIALL)):
            self.assertEqual(gotoh(NIALL[0], NIALL[i], 2, 2, _sim_nw),
                             nw_vals[i])
        nw_vals2 = (5, 0, -2, 3, 1, 1, -2, -2, -1, -2, -3, -3, -2, -6, -6, -8)
        for i in range(len(NIALL)):
            self.assertEqual(gotoh(NIALL[0], NIALL[i], 2, 1, _sim_nw),
                             nw_vals2[i])
            self.assertGreaterEqual(gotoh(NIALL[0], NIALL[i], 2, 0.5, _sim_nw),
                                    needleman_wunsch(NIALL[0], NIALL[i], 2,
                                                     _sim_nw))


class LengthTestCases(unittest.TestCase):
    """Test length similarity functions.

    abydos.distance.sim_length & .dist_length
    """

    def test_sim_ident(self):
        """Test abydos.distance.sim_length."""
        self.assertEqual(sim_length('', ''), 1)
        self.assertEqual(sim_length('', 'a'), 0)
        self.assertEqual(sim_length('a', ''), 0)
        self.assertEqual(sim_length('a', 'a'), 1)
        self.assertEqual(sim_length('abcd', 'abcd'), 1)
        self.assertEqual(sim_length('abcd', 'dcba'), 1)
        self.assertEqual(sim_length('abc', 'cba'), 1)
        self.assertEqual(sim_length('abc', 'dcba'), 0.75)
        self.assertEqual(sim_length('abcd', 'cba'), 0.75)
        self.assertEqual(sim_length('ab', 'dcba'), 0.5)
        self.assertEqual(sim_length('abcd', 'ba'), 0.5)

    def test_dist_ident(self):
        """Test abydos.distance.dist_length."""
        self.assertEqual(dist_length('', ''), 0)
        self.assertEqual(dist_length('', 'a'), 1)
        self.assertEqual(dist_length('a', ''), 1)
        self.assertEqual(dist_length('a', 'a'), 0)
        self.assertEqual(dist_length('abcd', 'abcd'), 0)
        self.assertEqual(dist_length('abcd', 'dcba'), 0)
        self.assertEqual(dist_length('abc', 'cba'), 0)
        self.assertEqual(dist_length('abc', 'dcba'), 0.25)
        self.assertEqual(dist_length('abcd', 'cba'), 0.25)
        self.assertEqual(dist_length('ab', 'dcba'), 0.5)
        self.assertEqual(dist_length('abcd', 'ba'), 0.5)


class PrefixTestCases(unittest.TestCase):
    """Test prefix similarity functions.

    abydos.distance.sim_prefix & .dist_prefix
    """

    def test_sim_prefix(self):
        """Test abydos.distance.sim_prefix."""
        self.assertEqual(sim_prefix('', ''), 1)
        self.assertEqual(sim_prefix('a', ''), 0)
        self.assertEqual(sim_prefix('', 'a'), 0)
        self.assertEqual(sim_prefix('a', 'a'), 1)
        self.assertEqual(sim_prefix('ax', 'a'), 1)
        self.assertEqual(sim_prefix('axx', 'a'), 1)
        self.assertEqual(sim_prefix('ax', 'ay'), 1/2)
        self.assertEqual(sim_prefix('a', 'ay'), 1)
        self.assertEqual(sim_prefix('a', 'ayy'), 1)
        self.assertEqual(sim_prefix('ax', 'ay'), 1/2)
        self.assertEqual(sim_prefix('a', 'y'), 0)
        self.assertEqual(sim_prefix('y', 'a'), 0)
        self.assertEqual(sim_prefix('aaax', 'aaa'), 1)
        self.assertAlmostEqual(sim_prefix('axxx', 'aaa'), 1/3)
        self.assertEqual(sim_prefix('aaxx', 'aayy'), 1/2)
        self.assertEqual(sim_prefix('xxaa', 'yyaa'), 0)
        self.assertAlmostEqual(sim_prefix('aaxxx', 'aay'), 2/3)
        self.assertEqual(sim_prefix('aaxxxx', 'aayyy'), 2/5)
        self.assertEqual(sim_prefix('xa', 'a'), 0)
        self.assertEqual(sim_prefix('xxa', 'a'), 0)
        self.assertEqual(sim_prefix('xa', 'ya'), 0)
        self.assertEqual(sim_prefix('a', 'ya'), 0)
        self.assertEqual(sim_prefix('a', 'yya'), 0)
        self.assertEqual(sim_prefix('xa', 'ya'), 0)
        self.assertEqual(sim_prefix('xaaa', 'aaa'), 0)
        self.assertEqual(sim_prefix('xxxa', 'aaa'), 0)
        self.assertEqual(sim_prefix('xxxaa', 'yaa'), 0)
        self.assertEqual(sim_prefix('xxxxaa', 'yyyaa'), 0)

    def test_dist_prefix(self):
        """Test abydos.distance.dist_prefix."""
        self.assertEqual(dist_prefix('', ''), 0)
        self.assertEqual(dist_prefix('a', ''), 1)
        self.assertEqual(dist_prefix('', 'a'), 1)
        self.assertEqual(dist_prefix('a', 'a'), 0)
        self.assertEqual(dist_prefix('ax', 'a'), 0)
        self.assertEqual(dist_prefix('axx', 'a'), 0)
        self.assertEqual(dist_prefix('ax', 'ay'), 1/2)
        self.assertEqual(dist_prefix('a', 'ay'), 0)
        self.assertEqual(dist_prefix('a', 'ayy'), 0)
        self.assertEqual(dist_prefix('ax', 'ay'), 1/2)
        self.assertEqual(dist_prefix('a', 'y'), 1)
        self.assertEqual(dist_prefix('y', 'a'), 1)
        self.assertEqual(dist_prefix('aaax', 'aaa'), 0)
        self.assertAlmostEqual(dist_prefix('axxx', 'aaa'), 2/3)
        self.assertEqual(dist_prefix('aaxx', 'aayy'), 1/2)
        self.assertEqual(dist_prefix('xxaa', 'yyaa'), 1)
        self.assertAlmostEqual(dist_prefix('aaxxx', 'aay'), 1/3)
        self.assertEqual(dist_prefix('aaxxxx', 'aayyy'), 3/5)
        self.assertEqual(dist_prefix('xa', 'a'), 1)
        self.assertEqual(dist_prefix('xxa', 'a'), 1)
        self.assertEqual(dist_prefix('xa', 'ya'), 1)
        self.assertEqual(dist_prefix('a', 'ya'), 1)
        self.assertEqual(dist_prefix('a', 'yya'), 1)
        self.assertEqual(dist_prefix('xa', 'ya'), 1)
        self.assertEqual(dist_prefix('xaaa', 'aaa'), 1)
        self.assertEqual(dist_prefix('xxxa', 'aaa'), 1)
        self.assertEqual(dist_prefix('xxxaa', 'yaa'), 1)
        self.assertEqual(dist_prefix('xxxxaa', 'yyyaa'), 1)


class SuffixTestCases(unittest.TestCase):
    """Test suffix similarity functions.

    abydos.distance.sim_suffix & .dist_suffix
    """

    def test_sim_suffix(self):
        """Test abydos.distance.sim_suffix."""
        self.assertEqual(sim_suffix('', ''), 1)
        self.assertEqual(sim_suffix('a', ''), 0)
        self.assertEqual(sim_suffix('', 'a'), 0)
        self.assertEqual(sim_suffix('a', 'a'), 1)
        self.assertEqual(sim_suffix('ax', 'a'), 0)
        self.assertEqual(sim_suffix('axx', 'a'), 0)
        self.assertEqual(sim_suffix('ax', 'ay'), 0)
        self.assertEqual(sim_suffix('a', 'ay'), 0)
        self.assertEqual(sim_suffix('a', 'ayy'), 0)
        self.assertEqual(sim_suffix('ax', 'ay'), 0)
        self.assertEqual(sim_suffix('a', 'y'), 0)
        self.assertEqual(sim_suffix('y', 'a'), 0)
        self.assertEqual(sim_suffix('aaax', 'aaa'), 0)
        self.assertEqual(sim_suffix('axxx', 'aaa'), 0)
        self.assertEqual(sim_suffix('aaxx', 'aayy'), 0)
        self.assertEqual(sim_suffix('xxaa', 'yyaa'), 1/2)
        self.assertEqual(sim_suffix('aaxxx', 'aay'), 0)
        self.assertEqual(sim_suffix('aaxxxx', 'aayyy'), 0)
        self.assertEqual(sim_suffix('xa', 'a'), 1)
        self.assertEqual(sim_suffix('xxa', 'a'), 1)
        self.assertEqual(sim_suffix('xa', 'ya'), 1/2)
        self.assertEqual(sim_suffix('a', 'ya'), 1)
        self.assertEqual(sim_suffix('a', 'yya'), 1)
        self.assertEqual(sim_suffix('xa', 'ya'), 1/2)
        self.assertEqual(sim_suffix('xaaa', 'aaa'), 1)
        self.assertAlmostEqual(sim_suffix('xxxa', 'aaa'), 1/3)
        self.assertAlmostEqual(sim_suffix('xxxaa', 'yaa'), 2/3)
        self.assertEqual(sim_suffix('xxxxaa', 'yyyaa'), 2/5)

    def test_dist_suffix(self):
        """Test abydos.distance.dist_suffix."""
        self.assertEqual(dist_suffix('', ''), 0)
        self.assertEqual(dist_suffix('a', ''), 1)
        self.assertEqual(dist_suffix('', 'a'), 1)
        self.assertEqual(dist_suffix('a', 'a'), 0)
        self.assertEqual(dist_suffix('ax', 'a'), 1)
        self.assertEqual(dist_suffix('axx', 'a'), 1)
        self.assertEqual(dist_suffix('ax', 'ay'), 1)
        self.assertEqual(dist_suffix('a', 'ay'), 1)
        self.assertEqual(dist_suffix('a', 'ayy'), 1)
        self.assertEqual(dist_suffix('ax', 'ay'), 1)
        self.assertEqual(dist_suffix('a', 'y'), 1)
        self.assertEqual(dist_suffix('y', 'a'), 1)
        self.assertEqual(dist_suffix('aaax', 'aaa'), 1)
        self.assertEqual(dist_suffix('axxx', 'aaa'), 1)
        self.assertEqual(dist_suffix('aaxx', 'aayy'), 1)
        self.assertEqual(dist_suffix('xxaa', 'yyaa'), 1/2)
        self.assertEqual(dist_suffix('aaxxx', 'aay'), 1)
        self.assertEqual(dist_suffix('aaxxxx', 'aayyy'), 1)
        self.assertEqual(dist_suffix('xa', 'a'), 0)
        self.assertEqual(dist_suffix('xxa', 'a'), 0)
        self.assertEqual(dist_suffix('xa', 'ya'), 1/2)
        self.assertEqual(dist_suffix('a', 'ya'), 0)
        self.assertEqual(dist_suffix('a', 'yya'), 0)
        self.assertEqual(dist_suffix('xa', 'ya'), 1/2)
        self.assertEqual(dist_suffix('xaaa', 'aaa'), 0)
        self.assertAlmostEqual(dist_suffix('xxxa', 'aaa'), 2/3)
        self.assertAlmostEqual(dist_suffix('xxxaa', 'yaa'), 1/3)
        self.assertEqual(dist_suffix('xxxxaa', 'yyyaa'), 3/5)


class MLIPNSTestCases(unittest.TestCase):
    """Test MLIPNS functions.

    abydos.distance.sim_mlipns & .dist_mlipns
    """

    def test_sim_mlipns(self):
        """Test abydos.distance.sim_mlipns."""
        self.assertEqual(sim_mlipns('', ''), 1)
        self.assertEqual(sim_mlipns('a', ''), 0)
        self.assertEqual(sim_mlipns('', 'a'), 0)
        self.assertEqual(sim_mlipns('a', 'a'), 1)
        self.assertEqual(sim_mlipns('ab', 'a'), 1)
        self.assertEqual(sim_mlipns('abc', 'abc'), 1)
        self.assertEqual(sim_mlipns('abc', 'abcde'), 1)
        self.assertEqual(sim_mlipns('abcg', 'abcdeg'), 1)
        self.assertEqual(sim_mlipns('abcg', 'abcdefg'), 0)
        self.assertEqual(sim_mlipns('Tomato', 'Tamato'), 1)
        self.assertEqual(sim_mlipns('ato', 'Tam'), 1)

    def test_dist_mlipns(self):
        """Test abydos.distance.dist_mlipns."""
        self.assertEqual(dist_mlipns('', ''), 0)
        self.assertEqual(dist_mlipns('a', ''), 1)
        self.assertEqual(dist_mlipns('', 'a'), 1)
        self.assertEqual(dist_mlipns('a', 'a'), 0)
        self.assertEqual(dist_mlipns('ab', 'a'), 0)
        self.assertEqual(dist_mlipns('abc', 'abc'), 0)
        self.assertEqual(dist_mlipns('abc', 'abcde'), 0)
        self.assertEqual(dist_mlipns('abcg', 'abcdeg'), 0)
        self.assertEqual(dist_mlipns('abcg', 'abcdefg'), 1)
        self.assertEqual(dist_mlipns('Tomato', 'Tamato'), 0)
        self.assertEqual(dist_mlipns('ato', 'Tam'), 0)


class BagTestCases(unittest.TestCase):
    """Test bag similarity functions.

    abydos.distance.bag, .sim_bag & .dist_bag
    """

    def test_bag(self):
        """Test abydos.distance.bag."""
        self.assertEqual(bag('', ''), 0)
        self.assertEqual(bag('nelson', ''), 6)
        self.assertEqual(bag('', 'neilsen'), 7)
        self.assertEqual(bag('ab', 'a'), 1)
        self.assertEqual(bag('ab', 'c'), 2)
        self.assertEqual(bag('nelson', 'neilsen'), 2)
        self.assertEqual(bag('neilsen', 'nelson'), 2)
        self.assertEqual(bag('niall', 'neal'), 2)
        self.assertEqual(bag('aluminum', 'Catalan'), 5)
        self.assertEqual(bag('abcdefg', 'hijklm'), 7)
        self.assertEqual(bag('abcdefg', 'hijklmno'), 8)

    def test_sim_bag(self):
        """Test abydos.distance.sim_bag."""
        self.assertEqual(sim_bag('', ''), 1)
        self.assertEqual(sim_bag('nelson', ''), 0)
        self.assertEqual(sim_bag('', 'neilsen'), 0)
        self.assertEqual(sim_bag('ab', 'a'), 0.5)
        self.assertEqual(sim_bag('ab', 'c'), 0)
        self.assertAlmostEqual(sim_bag('nelson', 'neilsen'), 5/7)
        self.assertAlmostEqual(sim_bag('neilsen', 'nelson'), 5/7)
        self.assertAlmostEqual(sim_bag('niall', 'neal'), 3/5)
        self.assertAlmostEqual(sim_bag('aluminum', 'Catalan'), 3/8)
        self.assertEqual(sim_bag('abcdefg', 'hijklm'), 0)
        self.assertEqual(sim_bag('abcdefg', 'hijklmno'), 0)

    def test_dist_bag(self):
        """Test abydos.distance.dist_bag."""
        self.assertEqual(dist_bag('', ''), 0)
        self.assertEqual(dist_bag('nelson', ''), 1)
        self.assertEqual(dist_bag('', 'neilsen'), 1)
        self.assertEqual(dist_bag('ab', 'a'), 0.5)
        self.assertEqual(dist_bag('ab', 'c'), 1)
        self.assertAlmostEqual(dist_bag('nelson', 'neilsen'), 2/7)
        self.assertAlmostEqual(dist_bag('neilsen', 'nelson'), 2/7)
        self.assertAlmostEqual(dist_bag('niall', 'neal'), 2/5)
        self.assertAlmostEqual(dist_bag('aluminum', 'Catalan'), 5/8)
        self.assertEqual(dist_bag('abcdefg', 'hijklm'), 1)
        self.assertEqual(dist_bag('abcdefg', 'hijklmno'), 1)


class EditexTestCases(unittest.TestCase):
    """Test Editex functions.

    abydos.distance.editex, .sim_editex & .dist_editex
    """

    def test_editex(self):
        """Test abydos.distance.editex."""
        self.assertEqual(editex('', ''), 0)
        self.assertEqual(editex('nelson', ''), 12)
        self.assertEqual(editex('', 'neilsen'), 14)
        self.assertEqual(editex('ab', 'a'), 2)
        self.assertEqual(editex('ab', 'c'), 4)
        self.assertEqual(editex('nelson', 'neilsen'), 2)
        self.assertEqual(editex('neilsen', 'nelson'), 2)
        self.assertEqual(editex('niall', 'neal'), 1)
        self.assertEqual(editex('neal', 'niall'), 1)
        self.assertEqual(editex('niall', 'nihal'), 2)
        self.assertEqual(editex('nihal', 'niall'), 2)
        self.assertEqual(editex('neal', 'nihl'), 3)
        self.assertEqual(editex('nihl', 'neal'), 3)

    def test_editex_local(self):
        """Test abydos.distance.editex (local variant)."""
        self.assertEqual(editex('', '', local=True), 0)
        self.assertEqual(editex('nelson', '', local=True), 12)
        self.assertEqual(editex('', 'neilsen', local=True), 14)
        self.assertEqual(editex('ab', 'a', local=True), 2)
        self.assertEqual(editex('ab', 'c', local=True), 2)
        self.assertEqual(editex('nelson', 'neilsen', local=True), 2)
        self.assertEqual(editex('neilsen', 'nelson', local=True), 2)
        self.assertEqual(editex('niall', 'neal', local=True), 1)
        self.assertEqual(editex('neal', 'niall', local=True), 1)
        self.assertEqual(editex('niall', 'nihal', local=True), 2)
        self.assertEqual(editex('nihal', 'niall', local=True), 2)
        self.assertEqual(editex('neal', 'nihl', local=True), 3)
        self.assertEqual(editex('nihl', 'neal', local=True), 3)

    def test_sim_editex(self):
        """Test abydos.distance.sim_editex."""
        self.assertEqual(sim_editex('', ''), 1)
        self.assertEqual(sim_editex('nelson', ''), 0)
        self.assertEqual(sim_editex('', 'neilsen'), 0)
        self.assertEqual(sim_editex('ab', 'a'), 0.5)
        self.assertEqual(sim_editex('ab', 'c'), 0)
        self.assertAlmostEqual(sim_editex('nelson', 'neilsen'), 12/14)
        self.assertAlmostEqual(sim_editex('neilsen', 'nelson'), 12/14)
        self.assertEqual(sim_editex('niall', 'neal'), 0.9)

    def test_dist_editex(self):
        """Test abydos.distance.dist_editex."""
        self.assertEqual(dist_editex('', ''), 0)
        self.assertEqual(dist_editex('nelson', ''), 1)
        self.assertEqual(dist_editex('', 'neilsen'), 1)
        self.assertEqual(dist_editex('ab', 'a'), 0.5)
        self.assertEqual(dist_editex('ab', 'c'), 1)
        self.assertAlmostEqual(dist_editex('nelson', 'neilsen'), 2/14)
        self.assertAlmostEqual(dist_editex('neilsen', 'nelson'), 2/14)
        self.assertEqual(dist_editex('niall', 'neal'), 0.1)


class EudexTestCases(unittest.TestCase):
    """Test Eudex distance functions.

    abydos.distance.eudex_hamming, dist_eudex, & sim_eudex
    """

    def test_eudex_hamming(self):
        """Test abydos.distance.eudex_hamming."""
        # Base cases
        self.assertEqual(eudex_hamming('', ''), 0)
        self.assertEqual(eudex_hamming('', '', None), 0)
        self.assertEqual(eudex_hamming('', '', 'fibonacci'), 0)
        self.assertEqual(eudex_hamming('', '', [10, 1, 1, 1]), 0)
        self.assertEqual(eudex_hamming('', '',
                                       lambda: [(yield 1) for _
                                                in range(10)]), 0)
        self.assertEqual(eudex_hamming('', '', normalized=True), 0)

        self.assertEqual(eudex_hamming('Niall', 'Niall'), 0)
        self.assertEqual(eudex_hamming('Niall', 'Niall', None), 0)
        self.assertEqual(eudex_hamming('Niall', 'Niall', 'fibonacci'), 0)
        self.assertEqual(eudex_hamming('Niall', 'Niall', [10, 1, 1, 1]), 0)
        self.assertEqual(eudex_hamming('Niall', 'Niall',
                                       lambda: [(yield 1) for _
                                                in range(10)]), 0)
        self.assertEqual(eudex_hamming('Niall', 'Niall', normalized=True), 0)

        self.assertEqual(eudex_hamming('Niall', 'Neil'), 2)
        self.assertEqual(eudex_hamming('Niall', 'Neil', None), 1)
        self.assertEqual(eudex_hamming('Niall', 'Neil', 'fibonacci'), 2)
        self.assertEqual(eudex_hamming('Niall', 'Neil', [10, 1, 1, 1]), 1)
        self.assertEqual(eudex_hamming('Niall', 'Neil',
                                       lambda: [(yield 1) for _
                                                in range(10)]), 1)
        self.assertAlmostEqual(eudex_hamming('Niall', 'Neil', normalized=True),
                               0.00098039)

        self.assertEqual(eudex_hamming('Niall', 'Colin'), 524)
        self.assertEqual(eudex_hamming('Niall', 'Colin', None), 10)
        self.assertEqual(eudex_hamming('Niall', 'Colin', 'fibonacci'), 146)
        self.assertEqual(eudex_hamming('Niall', 'Colin', [10, 1, 1, 1]), 6)
        self.assertEqual(eudex_hamming('Niall', 'Colin',
                                       lambda: [(yield 1) for _
                                                in range(10)]), 10)
        self.assertAlmostEqual(eudex_hamming('Niall', 'Colin',
                                             normalized=True), 0.25686274)

    def test_dist_eudex(self):
        """Test abydos.distance.dist_eudex."""
        # Base cases
        self.assertEqual(dist_eudex('', ''), 0)
        self.assertEqual(dist_eudex('', '', None), 0)
        self.assertEqual(dist_eudex('', '', 'fibonacci'), 0)

        self.assertEqual(dist_eudex('Niall', 'Niall'), 0)
        self.assertEqual(dist_eudex('Niall', 'Niall', None), 0)
        self.assertEqual(dist_eudex('Niall', 'Niall', 'fibonacci'), 0)

        self.assertAlmostEqual(dist_eudex('Niall', 'Neil'), 0.00098039)
        self.assertAlmostEqual(dist_eudex('Niall', 'Neil', None), 0.11111111)
        self.assertAlmostEqual(dist_eudex('Niall', 'Neil', 'fibonacci'),
                               0.00287356)

        self.assertAlmostEqual(dist_eudex('Niall', 'Colin'), 0.25686275)
        self.assertAlmostEqual(dist_eudex('Niall', 'Colin', None), 0.16666667)
        self.assertAlmostEqual(dist_eudex('Niall', 'Colin', 'fibonacci'),
                               0.20977011)

    def test_sim_eudex(self):
        """Test abydos.distance.sim_eudex."""
        # Base cases
        self.assertEqual(sim_eudex('', ''), 1)
        self.assertEqual(sim_eudex('', '', None), 1)
        self.assertEqual(sim_eudex('', '', 'fibonacci'), 1)

        self.assertEqual(sim_eudex('Niall', 'Niall'), 1)
        self.assertEqual(sim_eudex('Niall', 'Niall', None), 1)
        self.assertEqual(sim_eudex('Niall', 'Niall', 'fibonacci'), 1)

        self.assertAlmostEqual(sim_eudex('Niall', 'Neil'), 0.99901961)
        self.assertAlmostEqual(sim_eudex('Niall', 'Neil', None), 0.88888889)
        self.assertAlmostEqual(sim_eudex('Niall', 'Neil', 'fibonacci'),
                               0.99712644)

        self.assertAlmostEqual(sim_eudex('Niall', 'Colin'), 0.74313725)
        self.assertAlmostEqual(sim_eudex('Niall', 'Colin', None), 0.83333333)
        self.assertAlmostEqual(sim_eudex('Niall', 'Colin', 'fibonacci'),
                               0.79022989)


class Sift4TestCases(unittest.TestCase):
    """Test Sift4 functions.

    abydos.distance.sift4_simplest, sift4_common, sim_sift4, & sim_sift4
    """

    def test_sift4_simplest(self):
        """Test abydos.distance.sift4_simplest."""
        # tests copied from Lukas Benedix's post at
        # https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
        self.assertEqual(sift4_simplest('', ''), 0)
        self.assertEqual(sift4_simplest('a', ''), 1)
        self.assertEqual(sift4_simplest('', 'a'), 1)
        self.assertEqual(sift4_simplest('abc', ''), 3)
        self.assertEqual(sift4_simplest('', 'abc'), 3)

        self.assertEqual(sift4_simplest('a', 'a'), 0)
        self.assertEqual(sift4_simplest('abc', 'abc'), 0)

        self.assertEqual(sift4_simplest('a', 'ab'), 1)
        self.assertEqual(sift4_simplest('ac', 'abc'), 1)
        self.assertEqual(sift4_simplest('abcdefg', 'xabxcdxxefxgx'), 10)

        self.assertEqual(sift4_simplest('ab', 'b'), 1)
        self.assertEqual(sift4_simplest('ab', 'a'), 1)
        self.assertEqual(sift4_simplest('abc', 'ac'), 1)
        self.assertEqual(sift4_simplest('xabxcdxxefxgx', 'abcdefg'), 10)

        self.assertEqual(sift4_simplest('a', 'b'), 1)
        self.assertEqual(sift4_simplest('ab', 'ac'), 1)
        self.assertEqual(sift4_simplest('ac', 'bc'), 1)
        self.assertEqual(sift4_simplest('abc', 'axc'), 1)
        self.assertEqual(sift4_simplest('xabxcdxxefxgx', '1ab2cd34ef5g6'), 6)

        self.assertEqual(sift4_simplest('example', 'samples'), 2)
        self.assertEqual(sift4_simplest('sturgeon', 'urgently'), 4)
        self.assertEqual(sift4_simplest('levenshtein', 'frankenstein'), 10)
        self.assertEqual(sift4_simplest('distance', 'difference'), 7)

        # Tests copied from
        # https://github.com/tdebatty/java-string-similarity/blob/master/src/test/java/info/debatty/java/stringsimilarity/experimental/Sift4Test.java
        self.assertEqual(sift4_simplest('This is the first string',
                                        'And this is another string', 5), 13)
        self.assertEqual(sift4_simplest('Lorem ipsum dolor sit amet, ' +
                                        'consectetur adipiscing elit.',
                                        'Amet Lorm ispum dolor sit amet, ' +
                                        'consetetur adixxxpiscing elit.',
                                        10), 20)

    def test_sift4_common(self):
        """Test abydos.distance.sift4_common."""
        # tests copied from Lukas Benedix's post at
        # https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
        self.assertEqual(sift4_common('', ''), 0)
        self.assertEqual(sift4_common('a', ''), 1)
        self.assertEqual(sift4_common('', 'a'), 1)
        self.assertEqual(sift4_common('abc', ''), 3)
        self.assertEqual(sift4_common('', 'abc'), 3)

        self.assertEqual(sift4_common('a', 'a'), 0)
        self.assertEqual(sift4_common('abc', 'abc'), 0)

        self.assertEqual(sift4_common('a', 'ab'), 1)
        self.assertEqual(sift4_common('ac', 'abc'), 1)
        self.assertEqual(sift4_common('abcdefg', 'xabxcdxxefxgx'), 7)

        self.assertEqual(sift4_common('ab', 'b'), 1)
        self.assertEqual(sift4_common('ab', 'a'), 1)
        self.assertEqual(sift4_common('abc', 'ac'), 1)
        self.assertEqual(sift4_common('xabxcdxxefxgx', 'abcdefg'), 7)

        self.assertEqual(sift4_common('a', 'b'), 1)
        self.assertEqual(sift4_common('ab', 'ac'), 1)
        self.assertEqual(sift4_common('ac', 'bc'), 1)
        self.assertEqual(sift4_common('abc', 'axc'), 1)
        self.assertEqual(sift4_common('xabxcdxxefxgx', '1ab2cd34ef5g6'), 6)

        self.assertEqual(sift4_common('example', 'samples'), 2)
        self.assertEqual(sift4_common('sturgeon', 'urgently'), 3)
        self.assertEqual(sift4_common('levenshtein', 'frankenstein'), 6)
        self.assertEqual(sift4_common('distance', 'difference'), 5)

        # Tests copied from
        # https://github.com/tdebatty/java-string-similarity/blob/master/src/test/java/info/debatty/java/stringsimilarity/experimental/Sift4Test.java
        self.assertEqual(sift4_common('This is the first string',
                                      'And this is another string', 5), 11)
        self.assertEqual(sift4_common('Lorem ipsum dolor sit amet, ' +
                                      'consectetur adipiscing elit.',
                                      'Amet Lorm ispum dolor sit amet, ' +
                                      'consetetur adixxxpiscing elit.',
                                      10), 12)

        # cases with max_distance
        self.assertEqual(sift4_common('example', 'samples', 5, 5), 5)
        self.assertEqual(sift4_common('sturgeon', 'urgently', 5, 5), 5)
        self.assertEqual(sift4_common('levenshtein', 'frankenstein', 5, 5), 5)
        self.assertEqual(sift4_common('distance', 'difference', 5, 5), 5)

    def test_dist_sift4(self):
        """Test abydos.distance.dist_sift4."""
        # tests copied from Lukas Benedix's post at
        # https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
        self.assertEqual(dist_sift4('', ''), 0)
        self.assertEqual(dist_sift4('a', ''), 1)
        self.assertEqual(dist_sift4('', 'a'), 1)
        self.assertEqual(dist_sift4('abc', ''), 1)
        self.assertEqual(dist_sift4('', 'abc'), 1)

        self.assertEqual(dist_sift4('a', 'a'), 0)
        self.assertEqual(dist_sift4('abc', 'abc'), 0)

        self.assertEqual(dist_sift4('a', 'ab'), 0.5)
        self.assertEqual(dist_sift4('ac', 'abc'), 1/3)
        self.assertAlmostEqual(dist_sift4('abcdefg', 'xabxcdxxefxgx'),
                               0.538461538)

        self.assertEqual(dist_sift4('ab', 'b'), 0.5)
        self.assertEqual(dist_sift4('ab', 'a'), 0.5)
        self.assertEqual(dist_sift4('abc', 'ac'), 1/3)
        self.assertAlmostEqual(dist_sift4('xabxcdxxefxgx', 'abcdefg'),
                               0.538461538)

        self.assertEqual(dist_sift4('a', 'b'), 1)
        self.assertEqual(dist_sift4('ab', 'ac'), 0.5)
        self.assertEqual(dist_sift4('ac', 'bc'), 0.5)
        self.assertEqual(dist_sift4('abc', 'axc'), 1/3)
        self.assertAlmostEqual(dist_sift4('xabxcdxxefxgx', '1ab2cd34ef5g6'),
                               0.461538461)

        self.assertAlmostEqual(dist_sift4('example', 'samples'), 0.285714285)
        self.assertAlmostEqual(dist_sift4('sturgeon', 'urgently'), 0.375)
        self.assertAlmostEqual(dist_sift4('levenshtein', 'frankenstein'), 0.5)
        self.assertAlmostEqual(dist_sift4('distance', 'difference'), 0.5)

        # Tests copied from
        # https://github.com/tdebatty/java-string-similarity/blob/master/src/test/java/info/debatty/java/stringsimilarity/experimental/Sift4Test.java
        self.assertAlmostEqual(dist_sift4('This is the first string',
                                          'And this is another string',
                                          5), 0.423076923)
        self.assertAlmostEqual(dist_sift4('Lorem ipsum dolor sit amet, ' +
                                          'consectetur adipiscing elit.',
                                          'Amet Lorm ispum dolor sit amet, ' +
                                          'consetetur adixxxpiscing elit.',
                                          10), 0.193548387)

        # cases with max_distance
        self.assertAlmostEqual(dist_sift4('example', 'samples', 5, 5),
                               0.714285714)
        self.assertAlmostEqual(dist_sift4('sturgeon', 'urgently', 5, 5), 0.625)
        self.assertAlmostEqual(dist_sift4('levenshtein', 'frankenstein', 5, 5),
                               0.416666666)
        self.assertAlmostEqual(dist_sift4('distance', 'difference', 5, 5), 0.5)

    def test_sim_sift4(self):
        """Test abydos.distance.sim_sift4."""
        # tests copied from Lukas Benedix's post at
        # https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
        self.assertEqual(sim_sift4('', ''), 1)
        self.assertEqual(sim_sift4('a', ''), 0)
        self.assertEqual(sim_sift4('', 'a'), 0)
        self.assertEqual(sim_sift4('abc', ''), 0)
        self.assertEqual(sim_sift4('', 'abc'), 0)

        self.assertEqual(sim_sift4('a', 'a'), 1)
        self.assertEqual(sim_sift4('abc', 'abc'), 1)

        self.assertEqual(sim_sift4('a', 'ab'), 0.5)
        self.assertAlmostEqual(sim_sift4('ac', 'abc'), 2/3)
        self.assertAlmostEqual(sim_sift4('abcdefg', 'xabxcdxxefxgx'),
                               0.461538461)

        self.assertEqual(sim_sift4('ab', 'b'), 0.5)
        self.assertEqual(sim_sift4('ab', 'a'), 0.5)
        self.assertAlmostEqual(sim_sift4('abc', 'ac'), 2/3)
        self.assertAlmostEqual(sim_sift4('xabxcdxxefxgx', 'abcdefg'),
                               0.461538461)

        self.assertEqual(sim_sift4('a', 'b'), 0)
        self.assertEqual(sim_sift4('ab', 'ac'), 0.5)
        self.assertEqual(sim_sift4('ac', 'bc'), 0.5)
        self.assertAlmostEqual(sim_sift4('abc', 'axc'), 2/3)
        self.assertAlmostEqual(sim_sift4('xabxcdxxefxgx', '1ab2cd34ef5g6'),
                               0.538461538)

        self.assertAlmostEqual(sim_sift4('example', 'samples'), 0.714285714)
        self.assertAlmostEqual(sim_sift4('sturgeon', 'urgently'), 0.625)
        self.assertAlmostEqual(sim_sift4('levenshtein', 'frankenstein'), 0.5)
        self.assertAlmostEqual(sim_sift4('distance', 'difference'), 0.5)

        # Tests copied from
        # https://github.com/tdebatty/java-string-similarity/blob/master/src/test/java/info/debatty/java/stringsimilarity/experimental/Sift4Test.java
        self.assertAlmostEqual(sim_sift4('This is the first string',
                                         'And this is another string',
                                         5), 0.576923077)
        self.assertAlmostEqual(sim_sift4('Lorem ipsum dolor sit amet, ' +
                                         'consectetur adipiscing elit.',
                                         'Amet Lorm ispum dolor sit amet, ' +
                                         'consetetur adixxxpiscing elit.',
                                         10), 0.806451613)

        # cases with max_distance
        self.assertAlmostEqual(sim_sift4('example', 'samples', 5, 5),
                               0.285714286)
        self.assertAlmostEqual(sim_sift4('sturgeon', 'urgently', 5, 5), 0.375)
        self.assertAlmostEqual(sim_sift4('levenshtein', 'frankenstein', 5, 5),
                               0.583333333)
        self.assertAlmostEqual(sim_sift4('distance', 'difference', 5, 5), 0.5)


class BaystatTestCases(unittest.TestCase):
    """Test Baystat functions.

    abydos.distance.sim_baystat & .dist_baystat
    """

    def test_sim_baystat(self):
        """Test abydos.distance.sim_editex."""
        # Base cases
        self.assertEqual(sim_baystat('', ''), 1)
        self.assertEqual(sim_baystat('Colin', ''), 0)
        self.assertEqual(sim_baystat('Colin', 'Colin'), 1)

        # Examples given in the paper
        # https://www.statistik.bayern.de/medien/statistik/zensus/zusammenf__hrung_von_datenbest__nden_ohne_numerische_identifikatoren.pdf
        self.assertAlmostEqual(sim_baystat('DRAKOMENA', 'DRAOMINA'), 7/9)
        self.assertAlmostEqual(sim_baystat('RIEKI', 'RILKI'), 4/5)
        self.assertAlmostEqual(sim_baystat('ATANASSIONI', 'ATANASIOU'), 8/11)
        self.assertAlmostEqual(sim_baystat('LIESKOVSKY', 'LIESZKOVSZKY'),
                               10/12)
        self.assertAlmostEqual(sim_baystat('JEANETTE', 'JEANNETTE'), 8/9)
        self.assertAlmostEqual(sim_baystat('JOHANNES', 'JOHAN'), 0.625)
        self.assertAlmostEqual(sim_baystat('JOHANNES', 'HANS'), 0.375)
        self.assertAlmostEqual(sim_baystat('JOHANNES', 'HANNES'), 0.75)
        self.assertAlmostEqual(sim_baystat('ZIMMERMANN', 'SEMMERMANN'), 0.8)
        self.assertAlmostEqual(sim_baystat('ZIMMERMANN', 'ZIMMERER'), 0.6)
        self.assertAlmostEqual(sim_baystat('ZIMMERMANN', 'ZIMMER'), 0.6)

        # Tests to maximize coverage
        self.assertAlmostEqual(sim_baystat('ZIMMERMANN', 'SEMMERMANN',
                                           2, 2, 2), 0.8)
        self.assertAlmostEqual(sim_baystat('ZIMMER', 'ZIMMERMANN'), 0.6)

    def test_dist_baystat(self):
        """Test abydos.distance.dist_editex."""
        # Base cases
        self.assertEqual(dist_baystat('', ''), 0)
        self.assertEqual(dist_baystat('Colin', ''), 1)
        self.assertEqual(dist_baystat('Colin', 'Colin'), 0)

        # Examples given in the paper
        # https://www.statistik.bayern.de/medien/statistik/zensus/zusammenf__hrung_von_datenbest__nden_ohne_numerische_identifikatoren.pdf
        self.assertAlmostEqual(dist_baystat('DRAKOMENA', 'DRAOMINA'), 2/9)
        self.assertAlmostEqual(dist_baystat('RIEKI', 'RILKI'), 1/5)
        self.assertAlmostEqual(dist_baystat('ATANASSIONI', 'ATANASIOU'), 3/11)
        self.assertAlmostEqual(dist_baystat('LIESKOVSKY', 'LIESZKOVSZKY'),
                               2/12)
        self.assertAlmostEqual(dist_baystat('JEANETTE', 'JEANNETTE'), 1/9)
        self.assertAlmostEqual(dist_baystat('JOHANNES', 'JOHAN'), 0.375)
        self.assertAlmostEqual(dist_baystat('JOHANNES', 'HANS'), 0.625)
        self.assertAlmostEqual(dist_baystat('JOHANNES', 'HANNES'), 0.25)
        self.assertAlmostEqual(dist_baystat('ZIMMERMANN', 'SEMMERMANN'), 0.2)
        self.assertAlmostEqual(dist_baystat('ZIMMERMANN', 'ZIMMERER'), 0.4)
        self.assertAlmostEqual(dist_baystat('ZIMMERMANN', 'ZIMMER'), 0.4)


class TypoTestCases(unittest.TestCase):
    """Test Typo functions.

    abydos.distance.typo, sim_typo & .dist_typo
    """

    def test_typo(self):
        """Test abydos.distance.typo."""
        # Base cases
        self.assertEqual(typo('', ''), 0)
        self.assertEqual(typo('', 'typo'), 4)
        self.assertEqual(typo('typo', ''), 4)

        self.assertEqual(typo('asdf', 'zxcv'), 2)
        self.assertEqual(typo('asdf', 'ASDF'), 1)
        self.assertEqual(typo('asdf', 'qsdf'), 0.5)

        self.assertAlmostEqual(typo('asdf', 'asdt', metric='euclidean'),
                               0.70710677)
        self.assertAlmostEqual(typo('asdf', 'asdt', metric='manhattan'),
                               1)
        self.assertAlmostEqual(typo('asdf', 'asdt', metric='log-euclidean'),
                               0.4406868)
        self.assertAlmostEqual(typo('asdf', 'asdt', metric='log-manhattan'),
                               0.54930615)

        self.assertRaises(ValueError, typo, 'asdf', 'Ösdf')

    def test_sim_typo(self):
        """Test abydos.distance.sim_typo."""
        # Base cases
        self.assertEqual(sim_typo('', ''), 1)
        self.assertEqual(sim_typo('', 'typo'), 0)
        self.assertEqual(sim_typo('typo', ''), 0)

        self.assertEqual(sim_typo('asdf', 'zxcv'), 0.5)
        self.assertEqual(sim_typo('asdf', 'ASDF'), 0.75)
        self.assertEqual(sim_typo('asdf', 'qsdf'), 0.875)

        self.assertAlmostEqual(sim_typo('asdf', 'asdt', metric='euclidean'),
                               1-(0.70710677/4))
        self.assertAlmostEqual(sim_typo('asdf', 'asdt', metric='manhattan'),
                               0.75)
        self.assertAlmostEqual(sim_typo('asdf', 'asdt',
                                        metric='log-euclidean'),
                               1-(0.4406868/4))
        self.assertAlmostEqual(sim_typo('asdf', 'asdt',
                                        metric='log-manhattan'),
                               1-(0.54930615/4))

    def test_dist_typo(self):
        """Test abydos.distance.dist_typo."""
        # Base cases
        self.assertEqual(dist_typo('', ''), 0)
        self.assertEqual(dist_typo('', 'typo'), 1)
        self.assertEqual(dist_typo('typo', ''), 1)

        self.assertEqual(dist_typo('asdf', 'zxcv'), 0.5)
        self.assertEqual(dist_typo('asdf', 'ASDF'), 0.25)
        self.assertEqual(dist_typo('asdf', 'qsdf'), 0.125)

        self.assertAlmostEqual(dist_typo('asdf', 'asdt', metric='euclidean'),
                               0.70710677/4)
        self.assertAlmostEqual(dist_typo('asdf', 'asdt', metric='manhattan'),
                               0.25)
        self.assertAlmostEqual(dist_typo('asdf', 'asdt',
                                         metric='log-euclidean'), 0.4406868/4)
        self.assertAlmostEqual(dist_typo('asdf', 'asdt',
                                         metric='log-manhattan'), 0.54930615/4)


class IndelTestCases(unittest.TestCase):
    """Test indel functions.

    abydos.distance.sim_indel & .dist_indel
    """

    def test_sim_indel(self):
        """Test abydos.distance.sim_indel."""
        # Base cases
        self.assertEqual(sim_indel('', ''), 1)
        self.assertEqual(sim_indel('a', ''), 0)
        self.assertEqual(sim_indel('', 'a'), 0)
        self.assertEqual(sim_indel('abc', ''), 0)
        self.assertEqual(sim_indel('', 'abc'), 0)
        self.assertEqual(sim_indel('abcd', 'efgh'), 0)

        self.assertAlmostEqual(sim_indel('Nigel', 'Niall'), 0.6)
        self.assertAlmostEqual(sim_indel('Niall', 'Nigel'), 0.6)
        self.assertAlmostEqual(sim_indel('Colin', 'Coiln'), 0.8)
        self.assertAlmostEqual(sim_indel('Coiln', 'Colin'), 0.8)

    def test_dist_indel(self):
        """Test abydos.distance.dist_indel."""
        # Base cases
        self.assertEqual(dist_indel('', ''), 0)
        self.assertEqual(dist_indel('a', ''), 1)
        self.assertEqual(dist_indel('', 'a'), 1)
        self.assertEqual(dist_indel('abc', ''), 1)
        self.assertEqual(dist_indel('', 'abc'), 1)
        self.assertEqual(dist_indel('abcd', 'efgh'), 1)

        self.assertAlmostEqual(dist_indel('Nigel', 'Niall'), 0.4)
        self.assertAlmostEqual(dist_indel('Niall', 'Nigel'), 0.4)
        self.assertAlmostEqual(dist_indel('Colin', 'Coiln'), 0.2)
        self.assertAlmostEqual(dist_indel('Coiln', 'Colin'), 0.2)


class SynonameTestCases(unittest.TestCase):
    """Test Synoname functions.

    abydos.distance._synoname_strip_punct, synoname_word_approximation, &
    synoname
    """

    def test_synoname_strip_punct(self):
        """Test abydos.distance._synoname_strip_punct."""
        # Base cases
        self.assertEqual(_synoname_strip_punct(''), '')
        self.assertEqual(_synoname_strip_punct('abcdefg'), 'abcdefg')
        self.assertEqual(_synoname_strip_punct('a\'b-c,d!e:f%g'), 'abcdefg')

    def test_synoname_word_approximation(self):
        """Test abydos.distance.synoname_word_approximation."""
        # Base cases
        self.assertEqual(synoname_word_approximation('', ''), 0)

        self.assertEqual(synoname_word_approximation('di Domenico di ' +
                                                     'Bonaventura',
                                                     'di Tomme di Nuto',
                                                     'Cosimo', 'Luca'), 0.4)
        self.assertEqual(synoname_word_approximation('Antonello da Messina',
                                                     'Messina',
                                                     '', 'Antonello da',
                                                     {'gen_conflict': False,
                                                      'roman_conflict': False,
                                                      'src_specials':
                                                          [(35, 'b'),
                                                           (35, 'c')],
                                                      'tar_specials':
                                                          [(35, 'b'),
                                                           (35, 'c')]}), 0)

    def test_synoname(self):
        """Test abydos.distance.synoname."""
        # Base cases
        self.assertEqual(synoname('', ''), 1)
        self.assertEqual(synoname('', '', tests=['exact']), 1)
        self.assertEqual(synoname('', '', tests=[]), 13)
        self.assertEqual(synoname('', '', tests=['nonsense-test']), 13)
        self.assertEqual(synoname('', '', ret_name=True), 'exact')

        # Test input formats
        self.assertEqual(synoname(('Brueghel II (the Younger)', 'Pieter',
                                   'Workshop of'),
                                  ('Brueghel II (the Younger)', 'Pieter',
                                   'Workshop of')), 1)
        self.assertEqual(synoname('Brueghel II (the Younger)#Pieter#' +
                                  'Workshop of',
                                  'Brueghel II (the Younger)#Pieter#' +
                                  'Workshop of'), 1)
        self.assertEqual(synoname('22#Brueghel II (the Younger)#Pieter#' +
                                  'Workshop of',
                                  '44#Brueghel II (the Younger)#Pieter#' +
                                  'Workshop of'), 1)

        # approx_c tests
        self.assertEqual(synoname(('Master of Brueghel II (the Younger)',
                                   'Pieter', 'Workshop of'),
                                  ('Brueghel I (the Elder)', 'Pieter',
                                   'Workshop of')), 13)
        self.assertEqual(synoname(('Master of Brueghel II',
                                   'Pieter', 'Workshop of'),
                                  ('Master known as the Brueghel II', 'Pieter',
                                   'Workshop of')), 10)

        # Types 1-12
        self.assertEqual(synoname(('Brueghel', 'Pieter', ''),
                                  ('Brueghel', 'Pieter', ''),
                                  ret_name=True), 'exact')

        self.assertEqual(synoname(('Brueghel II', 'Pieter', ''),
                                  ('Brueghel I', 'Pieter', ''),
                                  ret_name=True), 'no_match')
        self.assertEqual(synoname(('Breghel', 'Pieter', ''),
                                  ('Brueghel', 'Pieter', ''),
                                  ret_name=True), 'omission')
        self.assertEqual(synoname(('Brueghel', 'Pieter', ''),
                                  ('Breghel', 'Pieter', ''),
                                  ret_name=True), 'omission')
        self.assertEqual(synoname(('Brueghel', 'Piter', ''),
                                  ('Brueghel', 'Pieter', ''),
                                  ret_name=True), 'omission')
        self.assertEqual(synoname(('Brueghel', 'Pieter', ''),
                                  ('Brueghel', 'Piter', ''),
                                  ret_name=True), 'omission')
        self.assertEqual(synoname(('Brughel', 'Pieter', ''),
                                  ('Breghel', 'Pieter', ''),
                                  ret_name=True), 'substitution')
        self.assertEqual(synoname(('Breughel', 'Peter', ''),
                                  ('Breughel', 'Piter', ''),
                                  ret_name=True), 'substitution')
        self.assertEqual(synoname(('Brueghel', 'Pieter', ''),
                                  ('Breughel', 'Pieter', ''),
                                  ret_name=True), 'transposition')
        self.assertEqual(synoname(('Brueghel', 'Peiter', ''),
                                  ('Brueghel', 'Pieter', ''),
                                  ret_name=True), 'transposition')

        self.assertEqual(synoname(('Brueghel:', 'Pieter', ''),
                                  ('Brueghel', 'Pi-eter', ''),
                                  ret_name=True), 'punctuation')
        self.assertEqual(synoname(('Brueghel,', 'Pieter', ''),
                                  ('Brueghel', 'Pieter...', ''),
                                  ret_name=True), 'punctuation')
        self.assertEqual(synoname(('Seu rat', 'George Pierre', ''),
                                  ('Seu-rat', 'George-Pierre', ''),
                                  ret_name=True), 'punctuation')
        self.assertEqual(synoname(('Picasso', '', ''),
                                  ('Picasso', 'Pablo', ''),
                                  ret_name=True), 'no_first')
        self.assertEqual(synoname(('Pereira', 'I. R.', ''),
                                  ('Pereira', 'Irene Rice', ''),
                                  ret_name=True), 'initials')
        self.assertNotEqual(synoname(('Pereira', 'I. R.', ''),
                                     ('Pereira', 'I. Smith', ''),
                                     ret_name=True), 'initials')
        self.assertNotEqual(synoname(('Pereira', 'I. R. S.', ''),
                                     ('Pereira', 'I. S. R.', ''),
                                     ret_name=True), 'initials')
        self.assertEqual(synoname(('de Goya', 'Francisco', ''),
                                  ('de Goya y Lucientes', 'Francisco', ''),
                                  ret_name=True), 'extension')
        self.assertEqual(synoname(('Seurat', 'George', ''),
                                  ('Seurat', 'George-Pierre', ''),
                                  ret_name=True), 'extension')
        self.assertEqual(synoname(('Gericault', 'Theodore', ''),
                                  ('Gericault', 'Jean Louis Andre Theodore',
                                   ''),
                                  ret_name=True), 'inclusion')
        self.assertEqual(synoname(('Dore', 'Gustave', ''),
                                  ('Dore', 'Paul Gustave Louis Christophe',
                                   ''),
                                  ret_name=True), 'inclusion')

        self.assertEqual(synoname(('Rosetti', 'Dante Gabriel', ''),
                                  ('Rosetti', 'Gabriel Charles Dante', ''),
                                  ret_name=True), 'word_approx')
        self.assertEqual(synoname(('di Domenico di Bonaventura', 'Cosimo', ''),
                                  ('di Tomme di Nuto', 'Luca', ''),
                                  ret_name=True), 'no_match')
        self.assertEqual(synoname(('Pereira', 'I. R.', ''),
                                  ('Pereira', 'I. Smith', ''),
                                  ret_name=True), 'word_approx')
        self.assertEqual(synoname(('Antonello da Messina', '', ''),
                                  ('Messina', 'Antonello da', ''),
                                  ret_name=True), 'confusions')
        self.assertEqual(synoname(('Brueghel', 'Pietter', ''),
                                  ('Bruegghel', 'Pieter', ''),
                                  ret_name=True), 'char_approx')


class SimDistTestCases(unittest.TestCase):
    """Test generic sim & dist functions.

    abydos.distance.sim & .dist
    """

    def test_sim(self):
        """Test abydos.distance.sim."""
        self.assertEqual(sim('Niall', 'Nigel'),
                         sim_levenshtein('Niall', 'Nigel'))
        self.assertRaises(AttributeError, sim, 'abc', 'abc', 0)

    def test_dist(self):
        """Test abydos.distance.dist."""
        self.assertEqual(dist('Niall', 'Nigel'),
                         dist_levenshtein('Niall', 'Nigel'))
        self.assertRaises(AttributeError, dist, 'abc', 'abc', 0)


if __name__ == '__main__':
    unittest.main()